diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 00000000..1eca04bd --- /dev/null +++ b/.editorconfig @@ -0,0 +1,39 @@ +root = true + +# All files +[*] +charset = utf-8 +end_of_line = lf +insert_final_newline = true +trim_trailing_whitespace = true + +# Python files +[*.py] +indent_style = space +indent_size = 4 + +# YAML files - maintain 2-space indentation +[*.{yaml,yml}] +indent_style = space +indent_size = 2 + +# JSON files +[*.json] +indent_style = space +indent_size = 2 + +# Markdown files +[*.md] +trim_trailing_whitespace = false +indent_style = space +indent_size = 2 + +# Toml files +[*.toml] +indent_style = space +indent_size = 2 + +# GitHub Actions workflows +[.github/workflows/*.{yaml,yml}] +indent_style = space +indent_size = 2 diff --git a/.env.template b/.env.template new file mode 100644 index 00000000..ab1d2817 --- /dev/null +++ b/.env.template @@ -0,0 +1,6 @@ +# Mock server URLs for local development +# Copy this file to .env and uncomment the URLs you need + +# MOCK_ALGOD_URL=http://localhost:18000 +# MOCK_INDEXER_URL=http://localhost:18002 +# MOCK_KMD_URL=http://localhost:18001 diff --git a/.github/actions/publish-docs/action.yml b/.github/actions/publish-docs/action.yml new file mode 100644 index 00000000..cd933af3 --- /dev/null +++ b/.github/actions/publish-docs/action.yml @@ -0,0 +1,31 @@ +name: "Build Documentation" +description: "Generate API docs via Sphinx and build Starlight site" + +runs: + using: "composite" + steps: + - name: Setup Python environment + uses: algorandfoundation/algokit-shared-config/.github/actions/setup-algokit-python@main + with: + install-algokit: "false" + + - name: Set up Node.js 24 + uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6 + with: + node-version: "24.x" + + - uses: pnpm/action-setup@0e279bb959325dab635dd2c09392533439d90093 # v6 + with: + package_json_file: docs/package.json + + - name: Install docs dependencies + shell: bash + run: pnpm install --frozen-lockfile --dir docs + + - name: Generate API docs + shell: bash + run: uv run poe docs-api + + - name: Build Starlight site + shell: bash + run: pnpm --dir docs build diff --git a/.github/actions/setup-poetry/action.yaml b/.github/actions/setup-poetry/action.yaml deleted file mode 100644 index 465e662b..00000000 --- a/.github/actions/setup-poetry/action.yaml +++ /dev/null @@ -1,40 +0,0 @@ -name: "Python Poetry Action" -description: "An action to setup Poetry" -runs: - using: "composite" - steps: - # A workaround for pipx isn't installed on M1 runner. - # We should remove it after this issue is resolved. - # https://github.com/actions/runner-images/issues/9256 - - if: ${{ runner.os == 'macOS' && runner.arch == 'ARM64' }} - run: | - pip install poetry - pip install poetry-plugin-export - shell: bash - - # NOTE: Below commands currently causes a faulty behaviour in pipx where - # preinstalled pipx on github worker has shared venv instantiated via python 3.10 - # however 2 of the above commands are supposed to reinstall pipx and use python version - # specified in setup-python, however shared venv still uses 3.10 hence algokit fails on - # pkgutil.ImpImporter module not found error. - # To be approached as given until further clarified on corresponding issues on pipx repo. - # ------ - # pip install --user pipx - # pipx ensurepath - # ------ - - if: ${{ runner.os != 'macOS' || runner.arch != 'ARM64' }} - run: | - pipx install poetry ${{ runner.os == 'macOS' && '--python "$Python_ROOT_DIR/bin/python"' || '' }} - pipx inject poetry poetry-plugin-export - shell: bash - - - name: Get full Python version - id: full-python-version - shell: bash - run: echo "full_version=$(python -c 'import sys; print(".".join(map(str, sys.version_info[:3])))')" >> $GITHUB_OUTPUT - - - name: Setup poetry cache - uses: actions/cache@v4 - with: - path: ./.venv - key: venv-${{ hashFiles('poetry.lock') }}-${{ runner.os }}-${{ runner.arch }}-${{ steps.full-python-version.outputs.full_version }} diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index fabab730..a191e070 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,5 +1,19 @@ ## Proposed Changes -- -- -- +This pull request introduces optional runtime validation schemas for API client responses using Pydantic models, and adds automation and documentation to support their use and maintenance. The main themes are: adding schema generation and usage, updating developer workflow and dependencies, and documenting the new feature. + +### Validation schema generation and usage + +- Added a script (`scripts/generate_schemas.py`) that generates Pydantic validation schemas from OpenAPI specs for algod, kmd, and indexer clients, producing 208 schema files in total. These schemas enable runtime type and bounds validation of API responses. +- Added and exported all generated schemas in `src/algokit_algod_client/schemas/__init__.py` for easy import and usage in client code. + +### Developer workflow and automation + +- Introduced a new `poe` task (`generate-schemas`) in `pyproject.toml` to automate schema generation, and updated the CI workflow to generate schemas and check for uncommitted changes to ensure schema files remain in sync with OpenAPI specs. +- Added `pydantic>=2.0.0,<3` as a development dependency, and excluded generated schemas from mypy type checking in `pyproject.toml`. +- Updated linting configuration to ignore specific rules for generated API client and schema files. + +### Documentation + +- Added a new documentation file (`api/oas-generator/VALIDATION.md`) detailing the purpose, usage, features, and maintenance of the validation schemas. +- Updated `README.md` with a section introducing validation schemas, installation requirements, usage examples, and links to further documentation. diff --git a/.github/workflows/build-python.yaml b/.github/workflows/build-python.yaml index 5c319bea..5c0806d6 100644 --- a/.github/workflows/build-python.yaml +++ b/.github/workflows/build-python.yaml @@ -11,35 +11,98 @@ jobs: runs-on: ${{ matrix.os }} steps: - name: Checkout source code - uses: actions/checkout@v4 + uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6 - - name: Set up Python ${{ matrix.python }} - uses: actions/setup-python@v5 + - name: Setup Python environment + uses: algorandfoundation/algokit-shared-config/.github/actions/setup-algokit-python@main with: python-version: ${{ matrix.python }} + install-algokit: "false" - - name: Set up Poetry - uses: ./.github/actions/setup-poetry + - name: Install extra dependency groups + run: uv sync --group api-generator - - name: Install dependencies - run: poetry install --no-interaction + - name: Setup Polytest + uses: algorandfoundation/algokit-polytest/.github/actions/setup-polytest@main + with: + version: "^0.7" + + - name: Generate all polytest files + shell: bash + run: uv run poe polytest-generate-all + + - name: Start algod mock server + uses: algorandfoundation/algokit-polytest/.github/actions/run-mock-server@main + with: + client: algod + + - name: Start indexer mock server + uses: algorandfoundation/algokit-polytest/.github/actions/run-mock-server@main + with: + client: indexer + + - name: Start kmd mock server + uses: algorandfoundation/algokit-polytest/.github/actions/run-mock-server@main + with: + client: kmd + + - name: Generate API clients + run: uv run poe generate-api-clients + + - name: Check API output stability + shell: bash + run: | + git status --porcelain src > /tmp/post_api_status.txt + if [ -s /tmp/post_api_status.txt ]; then + echo "❌ API OpenAPI sync needed!" + git status --porcelain src + git diff -- src + echo "🔧 Run 'uv run poe generate-api-clients' locally and commit the results." + exit 1 + else + echo "✅ API OpenAPI sync passed" + fi + + - name: Generate validation schemas + run: uv run poe generate-schemas + + - name: Check schema output stability + shell: bash + run: | + git status --porcelain tests/fixtures/schemas > /tmp/post_schema_status.txt + if [ -s /tmp/post_schema_status.txt ]; then + echo "❌ Validation schema sync needed!" + git status --porcelain tests/fixtures/schemas + git diff -- tests/fixtures/schemas + echo "🔧 Run 'uv run poe generate-schemas' locally and commit the results." + exit 1 + else + echo "✅ Validation schema sync passed" + fi - name: pytest + coverage shell: bash run: | set -o pipefail - pipx install algokit - algokit localnet start - poetry run pytest -n auto --junitxml=pytest-junit.xml --cov-report=term-missing:skip-covered --cov=src | tee pytest-coverage.txt - algokit localnet stop + uvx algokit localnet start + uv run poe test-ci 2>&1 | tee pytest-coverage.txt + uvx algokit localnet stop - name: pytest coverage comment - using Python 3.10 on ubuntu-latest if: matrix.python == '3.10' && matrix.os == 'ubuntu-latest' - uses: MishaKav/pytest-coverage-comment@main + uses: MishaKav/pytest-coverage-comment@dd5b80bde6d16941f336518e92929e89069d8451 # v1.7.2 continue-on-error: true # forks fail to add a comment, so continue any way with: pytest-coverage-path: ./pytest-coverage.txt junitxml-path: ./pytest-junit.xml + - name: Upload test results and coverage artifacts + if: always() + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 + with: + name: test-results-python-${{ matrix.python }} + path: pytest-junit.xml + retention-days: 30 + - name: Build Wheel - run: poetry build --format wheel + run: uv build diff --git a/.github/workflows/cd.yaml b/.github/workflows/cd.yaml index 2fb75230..352f19ab 100644 --- a/.github/workflows/cd.yaml +++ b/.github/workflows/cd.yaml @@ -5,7 +5,6 @@ on: branches: - main paths-ignore: - - "docs/**" - ".github/**" workflow_dispatch: inputs: @@ -39,31 +38,28 @@ jobs: name: Release Library needs: ci-build-python runs-on: ubuntu-latest + permissions: + id-token: write + contents: write steps: - name: Generate bot token - uses: actions/create-github-app-token@v1 + uses: actions/create-github-app-token@bcd2ba49218906704ab6c1aa796996da409d3eb1 # v3 id: app_token with: app-id: ${{ secrets.BOT_ID }} private-key: ${{ secrets.BOT_SK }} - - uses: actions/checkout@v4 + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6 with: # Fetch entire repository history so we can determine version number from it fetch-depth: 0 token: ${{ steps.app_token.outputs.token }} - - name: Set up Python - uses: actions/setup-python@v5 + - name: Setup Python environment + uses: algorandfoundation/algokit-shared-config/.github/actions/setup-algokit-python@main with: - python-version: "3.10" - - - name: Set up Poetry - uses: ./.github/actions/setup-poetry - - - name: Install dependencies - run: poetry install --no-interaction --no-root + install-algokit: "false" - name: Get branch name shell: bash @@ -74,31 +70,58 @@ jobs: run: git config --global user.email "179917785+engineering-ci[bot]@users.noreply.github.com" && git config --global user.name "engineering-ci[bot]" - name: Create Continuous Deployment - Beta (non-prod) + id: release-beta if: steps.get_branch.outputs.branch == 'main' && !inputs.production_release - run: | - poetry run semantic-release \ - -v DEBUG \ - --prerelease \ - --define=branch=main \ - --define=upload_to_repository=true \ - publish - gh release edit --prerelease "v$(poetry run semantic-release print-version --current)" env: GH_TOKEN: ${{ steps.app_token.outputs.token }} - REPOSITORY_USERNAME: __token__ - REPOSITORY_PASSWORD: ${{ secrets.PYPI_API_KEY }} + run: | + uv run semantic-release -v version --as-prerelease + uv run semantic-release publish - name: Create Continuous Deployment - Production + id: release-prod if: steps.get_branch.outputs.branch == 'main' && inputs.production_release - run: | - poetry run semantic-release \ - -v DEBUG \ - --define=version_source="commit" \ - --define=patch_without_tag=true \ - --define=upload_to_repository=true \ - --define=branch=main \ - publish env: GH_TOKEN: ${{ steps.app_token.outputs.token }} - REPOSITORY_USERNAME: __token__ - REPOSITORY_PASSWORD: ${{ secrets.PYPI_API_KEY }} + run: | + uv run semantic-release -v version + uv run semantic-release publish + + - name: Publish package distributions to PyPI + if: | + (steps.release-beta.outputs.released == 'true') || + (steps.release-prod.outputs.released == 'true') + uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.0 + with: + verbose: true + + deploy-docs: + name: Deploy Documentation + needs: ci-build-python + runs-on: ubuntu-latest + if: github.ref == 'refs/heads/main' + concurrency: + group: deploy-docs + cancel-in-progress: true + permissions: + contents: read + pages: write + id-token: write + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + steps: + - name: Checkout code + uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6 + + - name: Build documentation + uses: ./.github/actions/publish-docs + + - name: Upload to GitHub Pages + uses: actions/upload-pages-artifact@fc324d3547104276b827a68afc52ff2a11cc49c9 # v5 + with: + path: docs/dist + + - name: Deploy to GitHub Pages + id: deployment + uses: actions/deploy-pages@cd2ce8fcbc39b97be8ca5fce6e763baed58fa128 # v5 diff --git a/.github/workflows/check-docs.yaml b/.github/workflows/check-docs.yaml index a58d1f8f..9d75ad23 100644 --- a/.github/workflows/check-docs.yaml +++ b/.github/workflows/check-docs.yaml @@ -8,23 +8,15 @@ jobs: runs-on: "ubuntu-latest" steps: - name: Checkout source code - uses: actions/checkout@v4 + uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6 - - name: Set up Python 3.12 - uses: actions/setup-python@v5 + - name: Setup Python environment + uses: algorandfoundation/algokit-shared-config/.github/actions/setup-algokit-python@main with: - python-version: "3.12" - - - name: Set up Poetry - uses: ./.github/actions/setup-poetry - - - name: Install dependencies - run: poetry install --no-interaction --no-root + install-algokit: "false" - name: Check docstrings are up to date - run: poetry run poe docstrings-check + run: uv run poe docstrings-check - - name: Check docs are up to date - run: | - poetry run poe docs-md-only - git diff --exit-code ':!docs/markdown/autoapi/index.md' ':!docs/markdown/autoapi/algokit_utils/applications/app_factory/index.md' docs + - name: Build documentation + uses: ./.github/actions/publish-docs diff --git a/.github/workflows/check-python.yaml b/.github/workflows/check-python.yaml index 94a46544..06d460d3 100644 --- a/.github/workflows/check-python.yaml +++ b/.github/workflows/check-python.yaml @@ -8,39 +8,47 @@ jobs: runs-on: "ubuntu-latest" steps: - name: Checkout source code - uses: actions/checkout@v4 + uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6 - - name: Set up Python 3.10 - uses: actions/setup-python@v5 + - name: Setup Python environment + uses: algorandfoundation/algokit-shared-config/.github/actions/setup-algokit-python@main with: python-version: "3.10" + install-algokit: "false" - - name: Set up Poetry - uses: ./.github/actions/setup-poetry - - - name: Install dependencies - run: poetry install --no-interaction --no-root + - name: Upgrade pip in uv environment + run: uv pip install --upgrade "pip>=26.0" - name: Audit with pip-audit run: | - # audit non dev dependencies, no exclusions - poetry export --without=dev > requirements.txt && poetry run pip-audit -r requirements.txt - - # audit all dependencies, with exclusions. + # Audit all installed dependencies with exclusions # If a vulnerability is found in a dev dependency without an available fix, # it can be temporarily ignored by adding --ignore-vuln e.g. - # --ignore-vuln "GHSA-hcpj-qp55-gfph" # GitPython vulnerability, dev only dependency - poetry run pip-audit --ignore-vuln GHSA-4xh5-x5gv-qwph - - - name: Check formatting with Ruff + # --ignore-vuln "GHSA-hcpj-qp55-gfph" # GitPython vulnerability, dev only dependency + # + # Ignored vulnerabilities: + # GHSA-gc5v-m9x4-r6x2 does not affect us since we don't use `extract_zipped_paths` + # GHSA-5239-wwwm-4pmq is a regex redos only affecting dev deps + uv run --no-sync pip-audit --ignore-vuln GHSA-gc5v-m9x4-r6x2 --ignore-vuln GHSA-5239-wwwm-4pmq + + - name: Check codebase with ruff and mypy run: | # stop the build if there are files that don't meet formatting requirements - poetry run ruff format --check . + uv run poe lint - - name: Check linting with Ruff - run: | - # stop the build if there are Python syntax errors or undefined names - poetry run ruff check . + - name: Setup Polytest + uses: algorandfoundation/algokit-polytest/.github/actions/setup-polytest@main + with: + version: "^0.7" + + - name: Validate polytest algod_client tests + run: uv run poe polytest-validate-algod + + - name: Validate polytest indexer_client tests + run: uv run poe polytest-validate-indexer + + - name: Validate polytest kmd_client tests + run: uv run poe polytest-validate-kmd - - name: Check types with mypy - run: poetry run mypy + - name: Validate polytest transact tests + run: uv run poe polytest-validate-transact diff --git a/.github/workflows/pr.yaml b/.github/workflows/pr.yaml index ed292ebd..18ca7805 100644 --- a/.github/workflows/pr.yaml +++ b/.github/workflows/pr.yaml @@ -11,6 +11,10 @@ jobs: name: Check Documentation uses: ./.github/workflows/check-docs.yaml + pr-verify-examples: + name: Verify Examples + uses: ./.github/workflows/verify-examples.yaml + pr-build: name: Build and Test Python needs: [pr-check, pr-check-docs] diff --git a/.github/workflows/publish-devportal-docs.yml b/.github/workflows/publish-devportal-docs.yml new file mode 100644 index 00000000..bb4ad565 --- /dev/null +++ b/.github/workflows/publish-devportal-docs.yml @@ -0,0 +1,37 @@ +name: Publish DevPortal Docs + +on: + workflow_dispatch: + push: + branches: [main] + tags: ['v*'] + +permissions: + contents: write + +jobs: + publish-docs: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6 + + - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6 + with: + node-version: 24.x + + - uses: pnpm/action-setup@0e279bb959325dab635dd2c09392533439d90093 # v6 + with: + package_json_file: docs/package.json + + - name: Setup Python environment + uses: algorandfoundation/algokit-shared-config/.github/actions/setup-algokit-python@main + with: + install-algokit: "false" + + - name: Generate API docs + run: uv run poe docs-api + + - name: Publish DevPortal Docs + uses: algorandfoundation/devportal/.github/actions/publish-devportal-docs@release/ak-v4 + with: + docs-dir: docs diff --git a/.github/workflows/verify-examples.yaml b/.github/workflows/verify-examples.yaml new file mode 100644 index 00000000..097b36c7 --- /dev/null +++ b/.github/workflows/verify-examples.yaml @@ -0,0 +1,26 @@ +name: Verify Examples + +on: [workflow_call] + +jobs: + verify-examples: + runs-on: ubuntu-latest + steps: + - name: Checkout source code + uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6 + + - name: Setup Python environment + uses: algorandfoundation/algokit-shared-config/.github/actions/setup-algokit-python@main + + - name: Install examples dependencies + run: cd examples && uv sync + + - name: Verify examples + run: | + cd examples + chmod +x verify-all.sh + ./verify-all.sh + + - name: Stop LocalNet + if: always() + run: algokit localnet stop diff --git a/.gitignore b/.gitignore index e7713f87..e13b043d 100644 --- a/.gitignore +++ b/.gitignore @@ -70,8 +70,15 @@ instance/ # Scrapy stuff: .scrapy -# Sphinx documentation -docs/_build/ +# Sphinx (API generation artifacts) +docs/sphinx/autoapi/ +docs/sphinx/.doctrees/ +docs/markdown/.doctrees/ + +# Starlight +docs/dist/ +docs/.astro/ +docs/node_modules/ # PyBuilder .pybuilder/ @@ -164,12 +171,26 @@ cython_debug/ # macOS .DS_Store -#Sphinx -.doctrees/ -# ignore auto-generated sources -/docs/source/apidocs - -!docs/html # Received approval test files *.received.* + +.references/ + +# Downloaded OAS specs (fetched from algokit-oas-generator) +api/specs/ + +# Note: schemas/ directories under client packages are NOT ignored +# They contain generated Pydantic validation schemas and should be committed + +*.xml + +.polytest*/ +polytest_resources/ +.algokit-* + +references/ + +AGENTS.md + +.claude/ diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 107998e0..ede5ec51 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,44 +1,77 @@ repos: + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v6.0.0 + hooks: + - id: end-of-file-fixer + exclude: | + (?x)^( + tests/_snapshots/.*\.approved\.txt$| + tests/applications/_snapshots/.*\.approved\.txt$| + tests/artifacts/.*\.(json|puya\.map)$ + ) + - id: trailing-whitespace + exclude: | + (?x)^( + tests/_snapshots/.*\.approved\.txt$| + tests/applications/_snapshots/.*\.approved\.txt$| + tests/artifacts/.*\.(json|puya\.map)$ + ) - repo: local hooks: - - id: ruff-format - name: ruff-format + - id: format + name: format description: "Run 'ruff format' for extremely fast Python formatting" - entry: poetry run ruff format + entry: uv run ruff format language: system types: [python] args: [] require_serial: true additional_dependencies: [] minimum_pre_commit_version: "2.9.2" - files: "^(src|tests)/" - - id: ruff - name: ruff - description: "Run 'ruff' for extremely fast Python linting" - entry: poetry run ruff check + pass_filenames: false + files: "^(src|tests|examples|api)/" + - id: generate-api-clients + name: generate-api-clients + description: "Generate API clients before linting" + entry: uv run poe generate-api-clients language: system - "types": [python] - args: [--fix] - require_serial: false - additional_dependencies: [] - minimum_pre_commit_version: "0" - files: "^(src|tests)/" - exclude: "^tests/artifacts/" - - id: mypy - name: mypy - description: "`mypy` will check Python types for correctness" - entry: poetry run mypy + types_or: [python, pyi] + args: [] + require_serial: true + pass_filenames: false + files: "^(src|tests|examples|api)/" + - id: lint + name: lint + description: "`mypy` and 'ruff' will check Python types for correctness" + entry: uv run poe lint language: system types_or: [python, pyi] + args: [] require_serial: true additional_dependencies: [] minimum_pre_commit_version: "2.9.2" - files: "^(src|tests)/" - exclude: "^tests/artifacts/" + pass_filenames: false + files: "^(src|tests|examples|api)/" + - id: docs + name: docs + description: "Build documentation (always passes)" + entry: bash -c 'uv run poe docs-build || true' + language: system + pass_filenames: false + always_run: true + verbose: true - id: docstrings-check name: docstrings-check description: "Check docstrings for correctness" - entry: poetry run poe docstrings-check + entry: uv run poe docstrings-check language: system types: [python] files: "^(src)/" + - id: test + name: test + description: "Run pytest as final validation" + entry: uv run pytest + language: system + pass_filenames: false + always_run: true + stages: [pre-commit] diff --git a/.vscode/launch.json b/.vscode/launch.json index 49cabdde..9eb8625b 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -1,23 +1,69 @@ { - "version": "0.2.0", - "configurations": [ - { - "name": "Python Debugger: Current File", - "type": "debugpy", - "request": "launch", - "program": "${file}", - "console": "integratedTerminal" - }, - { - "name": "Python: Debug Tests", - "type": "debugpy", - "request": "launch", - "program": "${file}", - "purpose": [ - "debug-test" - ], - "console": "integratedTerminal", - "justMyCode": false - } - ] + "version": "0.2.0", + "configurations": [ + { + "name": "Python Debugger: Current File", + "type": "debugpy", + "request": "launch", + "program": "${file}", + "console": "integratedTerminal" + }, + { + "name": "Python: Debug Tests", + "type": "debugpy", + "request": "launch", + "program": "${file}", + "purpose": ["debug-test"], + "console": "integratedTerminal", + "justMyCode": false + }, + { + "name": "Debug generate Algod Client", + "type": "debugpy", + "request": "launch", + "module": "oas_generator.cli", + "args": [ + "--spec", + "api/specs/algod.oas3.json", + "--out", + "src", + "--package", + "algokit_algod_client" + ], + "console": "integratedTerminal", + "cwd": "${workspaceFolder}" + }, + { + "name": "Debug generate Indexer Client", + "type": "debugpy", + "request": "launch", + "module": "oas_generator.cli", + "args": [ + "--spec", + "api/specs/indexer.oas3.json", + "--out", + "src", + "--package", + "algokit_indexer_client" + ], + "console": "integratedTerminal", + "cwd": "${workspaceFolder}" + }, + { + "name": "Debug generate KMD Client", + "type": "debugpy", + "request": "launch", + "module": "oas_generator.cli", + "args": [ + "--spec", + "api/specs/kmd.oas3.json", + "--out", + "src", + "--package", + "algokit_kmd_client" + ], + "console": "integratedTerminal", + "cwd": "${workspaceFolder}" + } + ] } diff --git a/.vscode/settings.json b/.vscode/settings.json index a1162966..95a45ac8 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -19,21 +19,11 @@ // Python "platformSettings.autoLoad": true, "python.defaultInterpreterPath": "${workspaceFolder}/.venv", - "python.analysis.extraPaths": [ - "${workspaceFolder}/src" - ], "[python]": { "editor.defaultFormatter": "charliermarsh.ruff" }, - "python.analysis.exclude": [ - "tests/artifacts/**" - ], - "python.analysis.typeCheckingMode": "basic", "ruff.enable": true, - "ruff.lint.run": "onSave", - "ruff.lint.args": [ - "--config=pyproject.toml" - ], + "ruff.configuration": "pyproject.toml", "ruff.importStrategy": "fromEnvironment", "ruff.fixAll": true, //lint and fix all files in workspace "ruff.organizeImports": true, //organize imports on save @@ -57,7 +47,5 @@ } ] }, - "python.testing.pytestArgs": [ - "." - ], + "python.testing.pytestArgs": ["tests"] } diff --git a/MIGRATION-NOTES.md b/MIGRATION-NOTES.md new file mode 100644 index 00000000..0c0efb48 --- /dev/null +++ b/MIGRATION-NOTES.md @@ -0,0 +1,314 @@ +# Migration Notes + +A collection of notes to consolidate todos during decoupling efforts (similar doc exists on ts version as well). + +## API + +### Generator + +- Currently generated models for KMD have explicit request models resulting in slightly different signatures in contrast with indexer and algod and requiring imports of explicit typed request models specifically on kmd client calls. Do we want to further refine the generation to auto flatten the keys to ensure it does not define an explicit request models or change those models to TypedDicts to reduce the import overhead? + +### Algod OAS + +- is_frozen field on models in algod is a boolean in the spec but actual returning value is an integer, serde must be updated to handle casting to bool. + +### KMD + +- algokit-core repo on a branch called feat/account-manager, we had a minor refinement in OAS spec for kmd adding a default value for wallet driver field as well as the generator adjustments to ensure generated model for related endpoint falls back to default 'sqlite' value. Do we want to restore this approach?: + +### Type annotations + +- Type hints and documentation now refer to the generated `algokit_algod_client.AlgodClient` (instead of `algosdk.v2client.algod.AlgodClient`). Update any downstream annotations or typing imports accordingly when migrating to v4. + +## ABI + +- decoding `byte`, `byte[]` and `byte[n]` now results in a python `bytes` type instead of `list[int]` +- encoding `byte` now accepts `bytes` or `int` types +- decoding `ufixed` types now returns a `decimal.Decimal` instead of an `int` +- encoding `ufixed` types now accepts a `decimal.Decimal` or an `int` +- tuple types decode to `tuple` instead of `list` +- Clarify on whether we are ok with dropping arc32 contracts from type unions in app spec params in app factory and app client + +### ABI return naming + +- Decide on naming for `ABIReturn` fields (e.g. `value` vs `return_value`, `raw_value` vs `raw_return_value`). +- Current branch aligns with the Rust approach where SDK and ABI variants of `ABIReturn` are merged into one abstraction; do we keep the same approach in the TS equivalent? + +## AlgoSDK primitives + +- What do we do with SourceMap abstraction? AlgoSDK version is more feature complete, while we also have a simple autogenerated sourcemap variant in algosdk. ts currently relies on ProgramSourceMap which is vendored from js algosdk. Do we drop the vendored variants completely and enhance api generator to hand roll a custom sourcemap variant we need and rely on that everywhere? Or do we move the vendored source map variant into the algokit-utils and enhance it there? + +- BoxReference used to be a subclass of algosdk BoxReference, now there is a direct equivalent imported from transact package. Do we want to keep aliasing the BoxReference to transact version or do we want to deprecate and advice consumers to import directly from transact? + +## Block Model Restructuring (TS Alignment) + +### Breaking Changes + +- `GetBlock` removed → use `BlockResponse` +- `BlockHeader` fields reorganized into nested types: + - `header.fee_sink` → `header.reward_state.fee_sink` + - `header.rewards_pool` → `header.reward_state.rewards_pool` + - `header.rewards_level` → `header.reward_state.rewards_level` + - `header.rewards_rate` → `header.reward_state.rewards_rate` + - `header.rewards_residue` → `header.reward_state.rewards_residue` + - `header.rewards_recalculation_round` → `header.reward_state.rewards_recalculation_round` + - `header.current_protocol` → `header.upgrade_state.current_protocol` + - `header.next_protocol` → `header.upgrade_state.next_protocol` + - `header.next_protocol_approvals` → `header.upgrade_state.next_protocol_approvals` + - `header.next_protocol_vote_before` → `header.upgrade_state.next_protocol_vote_before` + - `header.next_protocol_switch_on` → `header.upgrade_state.next_protocol_switch_on` + - `header.upgrade_propose` → `header.upgrade_vote.upgrade_propose` + - `header.upgrade_delay` → `header.upgrade_vote.upgrade_delay` + - `header.upgrade_approve` → `header.upgrade_vote.upgrade_approve` + - `header.transactions_root` → `header.txn_commitments.transactions_root` + - `header.transactions_root_sha256` → `header.txn_commitments.transactions_root_sha256` +- `BlockEvalDelta.bytes` → `BlockEvalDelta.bytes_value` (avoid Python keyword) +- `BlockAppEvalDelta.inner_txns` type changed: `SignedTxnInBlock` → `SignedTxnWithAD` +- `previous_block_hash` and `genesis_hash` now non-optional with `bytes(32)` defaults + +### Migration + +```python +# Before +from algokit_algod_client.models import GetBlock +response: GetBlock = algod_client.get_block(...) +fee_sink = response.block.header.fee_sink +protocol = response.block.header.current_protocol +proposal = response.block.header.upgrade_propose + +# After +from algokit_algod_client.models import BlockResponse +response: BlockResponse = algod_client.get_block(...) +fee_sink = response.block.header.reward_state.fee_sink +protocol = response.block.header.upgrade_state.current_protocol +proposal = response.block.header.upgrade_vote.upgrade_propose +``` + +## Fixed-Length Byte Validation + +### Breaking Changes + +- Runtime validation for fixed-length byte fields (32/64 bytes) +- `ValueError` raised if byte length doesn't match expected length +- Affects: `group`, `lease`, signatures, hashes, keys, commitment roots + +### Migration + +```python +# Validation now enforced at encode/decode +# 32-byte fields: group, lease, transaction hashes, block hashes, keys +# 64-byte fields: signatures, SHA-512 hashes + +# Before: silently accepted wrong lengths +txn.group = bytes(10) # No error + +# After: raises ValueError +txn.group = bytes(10) # ValueError: Expected 32 bytes, got 10 +txn.group = bytes(32) # OK +``` + +## Account and Signer Type Renames (TS Alignment) + +### Breaking Changes + +| Before | After | Notes | +|--------|-------|-------| +| `SigningAccount` | `AddressWithSigners` | Class renamed; `.address` → `.addr` | +| `TransactionSignerAccountProtocol` | `AddressWithTransactionSigner` | Protocol renamed; `.address` → `.addr` | +| `SignerAccountProtocol` | `AddressWithSigners` | Protocol merged into concrete class | +| `LsigSigner` | `DelegatedLsigSigner` | Type alias renamed | +| `AddressWithLsigSigner` | `AddressWithDelegatedLsigSigner` | Protocol renamed | + +### Justification + +- Aligns with `algokit-utils-ts` naming conventions +- Python uses `AddressWithTransactionSigner` despite having no `Address` type (unlike TS) for cross-SDK consistency +- The `addr` property matches TypeScript's `TransactionSignerAccount.addr` + +### Migration + +```python +# Before +from algokit_utils import SigningAccount, TransactionSignerAccountProtocol +account = SigningAccount(...) +print(account.address) + +# After +from algokit_utils.transact import AddressWithSigners, AddressWithTransactionSigner +account = AddressWithSigners(...) +print(account.addr) +``` + +## MultisigAccount and LogicSigAccount Relocation (TS Alignment) + +### Breaking Changes + +| Before | After | Notes | +|--------|-------|-------| +| `algokit_utils.models.account.MultisigAccount` | `algokit_transact.MultisigAccount` | Moved to transact package | +| `algokit_utils.models.account.MultisigMetadata` | `algokit_transact.MultisigMetadata` | Moved to transact package; `.addresses` → `.addrs` | +| `algokit_utils.models.account.LogicSigAccount` | `algokit_transact.LogicSigAccount` | Moved to transact package | + +### Justification + +- Aligns with `algokit-utils-ts` PR #465 which moved these classes to `@algorandfoundation/algokit-transact` +- `MultisigMetadata.addrs` matches TypeScript's `MultisigMetadata.addrs` property + +### Backward Compatibility + +Classes remain importable from original locations via re-exports: +- `algokit_utils.models.account` (re-exports from transact) +- `algokit_utils.transact` (re-exports from transact) + +### Migration + +```python +# Before +from algokit_utils.models.account import MultisigAccount, MultisigMetadata, LogicSigAccount +metadata = MultisigMetadata(version=1, threshold=2, addresses=["addr1", "addr2"]) + +# After (preferred) +from algokit_transact import MultisigAccount, MultisigMetadata, LogicSigAccount +metadata = MultisigMetadata(version=1, threshold=2, addrs=["addr1", "addr2"]) + +# Or via algokit_utils.transact +from algokit_utils.transact import MultisigAccount, MultisigMetadata, LogicSigAccount +``` + +## Contributing Guide + +- Introduce comprehensive contributing guide around running tests/updating snapshots in API client tests and dealing with Polytest + +## Polytest Integration + +Tracks polytest-generated API endpoint test coverage and **parity with `algokit-utils-ts`**. + +> Both Python and TypeScript use the same OAS spec (`fix/more-tweaks` from `algorandfoundation/algokit-oas-generator`) and skip the same endpoints (`private`, `experimental`, `Metrics`, `SwaggerJSON`, `GetBlockLogs`). The TS polytest config includes 13 extra endpoints that don't exist in either generated client. + +### Coverage Summary (Python vs TypeScript) + +| Client | Py Stubs | Py Impl | TS Stubs | TS Impl | Notes | +|--------|----------|---------|----------|---------|-------| +| Algod | 42 | 21 (50%) | 55 | 17 (31%) | TS has 13 orphan stubs for skipped endpoints | +| Indexer | 21 | 21 (100%) | 0 | 0 | TS has no indexer polytest config | +| KMD | 23 | 1 (4%) | 0 | 0 | TS has no KMD polytest config | + +### Algod Endpoint Coverage + +| Endpoint | Py | TS | Notes | +|----------|:--:|:--:|-------| +| `GET genesis` | ✅ | ✅ | | +| `GET health` | ✅ | ✅ | | +| `GET ready` | ✅ | ✅ | | +| `GET versions` | ✅ | ✅ | | +| `GET v2/accounts/{address}` | ✅ | ✅ | | +| `GET v2/accounts/{address}/applications/{app-id}` | ✅ | ✅ | | +| `GET v2/accounts/{address}/assets/{asset-id}` | ✅ | ✅ | | +| `GET v2/accounts/{address}/transactions/pending` | ✅ | ⬜ | | +| `GET v2/applications/{app-id}` | ✅ | ✅ | | +| `GET v2/applications/{app-id}/box` | ⬜ | ⬜ | | +| `GET v2/applications/{app-id}/boxes` | ⬜ | ⬜ | | +| `GET v2/assets/{asset-id}` | ✅ | ✅ | | +| `GET v2/blocks/{round}` | ✅ | ⬜ | | +| `GET v2/blocks/{round}/hash` | ✅ | ✅ | | +| `GET v2/blocks/{round}/lightheader/proof` | ✅ | ✅ | | +| `GET v2/blocks/{round}/transactions/{txid}/proof` | ⬜ | ⬜ | | +| `GET v2/blocks/{round}/txids` | ✅ | ✅ | | +| `GET v2/deltas/{round}` | ✅ | ⬜ | | +| `GET v2/deltas/{round}/txn/group` | ⬜ | ⬜ | | +| `GET v2/deltas/txn/group/{id}` | ⬜ | ⬜ | | +| `GET v2/devmode/blocks/offset` | ⬜ | ⬜ | Dev mode | +| `GET v2/experimental` | ⬜ | ⬜ | | +| `GET v2/ledger/supply` | ✅ | ✅ | | +| `GET v2/ledger/sync` | ✅ | ✅ | | +| `GET v2/stateproofs/{round}` | ⬜ | ⬜ | | +| `GET v2/status` | ✅ | ✅ | | +| `GET v2/status/wait-for-block-after/{round}` | ✅ | ✅ | | +| `GET v2/transactions/params` | ✅ | ✅ | | +| `GET v2/transactions/pending` | ✅ | ⬜ | | +| `GET v2/transactions/pending/{txid}` | ⬜ | ⬜ | | +| `DELETE v2/catchup/{catchpoint}` | ⬜ | ⬜ | Admin | +| `DELETE v2/ledger/sync` | ⬜ | ⬜ | Admin | +| `POST v2/catchup/{catchpoint}` | ⬜ | ⬜ | Admin | +| `POST v2/devmode/blocks/offset/{offset}` | ⬜ | ⬜ | Dev mode | +| `POST v2/ledger/sync/{round}` | ⬜ | ⬜ | Admin | +| `POST v2/shutdown` | ⬜ | ⬜ | Admin | +| `POST v2/teal/compile` | ⬜ | ⬜ | | +| `POST v2/teal/disassemble` | ⬜ | ⬜ | | +| `POST v2/teal/dryrun` | ⬜ | ⬜ | | +| `POST v2/transactions` | ⬜ | ⬜ | | +| `POST v2/transactions/async` | ⬜ | ⬜ | | +| `POST v2/transactions/simulate` | ⬜ | ⬜ | | + +**TS-only stubs (no client method):** `GET debug/settings/*`, `GET metrics`, `GET swagger.json`, `GET v2/accounts/{addr}/assets`, `GET v2/blocks/{round}/logs`, `*v2/participation/*` + +### Indexer Endpoint Coverage (Python only) + +| Endpoint | Py | +|----------|:--:| +| `GET health` | ✅ | +| `GET v2/accounts` | ✅ | +| `GET v2/accounts/{id}` | ✅ | +| `GET v2/accounts/{id}/apps-local-state` | ✅ | +| `GET v2/accounts/{id}/assets` | ✅ | +| `GET v2/accounts/{id}/created-applications` | ✅ | +| `GET v2/accounts/{id}/created-assets` | ✅ | +| `GET v2/accounts/{id}/transactions` | ✅ | +| `GET v2/applications` | ✅ | +| `GET v2/applications/{id}` | ✅ | +| `GET v2/applications/{id}/box` | ✅ | +| `GET v2/applications/{id}/boxes` | ✅ | +| `GET v2/applications/{id}/logs` | ✅ | +| `GET v2/assets` | ✅ | +| `GET v2/assets/{id}` | ✅ | +| `GET v2/assets/{id}/balances` | ✅ | +| `GET v2/assets/{id}/transactions` | ✅ | +| `GET v2/block-headers` | ✅ | +| `GET v2/blocks/{round}` | ✅ | +| `GET v2/transactions` | ✅ | +| `GET v2/transactions/{txid}` | ✅ | + +### KMD Endpoint Coverage (Python only) + +| Endpoint | Py | +|----------|:--:| +| `GET v1/wallets` | ✅ | +| `GET versions` | ⬜ | +| `GET swagger.json` | ⬜ | +| `DELETE v1/key` | ⬜ | +| `DELETE v1/multisig` | ⬜ | +| `POST v1/key` | ⬜ | +| `POST v1/key/export` | ⬜ | +| `POST v1/key/import` | ⬜ | +| `POST v1/key/list` | ⬜ | +| `POST v1/master-key/export` | ⬜ | +| `POST v1/multisig/*` (5 endpoints) | ⬜ | +| `POST v1/program/sign` | ⬜ | +| `POST v1/transaction/sign` | ⬜ | +| `POST v1/wallet` | ⬜ | +| `POST v1/wallet/info` | ⬜ | +| `POST v1/wallet/init` | ⬜ | +| `POST v1/wallet/release` | ⬜ | +| `POST v1/wallet/rename` | ⬜ | +| `POST v1/wallet/renew` | ⬜ | + +### Manual Tests + +| Client | Test | Description | +|--------|------|-------------| +| Algod | `manual/test_block.py` | Block endpoint against mainnet/testnet | +| Algod | `manual/test_ledger_state_delta.py` | Ledger state delta | +| Algod | `manual/test_pending_transaction_information.py` | Pending tx info on localnet | +| Algod | `manual/test_raw_transaction.py` | Raw tx broadcast on localnet | +| Algod | `manual/test_simulate_transactions.py` | Tx simulation with trace config | +| Algod | `manual/test_suggested_params.py` | Suggested params and error handling | +| Indexer | `manual/test_search_applications.py` | Search applications | +| Indexer | `manual/test_search_transactions.py` | Search/lookup transactions | +| KMD | `manual/test_wallet_lifecycle.py` | Wallet creation and listing | +| KMD | `manual/test_key_management.py` | Key generation and wallet handles | + +### Test Infrastructure + +- **Mock Server**: `ghcr.io/aorumbayev/polytest-mock-server:latest` (ports 18000-18002) +- **Parallel Execution**: `filelock` for xdist worker coordination +- **Config**: `tests/modules/conftest.py` diff --git a/README.md b/README.md index f1de931d..9d0a911d 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,7 @@ Largely these functions wrap the underlying Algorand SDK, but provide a higher l > **Note** > If you prefer TypeScript there's an equivalent [TypeScript utility library](https://github.com/algorandfoundation/algokit-utils-ts). -[Install](https://github.com/algorandfoundation/algokit-utils-py#install) | [Documentation](https://algorandfoundation.github.io/algokit-utils-py) +[Install](#install) | [Documentation](https://algorandfoundation.github.io/algokit-utils-py/) ## Install @@ -19,9 +19,35 @@ This library can be installed using pip, e.g.: pip install algokit-utils ``` +## Validation Schemas + +This repository includes Pydantic validation schemas for **development-time** validation of API client responses. These are test fixtures, not shipped as part of the published package. + +```python +from tests.fixtures.schemas.algod import AccountSchema, NodeStatusResponseSchema + +# Validate API responses +response = algod_client.status() +validated = NodeStatusResponseSchema.model_validate(response) +print(f"Last round: {validated.last_round}") +``` + +**Features:** +- Type validation (str, int, bool, etc.) +- Uint64 bounds checking (0 to 2^64-1) +- Nested schema support +- 208 schemas across algod, kmd, and indexer clients + +**For developers - regenerate schemas:** +```bash +poe generate-schemas +``` + +See [VALIDATION.md](./api/oas-generator/VALIDATION.md) for details. + ## Migration from `v2.x` to `v3.x` -Refer to the [v3 migration](./docs/source/v3-migration-guide.md) for more information on how to migrate to latest version of `algokit-utils-py`. +Refer to the [v3 migration guide](https://algorandfoundation.github.io/algokit-utils-py/migration/v3-migration-guide/) for more information on how to migrate to latest version of `algokit-utils-py`. ## Guiding principles @@ -37,3 +63,53 @@ To successfully run the tests in this repository you need to be running LocalNet ``` algokit localnet start ``` + +### Mock Server Tests + +Tests under `tests/modules/` use a mock server for deterministic API testing against pre-recorded HAR files. The mock server is managed externally (not by pytest). + +**In CI:** Mock servers are automatically started via the [algokit-polytest](https://github.com/algorandfoundation/algokit-polytest) GitHub Action. + +**Local development:** + +1. Clone algokit-polytest and start the mock servers: + +```bash +# Clone algokit-polytest (if not already) +git clone https://github.com/algorandfoundation/algokit-polytest.git + +# Start all mock servers (recommended) +cd algokit-polytest/resources/mock-server +./scripts/start_all_servers.sh +``` + +This starts algod (port 8000), kmd (port 8001), and indexer (port 8002) in the background. + +2. Set environment variables and run tests: + +```bash +export MOCK_ALGOD_URL=http://localhost:8000 +export MOCK_INDEXER_URL=http://localhost:8002 +export MOCK_KMD_URL=http://localhost:8001 + +# Run all module tests +pytest tests/modules/ + +# Or run specific client tests +pytest tests/modules/algod_client/ +``` + +3. Stop servers when done: + +```bash +cd algokit-polytest/resources/mock-server +./scripts/stop_all_servers.sh +``` + +| Environment Variable | Description | Default Port | +|---------------------|-------------|--------------| +| `MOCK_ALGOD_URL` | Algod mock server URL | 8000 | +| `MOCK_INDEXER_URL` | Indexer mock server URL | 8002 | +| `MOCK_KMD_URL` | KMD mock server URL | 8001 | + +Environment variables can also be set via `.env` file in project root (copy from `.env.template`). diff --git a/api/oas-generator/README.md b/api/oas-generator/README.md new file mode 100644 index 00000000..852e4ee4 --- /dev/null +++ b/api/oas-generator/README.md @@ -0,0 +1,53 @@ +# OAS Generator + +Local-only CLI that renders Algorand API clients from OpenAPI specs. + +## Layout + +```md +api/oas-generator/ +├── pyproject.toml # project config + console script +├── README.md # this file +└── src/oas_generator/ # generator package and templates +``` + +### Key modules + +- `cli.py` – argument parser and CLI entrypoint +- `parser.py` / `loader.py` – read & validate OpenAPI specs (supports local paths and URLs) +- `builder.py` / `models.py` – shape spec data for rendering +- `renderer/engine.py` / `filters.py` – Jinja environment and helpers +- `writer.py` – emit generated files into the target package + +### Template highlights + +- `templates/client.py.j2` – HTTP client implementation +- `templates/config.py.j2` – client configuration dataclass +- `templates/exceptions.py.j2` – error definitions surfaced by clients +- `templates/package_init.py.j2` – package-level exports +- `templates/types.py.j2` – shared type helpers +- `templates/models/*.j2` – request/response models and serde helpers + +## Usage + +The `--spec` argument accepts: +- **Local paths**: `api/specs/algod.oas3.json` +- **Remote URLs**: `https://raw.githubusercontent.com/.../algod.oas3.json` + +### Examples + +```bash +# Using a remote URL +uv run --project api/oas-generator python -m oas_generator.cli \ + --spec https://raw.githubusercontent.com/algorandfoundation/algokit-oas-generator/main/specs/algod.oas3.json \ + --out src \ + --package algokit_algod_client + +# Using a local path +uv run --project api/oas-generator python -m oas_generator.cli \ + --spec api/specs/algod.oas3.json \ + --out src \ + --package algokit_algod_client +``` + +Follow up with `uv run ruff check --fix` and `uv run ruff format` on the regenerated package to keep formatting tidy. diff --git a/api/oas-generator/VALIDATION.md b/api/oas-generator/VALIDATION.md new file mode 100644 index 00000000..20ed0793 --- /dev/null +++ b/api/oas-generator/VALIDATION.md @@ -0,0 +1,84 @@ +# Validation Schema Generator + +## Overview + +The validation schema generator creates Pydantic models from OpenAPI specifications for runtime validation of API client responses. This provides a sanity check layer on top of the generated API clients. + +> **Note**: Validation schemas are **optional**. Pydantic is a dev dependency, not required for production use of algokit-utils. + +## Usage + +### Generating Schemas + +```bash +# Using poe task +poe generate-schemas + +# Or directly +python scripts/generate_schemas.py +``` + +This fetches OpenAPI specs from GitHub and generates Pydantic schemas in: +- `tests/fixtures/schemas/algod/` (84 schemas) +- `tests/fixtures/schemas/kmd/` (50 schemas) +- `tests/fixtures/schemas/indexer/` (74 schemas) + +**Total: 208 validation schemas** + +### Using Schemas + +Use schemas for validation: +```python +from tests.fixtures.schemas.algod import AccountSchema, NodeStatusResponseSchema + +# Validate API response +response_data = algod_client.status() +validated = NodeStatusResponseSchema.model_validate(response_data) + +# Access validated data +print(f"Last round: {validated.last_round}") +``` + +## Features + +- **Type Validation**: Ensures fields match expected types (str, int, bool, etc.) +- **Uint64 Bounds**: Validates uint64 fields are within 0 to 2^64-1 +- **Nested Schemas**: Handles complex nested object structures +- **Array Types**: Supports both object and array-based schemas (RootModel) +- **Alias Support**: Maps hyphenated API field names to Python-friendly snake_case +- **Forward References**: Uses string annotations to handle cross-schema references + +## Testing + +Run validation tests: + +```bash +# All tests +pytest tests/modules/test_schema_validation.py -v + +# Exclude localnet tests +pytest tests/modules/test_schema_validation.py -v -m "not localnet" +``` + +Tests cover: +- Type validation (str, int, bool) +- Uint64 bounds checking +- Nested schema validation +- Schema imports + +## Maintenance + +Regenerate schemas when OpenAPI specs are updated: + +```bash +poe generate-schemas +``` + +The generator is decoupled from the OAS generator - it fetches specs independently and can be run anytime. + +## Files + +- **Generator**: `scripts/generate_schemas.py` (~170 lines) +- **Tests**: `tests/modules/test_schema_validation.py` +- **Dependencies**: `pydantic>=2.0.0,<3` (added to pyproject.toml) +- **Generated**: 208 schema files across 3 client packages diff --git a/api/oas-generator/pyproject.toml b/api/oas-generator/pyproject.toml new file mode 100644 index 00000000..227a1745 --- /dev/null +++ b/api/oas-generator/pyproject.toml @@ -0,0 +1,19 @@ +[project] +name = "oas-generator" +version = "0.1.0" +description = "Add your description here" +readme = "README.md" +requires-python = ">=3.10" +dependencies = [ + "jinja2>=3.1", +] + +[project.scripts] +oas-generator = "oas_generator.cli:main" + +[build-system] +requires = ["uv_build>=0.9.5,<0.10.0"] +build-backend = "uv_build" + +[tool.setuptools.packages.find] +where = ["src"] diff --git a/api/oas-generator/src/oas_generator/__init__.py b/api/oas-generator/src/oas_generator/__init__.py new file mode 100644 index 00000000..cf486084 --- /dev/null +++ b/api/oas-generator/src/oas_generator/__init__.py @@ -0,0 +1,5 @@ +"""Python OpenAPI generator package.""" + +__all__ = [ + "cli", +] diff --git a/api/oas-generator/src/oas_generator/builder.py b/api/oas-generator/src/oas_generator/builder.py new file mode 100644 index 00000000..ddc1bcea --- /dev/null +++ b/api/oas-generator/src/oas_generator/builder.py @@ -0,0 +1,1087 @@ +import re +from collections import defaultdict +from dataclasses import dataclass, field +from typing import Any, ClassVar + +from oas_generator import models as ctx +from oas_generator.naming import IdentifierSanitizer + + +@dataclass(slots=True) +class SchemaEntry: + name: str + schema: ctx.RawSchema + python_name: str + module_name: str + description: str | None + kind: str + synthetic: bool = False + + +@dataclass(slots=True) +class TypeInfo: + annotation: str + model: str | None = None + enum: str | None = None + is_list: bool = False + list_inner_model: str | None = None + list_inner_enum: str | None = None + is_bytes: bool = False + is_bytes_b64: bool = False # True for x-algokit-bytes-base64 fields (always base64 encoded) + list_inner_is_bytes: bool = False + list_inner_is_bytes_b64: bool = False # True for x-algokit-bytes-base64 list items + is_signed_transaction: bool = False + is_box_reference: bool = False + is_locals_reference: bool = False + is_holding_reference: bool = False + needs_datetime: bool = False + byte_length: int | None = None # Fixed byte length from x-algokit-byte-length + list_inner_byte_length: int | None = None # Fixed byte length for list items + imports: set[str] = field(default_factory=set) + + +LEDGER_STATE_DELTA_MODEL_NAMES: set[str] = { + "LedgerStateDelta", + "LedgerStateDeltaForTransactionGroup", + "TransactionGroupLedgerStateDeltasForRound", + "TransactionGroupLedgerStateDeltasForRoundResponseModel", +} + + +def _get_import_module(python_name: str, default_module: str) -> str: + """Get the correct module name for importing a model. + + Models in LEDGER_STATE_DELTA_MODEL_NAMES are defined in the custom + _ledger_state_delta template, not in individual module files. + """ + if python_name in LEDGER_STATE_DELTA_MODEL_NAMES: + return "_ledger_state_delta" + return default_module + + +class SchemaRegistry: + def __init__(self, spec: ctx.ParsedSpec, sanitizer: IdentifierSanitizer) -> None: + self.spec = spec + self.sanitizer = sanitizer + self.entries: dict[str, SchemaEntry] = {} + self.entries_by_python_name: dict[str, SchemaEntry] = {} + self._name_collisions: set[str] = set() + self._synthetic_index = 0 + self._register_components() + + def _register_components(self) -> None: + for name in sorted(self.spec.schemas): + schema = self.spec.schemas[name] + self._register_entry(name, schema, synthetic=False) + + def _register_entry( + self, + name: str, + schema: ctx.RawSchema, + *, + synthetic: bool, + preferred_python_name: str | None = None, + ) -> SchemaEntry: + raw_name = preferred_python_name or schema.get("title") or name + python_name = self._unique_python_name(raw_name) + module_name = self.sanitizer.module(python_name) + entry = SchemaEntry( + name=name, + schema=schema, + python_name=python_name, + module_name=module_name, + description=schema.get("description"), + kind=self._classify(schema), + synthetic=synthetic, + ) + self.entries[name] = entry + self.entries_by_python_name[python_name] = entry + return entry + + def _unique_python_name(self, raw: str) -> str: + candidate = self.sanitizer.pascal(raw) + base = candidate + index = 1 + while candidate in self._name_collisions: + index += 1 + candidate = f"{base}{index}" + self._name_collisions.add(candidate) + return candidate + + def register_inline(self, hint: str, schema: ctx.RawSchema) -> SchemaEntry: + self._synthetic_index += 1 + synthetic_key = f"inline_{self._synthetic_index}_{hint}" + return self._register_entry( + synthetic_key, + schema, + synthetic=True, + preferred_python_name=hint, + ) + + def _classify(self, schema: ctx.RawSchema) -> str: + if schema.get("enum"): + return "enum" + if schema.get("x-algokit-signed-txn"): + return "signed" + if schema.get("x-algokit-box-reference"): + return "box_reference" + if schema.get("x-algokit-locals-reference"): + return "locals_reference" + if schema.get("x-algokit-holding-reference"): + return "holding_reference" + if schema.get("type") == "object" or schema.get("properties"): + return "model" + return "alias" + + +class TypeResolver: + def __init__(self, registry: SchemaRegistry) -> None: + self.registry = registry + + def _is_array_of_uint8(self, schema: ctx.RawSchema) -> bool: + """Check if a schema represents an array of uint8 integers (should be bytes). + + This detects schemas like: + { + "type": "array", + "items": { + "type": "integer", + "format": "uint8" + } + } + """ + if not isinstance(schema, dict): + return False + + # Check if this is a $ref to another schema + if "$ref" in schema: + ref_name = schema["$ref"].split("/")[-1] + if ref_name in self.registry.entries: + ref_schema = self.registry.entries[ref_name].schema + return self._is_array_of_uint8(ref_schema) + + if schema.get("type") != "array": + return False + + items = schema.get("items") + if not isinstance(items, dict): + return False + + # Check if items are integers with uint8 format + return items.get("type") == "integer" and items.get("format") == "uint8" + + def resolve(self, schema: ctx.RawSchema, *, hint: str = "Inline") -> TypeInfo: + schema = schema or {} + schema_type = schema.get("type") + nullable = bool(schema.get("nullable")) + if isinstance(schema_type, list): + if "null" in schema_type: + nullable = True + schema_type = [t for t in schema_type if t != "null"] + schema_type = schema_type[0] if len(schema_type) == 1 else None + if "$ref" in schema: + ref_name = schema["$ref"].split("/")[-1] + entry = self.registry.entries[ref_name] + info = self._type_from_entry(entry, hint=entry.python_name) + return self._maybe_optional(info, nullable=nullable) + if schema.get("x-algokit-signed-txn"): + info = TypeInfo(annotation="SignedTransaction", model="SignedTransaction", is_signed_transaction=True) + return self._maybe_optional(info, nullable=nullable) + if schema.get("x-algokit-box-reference"): + info = TypeInfo(annotation="BoxReference", model="BoxReference", is_box_reference=True) + return self._maybe_optional(info, nullable=nullable) + if schema.get("x-algokit-locals-reference"): + info = TypeInfo(annotation="LocalsReference", model="LocalsReference", is_locals_reference=True) + return self._maybe_optional(info, nullable=nullable) + if schema.get("x-algokit-holding-reference"): + info = TypeInfo(annotation="HoldingReference", model="HoldingReference", is_holding_reference=True) + return self._maybe_optional(info, nullable=nullable) + if schema_type == "array": + info = self._resolve_array(schema, hint=hint) + return self._maybe_optional(info, nullable=nullable) + if schema_type == "object" and schema.get("properties"): + entry = self.registry.register_inline(f"{hint}Model", schema) + info = TypeInfo(annotation=entry.python_name, model=entry.python_name) + return self._maybe_optional(info, nullable=nullable) + if schema_type == "string": + fmt = schema.get("format") + is_bytes_b64 = bool(schema.get("x-algokit-bytes-base64")) + if fmt in {"byte", "binary"} or is_bytes_b64: + # Extract fixed byte length if present + byte_length_val = schema.get("x-algokit-byte-length") + byte_length = int(byte_length_val) if byte_length_val is not None else None + info = TypeInfo(annotation="bytes", is_bytes=True, is_bytes_b64=is_bytes_b64, byte_length=byte_length) + elif fmt == "date-time": + info = TypeInfo( + annotation="datetime", + needs_datetime=True, + imports={"from datetime import datetime"}, + ) + else: + info = TypeInfo(annotation="str") + return self._maybe_optional(info, nullable=nullable) + if schema_type == "integer": + return self._maybe_optional(TypeInfo(annotation="int"), nullable=nullable) + if schema_type == "number": + return self._maybe_optional(TypeInfo(annotation="float"), nullable=nullable) + if schema_type == "boolean": + return self._maybe_optional(TypeInfo(annotation="bool"), nullable=nullable) + if schema.get("enum"): + entry = self.registry.register_inline(f"{hint}Enum", schema) + info = TypeInfo(annotation=entry.python_name, enum=entry.python_name) + return self._maybe_optional(info, nullable=nullable) + if schema_type == "object": + return self._maybe_optional(TypeInfo(annotation="dict[str, object]"), nullable=nullable) + return self._maybe_optional(TypeInfo(annotation="object"), nullable=nullable) + + def _type_from_entry(self, entry: SchemaEntry, *, hint: str) -> TypeInfo: + if entry.kind == "model": + return TypeInfo(annotation=entry.python_name, model=entry.python_name) + if entry.kind == "enum": + return TypeInfo(annotation=entry.python_name, enum=entry.python_name) + if entry.kind == "signed": + return TypeInfo(annotation="SignedTransaction", model="SignedTransaction", is_signed_transaction=True) + if entry.kind == "box_reference": + return TypeInfo(annotation="BoxReference", model="BoxReference", is_box_reference=True) + if entry.kind == "locals_reference": + return TypeInfo(annotation="LocalsReference", model="LocalsReference", is_locals_reference=True) + if entry.kind == "holding_reference": + return TypeInfo(annotation="HoldingReference", model="HoldingReference", is_holding_reference=True) + return self.resolve(entry.schema, hint=hint) + + def _resolve_array(self, schema: ctx.RawSchema, *, hint: str) -> TypeInfo: + items = schema.get("items") or {"type": "object"} + + # Check if this is an array of uint8 integers (should be bytes) + if self._is_array_of_uint8(schema): + return TypeInfo(annotation="bytes", is_bytes=True) + + inner = self.resolve(items, hint=f"{hint}Item") + annotation = f"list[{inner.annotation}]" + return TypeInfo( + annotation=annotation, + is_list=True, + list_inner_model=inner.model, + list_inner_enum=inner.enum, + list_inner_is_bytes=inner.is_bytes, + list_inner_is_bytes_b64=inner.is_bytes_b64, + list_inner_byte_length=inner.byte_length, + is_signed_transaction=inner.is_signed_transaction, + is_box_reference=inner.is_box_reference, + is_locals_reference=inner.is_locals_reference, + is_holding_reference=inner.is_holding_reference, + needs_datetime=inner.needs_datetime, + imports=set(inner.imports), + ) + + def _maybe_optional(self, info: TypeInfo, *, nullable: bool) -> TypeInfo: + if nullable and "| None" not in info.annotation: + info.annotation = f"{info.annotation} | None" + return info + + +class ModelBuilder: + def __init__(self, registry: SchemaRegistry, resolver: TypeResolver, sanitizer: IdentifierSanitizer) -> None: + self.registry = registry + self.resolver = resolver + self.sanitizer = sanitizer + self.uses_signed_transaction = False + self.uses_box_reference = False + self.uses_locals_reference = False + self.uses_holding_reference = False + + def _compute_default_value(self, type_info: TypeInfo, prop_schema: ctx.RawSchema) -> str | None: + """Compute default value for a required field based on its type. + + This mirrors the TypeScript codec approach where each codec has a defaultValue(): + - string → "" + - int → 0 + - bool → False + - bytes → b"" + - list → [] (uses default_factory) + - address (x-algorand-format: Address) → ZERO_ADDRESS + - nested models → None (will use default_factory) + + Returns: + A string representation of the default value, or None if default_factory should be used. + """ + # Check for address format (algorand addresses get ZERO_ADDRESS) + algorand_format = prop_schema.get("x-algorand-format") + if algorand_format == "Address": + return "ZERO_ADDRESS" + + # Handle primitive types based on annotation + annotation = type_info.annotation + + # Strip Optional wrapper if present (shouldn't be for required fields, but be safe) + base_type = annotation.replace(" | None", "").strip() + + if base_type == "str": + return '""' + if base_type == "int": + return "0" + if base_type == "float": + return "0.0" + if base_type == "bool": + return "False" + if base_type == "bytes": + return 'b""' + + # Lists need default_factory - return None to signal this + if type_info.is_list or base_type.startswith("list["): + return None # Will use default_factory=list + + # Nested models - return None (they'll remain without default) + if type_info.model: + return None + + # Enums - return None (no sensible default) + if type_info.enum: + return None + + # datetime - return None + if type_info.needs_datetime: + return None + + # dict types - return None (will use default_factory) + if base_type.startswith("dict[") or base_type == "dict[str, object]": + return None + + # object type - no sensible default + if base_type == "object": + return None + + return None + + def build(self) -> tuple[list[ctx.ModelDescriptor], list[ctx.EnumDescriptor], list[ctx.TypeAliasDescriptor]]: + models: list[ctx.ModelDescriptor] = [] + enums: list[ctx.EnumDescriptor] = [] + aliases: list[ctx.TypeAliasDescriptor] = [] + + pending = sorted(self.registry.entries.keys()) + processed: set[str] = set() + while pending: + name = pending.pop(0) + if name in processed: + continue + processed.add(name) + entry = self.registry.entries[name] + if entry.kind == "model": + models.append(self._build_model(entry)) + elif entry.kind == "enum": + enums.append(self._build_enum(entry)) + elif entry.kind in ("signed", "box_reference", "locals_reference", "holding_reference"): + # These are imported from algokit_transact, not generated + pass + elif entry.kind == "alias": + alias_type = self.resolver.resolve(entry.schema).annotation + alias_imports = self._collect_alias_imports(alias_type, entry) + aliases.append( + ctx.TypeAliasDescriptor( + name=entry.python_name, + module_name=entry.module_name, + target=alias_type, + imports=alias_imports, + ) + ) + for candidate in sorted(self.registry.entries.keys()): + if candidate not in processed and candidate not in pending: + pending.append(candidate) + pending.sort() + return models, enums, aliases + + def _build_model(self, entry: SchemaEntry) -> ctx.ModelDescriptor: # noqa: PLR0915 + properties = entry.schema.get("properties", {}) or {} + required = set(entry.schema.get("required", []) or []) + fields: list[ctx.ModelField] = [] + imports: set[str] = set() + uses_nested = False + uses_flatten = False + uses_enum_value = False + needs_any = False + + for prop_name in sorted(properties): + prop_schema = properties[prop_name] or {} + wire_name = prop_name + python_name_hint = prop_schema.get("x-algokit-field-rename") or prop_name + type_info = self.resolver.resolve(prop_schema, hint=entry.python_name + self.sanitizer.pascal(prop_name)) + if type_info.is_signed_transaction: + self.uses_signed_transaction = True + imports.add("from algokit_transact.models.signed_transaction import SignedTransaction") + if type_info.is_box_reference: + self.uses_box_reference = True + imports.add("from algokit_transact.models.app_call import BoxReference") + if type_info.is_locals_reference: + self.uses_locals_reference = True + imports.add("from algokit_transact.models.app_call import LocalsReference") + if type_info.is_holding_reference: + self.uses_holding_reference = True + imports.add("from algokit_transact.models.app_call import HoldingReference") + annotation = type_info.annotation + if prop_name not in required and "| None" not in annotation: + annotation = f"{annotation} | None" + annotation = self._apply_forward_reference_annotation(annotation, entry, type_info) + + # Compute default value and factory + default_value: str | None = None + default_factory: str | None = None + + # Check for schema-level default value + schema_default = prop_schema.get("default") + + if prop_name in required: + # Required fields get type-appropriate defaults to handle canonical msgpack encoding + computed_default = self._compute_default_value(type_info, prop_schema) + if computed_default is not None: + default_value = computed_default + # Add ZERO_ADDRESS import if needed + if computed_default == "ZERO_ADDRESS": + imports.add("from algokit_common.constants import ZERO_ADDRESS") + elif type_info.is_list: + # Lists use default_factory=list + default_factory = "list" + # Optional fields: use schema default if provided, otherwise None + elif schema_default is not None: + # Format the default value based on type + if isinstance(schema_default, str): + default_value = f'"{schema_default}"' + elif isinstance(schema_default, bool | (int | float)): + default_value = str(schema_default) + else: + default_value = "None" + else: + default_value = "None" + + field = ctx.ModelField( + name=self.sanitizer.snake(python_name_hint), + wire_name=wire_name, + type_hint=annotation, + required=prop_name in required, + description=prop_schema.get("description"), + metadata=self._build_metadata(wire_name, type_info, required=prop_name in required), + default_value=default_value, + default_factory=default_factory, + ) + imports.update(type_info.imports) + if type_info.model and type_info.model != entry.python_name: + dep_entry = self.registry.entries_by_python_name.get(type_info.model) + if dep_entry: + dep_module = _get_import_module(dep_entry.python_name, dep_entry.module_name) + if dep_module != entry.module_name: + imports.add(f"from .{dep_module} import {dep_entry.python_name}") + if type_info.list_inner_model: + # Handle special external types first + if type_info.list_inner_model == "SignedTransaction": + imports.add("from algokit_transact.models.signed_transaction import SignedTransaction") + elif type_info.list_inner_model == "BoxReference" and type_info.is_box_reference: + imports.add("from algokit_transact.models.app_call import BoxReference") + elif type_info.list_inner_model == "LocalsReference" and type_info.is_locals_reference: + imports.add("from algokit_transact.models.app_call import LocalsReference") + elif type_info.list_inner_model == "HoldingReference" and type_info.is_holding_reference: + imports.add("from algokit_transact.models.app_call import HoldingReference") + else: + # Only add local import if not a special external type + dep_entry = self.registry.entries_by_python_name.get(type_info.list_inner_model) + if dep_entry: + dep_module = _get_import_module(dep_entry.python_name, dep_entry.module_name) + if dep_module != entry.module_name: + imports.add(f"from .{dep_module} import {dep_entry.python_name}") + if type_info.enum: + dep_entry = self.registry.entries_by_python_name.get(type_info.enum) + if dep_entry: + imports.add(f"from .{dep_entry.module_name} import {dep_entry.python_name}") + if type_info.list_inner_enum: + dep_entry = self.registry.entries_by_python_name.get(type_info.list_inner_enum) + if dep_entry: + imports.add(f"from .{dep_entry.module_name} import {dep_entry.python_name}") + if "encode_model_sequence" in field.metadata or "decode_model_sequence" in field.metadata: + imports.add("from ._serde_helpers import decode_model_sequence, encode_model_sequence") + if "encode_enum_sequence" in field.metadata or "decode_enum_sequence" in field.metadata: + imports.add("from ._serde_helpers import decode_enum_sequence, encode_enum_sequence") + if "encode_model_mapping" in field.metadata or "mapping_encoder" in field.metadata: + imports.add("from ._serde_helpers import encode_model_mapping, mapping_encoder") + if "decode_model_mapping" in field.metadata or "mapping_decoder" in field.metadata: + imports.add("from ._serde_helpers import decode_model_mapping, mapping_decoder") + if "encode_bytes" in field.metadata or "decode_bytes" in field.metadata: + imports.add("from ._serde_helpers import decode_bytes, encode_bytes") + if "decode_bytes_base64" in field.metadata: + imports.add("from ._serde_helpers import decode_bytes_base64, encode_bytes") + if "encode_bytes_sequence" in field.metadata or "decode_bytes_sequence" in field.metadata: + imports.add("from ._serde_helpers import decode_bytes_sequence, encode_bytes_sequence") + if "encode_fixed_bytes" in field.metadata or "decode_fixed_bytes" in field.metadata: + imports.add("from ._serde_helpers import decode_fixed_bytes, encode_fixed_bytes") + if "encode_fixed_bytes_sequence" in field.metadata or "decode_fixed_bytes_sequence" in field.metadata: + imports.add("from ._serde_helpers import decode_fixed_bytes_sequence, encode_fixed_bytes_sequence") + if "nested(" in field.metadata: + uses_nested = True + if "flatten(" in field.metadata: + uses_flatten = True + if "enum_value(" in field.metadata: + uses_enum_value = True + if "Any" in field.type_hint: + needs_any = True + imports.add("from typing import Any") + fields.append(field) + + # Sort fields: required without defaults first, then required with defaults, then optional + # This ensures dataclass field ordering rules are satisfied (non-default before default) + def field_sort_key(f: ctx.ModelField) -> tuple[int, str]: + has_default = f.default_value is not None or f.default_factory is not None + if f.required and not has_default: + return (0, f.name) # Required without default: first + elif f.required and has_default: + return (1, f.name) # Required with default: second + else: + return (2, f.name) # Optional (always has default): third + + fields.sort(key=field_sort_key) + return ctx.ModelDescriptor( + name=entry.python_name, + module_name=entry.module_name, + description=entry.description, + fields=fields, + imports=sorted(imports), + requires_datetime=any("datetime" in imp for imp in imports), + uses_nested=uses_nested, + uses_flatten=uses_flatten, + uses_enum_value=uses_enum_value, + needs_any=needs_any, + ) + + def _apply_forward_reference_annotation(self, annotation: str, entry: SchemaEntry, type_info: TypeInfo) -> str: + forward_refs = self._forward_reference_tokens(entry, type_info) + if not forward_refs: + return annotation + if self._requires_direct_forward_reference(entry, type_info): + stripped = annotation.strip() + if stripped.startswith(('"', "'")) and stripped.endswith(('"', "'")): + return annotation + return f'"{stripped}"' + for token in sorted(forward_refs, key=len, reverse=True): + if annotation == token: + annotation = f'"{token}"' + continue + if re.fullmatch(rf"\s*{re.escape(token)}\s*\|\s*None\s*", annotation): + annotation = f'"{annotation.strip()}"' + continue + if re.fullmatch(rf"\s*None\s*\|\s*{re.escape(token)}\s*", annotation): + annotation = f'"{annotation.strip()}"' + continue + pattern = rf'(? set[str]: + tokens: set[str] = set() + for ref_name in filter(None, [type_info.model, type_info.enum]): + if self._is_same_module(entry, ref_name): + tokens.add(ref_name) + for ref_name in filter(None, [type_info.list_inner_model, type_info.list_inner_enum]): + if self._is_same_module(entry, ref_name): + tokens.add(ref_name) + return tokens + + def _requires_direct_forward_reference(self, entry: SchemaEntry, type_info: TypeInfo) -> bool: + if not type_info.model: + return False + if type_info.model in ("SignedTransaction", "BoxReference", "LocalsReference", "HoldingReference"): + return False + if type_info.model == entry.python_name: + return True + dep_entry = self.registry.entries_by_python_name.get(type_info.model) + return bool(dep_entry and dep_entry.module_name == entry.module_name) + + def _is_same_module(self, entry: SchemaEntry, ref_name: str) -> bool: + if ref_name == entry.python_name: + return True + dep_entry = self.registry.entries_by_python_name.get(ref_name) + return bool(dep_entry and dep_entry.module_name == entry.module_name) + + def _build_enum(self, entry: SchemaEntry) -> ctx.EnumDescriptor: + members: list[ctx.EnumValue] = [] + for value in entry.schema.get("enum", []) or []: + member_name = self.sanitizer.const(str(value)) + members.append(ctx.EnumValue(member_name=member_name, value=value)) + return ctx.EnumDescriptor( + name=entry.python_name, + module_name=entry.module_name, + values=members, + description=entry.description, + ) + + def _build_metadata(self, wire_name: str, type_info: TypeInfo, *, required: bool = False) -> str: + alias = wire_name.replace('"', '\\"') + if type_info.model and not type_info.is_list: + # Pass required flag for nested fields to enable default instance construction + if required: + return f'nested("{alias}", lambda: {type_info.model}, required=True)' + return f'nested("{alias}", lambda: {type_info.model})' + if type_info.enum and not type_info.is_list: + return f'enum_value("{alias}", {type_info.enum})' + if type_info.is_list and type_info.list_inner_model: + return ( + "wire(\n" + f' "{alias}",\n' + " encode=encode_model_sequence,\n" + f" decode=lambda raw: decode_model_sequence(lambda: {type_info.list_inner_model}, raw),\n" + " )" + ) + if type_info.is_list and type_info.list_inner_enum: + return ( + "wire(\n" + f' "{alias}",\n' + " encode=encode_enum_sequence,\n" + f" decode=lambda raw: decode_enum_sequence(lambda: {type_info.list_inner_enum}, raw),\n" + " )" + ) + if type_info.is_list and type_info.list_inner_is_bytes: + # Handle fixed-length bytes in sequences + if type_info.list_inner_byte_length is not None: + return ( + "wire(\n" + f' "{alias}",\n' + f" encode=lambda v: encode_fixed_bytes_sequence(v, {type_info.list_inner_byte_length}),\n" + f" decode=lambda raw: decode_fixed_bytes_sequence(raw, {type_info.list_inner_byte_length}),\n" + " )" + ) + return ( + "wire(\n" + f' "{alias}",\n' + " encode=encode_bytes_sequence,\n" + " decode=decode_bytes_sequence,\n" + " )" + ) + if type_info.is_bytes: + # Use decode_bytes_base64 for fields marked with x-algokit-bytes-base64 + decode_fn = "decode_bytes_base64" if type_info.is_bytes_b64 else "decode_bytes" + # Handle fixed-length bytes + if type_info.byte_length is not None: + return ( + "wire(\n" + f' "{alias}",\n' + f" encode=lambda v: encode_fixed_bytes(v, {type_info.byte_length}),\n" + f" decode=lambda raw: decode_fixed_bytes(raw, {type_info.byte_length}),\n" + " )" + ) + return ( + "wire(\n" + f' "{alias}",\n' + " encode=encode_bytes,\n" + f" decode={decode_fn},\n" + " )" + ) + if type_info.is_signed_transaction: + return f'nested("{alias}", lambda: SignedTransaction)' + if type_info.is_box_reference: + return f'nested("{alias}", lambda: BoxReference)' + if type_info.is_locals_reference: + return f'nested("{alias}", lambda: LocalsReference)' + if type_info.is_holding_reference: + return f'nested("{alias}", lambda: HoldingReference)' + return f'wire("{alias}")' + + def _collect_alias_imports(self, annotation: str, entry: SchemaEntry) -> list[str]: + imports: set[str] = set() + tokens = set(re.findall(r"[A-Za-z_][A-Za-z0-9_]*", annotation)) + builtins = { + "list", + "dict", + "set", + "tuple", + "frozenset", + "Optional", + "Union", + "Literal", + "int", + "float", + "str", + "bool", + "object", + } + for token in tokens: + if token in builtins or token == entry.python_name: + continue + if token == "Any": + imports.add("from typing import Any") + continue + if token == "SignedTransaction": + imports.add("from algokit_transact.models.signed_transaction import SignedTransaction") + continue + if token == "BoxReference": + imports.add("from algokit_transact.models.app_call import BoxReference") + continue + if token == "LocalsReference": + imports.add("from algokit_transact.models.app_call import LocalsReference") + continue + if token == "HoldingReference": + imports.add("from algokit_transact.models.app_call import HoldingReference") + continue + dep_entry = self.registry.entries_by_python_name.get(token) + if dep_entry: + imports.add(f"from .{dep_entry.module_name} import {dep_entry.python_name}") + if "Any" in annotation: + imports.add("from typing import Any") + return sorted(imports) + + +class OperationBuilder: + RAW_LEDGER_STATE_DELTA_OPERATIONS: ClassVar[set[str]] = { + "LedgerStateDelta", + "LedgerStateDeltaForTransactionGroup", + "TransactionGroupLedgerStateDeltasForRound", + } + ALGOD_PRIVATE_OPERATIONS: ClassVar[set[str]] = { + "RawTransaction", + "ApplicationBoxByName", + "TransactionParams", + } + SKIP_TAGS: ClassVar[set[str]] = {"private", "experimental", "skip"} + + def __init__( + self, + spec: ctx.ParsedSpec, + resolver: TypeResolver, + sanitizer: IdentifierSanitizer, + registry: SchemaRegistry, + client_key: str, + ) -> None: + self.spec = spec + self.resolver = resolver + self.sanitizer = sanitizer + self.registry = registry + self.client_key = client_key + self.uses_signed_transaction = False + self.uses_msgpack = False + self.uses_block_models = False + self.uses_ledger_state_delta = False + self.uses_literal = False + self.used_schema_refs: set[str] = set() + + def build(self) -> list[ctx.OperationGroup]: + grouped: dict[str, list[ctx.OperationDescriptor]] = defaultdict(list) + for path, path_item in sorted(self.spec.paths.items()): + for method, operation in path_item.items(): + if method.lower() not in {"get", "post", "put", "delete", "patch"}: + continue + op_id = operation.get("operationId", "") + tags = operation.get("tags") or ["default"] + # Check if operation should be skipped before building + if self._should_skip_operation(op_id, tags): + continue + # Collect schema refs from kept operations + self._collect_schema_refs(operation, self.used_schema_refs) + descriptor = self._build_operation(path, method.upper(), operation) + grouped[descriptor.tag].append(descriptor) + result: list[ctx.OperationGroup] = [] + for tag, operations in grouped.items(): + operations.sort(key=lambda op: op.name) + result.append(ctx.OperationGroup(tag=tag, operations=operations)) + return sorted(result, key=lambda group: group.tag) + + def _build_operation(self, path: str, method: str, op: dict[str, Any]) -> ctx.OperationDescriptor: + operation_id = op.get("operationId") or self._derive_operation_id(method, path) + tags = op.get("tags") or ["default"] + tag = tags[0] + parameters, format_info = self._build_parameters(op.get("parameters", [])) + request_body = self._build_request_body(op.get("requestBody"), operation_id) + response = self._build_response(op.get("responses", {}), operation_id) + path_params = [p for p in parameters if p.location == "path"] + query_params = [p for p in parameters if p.location == "query"] + header_params = [p for p in parameters if p.location == "header"] + format_options: list[str] | None = None + format_default: str | None = None + format_required = False + format_single: str | None = None + if format_info: + fmt_enum = format_info.get("enum") or [] + format_required = format_info.get("required", False) + format_default = format_info.get("default") + if len(fmt_enum) == 1: + format_single = fmt_enum[0] + if format_default is None: + format_default = format_single + elif fmt_enum: + format_options = list(fmt_enum) + if format_default is not None and format_default not in format_options: + format_default = None + if len(format_options) > 1: + self.uses_literal = True + else: + format_single = None + sanitized_name = self.sanitizer.snake(operation_id) + is_private = self._is_private_operation(operation_id) + if is_private and not sanitized_name.startswith("_"): + sanitized_name = f"_{sanitized_name}" + return ctx.OperationDescriptor( + name=sanitized_name, + http_method=method, + path=path, + summary=op.get("summary"), + description=op.get("description"), + tag=tag, + parameters=parameters, + path_parameters=path_params, + query_parameters=query_params, + header_parameters=header_params, + request_body=request_body, + response=response, + operation_id=operation_id, + format_options=format_options, + format_default=format_default, + format_required=format_required, + format_single=format_single, + is_private=is_private, + ) + + def _derive_operation_id(self, method: str, path: str) -> str: + slug = path.strip("/").replace("/", "_").replace("{", "").replace("}", "") + raw = f"{method}_{slug}" if slug else method + return self.sanitizer.pascal(raw) + + def _is_private_operation(self, operation_id: str) -> bool: + if self.client_key == ctx.ClientType.ALGOD_CLIENT: + return operation_id in self.ALGOD_PRIVATE_OPERATIONS + return False + + def _should_skip_operation(self, operation_id: str, tags: list[str]) -> bool: + """Check if an operation should be skipped from generation. + + Operations are skipped if they have any tags that match SKIP_TAGS + ('private', 'experimental', 'skip'). + """ + return any(tag in self.SKIP_TAGS for tag in tags) + + def _collect_schema_refs(self, obj: Any, refs: set[str]) -> None: + """Recursively collect all schema $ref names from an object.""" + if isinstance(obj, dict): + if "$ref" in obj: + ref = obj["$ref"] + if ref.startswith("#/components/schemas/"): + schema_name = ref.split("/")[-1] + if schema_name not in refs: + refs.add(schema_name) + # Also collect refs from the schema itself (for nested refs) + schema = self.spec.schemas.get(schema_name, {}) + self._collect_schema_refs(schema, refs) + for v in obj.values(): + self._collect_schema_refs(v, refs) + elif isinstance(obj, list): + for item in obj: + self._collect_schema_refs(item, refs) + + def _build_parameters( + self, params: list[dict[str, Any]] + ) -> tuple[list[ctx.ParameterDescriptor], dict[str, Any] | None]: + result: list[ctx.ParameterDescriptor] = [] + format_info: dict[str, Any] | None = None + for raw_param in params: + param = self._resolve_parameter_ref(raw_param) + schema = param.get("schema") or {} + name = param.get("name", "param") + wire_name = name + if name == "format" and param.get("in") == "query": + enum_values = schema.get("enum") or [] + format_info = { + "enum": list(enum_values), + "default": schema.get("default"), + "required": param.get("required", False), + } + continue + type_info = self.resolver.resolve(schema, hint=self.sanitizer.pascal(name)) + result.append( + ctx.ParameterDescriptor( + name=self.sanitizer.snake(name), + wire_name=wire_name, + location=param.get("in", "query"), + required=param.get("required", False), + type_hint=type_info.annotation, + description=param.get("description"), + default_value="None" if not param.get("required", False) else None, + ) + ) + return result, format_info + + def _resolve_parameter_ref(self, param: dict[str, Any]) -> dict[str, Any]: + if "$ref" not in param: + return param + ref_name = param["$ref"].split("/")[-1] + parameters = self.spec.components.get("parameters", {}) or {} + return parameters.get(ref_name, {}) + + def _build_request_body( + self, request_body: dict[str, Any] | None, operation_id: str + ) -> ctx.RequestBodyDescriptor | None: + if not request_body: + return None + if "$ref" in request_body: + request_body = self._resolve_request_body_ref(request_body) + content = request_body.get("content") or {} + schema: ctx.RawSchema | None = None + media_types: list[str] = [] + for media_type in sorted(content): + candidate = content[media_type].get("schema") + if candidate is not None and schema is None: + schema = candidate + media_types.append(media_type) + if schema is None: + return None + type_info = self.resolver.resolve(schema, hint=f"{operation_id}Request") + if type_info.is_signed_transaction: + self.uses_signed_transaction = True + if any(media == "application/msgpack" for media in media_types): + self.uses_msgpack = True + return ctx.RequestBodyDescriptor( + type_hint=type_info.annotation, + media_types=media_types, + required=request_body.get("required", False), + description=request_body.get("description"), + is_binary=type_info.is_bytes, + model=type_info.model, + list_model=type_info.list_inner_model if type_info.is_list else None, + enum=type_info.enum, + list_enum=type_info.list_inner_enum if type_info.is_list else None, + ) + + def _build_response(self, responses: dict[str, Any], operation_id: str) -> ctx.ResponseDescriptor | None: + if not responses: + return None + preferred_codes = [code for code in responses if code.startswith("2")] + code = sorted(preferred_codes)[0] if preferred_codes else sorted(responses)[0] + payload = responses[code] + if isinstance(payload, dict) and "$ref" in payload: + payload = self._resolve_response_ref(payload) + content = payload.get("content") or {} + schema = None + media_types: list[str] = [] + for media_type in ("application/json", "application/msgpack", "application/octet-stream"): + if media_type in content: + schema = content[media_type].get("schema") + media_types.append(media_type) + if operation_id in self.RAW_LEDGER_STATE_DELTA_OPERATIONS: + if not media_types: + media_types = ["application/msgpack"] + if "application/msgpack" in media_types: + self.uses_msgpack = True + self.uses_ledger_state_delta = True + model_name = ( + "TransactionGroupLedgerStateDeltasForRound" + if operation_id == "TransactionGroupLedgerStateDeltasForRound" + else "LedgerStateDelta" + ) + return ctx.ResponseDescriptor( + type_hint=model_name, + media_types=media_types, + description=payload.get("description"), + model=model_name, + ) + if operation_id == "Block" and schema is not None: + self.uses_block_models = True + media_types = media_types or ["application/json"] + return ctx.ResponseDescriptor( + type_hint="models.BlockResponse", + media_types=media_types, + description=payload.get("description"), + is_binary=False, + model="BlockResponse", + ) + if schema is None: + return None + type_info = self.resolver.resolve(schema, hint=f"{operation_id}Response") + if type_info.is_signed_transaction: + self.uses_signed_transaction = True + if any(media == "application/msgpack" for media in media_types): + self.uses_msgpack = True + return ctx.ResponseDescriptor( + type_hint=type_info.annotation, + media_types=media_types, + description=payload.get("description"), + is_binary=type_info.is_bytes, + model=type_info.model, + list_model=type_info.list_inner_model if type_info.is_list else None, + enum=type_info.enum, + list_enum=type_info.list_inner_enum if type_info.is_list else None, + ) + + def _resolve_response_ref(self, response: dict[str, Any]) -> dict[str, Any]: + ref_name = response["$ref"].split("/")[-1] + responses = self.spec.components.get("responses", {}) or {} + return responses.get(ref_name, {}) + + def _resolve_request_body_ref(self, body: dict[str, Any]) -> dict[str, Any]: + ref_name = body["$ref"].split("/")[-1] + request_bodies = self.spec.components.get("requestBodies", {}) or {} + return request_bodies.get(ref_name, {}) + + +def build_client_descriptor( + spec: ctx.ParsedSpec, package_name: str, sanitizer: IdentifierSanitizer +) -> ctx.ClientDescriptor: + package_leaf = package_name.split(".")[-1] + client_key = ctx.ClientType(package_leaf.removeprefix("algokit_")) + class_name = sanitizer.pascal(client_key) + registry = SchemaRegistry(spec, sanitizer) + resolver = TypeResolver(registry) + operation_builder = OperationBuilder(spec, resolver, sanitizer, registry, client_key) + groups = operation_builder.build() + model_builder = ModelBuilder(registry, resolver, sanitizer) + models, enums, aliases = model_builder.build() + models = [model for model in models if model.name not in LEDGER_STATE_DELTA_MODEL_NAMES] + + # Filter out schemas only used by skipped operations + used_schema_refs = operation_builder.used_schema_refs + if used_schema_refs: + # Build set of used python names from used schema refs + used_python_names: set[str] = set() + for schema_name in used_schema_refs: + entry = registry.entries.get(schema_name) + if entry: + used_python_names.add(entry.python_name) + + # Filter models, enums, and aliases to only include used schemas + # Keep synthetic schemas (inline) as they are generated from used operations + models = [ + m + for m in models + if m.name in used_python_names + or registry.entries_by_python_name.get(m.name, SchemaEntry("", {}, "", "", None, "", True)).synthetic + ] + enums = [ + e + for e in enums + if e.name in used_python_names + or registry.entries_by_python_name.get(e.name, SchemaEntry("", {}, "", "", None, "", True)).synthetic + ] + aliases = [ + a + for a in aliases + if a.name in used_python_names + or registry.entries_by_python_name.get(a.name, SchemaEntry("", {}, "", "", None, "", True)).synthetic + ] + + uses_signed_txn = model_builder.uses_signed_transaction or operation_builder.uses_signed_transaction + defaults = { + ctx.ClientType.ALGOD_CLIENT: ("http://localhost:4001", "X-Algo-API-Token"), + ctx.ClientType.INDEXER_CLIENT: ("http://localhost:8980", "X-Indexer-API-Token"), + ctx.ClientType.KMD_CLIENT: ("http://localhost:7833", "X-KMD-API-Token"), + } + base_url, token_header = defaults.get(client_key, ("http://localhost", "X-Algo-API-Token")) + return ctx.ClientDescriptor( + package_name=package_name, + class_name=class_name, + version=spec.version, + description=spec.description, + groups=groups, + models=models, + enums=enums, + aliases=aliases, + default_base_url=base_url, + token_header=token_header, + uses_signed_transaction=uses_signed_txn, + uses_box_reference=model_builder.uses_box_reference, + uses_locals_reference=model_builder.uses_locals_reference, + uses_holding_reference=model_builder.uses_holding_reference, + uses_msgpack=operation_builder.uses_msgpack, + include_block_models=operation_builder.uses_block_models, + include_ledger_state_delta=operation_builder.uses_ledger_state_delta, + is_algod_client=client_key == ctx.ClientType.ALGOD_CLIENT, + ) diff --git a/api/oas-generator/src/oas_generator/cli.py b/api/oas-generator/src/oas_generator/cli.py new file mode 100644 index 00000000..fa7eced8 --- /dev/null +++ b/api/oas-generator/src/oas_generator/cli.py @@ -0,0 +1,54 @@ +import argparse +import sys +from pathlib import Path + +from oas_generator.builder import build_client_descriptor +from oas_generator.config import GeneratorConfig +from oas_generator.loader import resolve_spec +from oas_generator.naming import IdentifierSanitizer +from oas_generator.parser import SpecParser +from oas_generator.renderer.engine import TemplateRenderer +from oas_generator.writer import write_files + + +def parse_args(argv: list[str] | None = None) -> argparse.Namespace: + parser = argparse.ArgumentParser(description="Generate Python API clients from an OpenAPI spec") + parser.add_argument( + "--spec", + required=True, + help="Path or URL to the OpenAPI spec", + ) + parser.add_argument( + "--out", + required=True, + type=Path, + help="Base output directory that contains generated packages (e.g. src)", + ) + parser.add_argument( + "--package", required=True, help="Package module path relative to --out (e.g. algokit_algod_client)" + ) + parser.add_argument("--template-dir", type=Path, help="Optional path to override templates") + return parser.parse_args(argv) + + +def main(argv: list[str] | None = None) -> int: + args = parse_args(argv) + spec_path = resolve_spec(args.spec) + parser = SpecParser() + spec = parser.parse(spec_path) + sanitizer = IdentifierSanitizer() + config = GeneratorConfig( + spec_path=spec_path, + output_root=args.out, + package_name=args.package, + template_root=args.template_dir, + ) + descriptor = build_client_descriptor(spec, args.package, sanitizer) + renderer = TemplateRenderer(template_dir=args.template_dir) + files = renderer.render(descriptor, config) + write_files(files, config.target_package_dir) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main(sys.argv[1:])) diff --git a/api/oas-generator/src/oas_generator/config.py b/api/oas-generator/src/oas_generator/config.py new file mode 100644 index 00000000..a3979fe1 --- /dev/null +++ b/api/oas-generator/src/oas_generator/config.py @@ -0,0 +1,19 @@ +from dataclasses import dataclass +from pathlib import Path + + +@dataclass(frozen=True, slots=True) +class GeneratorConfig: + """Configuration resolved from CLI arguments.""" + + spec_path: Path + output_root: Path + package_name: str + template_root: Path | None = None + description_override: str | None = None + + @property + def target_package_dir(self) -> Path: + """Fully qualified target directory for generated files.""" + + return self.output_root.joinpath(*self.package_name.split(".")) diff --git a/api/oas-generator/src/oas_generator/loader.py b/api/oas-generator/src/oas_generator/loader.py new file mode 100644 index 00000000..851a2295 --- /dev/null +++ b/api/oas-generator/src/oas_generator/loader.py @@ -0,0 +1,56 @@ +import json +import tempfile +import urllib.error +import urllib.request +from pathlib import Path +from typing import Any + + +def resolve_spec(spec: str) -> Path: + """Resolve a spec reference to a local path, downloading if needed. + + Supports: + - Local paths: "api/specs/algod.oas3.json" + - Remote URLs: "https://example.com/spec.json" + """ + # Remote URL + if spec.startswith(("http://", "https://")): + return _download_to_temp(spec) + + # Local path + return Path(spec) + + +def _download_to_temp(url: str) -> Path: + """Download URL to a temporary file and return the path.""" + tmp = tempfile.NamedTemporaryFile(suffix=".json", delete=False) # noqa: SIM115 + try: + urllib.request.urlretrieve(url, tmp.name) + except urllib.error.URLError as e: + msg = f"Failed to download spec from {url}: {e}" + raise RuntimeError(msg) from e + return Path(tmp.name) + + +class SpecLoader: + """Lightweight OpenAPI specification loader.""" + + def __init__(self) -> None: + self._data: dict[str, Any] | None = None + + @property + def data(self) -> dict[str, Any]: + if self._data is None: + msg = "Specification has not been loaded" + raise RuntimeError(msg) + return self._data + + def load(self, path: Path) -> None: + if not path.exists(): + msg = f"Specification file not found: {path!s}" + raise FileNotFoundError(msg) + self._data = self._load_json(path) + + def _load_json(self, path: Path) -> dict[str, Any]: + with path.open("r", encoding="utf-8") as handle: + return json.load(handle) diff --git a/api/oas-generator/src/oas_generator/models.py b/api/oas-generator/src/oas_generator/models.py new file mode 100644 index 00000000..c0290a25 --- /dev/null +++ b/api/oas-generator/src/oas_generator/models.py @@ -0,0 +1,162 @@ +from dataclasses import dataclass, field +from enum import Enum +from typing import Any + +RawSchema = dict[str, Any] + + +class ClientType(str, Enum): + ALGOD_CLIENT = "algod_client" + INDEXER_CLIENT = "indexer_client" + KMD_CLIENT = "kmd_client" + + +@dataclass(slots=True) +class ParsedSpec: + title: str + version: str + description: str | None + paths: dict[str, Any] + components: dict[str, Any] + + @property + def schemas(self) -> dict[str, RawSchema]: + return self.components.get("schemas", {}) or {} + + +@dataclass(slots=True) +class ModelField: + name: str + wire_name: str + type_hint: str + required: bool + description: str | None + metadata: str + default_factory: str | None = None + default_value: str | None = None + + +@dataclass(slots=True) +class ModelDescriptor: + name: str + module_name: str + description: str | None + fields: list[ModelField] + imports: list[str] = field(default_factory=list) + requires_datetime: bool = False + uses_wire: bool = True + uses_nested: bool = False + uses_flatten: bool = False + uses_enum_value: bool = False + needs_any: bool = False + requires_enum: bool = False + + +@dataclass(slots=True) +class EnumValue: + member_name: str + value: str | int + description: str | None = None + + +@dataclass(slots=True) +class EnumDescriptor: + name: str + module_name: str + values: list[EnumValue] + description: str | None = None + + +@dataclass(slots=True) +class TypeAliasDescriptor: + name: str + module_name: str + target: str + imports: list[str] = field(default_factory=list) + + +@dataclass(slots=True) +class ParameterDescriptor: + name: str + wire_name: str + location: str + required: bool + type_hint: str + description: str | None + default_value: str | None = None + + +@dataclass(slots=True) +class RequestBodyDescriptor: + type_hint: str + media_types: list[str] + required: bool + description: str | None + is_binary: bool = False + model: str | None = None + list_model: str | None = None + enum: str | None = None + list_enum: str | None = None + + +@dataclass(slots=True) +class ResponseDescriptor: + type_hint: str + media_types: list[str] + description: str | None + is_binary: bool = False + is_raw_msgpack: bool = False + model: str | None = None + list_model: str | None = None + enum: str | None = None + list_enum: str | None = None + + +@dataclass(slots=True) +class OperationDescriptor: + name: str + http_method: str + path: str + summary: str | None + description: str | None + tag: str + parameters: list[ParameterDescriptor] + path_parameters: list[ParameterDescriptor] + query_parameters: list[ParameterDescriptor] + header_parameters: list[ParameterDescriptor] + request_body: RequestBodyDescriptor | None + response: ResponseDescriptor | None + operation_id: str + format_options: list[str] | None = None + format_default: str | None = None + format_required: bool = False + format_single: str | None = None + is_private: bool = False + + +@dataclass(slots=True) +class OperationGroup: + tag: str + operations: list[OperationDescriptor] + + +@dataclass(slots=True) +class ClientDescriptor: + package_name: str + class_name: str + version: str + description: str | None + groups: list[OperationGroup] + models: list[ModelDescriptor] + enums: list[EnumDescriptor] + aliases: list[TypeAliasDescriptor] + default_base_url: str + token_header: str + uses_signed_transaction: bool = False + uses_box_reference: bool = False + uses_locals_reference: bool = False + uses_holding_reference: bool = False + uses_msgpack: bool = False + include_block_models: bool = False + is_algod_client: bool = False + include_ledger_state_delta: bool = False diff --git a/api/oas-generator/src/oas_generator/naming.py b/api/oas-generator/src/oas_generator/naming.py new file mode 100644 index 00000000..2de60060 --- /dev/null +++ b/api/oas-generator/src/oas_generator/naming.py @@ -0,0 +1,49 @@ +import builtins +import keyword +import re +from dataclasses import dataclass + +_NON_WORD = re.compile(r"[^0-9a-zA-Z]+") +_ACRONYM_BOUNDARY = re.compile(r"([A-Z]+)([A-Z][a-z])") +_LOWER_TO_UPPER = re.compile(r"([a-z0-9])([A-Z])") +_PY_RESERVED = {*keyword.kwlist, *keyword.softkwlist, *dir(builtins), "self", "cls"} + + +@dataclass(slots=True) +class IdentifierSanitizer: + """Deterministic naming helper shared across generator stages.""" + + suffix: str = "_" + + def _words(self, raw: str) -> list[str]: + cleaned = _NON_WORD.sub(" ", raw) + # Split between consecutive uppercase acronym and a PascalCase word, + # e.g. "IDAndName" → "ID AndName", before applying the lower→upper pass. + spaced = _ACRONYM_BOUNDARY.sub(r"\1 \2", cleaned) + spaced = _LOWER_TO_UPPER.sub(r"\1 \2", spaced) + parts = [part for part in spaced.strip().split() if part] + return parts or ["value"] + + def pascal(self, raw: str) -> str: + words = self._words(raw) + return "".join(word.capitalize() for word in words) + + def camel(self, raw: str) -> str: + pascal = self.pascal(raw) + return pascal[0:1].lower() + pascal[1:] if pascal else pascal + + def snake(self, raw: str) -> str: + words = self._words(raw) + candidate = "_".join(word.lower() for word in words) + if candidate in _PY_RESERVED: + candidate = f"{candidate}{self.suffix}" + return candidate + + def const(self, raw: str) -> str: + return self.snake(raw).upper() + + def module(self, raw: str) -> str: + return "_" + self.snake(raw) + + def distribution(self, package_name: str) -> str: + return package_name.replace("_", "-") diff --git a/api/oas-generator/src/oas_generator/parser.py b/api/oas-generator/src/oas_generator/parser.py new file mode 100644 index 00000000..ab3e46b0 --- /dev/null +++ b/api/oas-generator/src/oas_generator/parser.py @@ -0,0 +1,26 @@ +from pathlib import Path +from typing import Any + +from oas_generator.loader import SpecLoader +from oas_generator.models import ParsedSpec + + +class SpecParser: + """Parse OpenAPI spec dictionaries into dataclasses used by the generator.""" + + def __init__(self) -> None: + self.loader = SpecLoader() + + def parse(self, path: Path) -> ParsedSpec: + self.loader.load(path) + return self.parse_dict(self.loader.data) + + def parse_dict(self, payload: dict[str, Any]) -> ParsedSpec: + info = payload.get("info", {}) + return ParsedSpec( + title=str(info.get("title", "AlgoKit Client")), + version=str(info.get("version", "0.0.0")), + description=info.get("description"), + paths=payload.get("paths", {}) or {}, + components=payload.get("components", {}) or {}, + ) diff --git a/legacy_v2_tests/__init__.py b/api/oas-generator/src/oas_generator/py.typed similarity index 100% rename from legacy_v2_tests/__init__.py rename to api/oas-generator/src/oas_generator/py.typed diff --git a/api/oas-generator/src/oas_generator/renderer/__init__.py b/api/oas-generator/src/oas_generator/renderer/__init__.py new file mode 100644 index 00000000..953a6634 --- /dev/null +++ b/api/oas-generator/src/oas_generator/renderer/__init__.py @@ -0,0 +1 @@ +"""Rendering helpers for the Python OAS generator.""" diff --git a/api/oas-generator/src/oas_generator/renderer/engine.py b/api/oas-generator/src/oas_generator/renderer/engine.py new file mode 100644 index 00000000..bd92a352 --- /dev/null +++ b/api/oas-generator/src/oas_generator/renderer/engine.py @@ -0,0 +1,197 @@ +from collections import defaultdict +from pathlib import Path +from typing import Any, ClassVar + +import jinja2 + +from oas_generator import models as ctx +from oas_generator.builder import LEDGER_STATE_DELTA_MODEL_NAMES +from oas_generator.config import GeneratorConfig +from oas_generator.renderer.filters import ( + descriptor_literal, + docstring, + optional_hint, + response_decode_arguments, +) + + +class TemplateRenderer: + BLOCK_MODEL_EXPORTS: ClassVar[list[str]] = [ + "ApplyData", + "BlockEvalDelta", + "BlockStateDelta", + "BlockAccountStateDelta", + "BlockAppEvalDelta", + "BlockStateProofTrackingData", + "BlockStateProofTracking", + "ParticipationUpdates", + "SignedTxnInBlock", + "SignedTxnWithAD", + "TxnCommitments", + "RewardState", + "UpgradeState", + "UpgradeVote", + "BlockHeader", + "Block", + "BlockResponse", + ] + LEDGER_STATE_DELTA_EXPORTS: ClassVar[list[str]] = [ + "LedgerTealValue", + "LedgerStateSchema", + "LedgerAppParams", + "LedgerAppLocalState", + "LedgerAppLocalStateDelta", + "LedgerAppParamsDelta", + "LedgerAppResourceRecord", + "LedgerAssetHolding", + "LedgerAssetHoldingDelta", + "LedgerAssetParams", + "LedgerAssetParamsDelta", + "LedgerAssetResourceRecord", + "LedgerVotingData", + "LedgerAccountBaseData", + "LedgerAccountData", + "LedgerBalanceRecord", + "LedgerAccountDeltas", + "LedgerKvValueDelta", + "LedgerIncludedTransactions", + "LedgerModifiedCreatable", + "LedgerAlgoCount", + "LedgerAccountTotals", + "LedgerStateDelta", + "LedgerStateDeltaForTransactionGroup", + "TransactionGroupLedgerStateDeltasForRound", + ] + + def __init__(self, template_dir: Path | None = None) -> None: + if template_dir: + loader: jinja2.BaseLoader = jinja2.FileSystemLoader(str(template_dir)) + else: + loader = jinja2.PackageLoader("oas_generator.renderer", "templates") + self.env = jinja2.Environment( + loader=loader, + autoescape=False, + trim_blocks=False, + lstrip_blocks=False, + ) + self.env.filters["docstring"] = docstring + self.env.filters["descriptor_literal"] = descriptor_literal + self.env.filters["optional_hint"] = optional_hint + self.env.filters["response_decode_arguments"] = response_decode_arguments + + def render(self, client: ctx.ClientDescriptor, config: GeneratorConfig) -> dict[Path, str]: + target = config.target_package_dir + context = self._build_context(client, config) + files: dict[Path, str] = {} + files[target / "__init__.py"] = self._render_template("package_init.py.j2", context) + files[target / "config.py"] = self._render_template("config.py.j2", context) + files[target / "exceptions.py"] = self._render_template("exceptions.py.j2", context) + files[target / "types.py"] = self._render_template("types.py.j2", context) + files[target / "client.py"] = self._render_template("client.py.j2", context) + models_dir = target / "models" + files[models_dir / "__init__.py"] = self._render_template("models/__init__.py.j2", context) + files[models_dir / "_serde_helpers.py"] = self._render_template("models/_serde_helpers.py.j2", context) + ledger_model_names = set(LEDGER_STATE_DELTA_MODEL_NAMES) + block_model_names = set(self.BLOCK_MODEL_EXPORTS) if client.include_block_models else set() + excluded_models = ledger_model_names | block_model_names + models = [model for model in context["client"].models if model.name not in excluded_models] + for model in models: + model_context = {**context, "model": model} + files[models_dir / f"{model.module_name}.py"] = self._render_template("models/model.py.j2", model_context) + for enum in context["client"].enums: + enum_context = {**context, "enum": enum} + files[models_dir / f"{enum.module_name}.py"] = self._render_template("models/enum.py.j2", enum_context) + for alias in context["client"].aliases: + alias_context = {**context, "alias": alias} + files[models_dir / f"{alias.module_name}.py"] = self._render_template( + "models/type_alias.py.j2", alias_context + ) + if client.include_block_models: + files[models_dir / "_block.py"] = self._render_template("models/block.py.j2", context) + if client.include_ledger_state_delta: + files[models_dir / "_ledger_state_delta.py"] = self._render_template( + "models/ledger_state_delta.py.j2", context + ) + if client.is_algod_client: + files[models_dir / "suggested_params.py"] = self._render_template("models/suggested_params.py.j2", context) + files[target / "py.typed"] = "" + return files + + def _render_template(self, template_name: str, context: dict[str, Any]) -> str: + template = self.env.get_template(template_name) + return template.render(**context) + + def _build_context(self, client: ctx.ClientDescriptor, config: GeneratorConfig) -> dict[str, Any]: + model_exports = [model.name for model in client.models] + model_exports.extend(enum.name for enum in client.enums) + model_exports.extend(alias.name for alias in client.aliases) + if client.uses_signed_transaction: + model_exports.append("SignedTransaction") + if client.include_block_models: + for name in self.BLOCK_MODEL_EXPORTS: + if name not in model_exports: + model_exports.append(name) + if client.include_ledger_state_delta: + for name in self.LEDGER_STATE_DELTA_EXPORTS: + if name not in model_exports: + model_exports.append(name) + if client.is_algod_client and "SuggestedParams" not in model_exports: + model_exports.append("SuggestedParams") + metadata_usage = self._collect_metadata_usage(client) + ledger_model_names = set(LEDGER_STATE_DELTA_MODEL_NAMES) + block_model_names = set(self.BLOCK_MODEL_EXPORTS) if client.include_block_models else set() + excluded_models = ledger_model_names | block_model_names + model_modules = [ + {"module": model.module_name, "name": model.name} + for model in client.models + if model.name not in excluded_models + ] + enum_modules = [{"module": enum.module_name, "name": enum.name} for enum in client.enums] + alias_modules = [{"module": alias.module_name, "name": alias.name} for alias in client.aliases] + needs_literal = any( + (op.format_options and len(op.format_options) > 1) for group in client.groups for op in group.operations + ) + return { + "client": client, + "config": config, + "model_exports": sorted(model_exports), + "model_modules": model_modules, + "enum_modules": enum_modules, + "alias_modules": alias_modules, + "needs_model_sequence": metadata_usage["model_sequence"], + "needs_enum_sequence": metadata_usage["enum_sequence"], + "needs_enum_value": metadata_usage["enum_value"], + "needs_datetime": any(model.requires_datetime for model in client.models), + "client_needs_datetime": self._client_requires_datetime(client), + "block_exports": self.BLOCK_MODEL_EXPORTS, + "ledger_exports": self.LEDGER_STATE_DELTA_EXPORTS, + "needs_literal": needs_literal, + "needs_suggested_params": client.is_algod_client, + "needs_algod_helpers": client.is_algod_client, + "needs_ledger_state_delta": client.include_ledger_state_delta, + } + + def _collect_metadata_usage(self, client: ctx.ClientDescriptor) -> dict[str, bool]: + flags = defaultdict(bool) + for model in client.models: + for field in model.fields: + expr = field.metadata + if "encode_model_sequence" in expr: + flags["model_sequence"] = True + if "encode_enum_sequence" in expr: + flags["enum_sequence"] = True + if "enum_value" in expr: + flags["enum_value"] = True + return flags + + def _client_requires_datetime(self, client: ctx.ClientDescriptor) -> bool: + for group in client.groups: + for op in group.operations: + for param in op.parameters: + if "datetime" in param.type_hint: + return True + if op.request_body and op.request_body.type_hint and "datetime" in op.request_body.type_hint: + return True + if op.response and op.response.type_hint and "datetime" in op.response.type_hint: + return True + return False diff --git a/api/oas-generator/src/oas_generator/renderer/filters.py b/api/oas-generator/src/oas_generator/renderer/filters.py new file mode 100644 index 00000000..fb98ddeb --- /dev/null +++ b/api/oas-generator/src/oas_generator/renderer/filters.py @@ -0,0 +1,72 @@ +import textwrap +from typing import Any + + +def docstring(text: str | None, indent: int = 4, width: int = 88) -> str: + if not text: + return "" + indent_str = " " * indent + body = textwrap.dedent(text).strip().splitlines() + rendered_lines: list[str] = [] + for line in body: + if not line: + rendered_lines.append("") + continue + wrapped = textwrap.fill(line, width=width) + rendered_lines.extend(wrapped.splitlines()) + rendered = "\n".join(f"{indent_str}{line}" if line else "" for line in rendered_lines) + return f'{indent_str}"""\n{rendered}\n{indent_str}"""\n' + + +def descriptor_literal(descriptor: object, indent: int = 0) -> str: + if descriptor is None: + return "{}" + fields: dict[str, Any] = {} + bool_fields = ("is_binary", "is_raw_msgpack") + for key in bool_fields: + if getattr(descriptor, key, False): + fields[key] = True + for key in ("model", "list_model", "enum", "list_enum"): + value = getattr(descriptor, key, None) + if value is not None: + fields[key] = value + if not fields: + return "{}" + indent_str = " " * indent + inner_indent = indent_str + " " * 4 + lines = [f'{inner_indent}"{key}": {value!r},' for key, value in fields.items()] + body = "\n".join(lines) + return f"{{\n{body}\n{indent_str}}}" + + +def response_decode_arguments(descriptor: object, indent: int = 0) -> str: + if descriptor is None: + return "" + model = getattr(descriptor, "model", None) or getattr(descriptor, "enum", None) + list_model = getattr(descriptor, "list_model", None) or getattr(descriptor, "list_enum", None) + is_binary = bool(getattr(descriptor, "is_binary", False)) + raw_msgpack = bool(getattr(descriptor, "is_raw_msgpack", False)) + type_hint = getattr(descriptor, "type_hint", None) + parts: list[str] = [] + if is_binary: + parts.append("is_binary=True") + if raw_msgpack: + parts.append("raw_msgpack=True") + if model: + parts.append(f"model=models.{model}") + if list_model: + parts.append(f"list_model=models.{list_model}") + if not model and not list_model and not is_binary and not raw_msgpack and type_hint and type_hint != "object": + parts.append(f"type_={type_hint}") + if not parts: + return "" + indent_str = " " * indent + separator = ",\n" + indent_str + return ",\n" + indent_str + separator.join(parts) + + +def optional_hint(type_hint: str) -> str: + return type_hint if "| None" in type_hint else f"{type_hint} | None" + + +__all__ = ["descriptor_literal", "docstring", "optional_hint", "response_decode_arguments"] diff --git a/api/oas-generator/src/oas_generator/renderer/templates/client.py.j2 b/api/oas-generator/src/oas_generator/renderer/templates/client.py.j2 new file mode 100644 index 00000000..61975aad --- /dev/null +++ b/api/oas-generator/src/oas_generator/renderer/templates/client.py.j2 @@ -0,0 +1,537 @@ +import random +import time +{% if needs_algod_helpers %}from base64 import b64encode +from collections.abc import Sequence +{% endif %}from dataclasses import is_dataclass +{% if client_needs_datetime %}from datetime import datetime +{% endif %}from typing import Any, Literal, TypeVar, overload + +import httpx +import msgpack + +from algokit_common.serde import from_wire, to_wire + +from . import models +from .config import ClientConfig +from .exceptions import UnexpectedStatusError +from .types import Headers + +# HTTP status codes that warrant a retry (aligned with algokit-utils-ts) +_RETRY_STATUS_CODES: frozenset[int] = frozenset({408, 413, 429, 500, 502, 503, 504}) +# Network error codes that warrant a retry (aligned with algokit-utils-ts) +_RETRY_ERROR_CODES: frozenset[str] = frozenset({ + "ETIMEDOUT", + "ECONNRESET", + "EADDRINUSE", + "ECONNREFUSED", + "EPIPE", + "ENOTFOUND", + "ENETUNREACH", + "EAI_AGAIN", + "EPROTO", +}) +_MAX_BACKOFF_MS: float = 10_000.0 +_DEFAULT_MAX_TRIES: int = 5 + +ModelT = TypeVar("ModelT") +ListModelT = TypeVar("ListModelT") +PrimitiveT = TypeVar("PrimitiveT") + +# Prefixed markers used when converting unhashable msgpack map keys into hashable tuples +_UNHASHABLE_PREFIXES: dict[str, str] = { + "dict": "__dict_key__", + "list": "__list_key__", + "set": "__set_key__", + "generic": "__unhashable__", +} + + +class {{ client.class_name }}: + def __init__(self, config: ClientConfig | None = None, *, http_client: httpx.Client | None = None) -> None: + self._config = config or ClientConfig() + # Track whether a custom HTTP client was provided to avoid retry conflicts + self._uses_custom_client = http_client is not None + self._client = http_client or httpx.Client( + base_url=self._config.base_url, + timeout=self._config.timeout, + verify=self._config.verify, + ) + + def close(self) -> None: + self._client.close() + + def _calculate_max_tries(self) -> int: + """Calculate maximum number of tries from config.max_retries.""" + max_retries = self._config.max_retries + if not isinstance(max_retries, int) or max_retries < 0: + return _DEFAULT_MAX_TRIES + return max_retries + 1 + + def _should_retry(self, error: Exception | None, status_code: int | None, attempt: int, max_tries: int) -> bool: + """Determine if a request should be retried based on error/status and attempt count.""" + if attempt >= max_tries: + return False + + # Check HTTP status code + if status_code is not None and status_code in _RETRY_STATUS_CODES: + return True + + # Check network error codes (aligned with algokit-utils-ts) + if error is not None: + error_code = self._extract_error_code(error) + if error_code and error_code in _RETRY_ERROR_CODES: + return True + + return False + + def _extract_error_code(self, error: BaseException) -> str | None: + """Extract error code from exception, checking common attributes.""" + # Check for 'code' attribute (common in OS/network errors) + if hasattr(error, "code") and isinstance(error.code, str): + return error.code + # Check for errno attribute + if hasattr(error, "errno") and error.errno is not None: + import errno as errno_module + try: + return errno_module.errorcode.get(error.errno) + except (TypeError, AttributeError): + pass + # Check __cause__ for wrapped errors + if error.__cause__ is not None: + return self._extract_error_code(error.__cause__) + return None + + def _request_with_retry(self, request_kwargs: dict[str, Any]) -> httpx.Response: + """Execute request with exponential backoff retry for transient failures. + + When a custom HTTP client is provided, retries are disabled to avoid + conflicts with any retry mechanism the custom client may implement. + """ + # Disable retries when using a custom HTTP client to avoid conflicts + # with the client's own retry mechanism + if self._uses_custom_client: + return self._client.request(**request_kwargs) + + max_tries = self._calculate_max_tries() + attempt = 1 + last_error: Exception | None = None + + while attempt <= max_tries: + status_code: int | None = None + try: + response = self._client.request(**request_kwargs) + status_code = response.status_code + if not self._should_retry(None, status_code, attempt, max_tries): + return response + except httpx.TransportError as exc: + last_error = exc + if not self._should_retry(exc, None, attempt, max_tries): + raise + + if attempt == 1: + backoff_ms = 0.0 + else: + base_backoff = min(1000.0 * (2 ** (attempt - 1)), _MAX_BACKOFF_MS) + jitter = 0.5 + random.random() # Random value between 0.5 and 1.5 + backoff_ms = base_backoff * jitter + if backoff_ms > 0: + time.sleep(backoff_ms / 1000.0) + attempt += 1 + + # Should not reach here, but satisfy type checker + if last_error: + raise last_error + raise RuntimeError(f"Request failed after {max_tries} attempt(s)") +{%- for group in client.groups %} + # {{ group.tag }} +{%- for operation in group.operations %} +{% set response = operation.response -%} +{% set request = operation.request_body -%} +{% if response and response.model -%} +{% set return_type = 'models.' + response.model -%} +{% elif response and response.list_model -%} +{% set return_type = 'list[models.' + response.list_model + ']' -%} +{% elif response -%} +{% set return_type = response.type_hint -%} +{% else -%} +{% set return_type = 'None' -%} +{% endif -%} +{% if request is not none and request.model -%} +{% set body_type = 'models.' + request.model -%} +{% elif request is not none and request.list_model -%} +{% set body_type = 'list[models.' + request.list_model + ']' -%} +{% elif request is not none -%} +{% set body_type = request.type_hint -%} +{% endif -%} +{% set kw_required = (operation.query_parameters + operation.header_parameters) | selectattr('required') | list -%} +{% set kw_optional = (operation.query_parameters + operation.header_parameters) | rejectattr('required') | list -%} +{% set has_keyword_only = (operation.format_options is not none) or kw_optional or (request is not none and not request.required) %} + def {{ operation.name }}( # noqa: C901, PLR0912, PLR0913 + self, + {% for param in operation.path_parameters %}{{ param.name }}: {{ param.type_hint }}, + {% endfor %}{% for param in kw_required %}{{ param.name }}: {{ param.type_hint }}, + {% endfor %}{% if request is not none and request.required %}body: {{ body_type }}, + {% endif %}{% if has_keyword_only %} + *, + {% if operation.format_options %} + response_format: Literal[{% for opt in operation.format_options %}{{ '"' ~ opt ~ '"' }}{% if not loop.last %}, {% endif %}{% endfor %}]{% if not operation.format_required %} | None{% endif %}{% if operation.format_required %}{% if operation.format_default %} = {{ '"' ~ operation.format_default ~ '"' }}{% endif %}{% else %}{% if operation.format_default %} = {{ '"' ~ operation.format_default ~ '"' }}{% else %} = None{% endif %}{% endif %}, + {% endif %}{% for param in kw_optional %} + {{ param.name }}: {{ param.type_hint | optional_hint }}{% if param.default_value %} = {{ param.default_value }}{% else %} = None{% endif %}, + {% endfor %}{% if request is not none and not request.required %} + body: {{ body_type | optional_hint }} = None, + {% endif %}{% endif %} + ) -> {{ return_type }}: +{% set doc = operation.summary or operation.description or operation.operation_id %}{{ doc | docstring(8) }} + path = "{{ operation.path }}" + {%- for param in operation.path_parameters %} + path = path.replace("{{ '{' + param.wire_name + '}' }}", str({{ param.name }})) + {% endfor %} + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + {%- for param in operation.query_parameters %} + if {{ param.name }} is not None: + params["{{ param.wire_name }}"] = {{ param.name }} + {% endfor %} + {%- for param in operation.header_parameters %} + if {{ param.name }} is not None: + headers["{{ param.wire_name }}"] = str({{ param.name }}) + {% endfor %} + {% set default_accept = 'application/json' %} + {% if response and 'application/json' not in response.media_types and response.media_types %} + {% set default_accept = response.media_types[0] %} + {% elif response and 'application/json' in response.media_types %} + {% set default_accept = 'application/json' %} + {% endif %} + accept_value: str | None = None + {% if request %} + body_media_types = {{ request.media_types }} + {% endif %} + {% if operation.format_options %} + selected_format = response_format + {% if operation.format_default %} + if selected_format is None: + selected_format = "{{ operation.format_default }}" + {% endif %} + if selected_format == "msgpack": + params["format"] = "msgpack" + accept_value = "application/msgpack" + {% if request %} + if "application/msgpack" in body_media_types: + body_media_types = ["application/msgpack"] + {% endif %} + {% elif operation.format_single %} + {% if operation.format_single == "msgpack" %} + params["format"] = "msgpack" + accept_value = "application/msgpack" + {% if request %} + if "application/msgpack" in body_media_types: + body_media_types = ["application/msgpack"] + {% endif %} + {% endif %} + {% endif %} + headers.setdefault("accept", accept_value or '{{ default_accept }}') + request_kwargs: dict[str, Any] = { + "method": "{{ operation.http_method }}", + "url": path, + "params": params, + "headers": headers, + } + {% if request %} + if body is not None: + self._assign_body( + request_kwargs, + body, + {{ request | descriptor_literal(16) }}, + body_media_types, + ) + {% endif %} + response = self._request_with_retry(request_kwargs) + if response.is_success: + {% if response %} + {% set decode_args = response | response_decode_arguments(16) %} + return self._decode_response( + response{{ decode_args }} + ) + {% else %} + return None + {% endif %} + raise UnexpectedStatusError(response.status_code, response.text) + + {% endfor %} +{% endfor %} +{% if needs_algod_helpers %} + def send_raw_transaction( + self, + stx_or_stxs: bytes | bytearray | memoryview | Sequence[bytes | bytearray | memoryview], + ) -> models.PostTransactionsResponse: + """ + Send a signed transaction or array of signed transactions to the network. + """ + + payload: bytes + if isinstance(stx_or_stxs, bytes | bytearray | memoryview): + payload = bytes(stx_or_stxs) + elif isinstance(stx_or_stxs, Sequence): + segments: list[bytes] = [] + for value in stx_or_stxs: + if not isinstance(value, bytes | bytearray | memoryview): + raise TypeError("All sequence elements must be bytes-like") + segments.append(bytes(value)) + payload = b"".join(segments) + else: + raise TypeError("stx_or_stxs must be bytes or a sequence of bytes-like values") + + return self._raw_transaction(payload) + + def application_box_by_name( + self, + application_id: int, + box_name: bytes | bytearray | memoryview | str, + ) -> models.Box: + """ + Given an application ID and box name, return the corresponding box details. + """ + + box_bytes = box_name.encode() if isinstance(box_name, str) else bytes(box_name) + encoded_name = "b64:" + b64encode(box_bytes).decode("ascii") + return self._application_box_by_name(application_id, name=encoded_name) + + def suggested_params(self) -> models.SuggestedParams: + """ + Return the common parameters required for assembling a transaction. + """ + + txn_params = self._transaction_params() + last_round = txn_params.last_round + return models.SuggestedParams( + consensus_version=txn_params.consensus_version, + fee=txn_params.fee, + genesis_hash=txn_params.genesis_hash, + genesis_id=txn_params.genesis_id, + min_fee=txn_params.min_fee, + flat_fee=False, + first_valid=last_round, + last_valid=last_round + 1000, + ) +{% endif %} + def _assign_body( + self, + request_kwargs: dict[str, Any], + payload: object, + descriptor: dict[str, object], + media_types: list[str], + ) -> None: + encoded = self._encode_payload(payload, descriptor) + binary_types = {"application/x-binary", "application/octet-stream"} + if bool(descriptor.get("is_binary")) or any(mt in binary_types for mt in media_types): + if encoded is None: + return + request_kwargs["content"] = encoded + if media_types: + request_kwargs.setdefault("headers", {})["content-type"] = media_types[0] + else: + request_kwargs.setdefault("headers", {})["content-type"] = "application/octet-stream" + elif "application/json" in media_types: + request_kwargs["json"] = encoded + elif "application/msgpack" in media_types: + request_kwargs["content"] = msgpack.packb(encoded, use_bin_type=True) + request_kwargs.setdefault("headers", {})["content-type"] = "application/msgpack" + else: + request_kwargs["json"] = encoded + + def _encode_payload(self, payload: object, descriptor: dict[str, object]) -> object: + if payload is None: + return None + if is_dataclass(payload): + return to_wire(payload) + list_model = descriptor.get("list_model") + if list_model and isinstance(payload, list): + return [to_wire(item) if is_dataclass(item) else item for item in payload] + return payload + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + model: type[ModelT], + is_binary: bool = False, + raw_msgpack: bool = False, + ) -> ModelT: + ... + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + list_model: type[ListModelT], + is_binary: bool = False, + raw_msgpack: bool = False, + ) -> list[ListModelT]: + ... + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + type_: type[PrimitiveT], + is_binary: bool = False, + raw_msgpack: bool = False, + ) -> PrimitiveT: + ... + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + is_binary: Literal[True], + raw_msgpack: bool = False, + ) -> bytes: + ... + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + raw_msgpack: Literal[True], + ) -> bytes: + ... + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + type_: None = None, + is_binary: bool = False, + raw_msgpack: bool = False, + ) -> object: + ... + + def _decode_response( + self, + response: httpx.Response, + *, + model: type[Any] | None = None, + list_model: type[Any] | None = None, + type_: type[Any] | None = None, + is_binary: bool = False, + raw_msgpack: bool = False, + ) -> object: + if is_binary or raw_msgpack: + return response.content + content_type = response.headers.get("content-type", "application/json") + if "msgpack" in content_type: + # Handle msgpack unpacking with support for unhashable keys + # Use Unpacker for more control over the unpacking process + unpacker = msgpack.Unpacker( + raw=True, + strict_map_key=False, + object_pairs_hook=self._msgpack_pairs_hook, + ) + unpacker.feed(response.content) + try: + data = unpacker.unpack() + except TypeError: + # If unpacking fails due to unhashable keys, try without the hook + # and handle in normalization + unpacker = msgpack.Unpacker(raw=True, strict_map_key=False) + unpacker.feed(response.content) + data = unpacker.unpack() + data = self._normalize_msgpack(data) + elif content_type.startswith("application/json"): + data = response.json() + else: + data = response.text + if model is not None: + return from_wire(model, data) + if list_model is not None: + return [from_wire(list_model, item) for item in data] + if type_ is not None: + return data + return data + + def _normalize_msgpack(self, value: object) -> object: # noqa: C901, PLR0912 + # Handle pairs returned from msgpack_pairs_hook when keys are unhashable + _pair_length = 2 + if ( + isinstance(value, list) + and value + and isinstance(value[0], tuple | list) + and len(value[0]) == _pair_length + ): + # Convert to dict with normalized keys + pairs_dict: dict[object, object] = {} + for pair in value: + if isinstance(pair, tuple | list) and len(pair) == _pair_length: + k, v = pair + # For unhashable keys (like dict keys), use a tuple representation + try: + normalized_key = self._coerce_msgpack_key(k) + pairs_dict[normalized_key] = self._normalize_msgpack(v) + except TypeError: + # Key is unhashable - use tuple representation + normalized_key = ("__unhashable__", id(k), str(k)) + pairs_dict[normalized_key] = self._normalize_msgpack(v) + return pairs_dict + if isinstance(value, dict): + # Safely normalize maps: coerce string/bytes keys, but tolerate complex/unhashable keys + try: + normalized_dict: dict[object, object] = {} + for key, item in value.items(): + normalized_dict[self._coerce_msgpack_key(key)] = self._normalize_msgpack(item) + return normalized_dict + except TypeError: + # Some maps can decode to object/dict keys; keep original keys and + # only normalize values to avoid "unhashable type: 'dict'" errors. + for k, item in list(value.items()): + value[k] = self._normalize_msgpack(item) + return value + if isinstance(value, list): + return [self._normalize_msgpack(item) for item in value] + return value + + def _coerce_msgpack_key(self, key: object) -> object: + if isinstance(key, bytes): + try: + return key.decode("utf-8", errors="strict") + except UnicodeDecodeError: + return key + return key + + def _msgpack_pairs_hook(self, pairs: list[tuple[object, object]] | list[list[object]]) -> dict[object, object]: + # Convert pairs to dict, handling unhashable keys by converting them to hashable tuples + out: dict[object, object] = {} + _hashable_type_tuple = (str, int, float, bool, type(None), bytes) + + for k, v in pairs: + if isinstance(k, dict | list | set): + # Convert unhashable key to hashable tuple + hashable_key: tuple[str, object] + if isinstance(k, dict): + try: + hashable_key = (_UNHASHABLE_PREFIXES["dict"], tuple(sorted(k.items()))) + except TypeError: + hashable_key = (_UNHASHABLE_PREFIXES["dict"], str(k)) + elif isinstance(k, list): + prefix = _UNHASHABLE_PREFIXES["list"] + hashable_key = (prefix, tuple(k) if all(isinstance(x, _hashable_type_tuple) for x in k) else str(k)) + else: # set + prefix = _UNHASHABLE_PREFIXES["set"] + if all(isinstance(x, _hashable_type_tuple) for x in k): + hashable_key = (prefix, tuple(sorted(k))) + else: + hashable_key = (prefix, str(k)) + out[hashable_key] = v + else: + # Key should be hashable, use as-is + try: + out[k] = v + except TypeError: + # Unexpected unhashable type, convert to tuple + out[(_UNHASHABLE_PREFIXES["generic"], str(type(k).__name__), str(k))] = v + return out diff --git a/api/oas-generator/src/oas_generator/renderer/templates/config.py.j2 b/api/oas-generator/src/oas_generator/renderer/templates/config.py.j2 new file mode 100644 index 00000000..1a87edfe --- /dev/null +++ b/api/oas-generator/src/oas_generator/renderer/templates/config.py.j2 @@ -0,0 +1,35 @@ + + +from dataclasses import dataclass, field + + +@dataclass(slots=True) +class ClientConfig: + """Runtime configuration for {{ client.class_name }}. + + Attributes: + base_url: Base URL for the API endpoint. + token: Optional authentication token. + token_header: Header name for the authentication token. + timeout: Request timeout in seconds. Set to None for no timeout. + verify: SSL certificate verification. Can be a boolean or path to CA bundle. + extra_headers: Additional headers to include in all requests. + max_retries: Maximum number of retry attempts for transient failures. + Set to 0 to disable retries. Default is 4 (5 total attempts). + Note: Retries are automatically disabled when a custom http_client + is provided to avoid conflicts with the client's own retry mechanism. + """ + + base_url: str = "{{ client.default_base_url }}" + token: str | None = None + token_header: str = "{{ client.token_header }}" + timeout: float | None = 30.0 + verify: bool | str = True + extra_headers: dict[str, str] = field(default_factory=dict) + max_retries: int = 4 + + def resolve_headers(self) -> dict[str, str]: + headers = dict(self.extra_headers) + if self.token: + headers[self.token_header] = self.token + return headers diff --git a/api/oas-generator/src/oas_generator/renderer/templates/exceptions.py.j2 b/api/oas-generator/src/oas_generator/renderer/templates/exceptions.py.j2 new file mode 100644 index 00000000..e487037f --- /dev/null +++ b/api/oas-generator/src/oas_generator/renderer/templates/exceptions.py.j2 @@ -0,0 +1,59 @@ + +from http import HTTPStatus +from json import JSONDecodeError, loads +from typing import Any + + +class ApiError(RuntimeError): + """Base exception for errors raised by generated clients.""" + + +def _format_payload(payload: object) -> str | None: # noqa: C901, PLR0912 + """Extract a human-friendly message from a payload.""" + if payload is None: + return None + + text: str | None = None + if isinstance(payload, (bytes | bytearray | memoryview)): + try: + text = bytes(payload).decode("utf-8", errors="ignore") + except Exception: + text = None + if text is None: + text = str(payload) + + result = text.strip() + if not result: + return None + + try: + decoded = loads(result) + except (JSONDecodeError, TypeError): + return result + + if isinstance(decoded, dict): + for key in ("message", "msg", "error", "detail", "description", "data"): + value = decoded.get(key) + if isinstance(value, str): + candidate = value.strip() + if candidate: + result = candidate + break + + if isinstance(decoded, list) and decoded: + first = decoded[0] + if isinstance(first, str): + candidate = first.strip() + if candidate: + result = candidate + + return result + + +class UnexpectedStatusError(ApiError): + def __init__(self, status_code: int, payload: object) -> None: + message = _format_payload(payload) + description = f" {message}" if message else "" + super().__init__(f"Unexpected status code {status_code}{description}") + self.status_code = HTTPStatus(status_code) + self.payload = payload diff --git a/api/oas-generator/src/oas_generator/renderer/templates/models/__init__.py.j2 b/api/oas-generator/src/oas_generator/renderer/templates/models/__init__.py.j2 new file mode 100644 index 00000000..02a74ef7 --- /dev/null +++ b/api/oas-generator/src/oas_generator/renderer/templates/models/__init__.py.j2 @@ -0,0 +1,25 @@ + + +{% if client.uses_signed_transaction %}from algokit_transact.models.signed_transaction import SignedTransaction +{% endif %}{% if client.uses_box_reference %}from algokit_transact.models.app_call import BoxReference +{% endif %}{% if client.uses_locals_reference %}from algokit_transact.models.app_call import LocalsReference +{% endif %}{% if client.uses_holding_reference %}from algokit_transact.models.app_call import HoldingReference +{% endif %}{% for item in model_modules %}from .{{ item.module }} import {{ item.name }} +{% endfor %}{% for item in enum_modules %}from .{{ item.module }} import {{ item.name }} +{% endfor %}{% for item in alias_modules %}from .{{ item.module }} import {{ item.name }} +{% endfor %}{% if needs_suggested_params %}from .suggested_params import SuggestedParams +{% endif %}{% if client.include_block_models %}from ._block import ( + {{ block_exports | join(',\n ') }} +) +{% endif %}{% if needs_ledger_state_delta %}from ._ledger_state_delta import ( + {{ ledger_exports | join(',\n ') }} +) +{% endif %} + +__all__ = [ + {% if client.uses_box_reference %}"BoxReference", + {% endif %}{% if client.uses_locals_reference %}"LocalsReference", + {% endif %}{% if client.uses_holding_reference %}"HoldingReference", + {% endif %}{% for name in model_exports %}"{{ name }}", + {% endfor %} +] diff --git a/api/oas-generator/src/oas_generator/renderer/templates/models/_serde_helpers.py.j2 b/api/oas-generator/src/oas_generator/renderer/templates/models/_serde_helpers.py.j2 new file mode 100644 index 00000000..ee11b3e4 --- /dev/null +++ b/api/oas-generator/src/oas_generator/renderer/templates/models/_serde_helpers.py.j2 @@ -0,0 +1,254 @@ +import base64 +from binascii import Error as BinasciiError + +from collections.abc import Iterable, Mapping +from dataclasses import is_dataclass +from enum import Enum +from typing import Callable, TypeAlias, TypeVar + +from algokit_common.serde import from_wire, to_wire + +DecodedT = TypeVar("DecodedT") +EnumValueT = TypeVar("EnumValueT", bound=Enum) +MapKeyT = TypeVar("MapKeyT") +BytesLike: TypeAlias = bytes | bytearray | memoryview + + +def _coerce_bytes(value: bytes | bytearray | memoryview) -> bytes: + if isinstance(value, memoryview | bytearray): + return bytes(value) + return value + + +def encode_bytes(value: BytesLike) -> str: + return base64.b64encode(_coerce_bytes(value)).decode("ascii") + + +def decode_bytes(raw: object) -> bytes: + """Decode bytes that may be raw (msgpack) or base64-encoded (JSON).""" + if isinstance(raw, bytes | bytearray | memoryview): + return bytes(raw) + if isinstance(raw, str): + try: + return base64.b64decode(raw.encode("ascii"), validate=True) + except (BinasciiError, UnicodeEncodeError) as exc: + raise ValueError("Invalid base64 payload") from exc + raise TypeError(f"Unsupported value for bytes field: {type(raw)!r}") + + +def decode_bytes_base64(raw: object) -> bytes: + """Decode bytes that are always base64-encoded strings (even in msgpack). + + Used for fields marked with x-algokit-bytes-base64 in the OpenAPI spec. + These fields contain base64-encoded strings in both JSON and msgpack responses. + """ + if isinstance(raw, bytes | bytearray | memoryview | str): + try: + return base64.b64decode(raw, validate=True) + except (BinasciiError, ValueError, UnicodeEncodeError) as exc: + raise ValueError("Invalid base64 payload") from exc + raise TypeError(f"Unsupported value for bytes field: {type(raw)!r}") + + +def encode_fixed_bytes(value: BytesLike, expected_length: int) -> str: + """Encode fixed-length bytes to base64, validating the length.""" + coerced = _coerce_bytes(value) + if len(coerced) != expected_length: + raise ValueError(f"Expected {expected_length} bytes, got {len(coerced)}") + return base64.b64encode(coerced).decode("ascii") + + +def decode_fixed_bytes(raw: object, expected_length: int) -> bytes: + """Decode base64 to fixed-length bytes, validating the length.""" + decoded = decode_bytes(raw) + if len(decoded) != expected_length: + raise ValueError(f"Expected {expected_length} bytes, got {len(decoded)}") + return decoded + + +def decode_bytes_map_key(raw: object) -> bytes: + if isinstance(raw, bytes | bytearray | memoryview): + return bytes(raw) + if isinstance(raw, str): + # note: this is undoing the implicit bytes -> str conversion that + # _coerce_msgpack_key does in client.py + # as long as "strict" was used to encode the str then this should be safe + try: + return raw.encode("utf-8", errors="strict") + except UnicodeEncodeError as fallback_exc: + raise ValueError("Invalid bytes map key") from fallback_exc + raise TypeError(f"Unsupported map key for bytes field: {type(raw)!r}") + + +def encode_bytes_sequence(values: Iterable[BytesLike | None] | None) -> list[str | None] | None: + if values is None: + return None + encoded: list[str | None] = [] + for value in values: + if value is None: + encoded.append(None) + continue + if not isinstance(value, bytes | bytearray | memoryview): + raise TypeError(f"Unsupported value for bytes field sequence: {type(value)!r}") + encoded.append(encode_bytes(value)) + return encoded or None + + +def decode_bytes_sequence(raw: object) -> list[bytes | None] | None: + if not isinstance(raw, list): + return None + decoded: list[bytes | None] = [] + for item in raw: + if item is None: + decoded.append(None) + continue + decoded.append(decode_bytes(item)) + return decoded or None + + +def encode_fixed_bytes_sequence( + values: Iterable[BytesLike | None] | None, expected_length: int +) -> list[str | None] | None: + """Encode a sequence of fixed-length bytes to base64, validating each element's length.""" + if values is None: + return None + encoded: list[str | None] = [] + for value in values: + if value is None: + encoded.append(None) + continue + if not isinstance(value, bytes | bytearray | memoryview): + raise TypeError(f"Unsupported value for bytes field sequence: {type(value)!r}") + encoded.append(encode_fixed_bytes(value, expected_length)) + return encoded or None + + +def decode_fixed_bytes_sequence(raw: object, expected_length: int) -> list[bytes | None] | None: + """Decode a sequence of base64 strings to fixed-length bytes, validating each element's length.""" + if not isinstance(raw, list): + return None + decoded: list[bytes | None] = [] + for item in raw: + if item is None: + decoded.append(None) + continue + decoded.append(decode_fixed_bytes(item, expected_length)) + return decoded or None + + +def encode_model_sequence(values: Iterable[object] | None) -> list[dict[str, object]] | None: + if values is None: + return None + encoded: list[dict[str, object]] = [] + for value in values: + if value is None: + continue + encoded.append(to_wire(value)) + return encoded or None + + +def decode_model_sequence(cls_factory: Callable[[], type[DecodedT]], raw: object) -> list[DecodedT] | None: + if not isinstance(raw, list): + return None + cls = cls_factory() + decoded: list[DecodedT] = [] + for item in raw: + if isinstance(item, Mapping): + decoded.append(from_wire(cls, item)) + return decoded or None + + +def encode_enum_sequence(values: Iterable[object] | None) -> list[object] | None: + if values is None: + return None + encoded: list[object] = [] + for value in values: + if value is None: + continue + encoded.append(value.value if hasattr(value, "value") else value) + return encoded or None + + +def decode_enum_sequence(enum_factory: Callable[[], type[EnumValueT]], raw: object) -> list[EnumValueT] | None: + if not isinstance(raw, list): + return None + enum_cls = enum_factory() + decoded: list[EnumValueT] = [] + for item in raw: + try: + decoded.append(enum_cls(item)) + except Exception: + continue + return decoded or None + + +def encode_model_mapping( + factory: Callable[[], type[DecodedT]], + mapping: Mapping[object, object] | None, + *, + key_encoder: Callable[[object], str] | None = None, +) -> dict[str, object] | None: + if mapping is None: + return None + cls = factory() + encoded: dict[str, object] = {} + for key, value in mapping.items(): + if value is None: + continue + encoded_key: str + if key_encoder is not None: + encoded_key = key_encoder(key) + elif isinstance(key, str): + encoded_key = key + else: + encoded_key = str(key) + if isinstance(value, cls) or is_dataclass(value): + encoded[encoded_key] = to_wire(value) + else: + encoded[encoded_key] = value + return encoded or None + + +def decode_model_mapping( + factory: Callable[[], type[DecodedT]], + raw: object, + *, + key_decoder: Callable[[object], MapKeyT] | None = None, +) -> dict[MapKeyT, DecodedT] | None: + if not isinstance(raw, Mapping): + return None + cls = factory() + decoded: dict[MapKeyT, DecodedT] = {} + for key, value in raw.items(): + if isinstance(value, Mapping): + decoded_key = key_decoder(key) if key_decoder is not None else key + decoded[decoded_key] = from_wire(cls, value) + return decoded or None + + +def decode_optional_bool(raw: object) -> bool | None: + if raw is None: + return None + return bool(raw) + + +def mapping_encoder( + factory: Callable[[], type[DecodedT]], + *, + key_encoder: Callable[[object], str] | None = None, +) -> Callable[[Mapping[object, object] | None], dict[str, object] | None]: + def _encode(mapping: Mapping[object, object] | None) -> dict[str, object] | None: + return encode_model_mapping(factory, mapping, key_encoder=key_encoder) + + return _encode + + +def mapping_decoder( + factory: Callable[[], type[DecodedT]], + *, + key_decoder: Callable[[object], MapKeyT] | None = None, +) -> Callable[[object], dict[MapKeyT, DecodedT] | None]: + def _decode(raw: object) -> dict[MapKeyT, DecodedT] | None: + return decode_model_mapping(factory, raw, key_decoder=key_decoder) + + return _decode diff --git a/api/oas-generator/src/oas_generator/renderer/templates/models/block.py.j2 b/api/oas-generator/src/oas_generator/renderer/templates/models/block.py.j2 new file mode 100644 index 00000000..73c4ac9f --- /dev/null +++ b/api/oas-generator/src/oas_generator/renderer/templates/models/block.py.j2 @@ -0,0 +1,363 @@ +from collections.abc import Mapping +from dataclasses import dataclass, field +from typing import cast + +from algokit_common import ZERO_ADDRESS +from algokit_common.serde import addr, addr_seq, flatten, nested, wire +from algokit_transact.models.signed_transaction import SignedTransaction + +from ._serde_helpers import ( + decode_bytes_map_key, + decode_model_mapping, + decode_model_sequence, + decode_optional_bool, + encode_bytes, + encode_model_mapping, + encode_model_sequence, + mapping_decoder, + mapping_encoder, +) + +__all__ = [ + "ApplyData", + "Block", + "BlockAccountStateDelta", + "BlockAppEvalDelta", + "BlockEvalDelta", + "BlockHeader", + "BlockResponse", + "BlockStateDelta", + "BlockStateProofTracking", + "BlockStateProofTrackingData", + "ParticipationUpdates", + "RewardState", + "SignedTxnInBlock", + "SignedTxnWithAD", + "TxnCommitments", + "UpgradeState", + "UpgradeVote", +] + +BlockStateDelta = dict[bytes, "BlockEvalDelta"] +BlockStateProofTracking = dict[int, "BlockStateProofTrackingData"] + + +def _encode_block_state_delta(value: BlockStateDelta | None) -> dict[str, object] | None: + if value is None: + return None + return encode_model_mapping( + lambda: BlockEvalDelta, + cast(Mapping[object, object], value), + key_encoder=_encode_state_delta_key, + ) + + +def _encode_state_delta_key(key: object) -> str: + if isinstance(key, bytes): + return encode_bytes(key) + if isinstance(key, memoryview): + return encode_bytes(bytes(key)) + if isinstance(key, bytearray): + return encode_bytes(bytes(key)) + raise TypeError("State delta keys must be bytes-like") + + +def _decode_state_proof_tracking_key(key: object) -> int: + if isinstance(key, int): + return key + if isinstance(key, str): + return int(key) + raise TypeError("State proof tracking keys must be numeric") + + +def _decode_block_state_delta(raw: object) -> BlockStateDelta | None: + decoded = decode_model_mapping(lambda: BlockEvalDelta, raw, key_decoder=decode_bytes_map_key) + return decoded or None + + +def _encode_local_delta_index_key(key: object) -> str: + if isinstance(key, bool): + return str(int(key)) + if isinstance(key, int): + return str(key) + if isinstance(key, str): + return str(int(key)) + raise TypeError("Local delta keys must be numeric") + + +def _encode_local_deltas(mapping: Mapping[int, BlockStateDelta] | None) -> dict[str, object] | None: + if mapping is None: + return None + out: dict[str, object] = {} + for key, value in mapping.items(): + encoded = _encode_block_state_delta(value) + if encoded: + out[_encode_local_delta_index_key(key)] = encoded + return out or None + + +def _decode_local_deltas(raw: object) -> dict[int, BlockStateDelta] | None: + if not isinstance(raw, Mapping): + return None + out: dict[int, BlockStateDelta] = {} + for key, value in raw.items(): + decoded = _decode_block_state_delta(value) + if decoded is not None: + out[_decode_local_delta_index_key(key)] = decoded + return out or None + + +def _decode_local_delta_index_key(key: object) -> int: + if isinstance(key, int): + return key + if isinstance(key, str): + return int(key) + raise TypeError("Local delta keys must be numeric") + + +@dataclass(slots=True) +class BlockEvalDelta: + """Represents a TEAL value delta within block state changes.""" + + action: int = field(metadata=wire("at", required=True)) + bytes_: bytes | None = field(default=None, metadata=wire("bs")) + uint: int | None = field(default=None, metadata=wire("ui")) + + +@dataclass(slots=True) +class BlockAccountStateDelta: + """Associates an account address with its state delta.""" + + address: str = field(metadata=wire("address", required=True)) + delta: BlockStateDelta = field( + metadata=wire( + "delta", + encode=_encode_block_state_delta, + decode=_decode_block_state_delta, + ) + ) + + +@dataclass(slots=True) +class BlockStateProofTrackingData: + """Tracking metadata for a specific state proof type.""" + + state_proof_voters_commitment: bytes | None = field( + default=None, + metadata=wire("v"), + ) + state_proof_online_total_weight: int | None = field( + default=None, + metadata=wire("t"), + ) + state_proof_next_round: int | None = field( + default=None, + metadata=wire("n"), + ) + + +@dataclass(slots=True) +class ApplyData: + """Transaction execution apply data containing state changes and rewards.""" + + closing_amount: int | None = field(default=None, metadata=wire("ca")) + asset_closing_amount: int | None = field(default=None, metadata=wire("aca")) + sender_rewards: int | None = field(default=None, metadata=wire("rs")) + receiver_rewards: int | None = field(default=None, metadata=wire("rr")) + close_rewards: int | None = field(default=None, metadata=wire("rc")) + eval_delta: "BlockAppEvalDelta | None" = field( + default=None, + metadata=nested("dt", lambda: BlockAppEvalDelta), + ) + config_asset: int | None = field(default=None, metadata=wire("caid")) + application_id: int | None = field(default=None, metadata=wire("apid")) + + +@dataclass(slots=True) +class SignedTxnWithAD: + """Signed transaction with associated apply data.""" + + signed_transaction: SignedTransaction = field(metadata=flatten(lambda: SignedTransaction)) + apply_data: ApplyData | None = field(default=None, metadata=flatten(lambda: ApplyData)) + + +@dataclass(slots=True) +class TxnCommitments: + """Transaction commitment hashes for the block.""" + + native_sha512_256_commitment: bytes = field(default_factory=lambda: bytes(32), metadata=wire("txn")) + """Root of transaction merkle tree using SHA512_256.""" + sha256_commitment: bytes | None = field(default_factory=lambda: bytes(32), metadata=wire("txn256")) + """Root of transaction vector commitment using SHA256.""" + sha512_commitment: bytes | None = field(default_factory=lambda: bytes(64), metadata=wire("txn512")) + """Root of transaction vector commitment using SHA512.""" + + +@dataclass(slots=True) +class RewardState: + """Reward distribution state for the block.""" + + fee_sink: str = field(default=ZERO_ADDRESS, metadata=addr("fees")) + rewards_pool: str = field(default=ZERO_ADDRESS, metadata=addr("rwd")) + rewards_level: int = field(default=0, metadata=wire("earn")) + rewards_rate: int = field(default=0, metadata=wire("rate")) + rewards_residue: int = field(default=0, metadata=wire("frac")) + rewards_recalculation_round: int = field(default=0, metadata=wire("rwcalr")) + + +@dataclass(slots=True) +class UpgradeState: + """Protocol upgrade state for the block.""" + + current_protocol: str = field(default="", metadata=wire("proto", required=True)) + next_protocol: str | None = field(default=None, metadata=wire("nextproto")) + next_protocol_approvals: int | None = field(default=None, metadata=wire("nextyes")) + next_protocol_vote_before: int | None = field(default=None, metadata=wire("nextbefore")) + next_protocol_switch_on: int | None = field(default=None, metadata=wire("nextswitch")) + + +@dataclass(slots=True) +class UpgradeVote: + """Protocol upgrade vote parameters for the block.""" + + upgrade_propose: str | None = field(default=None, metadata=wire("upgradeprop")) + upgrade_delay: int | None = field(default=None, metadata=wire("upgradedelay")) + upgrade_approve: bool | None = field(default=None, metadata=wire("upgradeyes")) + + +@dataclass(slots=True) +class ParticipationUpdates: + """Participation account updates embedded in a block.""" + + expired_participation_accounts: tuple[str, ...] = field(default=(), metadata=addr_seq("partupdrmv")) + absent_participation_accounts: tuple[str, ...] = field(default=(), metadata=addr_seq("partupdabs")) + + +@dataclass(slots=True) +class SignedTxnInBlock: + """Signed transaction details with block-specific apply data.""" + + signed_transaction: SignedTxnWithAD = field(metadata=flatten(lambda: SignedTxnWithAD)) + has_genesis_id: bool | None = field(default=None, metadata=wire("hgi", decode=decode_optional_bool)) + has_genesis_hash: bool | None = field(default=None, metadata=wire("hgh", decode=decode_optional_bool)) + + +@dataclass(slots=True) +class BlockAppEvalDelta: + """State changes produced by an application execution during block evaluation.""" + + global_delta: BlockStateDelta | None = field( + default=None, + metadata=wire( + "gd", + encode=_encode_block_state_delta, + decode=_decode_block_state_delta, + ), + ) + local_deltas: dict[int, BlockStateDelta] | None = field( + default=None, + metadata=wire( + "ld", + encode=_encode_local_deltas, + decode=_decode_local_deltas, + ), + ) + inner_txns: list[SignedTxnWithAD] | None = field( + default=None, + metadata=wire( + "itx", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: SignedTxnWithAD, raw), + ), + ) + shared_accounts: tuple[str, ...] | None = field(default=None, metadata=addr_seq("sa")) + logs: list[bytes] | None = field(default=None, metadata=wire("lg")) + + +@dataclass(slots=True) +class BlockHeader: + """Block header fields.""" + + round: int = field(default=0, metadata=wire("rnd")) + previous_block_hash: bytes = field(default_factory=lambda: bytes(32), metadata=wire("prev")) + previous_block_hash_512: bytes | None = field(default=None, metadata=wire("prev512")) + seed: bytes = field(default=b"", metadata=wire("seed")) + txn_commitments: TxnCommitments = field( + default_factory=TxnCommitments, + metadata=flatten(lambda: TxnCommitments), + ) + timestamp: int = field(default=0, metadata=wire("ts")) + genesis_id: str = field(default="", metadata=wire("gen")) + genesis_hash: bytes = field(default_factory=lambda: bytes(32), metadata=wire("gh")) + proposer: str | None = field(default=None, metadata=addr("prp")) + fees_collected: int | None = field(default=None, metadata=wire("fc")) + bonus: int | None = field(default=None, metadata=wire("bi")) + proposer_payout: int | None = field(default=None, metadata=wire("pp")) + reward_state: RewardState = field( + default_factory=RewardState, + metadata=flatten(lambda: RewardState), + ) + upgrade_state: UpgradeState = field( + default_factory=UpgradeState, + metadata=flatten(lambda: UpgradeState), + ) + upgrade_vote: UpgradeVote | None = field( + default=None, + metadata=flatten(lambda: UpgradeVote), + ) + txn_counter: int | None = field(default=None, metadata=wire("tc")) + state_proof_tracking: BlockStateProofTracking | None = field( + default=None, + metadata=wire( + "spt", + encode=mapping_encoder(lambda: BlockStateProofTrackingData), + decode=mapping_decoder( + lambda: BlockStateProofTrackingData, + key_decoder=_decode_state_proof_tracking_key, + ), + ), + ) + participation_updates: ParticipationUpdates = field( + default_factory=ParticipationUpdates, + metadata=flatten(lambda: ParticipationUpdates), + ) + + +@dataclass(slots=True) +class Block: + """Block header fields and transactions for a ledger round.""" + + header: BlockHeader = field(metadata=flatten(lambda: BlockHeader)) + payset: list[SignedTxnInBlock] | None = field( + default=None, + metadata=wire( + "txns", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: SignedTxnInBlock, raw), + ), + ) + + def __post_init__(self) -> None: + # populates genesis id and hash on transactions if required to ensure + # tx id's are correct + genesis_id = self.header.genesis_id + genesis_hash = self.header.genesis_hash + set_frozen_field = object.__setattr__ + for txn_in_block in self.payset or []: + txn = txn_in_block.signed_transaction.signed_transaction.txn + + if txn_in_block.has_genesis_id and txn.genesis_id is None: + set_frozen_field(txn, "genesis_id", genesis_id) + + # the following assumes that Consensus.RequireGenesisHash is true + # so assigns genesis hash unless explicitly set to False + if txn_in_block.has_genesis_hash is not False and txn.genesis_hash is None: + set_frozen_field(txn, "genesis_hash", genesis_hash) + + +@dataclass(slots=True) +class BlockResponse: + """Response payload for the get block endpoint (with optional certificate).""" + + block: Block = field(metadata=nested("block", lambda: Block)) + cert: dict[str, object] | None = field(default=None, metadata=wire("cert")) diff --git a/api/oas-generator/src/oas_generator/renderer/templates/models/enum.py.j2 b/api/oas-generator/src/oas_generator/renderer/templates/models/enum.py.j2 new file mode 100644 index 00000000..f6194549 --- /dev/null +++ b/api/oas-generator/src/oas_generator/renderer/templates/models/enum.py.j2 @@ -0,0 +1,10 @@ + + +from enum import Enum + + +class {{ enum.name }}(Enum): +{% if enum.description %}{{ enum.description | docstring(4) }}{% endif %} + {%- for value in enum.values %} + {{ value.member_name }} = {{ value.value | tojson }} + {%- endfor %} diff --git a/api/oas-generator/src/oas_generator/renderer/templates/models/ledger_state_delta.py.j2 b/api/oas-generator/src/oas_generator/renderer/templates/models/ledger_state_delta.py.j2 new file mode 100644 index 00000000..a6900948 --- /dev/null +++ b/api/oas-generator/src/oas_generator/renderer/templates/models/ledger_state_delta.py.j2 @@ -0,0 +1,388 @@ +from __future__ import annotations + +from dataclasses import dataclass, field + +from algokit_common.serde import addr, flatten, nested, wire + +from ._block import Block +from ._serde_helpers import ( + decode_bytes_map_key, + decode_model_sequence, + encode_bytes, + encode_model_sequence, + mapping_decoder, + mapping_encoder, +) + +__all__ = [ + "LedgerTealValue", + "LedgerStateSchema", + "LedgerAppParams", + "LedgerAppLocalState", + "LedgerAppLocalStateDelta", + "LedgerAppParamsDelta", + "LedgerAppResourceRecord", + "LedgerAssetHolding", + "LedgerAssetHoldingDelta", + "LedgerAssetParams", + "LedgerAssetParamsDelta", + "LedgerAssetResourceRecord", + "LedgerVotingData", + "LedgerAccountBaseData", + "LedgerAccountData", + "LedgerBalanceRecord", + "LedgerAccountDeltas", + "LedgerKvValueDelta", + "LedgerIncludedTransactions", + "LedgerModifiedCreatable", + "LedgerAlgoCount", + "LedgerAccountTotals", + "LedgerStateDelta", + "LedgerStateDeltaForTransactionGroup", + "TransactionGroupLedgerStateDeltasForRound", +] + + +def _encode_bytes_key(key: object) -> str: + if isinstance(key, bytes): + return encode_bytes(key) + if isinstance(key, memoryview | bytearray): + return encode_bytes(bytes(key)) + raise TypeError("Ledger map keys must be bytes-like") + + +def _encode_numeric_key(key: object) -> str: + if isinstance(key, bool): + return str(int(key)) + if isinstance(key, int): + return str(key) + if isinstance(key, str): + return str(int(key)) + raise TypeError("Ledger map keys must be numeric") + + +def _decode_numeric_key(key: object) -> int: + if isinstance(key, int): + return key + if isinstance(key, str): + return int(key) + raise TypeError("Ledger map keys must be numeric") + + +@dataclass(slots=True) +class LedgerTealValue: + """Type and value for TEAL key-value entries.""" + + type: int = field(metadata=wire("tt", required=True)) + bytes_: bytes | None = field(default=None, metadata=wire("tb")) + uint: int | None = field(default=None, metadata=wire("ui")) + + +@dataclass(slots=True) +class LedgerStateSchema: + """Maximum counts for values stored in state.""" + + num_uints: int | None = field(default=None, metadata=wire("nui")) + num_byte_slices: int | None = field(default=None, metadata=wire("nbs")) + + +@dataclass(slots=True) +class LedgerAppParams: + """Application parameters in ledger deltas.""" + + approval_program: bytes = field(metadata=wire("approv", required=True)) + clear_state_program: bytes = field(metadata=wire("clearp", required=True)) + extra_program_pages: int | None = field(default=None, metadata=wire("epp")) + version: int | None = field(default=None, metadata=wire("v")) + size_sponsor: str | None = field(default=None, metadata=addr("ss")) + local_state_schema: LedgerStateSchema | None = field( + default=None, metadata=nested("lsch", lambda: LedgerStateSchema) + ) + global_state_schema: LedgerStateSchema | None = field( + default=None, metadata=nested("gsch", lambda: LedgerStateSchema) + ) + global_state: dict[bytes, LedgerTealValue] | None = field( + default=None, + metadata=wire( + "gs", + encode=mapping_encoder(lambda: LedgerTealValue, key_encoder=_encode_bytes_key), + decode=mapping_decoder(lambda: LedgerTealValue, key_decoder=decode_bytes_map_key), + ), + ) + + +@dataclass(slots=True) +class LedgerAppLocalState: + """Local state information for an application.""" + + schema: LedgerStateSchema | None = field(default=None, metadata=nested("hsch", lambda: LedgerStateSchema)) + key_value: dict[bytes, LedgerTealValue] | None = field( + default=None, + metadata=wire( + "tkv", + encode=mapping_encoder(lambda: LedgerTealValue, key_encoder=_encode_bytes_key), + decode=mapping_decoder(lambda: LedgerTealValue, key_decoder=decode_bytes_map_key), + ), + ) + + +@dataclass(slots=True) +class LedgerAppLocalStateDelta: + """Tracks changes to an application's local state.""" + + deleted: bool = field(metadata=wire("Deleted", required=True)) + local_state: LedgerAppLocalState | None = field( + default=None, + metadata=nested("LocalState", lambda: LedgerAppLocalState), + ) + + +@dataclass(slots=True) +class LedgerAppParamsDelta: + """Tracks changes to application parameters.""" + + deleted: bool = field(metadata=wire("Deleted", required=True)) + params: LedgerAppParams | None = field(default=None, metadata=nested("Params", lambda: LedgerAppParams)) + + +@dataclass(slots=True) +class LedgerAppResourceRecord: + """App params and local state changes keyed by app and address.""" + + app_id: int = field(metadata=wire("Aidx", required=True)) + address: str = field(metadata=addr("Addr")) + params: LedgerAppParamsDelta = field(metadata=nested("Params", lambda: LedgerAppParamsDelta)) + state: LedgerAppLocalStateDelta = field(metadata=nested("State", lambda: LedgerAppLocalStateDelta)) + + +@dataclass(slots=True) +class LedgerAssetHolding: + """Asset holding details in ledger deltas.""" + + amount: int | None = field(default=None, metadata=wire("a")) + frozen: bool | None = field(default=None, metadata=wire("f")) + + +@dataclass(slots=True) +class LedgerAssetHoldingDelta: + """Tracks a changed asset holding.""" + + deleted: bool = field(metadata=wire("Deleted", required=True)) + holding: LedgerAssetHolding | None = field(default=None, metadata=nested("Holding", lambda: LedgerAssetHolding)) + + +@dataclass(slots=True) +class LedgerAssetParams: + """Asset parameters reflected in ledger deltas.""" + + total: int = field(metadata=wire("t", required=True)) + decimals: int = field(metadata=wire("dc", required=True)) + default_frozen: bool | None = field(default=None, metadata=wire("df")) + unit_name: str | None = field(default=None, metadata=wire("un")) + asset_name: str | None = field(default=None, metadata=wire("an")) + url: str | None = field(default=None, metadata=wire("au")) + metadata_hash: bytes | None = field(default=None, metadata=wire("am")) + manager: str | None = field(default=None, metadata=addr("m")) + reserve: str | None = field(default=None, metadata=addr("r")) + freeze: str | None = field(default=None, metadata=addr("f")) + clawback: str | None = field(default=None, metadata=addr("c")) + + +@dataclass(slots=True) +class LedgerAssetParamsDelta: + """Tracks updates to asset parameters.""" + + deleted: bool = field(metadata=wire("Deleted", required=True)) + params: LedgerAssetParams | None = field(default=None, metadata=nested("Params", lambda: LedgerAssetParams)) + + +@dataclass(slots=True) +class LedgerAssetResourceRecord: + """Asset params and holding changes keyed by asset and address.""" + + asset_id: int = field(metadata=wire("Aidx", required=True)) + address: str = field(metadata=addr("Addr")) + params: LedgerAssetParamsDelta = field(metadata=nested("Params", lambda: LedgerAssetParamsDelta)) + holding: LedgerAssetHoldingDelta = field(metadata=nested("Holding", lambda: LedgerAssetHoldingDelta)) + + +@dataclass(slots=True) +class LedgerVotingData: + """Participation-related voting data.""" + + vote_id: bytes = field(metadata=wire("VoteID", required=True)) + selection_id: bytes = field(metadata=wire("SelectionID", required=True)) + state_proof_id: bytes = field(metadata=wire("StateProofID", required=True)) + vote_first_valid: int = field(metadata=wire("VoteFirstValid", required=True)) + vote_last_valid: int = field(metadata=wire("VoteLastValid", required=True)) + vote_key_dilution: int = field(metadata=wire("VoteKeyDilution", required=True)) + + +@dataclass(slots=True) +class LedgerAccountBaseData: + """Base account data captured in ledger deltas.""" + + status: int = field(metadata=wire("Status", required=True)) + micro_algos: int = field(metadata=wire("MicroAlgos", required=True)) + rewards_base: int = field(metadata=wire("RewardsBase", required=True)) + rewarded_micro_algos: int = field(metadata=wire("RewardedMicroAlgos", required=True)) + auth_address: str = field(metadata=addr("AuthAddr")) + incentive_eligible: bool = field(metadata=wire("IncentiveEligible", required=True)) + total_app_schema: LedgerStateSchema = field(metadata=nested("TotalAppSchema", lambda: LedgerStateSchema)) + total_extra_app_pages: int = field(metadata=wire("TotalExtraAppPages", required=True)) + total_app_params: int = field(metadata=wire("TotalAppParams", required=True)) + total_app_local_states: int = field(metadata=wire("TotalAppLocalStates", required=True)) + total_asset_params: int = field(metadata=wire("TotalAssetParams", required=True)) + total_assets: int = field(metadata=wire("TotalAssets", required=True)) + total_boxes: int = field(metadata=wire("TotalBoxes", required=True)) + total_box_bytes: int = field(metadata=wire("TotalBoxBytes", required=True)) + last_proposed: int = field(metadata=wire("LastProposed", required=True)) + last_heartbeat: int = field(metadata=wire("LastHeartbeat", required=True)) + + +@dataclass(slots=True) +class LedgerAccountData: + """Aggregates base and voting data for an account.""" + + account_base_data: LedgerAccountBaseData = field(metadata=flatten(lambda: LedgerAccountBaseData)) + voting_data: LedgerVotingData = field(metadata=flatten(lambda: LedgerVotingData)) + + +@dataclass(slots=True) +class LedgerBalanceRecord: + """Account data keyed by address.""" + + address: str = field(metadata=addr("Addr")) + account_data: LedgerAccountData = field(metadata=flatten(lambda: LedgerAccountData)) + + +@dataclass(slots=True) +class LedgerAccountDeltas: + """Account/app/asset updates included in a ledger delta.""" + + accounts: list[LedgerBalanceRecord] | None = field( + default=None, + metadata=wire( + "Accts", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: LedgerBalanceRecord, raw), + ), + ) + app_resources: list[LedgerAppResourceRecord] | None = field( + default=None, + metadata=wire( + "AppResources", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: LedgerAppResourceRecord, raw), + ), + ) + asset_resources: list[LedgerAssetResourceRecord] | None = field( + default=None, + metadata=wire( + "AssetResources", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: LedgerAssetResourceRecord, raw), + ), + ) + + +@dataclass(slots=True) +class LedgerKvValueDelta: + """Delta for a single key/value entry in the KV store.""" + + data: bytes | None = field(default=None, metadata=wire("Data")) + old_data: bytes | None = field(default=None, metadata=wire("OldData")) + + +@dataclass(slots=True) +class LedgerIncludedTransactions: + """Transaction placement information.""" + + last_valid: int = field(metadata=wire("LastValid", required=True)) + intra: int = field(metadata=wire("Intra", required=True)) + + +@dataclass(slots=True) +class LedgerModifiedCreatable: + """Changes to a creatable resource.""" + + creatable_type: int = field(metadata=wire("Ctype", required=True)) + created: bool = field(metadata=wire("Created", required=True)) + creator: str = field(metadata=addr("Creator")) + ndeltas: int = field(metadata=wire("Ndeltas", required=True)) + + +@dataclass(slots=True) +class LedgerAlgoCount: + """Totals for groups of accounts.""" + + money: int = field(metadata=wire("mon", required=True)) + reward_units: int = field(metadata=wire("rwd", required=True)) + + +@dataclass(slots=True) +class LedgerAccountTotals: + """Aggregate Algo totals grouped by account status.""" + + online: LedgerAlgoCount = field(metadata=nested("online", lambda: LedgerAlgoCount)) + offline: LedgerAlgoCount = field(metadata=nested("offline", lambda: LedgerAlgoCount)) + not_participating: LedgerAlgoCount = field(metadata=nested("notpart", lambda: LedgerAlgoCount)) + rewards_level: int = field(metadata=wire("rwdlvl", required=True)) + + +@dataclass(slots=True) +class LedgerStateDelta: + """State delta between rounds.""" + + accounts: LedgerAccountDeltas = field(metadata=nested("Accts", lambda: LedgerAccountDeltas)) + block: Block = field(metadata=nested("Hdr", lambda: Block)) + state_proof_next: int = field(metadata=wire("StateProofNext", required=True)) + prev_timestamp: int = field(metadata=wire("PrevTimestamp", required=True)) + totals: LedgerAccountTotals = field(metadata=nested("Totals", lambda: LedgerAccountTotals)) + kv_mods: dict[bytes, LedgerKvValueDelta] | None = field( + default=None, + metadata=wire( + "KvMods", + encode=mapping_encoder(lambda: LedgerKvValueDelta, key_encoder=_encode_bytes_key), + decode=mapping_decoder(lambda: LedgerKvValueDelta, key_decoder=decode_bytes_map_key), + ), + ) + tx_ids: dict[bytes, LedgerIncludedTransactions] | None = field( + default=None, + metadata=wire( + "Txids", + encode=mapping_encoder(lambda: LedgerIncludedTransactions, key_encoder=_encode_bytes_key), + decode=mapping_decoder(lambda: LedgerIncludedTransactions, key_decoder=decode_bytes_map_key), + ), + ) + # NOTE: tx_leases field is intentionally omitted - msgpack maps with object keys are not supported + creatables: dict[int, LedgerModifiedCreatable] | None = field( + default=None, + metadata=wire( + "Creatables", + encode=mapping_encoder(lambda: LedgerModifiedCreatable, key_encoder=_encode_numeric_key), + decode=mapping_decoder(lambda: LedgerModifiedCreatable, key_decoder=_decode_numeric_key), + ), + ) + + +@dataclass(slots=True) +class LedgerStateDeltaForTransactionGroup: + """Ledger delta for a single transaction group.""" + + delta: LedgerStateDelta = field(metadata=nested("Delta", lambda: LedgerStateDelta)) + ids: list[str] = field(metadata=wire("Ids", required=True)) + + +@dataclass(slots=True) +class TransactionGroupLedgerStateDeltasForRound: + """All ledger deltas for transaction groups in a round.""" + + deltas: list[LedgerStateDeltaForTransactionGroup] = field( + metadata=wire( + "Deltas", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: LedgerStateDeltaForTransactionGroup, raw), + required=True, + ) + ) diff --git a/api/oas-generator/src/oas_generator/renderer/templates/models/model.py.j2 b/api/oas-generator/src/oas_generator/renderer/templates/models/model.py.j2 new file mode 100644 index 00000000..a4e663b4 --- /dev/null +++ b/api/oas-generator/src/oas_generator/renderer/templates/models/model.py.j2 @@ -0,0 +1,23 @@ + + +from dataclasses import dataclass, field +{% if model.needs_any %}from typing import Any +{% endif %}{% set helper_ns = namespace(items=[]) %}{% if model.uses_wire %}{% set helper_ns.items = helper_ns.items + ['wire'] %}{% endif %}{% if model.uses_nested %}{% set helper_ns.items = helper_ns.items + ['nested'] %}{% endif %}{% if model.uses_flatten %}{% set helper_ns.items = helper_ns.items + ['flatten'] %}{% endif %}{% if model.uses_enum_value %}{% set helper_ns.items = helper_ns.items + ['enum_value'] %}{% endif %}{% if helper_ns.items %}from algokit_common.serde import {{ helper_ns.items | join(', ') }} +{% endif %}{% for imp in model.imports %}{{ imp }} +{% endfor %} + + +@dataclass(slots=True) +class {{ model.name }}: +{% if model.description %}{{ model.description | docstring(4) }}{% endif %} + {%- for field in model.fields %} + {{ field.name }}: {{ field.type_hint }} = field( + {%- if field.default_value %} + default={{ field.default_value }}, + {%- endif %} + {%- if field.default_factory %} + default_factory={{ field.default_factory }}, + {%- endif %} + metadata={{ field.metadata }}, + ) + {%- endfor %} diff --git a/api/oas-generator/src/oas_generator/renderer/templates/models/suggested_params.py.j2 b/api/oas-generator/src/oas_generator/renderer/templates/models/suggested_params.py.j2 new file mode 100644 index 00000000..c3e0aa55 --- /dev/null +++ b/api/oas-generator/src/oas_generator/renderer/templates/models/suggested_params.py.j2 @@ -0,0 +1,42 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class SuggestedParams: + """Contains parameters relevant to creating a new transaction over a time window.""" + + consensus_version: str = field( + metadata=wire("consensus-version"), + ) + fee: int = field( + metadata=wire("fee"), + ) + genesis_hash: bytes = field( + metadata=wire( + "genesis-hash", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + genesis_id: str = field( + metadata=wire("genesis-id"), + ) + min_fee: int = field( + metadata=wire("min-fee"), + ) + flat_fee: bool = field( + metadata=wire("flat-fee"), + ) + first_valid: int = field( + metadata=wire("first-valid"), + ) + last_valid: int = field( + metadata=wire("last-valid"), + ) diff --git a/api/oas-generator/src/oas_generator/renderer/templates/models/type_alias.py.j2 b/api/oas-generator/src/oas_generator/renderer/templates/models/type_alias.py.j2 new file mode 100644 index 00000000..6560c74a --- /dev/null +++ b/api/oas-generator/src/oas_generator/renderer/templates/models/type_alias.py.j2 @@ -0,0 +1,6 @@ + + +{% for imp in alias.imports %}{{ imp }} +{% endfor %} + +{{ alias.name }} = {{ alias.target }} diff --git a/api/oas-generator/src/oas_generator/renderer/templates/package_init.py.j2 b/api/oas-generator/src/oas_generator/renderer/templates/package_init.py.j2 new file mode 100644 index 00000000..615944b4 --- /dev/null +++ b/api/oas-generator/src/oas_generator/renderer/templates/package_init.py.j2 @@ -0,0 +1,9 @@ + + +from .client import {{ client.class_name }} +from .config import ClientConfig + +__all__ = [ + "{{ client.class_name }}", + "ClientConfig", +] diff --git a/api/oas-generator/src/oas_generator/renderer/templates/types.py.j2 b/api/oas-generator/src/oas_generator/renderer/templates/types.py.j2 new file mode 100644 index 00000000..3c0891dd --- /dev/null +++ b/api/oas-generator/src/oas_generator/renderer/templates/types.py.j2 @@ -0,0 +1,6 @@ + + +from typing import Any + +JSONMapping = dict[str, Any] +Headers = dict[str, str] diff --git a/api/oas-generator/src/oas_generator/writer.py b/api/oas-generator/src/oas_generator/writer.py new file mode 100644 index 00000000..6e482db2 --- /dev/null +++ b/api/oas-generator/src/oas_generator/writer.py @@ -0,0 +1,82 @@ +from collections.abc import Iterable +from pathlib import Path + +_SENTINEL = "# AUTO-GENERATED: oas_generator" + + +def write_files(file_map: dict[Path, str], target_root: Path) -> None: + target_root.mkdir(parents=True, exist_ok=True) + legacy_manifest = target_root / ".generated-files" + if legacy_manifest.exists(): + legacy_manifest.unlink() + relative_map = _map_relative_paths(file_map, target_root) + existing_generated = _discover_generated_files(target_root) + new_files = set(relative_map.values()) + _remove_stale_files(target_root, existing_generated - new_files) + for path, contents in file_map.items(): + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(_ensure_sentinel(contents), encoding="utf-8") + _remove_empty_directories(target_root) + + +def _map_relative_paths(file_map: dict[Path, str], target_root: Path) -> dict[Path, Path]: + relative: dict[Path, Path] = {} + for absolute_path in file_map: + try: + relative_path = absolute_path.relative_to(target_root) + except ValueError as exc: # pragma: no cover - defensive branch + raise ValueError(f"Generated file {absolute_path} is outside of target root {target_root}") from exc + relative[absolute_path] = relative_path + return relative + + +def _ensure_sentinel(contents: str) -> str: + text = contents.lstrip("\ufeff") + if _SENTINEL in text.splitlines()[:3]: + return text + if not text: + return f"{_SENTINEL}\n" + return f"{_SENTINEL}\n{text}" + + +def _discover_generated_files(target_root: Path) -> set[Path]: + generated: set[Path] = set() + if not target_root.exists(): + return generated + for path in target_root.rglob("*"): + if not path.is_file(): + continue + try: + with path.open("r", encoding="utf-8") as handle: + for _ in range(3): + line = handle.readline() + if not line: + break + if _SENTINEL in line: + generated.add(path.relative_to(target_root)) + break + except UnicodeDecodeError: + continue + return generated + + +def _remove_stale_files(target_root: Path, stale_paths: Iterable[Path]) -> None: + for relative_path in sorted(stale_paths, key=lambda p: len(p.parts), reverse=True): + absolute_path = target_root / relative_path + if absolute_path.is_file(): + absolute_path.unlink(missing_ok=True) + + +def _remove_empty_directories(target_root: Path) -> None: + directories = sorted( + {path for path in target_root.rglob("*") if path.is_dir()}, + key=lambda p: len(p.parts), + reverse=True, + ) + for directory in directories: + if directory == target_root: + continue + try: + directory.rmdir() + except OSError: + continue diff --git a/api/oas-generator/tests/test_naming.py b/api/oas-generator/tests/test_naming.py new file mode 100644 index 00000000..ccae93f2 --- /dev/null +++ b/api/oas-generator/tests/test_naming.py @@ -0,0 +1,76 @@ +"""Tests for IdentifierSanitizer camelCase / PascalCase → snake_case conversion.""" + +import pytest +from oas_generator.naming import IdentifierSanitizer + +_san = IdentifierSanitizer() + + +# ── snake() ────────────────────────────────────────────────────────────────── + + +@pytest.mark.parametrize( + ("raw", "expected"), + [ + # Simple camelCase + ("makeHealthCheck", "make_health_check"), + ("searchForAccounts", "search_for_accounts"), + # Trailing acronym (e.g. "ByID") + ("lookupAccountByID", "lookup_account_by_id"), + ("lookupApplicationByID", "lookup_application_by_id"), + ("lookupApplicationLogsByID", "lookup_application_logs_by_id"), + # Acronym followed by PascalCase word — the original bug + ("lookupApplicationBoxByIDAndName", "lookup_application_box_by_id_and_name"), + # Multiple consecutive acronyms + ("parseXMLToJSON", "parse_xml_to_json"), + ("getHTTPSUrl", "get_https_url"), + # Leading acronym + ("HTMLParser", "html_parser"), + ("JSONResponse", "json_response"), + # Single word + ("version", "version"), + ("Version", "version"), + # Already snake_case passthrough + ("already_snake", "already_snake"), + # Digits mixed in + ("sha256Hash", "sha256_hash"), + ("get2FACode", "get2_fa_code"), + # Hyphenated / non-word chars + ("content-type", "content_type"), + ("X-Forwarded-For", "x_forwarded_for"), + # Python reserved words get suffix + ("class", "class_"), + ("import", "import_"), + ], +) +def test_snake(raw: str, expected: str) -> None: + assert _san.snake(raw) == expected + + +# ── pascal() ───────────────────────────────────────────────────────────────── + + +@pytest.mark.parametrize( + ("raw", "expected"), + [ + ("make_health_check", "MakeHealthCheck"), + ("lookupAccountByID", "LookupAccountById"), + ("version", "Version"), + ], +) +def test_pascal(raw: str, expected: str) -> None: + assert _san.pascal(raw) == expected + + +# ── camel() ────────────────────────────────────────────────────────────────── + + +@pytest.mark.parametrize( + ("raw", "expected"), + [ + ("MakeHealthCheck", "makeHealthCheck"), + ("Version", "version"), + ], +) +def test_camel(raw: str, expected: str) -> None: + assert _san.camel(raw) == expected diff --git a/api/oas-generator/uv.lock b/api/oas-generator/uv.lock new file mode 100644 index 00000000..c2f6eae4 --- /dev/null +++ b/api/oas-generator/uv.lock @@ -0,0 +1,111 @@ +version = 1 +revision = 3 +requires-python = ">=3.10" + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, +] + +[[package]] +name = "markupsafe" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/4b/3541d44f3937ba468b75da9eebcae497dcf67adb65caa16760b0a6807ebb/markupsafe-3.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559", size = 11631, upload-time = "2025-09-27T18:36:05.558Z" }, + { url = "https://files.pythonhosted.org/packages/98/1b/fbd8eed11021cabd9226c37342fa6ca4e8a98d8188a8d9b66740494960e4/markupsafe-3.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419", size = 12057, upload-time = "2025-09-27T18:36:07.165Z" }, + { url = "https://files.pythonhosted.org/packages/40/01/e560d658dc0bb8ab762670ece35281dec7b6c1b33f5fbc09ebb57a185519/markupsafe-3.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695", size = 22050, upload-time = "2025-09-27T18:36:08.005Z" }, + { url = "https://files.pythonhosted.org/packages/af/cd/ce6e848bbf2c32314c9b237839119c5a564a59725b53157c856e90937b7a/markupsafe-3.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591", size = 20681, upload-time = "2025-09-27T18:36:08.881Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2a/b5c12c809f1c3045c4d580b035a743d12fcde53cf685dbc44660826308da/markupsafe-3.0.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c", size = 20705, upload-time = "2025-09-27T18:36:10.131Z" }, + { url = "https://files.pythonhosted.org/packages/cf/e3/9427a68c82728d0a88c50f890d0fc072a1484de2f3ac1ad0bfc1a7214fd5/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f", size = 21524, upload-time = "2025-09-27T18:36:11.324Z" }, + { url = "https://files.pythonhosted.org/packages/bc/36/23578f29e9e582a4d0278e009b38081dbe363c5e7165113fad546918a232/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6", size = 20282, upload-time = "2025-09-27T18:36:12.573Z" }, + { url = "https://files.pythonhosted.org/packages/56/21/dca11354e756ebd03e036bd8ad58d6d7168c80ce1fe5e75218e4945cbab7/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1", size = 20745, upload-time = "2025-09-27T18:36:13.504Z" }, + { url = "https://files.pythonhosted.org/packages/87/99/faba9369a7ad6e4d10b6a5fbf71fa2a188fe4a593b15f0963b73859a1bbd/markupsafe-3.0.3-cp310-cp310-win32.whl", hash = "sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa", size = 14571, upload-time = "2025-09-27T18:36:14.779Z" }, + { url = "https://files.pythonhosted.org/packages/d6/25/55dc3ab959917602c96985cb1253efaa4ff42f71194bddeb61eb7278b8be/markupsafe-3.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8", size = 15056, upload-time = "2025-09-27T18:36:16.125Z" }, + { url = "https://files.pythonhosted.org/packages/d0/9e/0a02226640c255d1da0b8d12e24ac2aa6734da68bff14c05dd53b94a0fc3/markupsafe-3.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1", size = 13932, upload-time = "2025-09-27T18:36:17.311Z" }, + { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" }, + { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" }, + { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" }, + { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" }, + { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" }, + { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" }, + { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" }, + { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" }, + { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" }, + { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" }, + { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" }, + { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" }, + { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" }, + { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" }, + { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" }, + { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" }, + { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" }, + { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" }, + { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" }, + { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" }, + { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" }, + { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" }, + { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" }, + { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" }, + { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" }, + { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" }, + { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" }, + { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" }, + { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" }, + { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" }, + { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" }, + { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" }, + { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" }, + { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" }, + { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" }, + { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" }, + { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" }, + { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" }, + { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" }, + { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" }, + { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" }, + { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" }, + { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" }, + { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" }, + { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" }, + { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" }, + { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" }, + { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" }, + { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" }, + { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" }, + { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" }, + { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" }, + { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" }, + { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" }, + { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" }, + { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" }, + { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" }, + { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" }, +] + +[[package]] +name = "oas-generator" +version = "0.1.0" +source = { editable = "." } +dependencies = [ + { name = "jinja2" }, +] + +[package.metadata] +requires-dist = [{ name = "jinja2", specifier = ">=3.1" }] diff --git a/docs/.gitignore b/docs/.gitignore new file mode 100644 index 00000000..1d6fe05b --- /dev/null +++ b/docs/.gitignore @@ -0,0 +1,25 @@ +# build output +dist/ +# generated types +.astro/ +# generated API docs (built by sphinx-autoapi) +src/content/docs/api/ + +# generated example pages (built by generate-examples-mdx.ts) +src/content/docs/examples/ + +# dependencies +node_modules/ + +# logs +npm-debug.log* +yarn-debug.log* +yarn-error.log* +pnpm-debug.log* + +# environment variables +.env +.env.production + +# macOS-specific files +.DS_Store diff --git a/docs/Makefile b/docs/Makefile deleted file mode 100644 index d0c3cbf1..00000000 --- a/docs/Makefile +++ /dev/null @@ -1,20 +0,0 @@ -# Minimal makefile for Sphinx documentation -# - -# You can set these variables from the command line, and also -# from the environment for the first two. -SPHINXOPTS ?= -SPHINXBUILD ?= sphinx-build -SOURCEDIR = source -BUILDDIR = build - -# Put it first so that "make" without argument is like "make help". -help: - @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) - -.PHONY: help Makefile - -# Catch-all target: route all unknown targets to Sphinx using the new -# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). -%: Makefile - @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/api_build.py b/docs/api_build.py new file mode 100644 index 00000000..0451d8e2 --- /dev/null +++ b/docs/api_build.py @@ -0,0 +1,181 @@ +#!/usr/bin/env python3 +"""Generate API reference markdown from Python source using Sphinx + autoapi, +then post-process the output for Starlight consumption. + +Replaces the former docs/api-build.sh with a cross-platform Python implementation +that includes better error handling and robustness. +""" + +from __future__ import annotations + +import re +import shutil +import subprocess +import sys +from pathlib import Path + +DOCS_DIR = Path(__file__).resolve().parent +REPO_ROOT = DOCS_DIR.parent +API_OUT = DOCS_DIR / "src" / "content" / "docs" / "api" + +# Regex patterns for shortening qualified names in headings +_HEADING_RE = re.compile(r"^#{3,4}\s") +_LINKED_QUALIFIED_RE = re.compile( + r"\[(?:algokit_\w+|typing_extensions|collections\.abc|algokit_common)" + r"(?:\.\w+)*\.(\w+)\]" +) +_PLAIN_QUALIFIED_RE = re.compile( + r"(? None: + """Remove previous API output and create a fresh directory.""" + print("==> Cleaning previous API output...") + if API_OUT.exists(): + shutil.rmtree(API_OUT) + API_OUT.mkdir(parents=True, exist_ok=True) + + +def _run_sphinx_build() -> None: + """Run Sphinx markdown build to generate API docs.""" + print("==> Running Sphinx markdown build...") + result = subprocess.run( + ["uv", "run", "sphinx-build", "-b", "markdown", "docs/sphinx", str(API_OUT), "-q"], + cwd=str(REPO_ROOT), + capture_output=True, + text=True, + ) + if result.returncode != 0: + print(f"ERROR: Sphinx build failed (exit code {result.returncode})", file=sys.stderr) + if result.stderr: + print(result.stderr, file=sys.stderr) + if result.stdout: + print(result.stdout, file=sys.stderr) + sys.exit(1) + + +def _remove_sphinx_artifacts() -> None: + """Remove Sphinx build artifacts not needed by Starlight.""" + print("==> Removing Sphinx artifacts...") + buildinfo = API_OUT / ".buildinfo" + if buildinfo.exists(): + buildinfo.unlink() + + doctrees = API_OUT / ".doctrees" + if doctrees.exists(): + shutil.rmtree(doctrees) + + # Remove top-level index.md generated from index.rst (not needed in Starlight) + index_md = API_OUT / "index.md" + if index_md.exists(): + index_md.unlink() + + +def _flatten_autoapi() -> None: + """Flatten autoapi/ -- move algokit_utils/ up one level so Starlight sees api/algokit_utils/.""" + print("==> Flattening autoapi directory structure...") + autoapi_algokit = API_OUT / "autoapi" / "algokit_utils" + target = API_OUT / "algokit_utils" + + if not autoapi_algokit.is_dir(): + print( + f"ERROR: Expected autoapi output directory not found: {autoapi_algokit}\n" + "This likely means the Sphinx autoapi configuration or package structure has changed.\n" + "Check that 'autoapi_dirs' in docs/sphinx/conf.py points to the correct source directory.", + file=sys.stderr, + ) + sys.exit(1) + + if target.exists(): + shutil.rmtree(target) + + shutil.move(str(autoapi_algokit), str(target)) + + # Clean up remaining autoapi directory + autoapi_dir = API_OUT / "autoapi" + if autoapi_dir.exists(): + shutil.rmtree(autoapi_dir) + + +def _extract_title(file_path: Path) -> str: + """Extract a human-readable title from the first H1 heading, or fall back to filename.""" + with open(file_path, encoding="utf-8") as f: + for line in f: + if line.startswith("# "): + return line[2:].strip() + return file_path.stem + + +def _inject_frontmatter() -> None: + """Prepend YAML frontmatter with title to each API markdown file.""" + print("==> Injecting Starlight frontmatter into API docs...") + for md_file in sorted(API_OUT.rglob("*.md")): + title = _extract_title(md_file) + # Escape double quotes in the title for YAML safety + escaped_title = title.replace('"', '\\"') + + content = md_file.read_text(encoding="utf-8") + md_file.write_text( + f'---\ntitle: "{escaped_title}"\n---\n\n
\n\n{content}\n\n
\n', + encoding="utf-8", + ) + + +def _fix_internal_links() -> None: + """Fix internal links for Starlight. + + Sphinx generates links like (foo/index.md) and (../../bar/index.md#anchor). + Starlight doesn't use .md extensions -- strip index.md from link paths. + """ + print("==> Fixing internal links for Starlight...") + for md_file in sorted(API_OUT.rglob("*.md")): + content = md_file.read_text(encoding="utf-8") + updated = _INDEX_MD_RE.sub("/", content) + if updated != content: + md_file.write_text(updated, encoding="utf-8") + + +def _shorten_qualified_names() -> None: + """Shorten fully-qualified module paths in H3/H4 headings. + + Strip fully-qualified module paths from heading text so the TOC sidebar and + headings show short names (e.g. "AccountManager" not "algokit_utils.x.y.AccountManager"). + Handles: algokit_utils.*, algokit_transact.*, algokit_common.*, typing_extensions.*, collections.abc.* + Only applies to H3/H4 heading lines. Preserves full paths inside link URLs (...). + """ + print("==> Shortening qualified names in headings...") + for md_file in sorted(API_OUT.rglob("*.md")): + lines = md_file.read_text(encoding="utf-8").splitlines(keepends=True) + changed = False + for i, line in enumerate(lines): + if not _HEADING_RE.match(line): + continue + new_line = _LINKED_QUALIFIED_RE.sub(r"[\1]", line) + new_line = _PLAIN_QUALIFIED_RE.sub(r"\1", new_line) + if new_line != line: + lines[i] = new_line + changed = True + if changed: + md_file.write_text("".join(lines), encoding="utf-8") + + +def main() -> None: + """Run the full API docs build pipeline.""" + _clean_api_output() + _run_sphinx_build() + _remove_sphinx_artifacts() + _flatten_autoapi() + _inject_frontmatter() + _fix_internal_links() + _shorten_qualified_names() + + file_count = sum(1 for _ in API_OUT.rglob("*.md")) + print(f"==> API docs generated at: {API_OUT}") + print(f" {file_count} markdown files") + + +if __name__ == "__main__": + main() diff --git a/docs/astro.config.mjs b/docs/astro.config.mjs new file mode 100644 index 00000000..c14ec17f --- /dev/null +++ b/docs/astro.config.mjs @@ -0,0 +1,40 @@ +// @ts-check +import starlight from "@astrojs/starlight"; +import { defineConfig } from "astro/config"; +import remarkGithubAlerts from "remark-github-alerts"; +import sidebar from "./sidebar.config.json"; + +// https://astro.build/config +export default defineConfig({ + site: "https://algorandfoundation.github.io", + base: "/algokit-utils-py/", + trailingSlash: "always", + markdown: { + remarkPlugins: [remarkGithubAlerts], + }, + integrations: [ + starlight({ + title: "AlgoKit Utils Python", + tableOfContents: { minHeadingLevel: 2, maxHeadingLevel: 4 }, + customCss: [ + "./src/styles/api-reference.css", + "remark-github-alerts/styles/github-colors-light.css", + "remark-github-alerts/styles/github-colors-dark-media.css", + "remark-github-alerts/styles/github-base.css", + ], + social: [ + { + icon: "github", + label: "GitHub", + href: "https://github.com/algorandfoundation/algokit-utils-py", + }, + { + icon: "discord", + label: "Discord", + href: "https://discord.gg/algorand", + }, + ], + sidebar, + }), + ], +}); diff --git a/docs/make.bat b/docs/make.bat deleted file mode 100644 index dc1312ab..00000000 --- a/docs/make.bat +++ /dev/null @@ -1,35 +0,0 @@ -@ECHO OFF - -pushd %~dp0 - -REM Command file for Sphinx documentation - -if "%SPHINXBUILD%" == "" ( - set SPHINXBUILD=sphinx-build -) -set SOURCEDIR=source -set BUILDDIR=build - -%SPHINXBUILD% >NUL 2>NUL -if errorlevel 9009 ( - echo. - echo.The 'sphinx-build' command was not found. Make sure you have Sphinx - echo.installed, then set the SPHINXBUILD environment variable to point - echo.to the full path of the 'sphinx-build' executable. Alternatively you - echo.may add the Sphinx directory to PATH. - echo. - echo.If you don't have Sphinx installed, grab it from - echo.https://www.sphinx-doc.org/ - exit /b 1 -) - -if "%1" == "" goto help - -%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% -goto end - -:help -%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% - -:end -popd diff --git a/docs/markdown/autoapi/algokit_utils/accounts/account_manager/index.md b/docs/markdown/autoapi/algokit_utils/accounts/account_manager/index.md deleted file mode 100644 index b1f7454a..00000000 --- a/docs/markdown/autoapi/algokit_utils/accounts/account_manager/index.md +++ /dev/null @@ -1,643 +0,0 @@ -# algokit_utils.accounts.account_manager - -## Classes - -| [`EnsureFundedResult`](#algokit_utils.accounts.account_manager.EnsureFundedResult) | Result from performing an ensure funded call. | -|----------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------| -| [`EnsureFundedFromTestnetDispenserApiResult`](#algokit_utils.accounts.account_manager.EnsureFundedFromTestnetDispenserApiResult) | Result from performing an ensure funded call using TestNet dispenser API. | -| [`AccountInformation`](#algokit_utils.accounts.account_manager.AccountInformation) | Information about an Algorand account's current status, balance and other properties. | -| [`AccountManager`](#algokit_utils.accounts.account_manager.AccountManager) | Creates and keeps track of signing accounts that can sign transactions for a sending address. | - -## Module Contents - -### *class* algokit_utils.accounts.account_manager.EnsureFundedResult - -Bases: [`algokit_utils.transactions.transaction_sender.SendSingleTransactionResult`](../../transactions/transaction_sender/index.md#algokit_utils.transactions.transaction_sender.SendSingleTransactionResult), `_CommonEnsureFundedParams` - -Result from performing an ensure funded call. - -### *class* algokit_utils.accounts.account_manager.EnsureFundedFromTestnetDispenserApiResult - -Bases: `_CommonEnsureFundedParams` - -Result from performing an ensure funded call using TestNet dispenser API. - -### *class* algokit_utils.accounts.account_manager.AccountInformation - -Information about an Algorand account’s current status, balance and other properties. - -See https://dev.algorand.co/reference/rest-apis/algod/#account for detailed field descriptions. - -#### address *: str* - -The account’s address - -#### amount *: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount)* - -The account’s current balance - -#### amount_without_pending_rewards *: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount)* - -The account’s balance without the pending rewards - -#### min_balance *: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount)* - -The account’s minimum required balance - -#### pending_rewards *: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount)* - -The amount of pending rewards - -#### rewards *: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount)* - -The amount of rewards earned - -#### round *: int* - -The round for which this information is relevant - -#### status *: str* - -The account’s status (e.g., ‘Offline’, ‘Online’) - -#### total_apps_opted_in *: int | None* *= None* - -Number of applications this account has opted into - -#### total_assets_opted_in *: int | None* *= None* - -Number of assets this account has opted into - -#### total_box_bytes *: int | None* *= None* - -Total number of box bytes used by this account - -#### total_boxes *: int | None* *= None* - -Total number of boxes used by this account - -#### total_created_apps *: int | None* *= None* - -Number of applications created by this account - -#### total_created_assets *: int | None* *= None* - -Number of assets created by this account - -#### apps_local_state *: list[dict] | None* *= None* - -Local state of applications this account has opted into - -#### apps_total_extra_pages *: int | None* *= None* - -Number of extra pages allocated to applications - -#### apps_total_schema *: dict | None* *= None* - -Total schema for all applications - -#### assets *: list[dict] | None* *= None* - -Assets held by this account - -#### auth_addr *: str | None* *= None* - -If rekeyed, the authorized address - -#### closed_at_round *: int | None* *= None* - -Round when this account was closed - -#### created_apps *: list[dict] | None* *= None* - -Applications created by this account - -#### created_assets *: list[dict] | None* *= None* - -Assets created by this account - -#### created_at_round *: int | None* *= None* - -Round when this account was created - -#### deleted *: bool | None* *= None* - -Whether this account is deleted - -#### incentive_eligible *: bool | None* *= None* - -Whether this account is eligible for incentives - -#### last_heartbeat *: int | None* *= None* - -Last heartbeat round for this account - -#### last_proposed *: int | None* *= None* - -Last round this account proposed a block - -#### participation *: dict | None* *= None* - -Participation information for this account - -#### reward_base *: int | None* *= None* - -Base reward for this account - -#### sig_type *: str | None* *= None* - -Signature type for this account - -### *class* algokit_utils.accounts.account_manager.AccountManager(client_manager: [algokit_utils.clients.client_manager.ClientManager](../../clients/client_manager/index.md#algokit_utils.clients.client_manager.ClientManager)) - -Creates and keeps track of signing accounts that can sign transactions for a sending address. - -This class provides functionality to create, track, and manage various types of accounts including -mnemonic-based, rekeyed, multisig, and logic signature accounts. - -* **Parameters:** - **client_manager** – The ClientManager client to use for algod and kmd clients -* **Example:** - ```python - account_manager = AccountManager(client_manager) - ``` - -#### *property* kmd *: [algokit_utils.accounts.kmd_account_manager.KmdAccountManager](../kmd_account_manager/index.md#algokit_utils.accounts.kmd_account_manager.KmdAccountManager)* - -KMD account manager that allows you to easily get and create accounts using KMD. - -* **Return KmdAccountManager:** - The ‘KmdAccountManager’ instance -* **Example:** - ```python - kmd_manager = account_manager.kmd - ``` - -#### set_default_signer(signer: algosdk.atomic_transaction_composer.TransactionSigner | [algokit_utils.protocols.account.TransactionSignerAccountProtocol](../../protocols/account/index.md#algokit_utils.protocols.account.TransactionSignerAccountProtocol)) → typing_extensions.Self - -Sets the default signer to use if no other signer is specified. - -If this isn’t set and a transaction needs signing for a given sender -then an error will be thrown from get_signer / get_account. - -* **Parameters:** - **signer** – A TransactionSigner signer to use. -* **Returns:** - The AccountManager so method calls can be chained -* **Example:** - ```python - signer_account = account_manager.random() - account_manager.set_default_signer(signer_account) - ``` - -#### set_signer(sender: str, signer: algosdk.atomic_transaction_composer.TransactionSigner) → typing_extensions.Self - -Tracks the given TransactionSigner against the given sender address for later signing. - -* **Parameters:** - * **sender** – The sender address to use this signer for - * **signer** – The TransactionSigner to sign transactions with for the given sender -* **Returns:** - The AccountManager instance for method chaining -* **Example:** - ```python - account_manager.set_signer("SENDERADDRESS", transaction_signer) - ``` - -#### set_signers(\*, another_account_manager: [AccountManager](#algokit_utils.accounts.account_manager.AccountManager), overwrite_existing: bool = True) → typing_extensions.Self - -Merges the given AccountManager into this one. - -* **Parameters:** - * **another_account_manager** – The AccountManager to merge into this one - * **overwrite_existing** – Whether to overwrite existing signers in this manager -* **Returns:** - The AccountManager instance for method chaining -* **Example:** - ```python - accountManager2.set_signers(accountManager1) - ``` - -#### set_signer_from_account(account: [algokit_utils.protocols.account.TransactionSignerAccountProtocol](../../protocols/account/index.md#algokit_utils.protocols.account.TransactionSignerAccountProtocol)) → typing_extensions.Self - -#### set_signer_from_account(signer: [algokit_utils.protocols.account.TransactionSignerAccountProtocol](../../protocols/account/index.md#algokit_utils.protocols.account.TransactionSignerAccountProtocol)) → typing_extensions.Self - -Tracks the given account for later signing. - -Note: If you are generating accounts via the various methods on AccountManager -(like random, from_mnemonic, logic_sig, etc.) then they automatically get tracked. - -The method accepts either a positional argument or a keyword argument named ‘account’ or ‘signer’. -The ‘signer’ parameter is deprecated and will show a warning when used. - -* **Parameters:** - * **\*args** – - - Variable positional arguments. The first argument should be a TransactionSignerAccountProtocol. - * **\*\*kwargs** – - - Variable keyword arguments. Can include ‘account’ or ‘signer’ (deprecated) as - TransactionSignerAccountProtocol. -* **Returns:** - The AccountManager instance for method chaining -* **Raises:** - **ValueError** – If no account or signer argument is provided -* **Example:** - ```python - account_manager = AccountManager(client_manager) - # Using positional argument - account_manager.set_signer_from_account( - SigningAccount(private_key=algosdk.account.generate_account()[0]) - ) - # Using keyword argument 'account' - account_manager.set_signer_from_account( - account=LogicSigAccount(AlgosdkLogicSigAccount(program, args)) - ) - # Using deprecated keyword argument 'signer' - account_manager.set_signer_from_account( - signer=MultiSigAccount(multisig_params, [account1, account2]) - ) - ``` - -#### get_signer(sender: str | [algokit_utils.protocols.account.TransactionSignerAccountProtocol](../../protocols/account/index.md#algokit_utils.protocols.account.TransactionSignerAccountProtocol)) → algosdk.atomic_transaction_composer.TransactionSigner - -Returns the TransactionSigner for the given sender address. - -If no signer has been registered for that address then the default signer is used if registered. - -* **Parameters:** - **sender** – The sender address or account -* **Returns:** - The TransactionSigner -* **Raises:** - **ValueError** – If no signer is found and no default signer is set -* **Example:** - ```python - signer = account_manager.get_signer("SENDERADDRESS") - ``` - -#### get_account(sender: str) → [algokit_utils.protocols.account.TransactionSignerAccountProtocol](../../protocols/account/index.md#algokit_utils.protocols.account.TransactionSignerAccountProtocol) - -Returns the TransactionSignerAccountProtocol for the given sender address. - -* **Parameters:** - **sender** – The sender address -* **Returns:** - The TransactionSignerAccountProtocol -* **Raises:** - **ValueError** – If no account is found or if the account is not a regular account -* **Example:** - ```python - sender = account_manager.random().address - # ... - # Returns the `TransactionSignerAccountProtocol` for `sender` that has previously been registered - account = account_manager.get_account(sender) - ``` - -#### get_information(sender: str | [algokit_utils.protocols.account.TransactionSignerAccountProtocol](../../protocols/account/index.md#algokit_utils.protocols.account.TransactionSignerAccountProtocol)) → [AccountInformation](#algokit_utils.accounts.account_manager.AccountInformation) - -Returns the given sender account’s current status, balance and spendable amounts. - -See [https://dev.algorand.co/reference/rest-apis/algod/#account](https://dev.algorand.co/reference/rest-apis/algod/#account) -for response data schema details. - -* **Parameters:** - **sender** – The address or account compliant with TransactionSignerAccountProtocol protocol to look up -* **Returns:** - The account information -* **Example:** - ```python - address = "XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA" - account_info = account_manager.get_information(address) - ``` - -#### from_mnemonic(\*, mnemonic: str, sender: str | None = None) → [algokit_utils.models.account.SigningAccount](../../models/account/index.md#algokit_utils.models.account.SigningAccount) - -Tracks and returns an Algorand account with secret key loaded by taking the mnemonic secret. - -* **Parameters:** - * **mnemonic** – The mnemonic secret representing the private key of an account - * **sender** – Optional address to use as the sender -* **Returns:** - The account - -#### WARNING -Be careful how the mnemonic is handled. Never commit it into source control and ideally load it -from the environment (ideally via a secret storage service) rather than the file system. - -* **Example:** - ```python - account = account_manager.from_mnemonic("mnemonic secret ...") - ``` - -#### from_environment(name: str, fund_with: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None = None) → [algokit_utils.models.account.SigningAccount](../../models/account/index.md#algokit_utils.models.account.SigningAccount) - -Tracks and returns an Algorand account with private key loaded by convention from environment variables. - -This allows you to write code that will work seamlessly in production and local development (LocalNet) -without manual config locally (including when you reset the LocalNet). - -* **Parameters:** - * **name** – The name identifier of the account - * **fund_with** – Optional amount to fund the account with when it gets created - (when targeting LocalNet) -* **Returns:** - The account -* **Raises:** - **ValueError** – If environment variable {NAME}_MNEMONIC is missing when looking for account {NAME} - -#### NOTE -Convention: -: * **Non-LocalNet:** will load {NAME}_MNEMONIC as a mnemonic secret. - If {NAME}_SENDER is defined then it will use that for the sender address - (i.e. to support rekeyed accounts) - * **LocalNet:** will load the account from a KMD wallet called {NAME} and if that wallet doesn’t exist - it will create it and fund the account for you - -* **Example:** - ```python - # If you have a mnemonic secret loaded into `MY_ACCOUNT_MNEMONIC` then you can call: - account = account_manager.from_environment('MY_ACCOUNT') - # If that code runs against LocalNet then a wallet called `MY_ACCOUNT` will automatically be created - # with an account that is automatically funded with the specified amount from the LocalNet dispenser - ``` - -#### from_kmd(name: str, predicate: collections.abc.Callable[[dict[str, Any]], bool] | None = None, sender: str | None = None) → [algokit_utils.models.account.SigningAccount](../../models/account/index.md#algokit_utils.models.account.SigningAccount) - -Tracks and returns an Algorand account with private key loaded from the given KMD wallet. - -* **Parameters:** - * **name** – The name of the wallet to retrieve an account from - * **predicate** – Optional filter to use to find the account - * **sender** – Optional sender address to use this signer for (aka a rekeyed account) -* **Returns:** - The account -* **Raises:** - **ValueError** – If unable to find KMD account with given name and predicate -* **Example:** - ```python - # Get default funded account in a LocalNet: - defaultDispenserAccount = account.from_kmd('unencrypted-default-wallet', - lambda a: a.status != 'Offline' and a.amount > 1_000_000_000 - ) - ``` - -#### logicsig(program: bytes, args: list[bytes] | None = None) → [algokit_utils.models.account.LogicSigAccount](../../models/account/index.md#algokit_utils.models.account.LogicSigAccount) - -Tracks and returns an account that represents a logic signature. - -* **Parameters:** - * **program** – The bytes that make up the compiled logic signature - * **args** – Optional (binary) arguments to pass into the logic signature -* **Returns:** - A logic signature account wrapper -* **Example:** - ```python - account = account.logicsig(program, [new Uint8Array(3, ...)]) - ``` - -#### multisig(metadata: [algokit_utils.models.account.MultisigMetadata](../../models/account/index.md#algokit_utils.models.account.MultisigMetadata), signing_accounts: list[[algokit_utils.models.account.SigningAccount](../../models/account/index.md#algokit_utils.models.account.SigningAccount)]) → [algokit_utils.models.account.MultiSigAccount](../../models/account/index.md#algokit_utils.models.account.MultiSigAccount) - -Tracks and returns an account that supports partial or full multisig signing. - -* **Parameters:** - * **metadata** – The metadata for the multisig account - * **signing_accounts** – The signers that are currently present -* **Returns:** - A multisig account wrapper -* **Example:** - ```python - account = account_manager.multi_sig( - version=1, - threshold=1, - addrs=["ADDRESS1...", "ADDRESS2..."], - signing_accounts=[account1, account2] - ) - ``` - -#### random() → [algokit_utils.models.account.SigningAccount](../../models/account/index.md#algokit_utils.models.account.SigningAccount) - -Tracks and returns a new, random Algorand account. - -* **Returns:** - The account -* **Example:** - ```python - account = account_manager.random() - ``` - -#### localnet_dispenser() → [algokit_utils.models.account.SigningAccount](../../models/account/index.md#algokit_utils.models.account.SigningAccount) - -Returns an Algorand account with private key loaded for the default LocalNet dispenser account. - -This account can be used to fund other accounts. - -* **Returns:** - The account -* **Example:** - ```python - account = account_manager.localnet_dispenser() - ``` - -#### dispenser_from_environment() → [algokit_utils.models.account.SigningAccount](../../models/account/index.md#algokit_utils.models.account.SigningAccount) - -Returns an account (with private key loaded) that can act as a dispenser from environment variables. - -If environment variables are not present, returns the default LocalNet dispenser account. - -* **Returns:** - The account -* **Example:** - ```python - account = account_manager.dispenser_from_environment() - ``` - -#### rekeyed(\*, sender: str, account: [algokit_utils.protocols.account.TransactionSignerAccountProtocol](../../protocols/account/index.md#algokit_utils.protocols.account.TransactionSignerAccountProtocol)) → [algokit_utils.models.account.TransactionSignerAccount](../../models/account/index.md#algokit_utils.models.account.TransactionSignerAccount) | [algokit_utils.models.account.SigningAccount](../../models/account/index.md#algokit_utils.models.account.SigningAccount) - -Tracks and returns an Algorand account that is a rekeyed version of the given account to a new sender. - -* **Parameters:** - * **sender** – The account or address to use as the sender - * **account** – The account to use as the signer for this new rekeyed account -* **Returns:** - The rekeyed account -* **Example:** - ```python - account = account.from_mnemonic("mnemonic secret ...") - rekeyed_account = account_manager.rekeyed(account, "SENDERADDRESS...") - ``` - -#### rekey_account(account: str, rekey_to: str | [algokit_utils.protocols.account.TransactionSignerAccountProtocol](../../protocols/account/index.md#algokit_utils.protocols.account.TransactionSignerAccountProtocol), \*, signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None, note: bytes | None = None, lease: bytes | None = None, static_fee: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None = None, extra_fee: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None = None, max_fee: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None = None, validity_window: int | None = None, first_valid_round: int | None = None, last_valid_round: int | None = None, suppress_log: bool | None = None) → [algokit_utils.transactions.transaction_composer.SendAtomicTransactionComposerResults](../../transactions/transaction_composer/index.md#algokit_utils.transactions.transaction_composer.SendAtomicTransactionComposerResults) - -Rekey an account to a new address. - -* **Parameters:** - * **account** – The account to rekey - * **rekey_to** – The address or account to rekey to - * **signer** – Optional transaction signer - * **note** – Optional transaction note - * **lease** – Optional transaction lease - * **static_fee** – Optional static fee - * **extra_fee** – Optional extra fee - * **max_fee** – Optional max fee - * **validity_window** – Optional validity window - * **first_valid_round** – Optional first valid round - * **last_valid_round** – Optional last valid round - * **suppress_log** – Optional flag to suppress logging -* **Returns:** - The result of the transaction and the transaction that was sent - -#### WARNING -Please be careful with this function and be sure to read the -[official rekey guidance](https://dev.algorand.co/concepts/accounts/rekeying). - -* **Example:** - ```python - # Basic example (with string addresses): - algorand.account.rekey_account("ACCOUNTADDRESS", "NEWADDRESS") - # Basic example (with signer accounts): - algorand.account.rekey_account(account1, newSignerAccount) - # Advanced example: - algorand.account.rekey_account( - account="ACCOUNTADDRESS", - rekey_to="NEWADDRESS", - lease='lease', - note='note', - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount.from_micro_algo(1000), - static_fee=AlgoAmount.from_micro_algo(1000), - max_fee=AlgoAmount.from_micro_algo(3000), - suppress_log=True, - ) - ``` - -#### ensure_funded(account_to_fund: str | [algokit_utils.models.account.SigningAccount](../../models/account/index.md#algokit_utils.models.account.SigningAccount), dispenser_account: str | [algokit_utils.models.account.SigningAccount](../../models/account/index.md#algokit_utils.models.account.SigningAccount), min_spending_balance: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount), min_funding_increment: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None = None, send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None, signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None, rekey_to: str | None = None, note: bytes | None = None, lease: bytes | None = None, static_fee: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None = None, extra_fee: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None = None, max_fee: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None = None, validity_window: int | None = None, first_valid_round: int | None = None, last_valid_round: int | None = None) → [EnsureFundedResult](#algokit_utils.accounts.account_manager.EnsureFundedResult) | None - -Funds a given account using a dispenser account as a funding source. - -Ensures the given account has a certain amount of Algo free to spend (accounting for -Algo locked in minimum balance requirement). - -See [https://dev.algorand.co/concepts/smart-contracts/costs-constraints#mbr](https://dev.algorand.co/concepts/smart-contracts/costs-constraints#mbr) for details. - -* **Parameters:** - * **account_to_fund** – The account to fund - * **dispenser_account** – The account to use as a dispenser funding source - * **min_spending_balance** – The minimum balance of Algo that the account - should have available to spend - * **min_funding_increment** – Optional minimum funding increment - * **send_params** – Parameters for the send operation, defaults to None - * **signer** – Optional transaction signer - * **rekey_to** – Optional rekey address - * **note** – Optional transaction note - * **lease** – Optional transaction lease - * **static_fee** – Optional static fee - * **extra_fee** – Optional extra fee - * **max_fee** – Optional maximum fee - * **validity_window** – Optional validity window - * **first_valid_round** – Optional first valid round - * **last_valid_round** – Optional last valid round -* **Returns:** - The result of executing the dispensing transaction and the amountFunded if funds were needed, - or None if no funds were needed -* **Example:** - ```python - # Basic example: - algorand.account.ensure_funded("ACCOUNTADDRESS", "DISPENSERADDRESS", AlgoAmount.from_algo(1)) - # With configuration: - algorand.account.ensure_funded( - "ACCOUNTADDRESS", - "DISPENSERADDRESS", - AlgoAmount.from_algo(1), - min_funding_increment=AlgoAmount.from_algo(2), - fee=AlgoAmount.from_micro_algo(1000), - suppress_log=True - ) - ``` - -#### ensure_funded_from_environment(account_to_fund: str | [algokit_utils.models.account.SigningAccount](../../models/account/index.md#algokit_utils.models.account.SigningAccount), min_spending_balance: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount), \*, min_funding_increment: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None = None, send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None, signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None, rekey_to: str | None = None, note: bytes | None = None, lease: bytes | None = None, static_fee: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None = None, extra_fee: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None = None, max_fee: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None = None, validity_window: int | None = None, first_valid_round: int | None = None, last_valid_round: int | None = None) → [EnsureFundedResult](#algokit_utils.accounts.account_manager.EnsureFundedResult) | None - -Ensure an account is funded from a dispenser account configured in environment. - -Uses a dispenser account retrieved from the environment, per the dispenser_from_environment method, -as a funding source such that the given account has a certain amount of Algo free to spend -(accounting for Algo locked in minimum balance requirement). - -See [https://dev.algorand.co/concepts/smart-contracts/costs-constraints#mbr](https://dev.algorand.co/concepts/smart-contracts/costs-constraints#mbr) for details. - -* **Parameters:** - * **account_to_fund** – The account to fund - * **min_spending_balance** – The minimum balance of Algo that the account should have available to - spend - * **min_funding_increment** – Optional minimum funding increment - * **send_params** – Parameters for the send operation, defaults to None - * **signer** – Optional transaction signer - * **rekey_to** – Optional rekey address - * **note** – Optional transaction note - * **lease** – Optional transaction lease - * **static_fee** – Optional static fee - * **extra_fee** – Optional extra fee - * **max_fee** – Optional maximum fee - * **validity_window** – Optional validity window - * **first_valid_round** – Optional first valid round - * **last_valid_round** – Optional last valid round -* **Returns:** - The result of executing the dispensing transaction and the amountFunded if funds were needed, or - None if no funds were needed - -#### NOTE -The dispenser account is retrieved from the account mnemonic stored in -process.env.DISPENSER_MNEMONIC and optionally process.env.DISPENSER_SENDER -if it’s a rekeyed account, or against default LocalNet if no environment variables present. - -* **Example:** - ```python - # Basic example: - algorand.account.ensure_funded_from_environment("ACCOUNTADDRESS", AlgoAmount.from_algo(1)) - # With configuration: - algorand.account.ensure_funded_from_environment( - "ACCOUNTADDRESS", - AlgoAmount.from_algo(1), - min_funding_increment=AlgoAmount.from_algo(2), - fee=AlgoAmount.from_micro_algo(1000), - suppress_log=True - ) - ``` - -#### ensure_funded_from_testnet_dispenser_api(account_to_fund: str | [algokit_utils.models.account.SigningAccount](../../models/account/index.md#algokit_utils.models.account.SigningAccount), dispenser_client: [algokit_utils.clients.dispenser_api_client.TestNetDispenserApiClient](../../clients/dispenser_api_client/index.md#algokit_utils.clients.dispenser_api_client.TestNetDispenserApiClient), min_spending_balance: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount), \*, min_funding_increment: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None = None) → [EnsureFundedFromTestnetDispenserApiResult](#algokit_utils.accounts.account_manager.EnsureFundedFromTestnetDispenserApiResult) | None - -Ensure an account is funded using the TestNet Dispenser API. - -Uses the TestNet Dispenser API as a funding source such that the account has a certain amount -of Algo free to spend (accounting for Algo locked in minimum balance requirement). - -See [https://dev.algorand.co/concepts/smart-contracts/costs-constraints#mbr](https://dev.algorand.co/concepts/smart-contracts/costs-constraints#mbr) for details. - -* **Parameters:** - * **account_to_fund** – The account to fund - * **dispenser_client** – The TestNet dispenser funding client - * **min_spending_balance** – The minimum balance of Algo that the account should have - available to spend - * **min_funding_increment** – Optional minimum funding increment -* **Returns:** - The result of executing the dispensing transaction and the amountFunded if funds were needed, or - None if no funds were needed -* **Raises:** - **ValueError** – If attempting to fund on non-TestNet network -* **Example:** - ```python - # Basic example: - account_manager.ensure_funded_from_testnet_dispenser_api( - "ACCOUNTADDRESS", - algorand.client.get_testnet_dispenser_from_environment(), - AlgoAmount.from_algo(1) - ) - # With configuration: - account_manager.ensure_funded_from_testnet_dispenser_api( - "ACCOUNTADDRESS", - algorand.client.get_testnet_dispenser_from_environment(), - AlgoAmount.from_algo(1), - min_funding_increment=AlgoAmount.from_algo(2) - ) - ``` diff --git a/docs/markdown/autoapi/algokit_utils/accounts/index.md b/docs/markdown/autoapi/algokit_utils/accounts/index.md deleted file mode 100644 index 97b69c7e..00000000 --- a/docs/markdown/autoapi/algokit_utils/accounts/index.md +++ /dev/null @@ -1,6 +0,0 @@ -# algokit_utils.accounts - -## Submodules - -* [algokit_utils.accounts.account_manager](account_manager/index.md) -* [algokit_utils.accounts.kmd_account_manager](kmd_account_manager/index.md) diff --git a/docs/markdown/autoapi/algokit_utils/accounts/kmd_account_manager/index.md b/docs/markdown/autoapi/algokit_utils/accounts/kmd_account_manager/index.md deleted file mode 100644 index 5041cc9b..00000000 --- a/docs/markdown/autoapi/algokit_utils/accounts/kmd_account_manager/index.md +++ /dev/null @@ -1,71 +0,0 @@ -# algokit_utils.accounts.kmd_account_manager - -## Classes - -| [`KmdAccount`](#algokit_utils.accounts.kmd_account_manager.KmdAccount) | Account retrieved from KMD with signing capabilities, extending base Account. | -|--------------------------------------------------------------------------------------|---------------------------------------------------------------------------------| -| [`KmdAccountManager`](#algokit_utils.accounts.kmd_account_manager.KmdAccountManager) | Provides abstractions over KMD that makes it easier to get and manage accounts. | - -## Module Contents - -### *class* algokit_utils.accounts.kmd_account_manager.KmdAccount(private_key: str, address: str | None = None) - -Bases: [`algokit_utils.models.account.SigningAccount`](../../models/account/index.md#algokit_utils.models.account.SigningAccount) - -Account retrieved from KMD with signing capabilities, extending base Account. - -Provides an account implementation that can be used to sign transactions using keys stored in KMD. - -* **Parameters:** - * **private_key** – Base64 encoded private key - * **address** – Optional address override for rekeyed accounts, defaults to None - -### *class* algokit_utils.accounts.kmd_account_manager.KmdAccountManager(client_manager: [algokit_utils.clients.client_manager.ClientManager](../../clients/client_manager/index.md#algokit_utils.clients.client_manager.ClientManager)) - -Provides abstractions over KMD that makes it easier to get and manage accounts. - -#### kmd() → algosdk.kmd.KMDClient - -Returns the KMD client, initializing it if needed. - -* **Raises:** - **Exception** – If KMD client is not configured and not running against LocalNet -* **Returns:** - The KMD client - -#### get_wallet_account(wallet_name: str, predicate: collections.abc.Callable[[dict[str, Any]], bool] | None = None, sender: str | None = None) → [KmdAccount](#algokit_utils.accounts.kmd_account_manager.KmdAccount) | None - -Returns an Algorand signing account with private key loaded from the given KMD wallet. - -Retrieves an account from a KMD wallet that matches the given predicate, or a random account -if no predicate is provided. - -* **Parameters:** - * **wallet_name** – The name of the wallet to retrieve an account from - * **predicate** – Optional filter to use to find the account (otherwise gets a random account from the wallet) - * **sender** – Optional sender address to use this signer for (aka a rekeyed account) -* **Returns:** - The signing account or None if no matching wallet or account was found - -#### get_or_create_wallet_account(name: str, fund_with: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None = None) → [KmdAccount](#algokit_utils.accounts.kmd_account_manager.KmdAccount) - -Gets or creates a funded account in a KMD wallet of the given name. - -Provides idempotent access to accounts from LocalNet without specifying the private key. - -* **Parameters:** - * **name** – The name of the wallet to retrieve / create - * **fund_with** – The number of Algos to fund the account with when created -* **Returns:** - An Algorand account with private key loaded - -#### get_localnet_dispenser_account() → [KmdAccount](#algokit_utils.accounts.kmd_account_manager.KmdAccount) - -Returns an Algorand account with private key loaded for the default LocalNet dispenser account. - -Retrieves the default funded account from LocalNet that can be used to fund other accounts. - -* **Raises:** - **Exception** – If not running against LocalNet or dispenser account not found -* **Returns:** - The default LocalNet dispenser account diff --git a/docs/markdown/autoapi/algokit_utils/algorand/index.md b/docs/markdown/autoapi/algokit_utils/algorand/index.md deleted file mode 100644 index 482ca557..00000000 --- a/docs/markdown/autoapi/algokit_utils/algorand/index.md +++ /dev/null @@ -1,288 +0,0 @@ -# algokit_utils.algorand - -## Classes - -| [`AlgorandClient`](#algokit_utils.algorand.AlgorandClient) | A client that brokers easy access to Algorand functionality. | -|--------------------------------------------------------------|----------------------------------------------------------------| - -## Module Contents - -### *class* algokit_utils.algorand.AlgorandClient(config: [algokit_utils.models.network.AlgoClientConfigs](../models/network/index.md#algokit_utils.models.network.AlgoClientConfigs) | [algokit_utils.clients.client_manager.AlgoSdkClients](../clients/client_manager/index.md#algokit_utils.clients.client_manager.AlgoSdkClients)) - -A client that brokers easy access to Algorand functionality. - -#### set_default_validity_window(validity_window: int) → typing_extensions.Self - -Sets the default validity window for transactions. - -* **Parameters:** - **validity_window** – The number of rounds between the first and last valid rounds -* **Returns:** - The AlgorandClient so method calls can be chained -* **Example:** - ```python - algorand = AlgorandClient.mainnet().set_default_validity_window(1000); - ``` - -#### set_default_signer(signer: algosdk.atomic_transaction_composer.TransactionSigner | [algokit_utils.protocols.account.TransactionSignerAccountProtocol](../protocols/account/index.md#algokit_utils.protocols.account.TransactionSignerAccountProtocol)) → typing_extensions.Self - -Sets the default signer to use if no other signer is specified. - -* **Parameters:** - **signer** – The signer to use, either a TransactionSigner or a TransactionSignerAccountProtocol -* **Returns:** - The AlgorandClient so method calls can be chained -* **Example:** - ```python - signer = SigningAccount(private_key=..., address=...) - algorand = AlgorandClient.mainnet().set_default_signer(signer) - ``` - -#### set_signer(sender: str, signer: algosdk.atomic_transaction_composer.TransactionSigner) → typing_extensions.Self - -Tracks the given account for later signing. - -* **Parameters:** - * **sender** – The sender address to use this signer for - * **signer** – The signer to sign transactions with for the given sender -* **Returns:** - The AlgorandClient so method calls can be chained -* **Example:** - ```python - signer = SigningAccount(private_key=..., address=...) - algorand = AlgorandClient.mainnet().set_signer(signer.addr, signer.signer) - ``` - -#### set_signer_from_account(signer: [algokit_utils.protocols.account.TransactionSignerAccountProtocol](../protocols/account/index.md#algokit_utils.protocols.account.TransactionSignerAccountProtocol)) → typing_extensions.Self - -Sets the default signer to use if no other signer is specified. - -* **Parameters:** - **signer** – The signer to use, either a TransactionSigner or a TransactionSignerAccountProtocol -* **Returns:** - The AlgorandClient so method calls can be chained -* **Example:** - ```python - accountManager = AlgorandClient.mainnet() - accountManager.set_signer_from_account(TransactionSignerAccount(address=..., signer=...)) - accountManager.set_signer_from_account(algosdk.LogicSigAccount(program, args)) - accountManager.set_signer_from_account(SigningAccount(private_key=..., address=...)) - accountManager.set_signer_from_account(MultisigAccount(metadata, signing_accounts)) - accountManager.set_signer_from_account(account) - ``` - -#### set_suggested_params_cache(suggested_params: algosdk.transaction.SuggestedParams, until: float | None = None) → typing_extensions.Self - -Sets a cache value to use for suggested params. - -* **Parameters:** - * **suggested_params** – The suggested params to use - * **until** – A timestamp until which to cache, or if not specified then the timeout is used -* **Returns:** - The AlgorandClient so method calls can be chained -* **Example:** - ```python - algorand = AlgorandClient.mainnet().set_suggested_params_cache(suggested_params, time.time() + 3.6e6) - ``` - -#### set_suggested_params_cache_timeout(timeout: int) → typing_extensions.Self - -Sets the timeout for caching suggested params. - -* **Parameters:** - **timeout** – The timeout in milliseconds -* **Returns:** - The AlgorandClient so method calls can be chained -* **Example:** - ```python - algorand = AlgorandClient.mainnet().set_suggested_params_cache_timeout(10_000) - ``` - -#### get_suggested_params() → algosdk.transaction.SuggestedParams - -Get suggested params for a transaction (either cached or from algod if the cache is stale or empty) - -* **Example:** - ```python - algorand = AlgorandClient.mainnet().get_suggested_params() - ``` - -#### register_error_transformer(transformer: algokit_utils.transactions.transaction_composer.ErrorTransformer) → typing_extensions.Self - -Register a function that will be used to transform an error caught when simulating or executing -composed transaction groups made from new_group - -* **Parameters:** - **transformer** – The error transformer function -* **Returns:** - The AlgorandClient so you can chain method calls - -#### unregister_error_transformer(transformer: algokit_utils.transactions.transaction_composer.ErrorTransformer) → typing_extensions.Self - -Unregister an error transformer function - -* **Parameters:** - **transformer** – The error transformer function to remove -* **Returns:** - The AlgorandClient so you can chain method calls - -#### new_group() → [algokit_utils.transactions.transaction_composer.TransactionComposer](../transactions/transaction_composer/index.md#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Start a new TransactionComposer transaction group - -* **Example:** - ```python - composer = AlgorandClient.mainnet().new_group() - result = await composer.add_transaction(payment).send() - ``` - -#### *property* client *: [algokit_utils.clients.client_manager.ClientManager](../clients/client_manager/index.md#algokit_utils.clients.client_manager.ClientManager)* - -Get clients, including algosdk clients and app clients. - -* **Example:** - ```python - clientManager = AlgorandClient.mainnet().client - ``` - -#### *property* account *: [algokit_utils.accounts.account_manager.AccountManager](../accounts/account_manager/index.md#algokit_utils.accounts.account_manager.AccountManager)* - -Get or create accounts that can sign transactions. - -* **Example:** - ```python - accountManager = AlgorandClient.mainnet().account - ``` - -#### *property* asset *: [algokit_utils.assets.asset_manager.AssetManager](../assets/asset_manager/index.md#algokit_utils.assets.asset_manager.AssetManager)* - -Get or create assets. - -* **Example:** - ```python - assetManager = AlgorandClient.mainnet().asset - ``` - -#### *property* app *: [algokit_utils.applications.app_manager.AppManager](../applications/app_manager/index.md#algokit_utils.applications.app_manager.AppManager)* - -Get or create applications. - -* **Example:** - ```python - appManager = AlgorandClient.mainnet().app - ``` - -#### *property* app_deployer *: [algokit_utils.applications.app_deployer.AppDeployer](../applications/app_deployer/index.md#algokit_utils.applications.app_deployer.AppDeployer)* - -Get or create applications. - -* **Example:** - ```python - appDeployer = AlgorandClient.mainnet().app_deployer - ``` - -#### *property* send *: [algokit_utils.transactions.transaction_sender.AlgorandClientTransactionSender](../transactions/transaction_sender/index.md#algokit_utils.transactions.transaction_sender.AlgorandClientTransactionSender)* - -Methods for sending a transaction and waiting for confirmation - -* **Example:** - ```python - result = await AlgorandClient.mainnet().send.payment( - PaymentParams( - sender="SENDERADDRESS", - receiver="RECEIVERADDRESS", - amount=AlgoAmount(algo-1) - )) - ``` - -#### *property* create_transaction *: [algokit_utils.transactions.transaction_creator.AlgorandClientTransactionCreator](../transactions/transaction_creator/index.md#algokit_utils.transactions.transaction_creator.AlgorandClientTransactionCreator)* - -Methods for building transactions - -* **Example:** - ```python - transaction = AlgorandClient.mainnet().create_transaction.payment( - PaymentParams( - sender="SENDERADDRESS", - receiver="RECEIVERADDRESS", - amount=AlgoAmount(algo=1) - )) - ``` - -#### *static* default_localnet() → [AlgorandClient](#algokit_utils.algorand.AlgorandClient) - -Returns an AlgorandClient pointing at default LocalNet ports and API token. - -* **Returns:** - The AlgorandClient -* **Example:** - ```python - algorand = AlgorandClient.default_localnet() - ``` - -#### *static* testnet() → [AlgorandClient](#algokit_utils.algorand.AlgorandClient) - -Returns an AlgorandClient pointing at TestNet using AlgoNode. - -* **Returns:** - The AlgorandClient -* **Example:** - ```python - algorand = AlgorandClient.testnet() - ``` - -#### *static* mainnet() → [AlgorandClient](#algokit_utils.algorand.AlgorandClient) - -Returns an AlgorandClient pointing at MainNet using AlgoNode. - -* **Returns:** - The AlgorandClient -* **Example:** - ```python - algorand = AlgorandClient.mainnet() - ``` - -#### *static* from_clients(algod: algosdk.v2client.algod.AlgodClient, indexer: algosdk.v2client.indexer.IndexerClient | None = None, kmd: algosdk.kmd.KMDClient | None = None) → [AlgorandClient](#algokit_utils.algorand.AlgorandClient) - -Returns an AlgorandClient pointing to the given client(s). - -* **Parameters:** - * **algod** – The algod client to use - * **indexer** – The indexer client to use - * **kmd** – The kmd client to use -* **Returns:** - The AlgorandClient -* **Example:** - ```python - algorand = AlgorandClient.from_clients(algod, indexer, kmd) - ``` - -#### *static* from_environment() → [AlgorandClient](#algokit_utils.algorand.AlgorandClient) - -Returns an AlgorandClient loading the configuration from environment variables. - -Retrieve configurations from environment variables when defined or get defaults. - -Expects to be called from a Python environment. - -* **Returns:** - The AlgorandClient -* **Example:** - ```python - algorand = AlgorandClient.from_environment() - ``` - -#### *static* from_config(algod_config: [algokit_utils.models.network.AlgoClientNetworkConfig](../models/network/index.md#algokit_utils.models.network.AlgoClientNetworkConfig), indexer_config: [algokit_utils.models.network.AlgoClientNetworkConfig](../models/network/index.md#algokit_utils.models.network.AlgoClientNetworkConfig) | None = None, kmd_config: [algokit_utils.models.network.AlgoClientNetworkConfig](../models/network/index.md#algokit_utils.models.network.AlgoClientNetworkConfig) | None = None) → [AlgorandClient](#algokit_utils.algorand.AlgorandClient) - -Returns an AlgorandClient from the given config. - -* **Parameters:** - * **algod_config** – The config to use for the algod client - * **indexer_config** – The config to use for the indexer client - * **kmd_config** – The config to use for the kmd client -* **Returns:** - The AlgorandClient -* **Example:** - ```python - algorand = AlgorandClient.from_config(algod_config, indexer_config, kmd_config) - ``` diff --git a/docs/markdown/autoapi/algokit_utils/applications/abi/index.md b/docs/markdown/autoapi/algokit_utils/applications/abi/index.md deleted file mode 100644 index 58b39c8d..00000000 --- a/docs/markdown/autoapi/algokit_utils/applications/abi/index.md +++ /dev/null @@ -1,166 +0,0 @@ -# algokit_utils.applications.abi - -## Attributes - -| [`ABIValue`](#algokit_utils.applications.abi.ABIValue) | | -|--------------------------------------------------------------------------------|----| -| [`ABIStruct`](#algokit_utils.applications.abi.ABIStruct) | | -| [`Arc56ReturnValueType`](#algokit_utils.applications.abi.Arc56ReturnValueType) | | -| [`ABIType`](#algokit_utils.applications.abi.ABIType) | | -| [`ABIArgumentType`](#algokit_utils.applications.abi.ABIArgumentType) | | - -## Classes - -| [`ABIReturn`](#algokit_utils.applications.abi.ABIReturn) | Represents the return value from an ABI method call. | -|--------------------------------------------------------------|--------------------------------------------------------| -| [`BoxABIValue`](#algokit_utils.applications.abi.BoxABIValue) | Represents an ABI value stored in a box. | - -## Functions - -| [`get_arc56_value`](#algokit_utils.applications.abi.get_arc56_value)(→ Arc56ReturnValueType) | Gets the ARC-56 formatted return value from an ABI return. | -|---------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------| -| [`get_abi_encoded_value`](#algokit_utils.applications.abi.get_abi_encoded_value)(→ bytes) | Encodes a value according to its ABI type. | -| [`get_abi_decoded_value`](#algokit_utils.applications.abi.get_abi_decoded_value)(→ ABIValue) | Decodes a value according to its ABI type. | -| [`get_abi_tuple_from_abi_struct`](#algokit_utils.applications.abi.get_abi_tuple_from_abi_struct)(→ list[Any]) | Converts an ABI struct to a tuple representation. | -| [`get_abi_tuple_type_from_abi_struct_definition`](#algokit_utils.applications.abi.get_abi_tuple_type_from_abi_struct_definition)(...) | Creates a TupleType from a struct definition. | -| [`get_abi_struct_from_abi_tuple`](#algokit_utils.applications.abi.get_abi_struct_from_abi_tuple)(→ dict[str, Any]) | Converts a decoded tuple to an ABI struct. | - -## Module Contents - -### *type* algokit_utils.applications.abi.ABIValue *= bool | int | str | bytes | bytearray | list['ABIValue'] | tuple['ABIValue'] | dict[str, 'ABIValue']* - -### *type* algokit_utils.applications.abi.ABIStruct *= dict[str, list[dict[str, 'ABIValue']]]* - -### *type* algokit_utils.applications.abi.Arc56ReturnValueType *= ABIValue | ABIStruct | None* - -### *type* algokit_utils.applications.abi.ABIType *= algosdk.abi.ABIType* - -### *type* algokit_utils.applications.abi.ABIArgumentType *= algosdk.abi.ABIType | algosdk.abi.ABITransactionType | algosdk.abi.ABIReferenceType* - -### *class* algokit_utils.applications.abi.ABIReturn(result: algosdk.atomic_transaction_composer.ABIResult) - -Represents the return value from an ABI method call. - -Wraps the raw return value and decoded value along with any decode errors. - -#### raw_value *: bytes | None* *= None* - -The raw return value from the method call - -#### value *: ABIValue | None* *= None* - -The decoded return value from the method call - -#### method *: algosdk.abi.method.Method | None* *= None* - -The ABI method definition - -#### decode_error *: Exception | None* *= None* - -The exception that occurred during decoding, if any - -#### tx_info *: dict[str, Any] | None* *= None* - -The transaction info for the method call from raw algosdk ABIResult - -#### *property* is_success *: bool* - -Returns True if the ABI call was successful (no decode error) - -* **Returns:** - True if no decode error occurred, False otherwise - -#### get_arc56_value(method: [algokit_utils.applications.app_spec.arc56.Method](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.Method) | algosdk.abi.method.Method, structs: dict[str, list[[algokit_utils.applications.app_spec.arc56.StructField](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.StructField)]]) → Arc56ReturnValueType - -Gets the ARC-56 formatted return value. - -* **Parameters:** - * **method** – The ABI method definition - * **structs** – Dictionary of struct definitions -* **Returns:** - The decoded return value in ARC-56 format - -### algokit_utils.applications.abi.get_arc56_value(abi_return: [ABIReturn](#algokit_utils.applications.abi.ABIReturn), method: [algokit_utils.applications.app_spec.arc56.Method](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.Method) | algosdk.abi.method.Method, structs: dict[str, list[[algokit_utils.applications.app_spec.arc56.StructField](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.StructField)]]) → Arc56ReturnValueType - -Gets the ARC-56 formatted return value from an ABI return. - -* **Parameters:** - * **abi_return** – The ABI return value to decode - * **method** – The ABI method definition - * **structs** – Dictionary of struct definitions -* **Raises:** - **ValueError** – If there was an error decoding the return value -* **Returns:** - The decoded return value in ARC-56 format - -### algokit_utils.applications.abi.get_abi_encoded_value(value: Any, type_str: str, structs: dict[str, list[[algokit_utils.applications.app_spec.arc56.StructField](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.StructField)]]) → bytes - -Encodes a value according to its ABI type. - -* **Parameters:** - * **value** – The value to encode - * **type_str** – The ABI type string - * **structs** – Dictionary of struct definitions -* **Raises:** - **ValueError** – If the value cannot be encoded for the given type -* **Returns:** - The ABI encoded bytes - -### algokit_utils.applications.abi.get_abi_decoded_value(value: bytes | int | str, type_str: str | ABIArgumentType, structs: dict[str, list[[algokit_utils.applications.app_spec.arc56.StructField](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.StructField)]]) → ABIValue - -Decodes a value according to its ABI type. - -* **Parameters:** - * **value** – The value to decode - * **type_str** – The ABI type string or type object - * **structs** – Dictionary of struct definitions -* **Returns:** - The decoded ABI value - -### algokit_utils.applications.abi.get_abi_tuple_from_abi_struct(struct_value: dict[str, Any], struct_fields: list[[algokit_utils.applications.app_spec.arc56.StructField](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.StructField)], structs: dict[str, list[[algokit_utils.applications.app_spec.arc56.StructField](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.StructField)]]) → list[Any] - -Converts an ABI struct to a tuple representation. - -* **Parameters:** - * **struct_value** – The struct value as a dictionary - * **struct_fields** – List of struct field definitions - * **structs** – Dictionary of struct definitions -* **Raises:** - **ValueError** – If a required field is missing from the struct -* **Returns:** - The struct as a tuple - -### algokit_utils.applications.abi.get_abi_tuple_type_from_abi_struct_definition(struct_def: list[[algokit_utils.applications.app_spec.arc56.StructField](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.StructField)], structs: dict[str, list[[algokit_utils.applications.app_spec.arc56.StructField](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.StructField)]]) → algosdk.abi.TupleType - -Creates a TupleType from a struct definition. - -* **Parameters:** - * **struct_def** – The struct field definitions - * **structs** – Dictionary of struct definitions -* **Raises:** - **ValueError** – If a field type is invalid -* **Returns:** - The TupleType representing the struct - -### algokit_utils.applications.abi.get_abi_struct_from_abi_tuple(decoded_tuple: Any, struct_fields: list[[algokit_utils.applications.app_spec.arc56.StructField](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.StructField)], structs: dict[str, list[[algokit_utils.applications.app_spec.arc56.StructField](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.StructField)]]) → dict[str, Any] - -Converts a decoded tuple to an ABI struct. - -* **Parameters:** - * **decoded_tuple** – The tuple to convert - * **struct_fields** – List of struct field definitions - * **structs** – Dictionary of struct definitions -* **Returns:** - The tuple as a struct dictionary - -### *class* algokit_utils.applications.abi.BoxABIValue - -Represents an ABI value stored in a box. - -#### name *: [algokit_utils.models.state.BoxName](../../models/state/index.md#algokit_utils.models.state.BoxName)* - -The name of the box - -#### value *: ABIValue* - -The ABI value stored in the box diff --git a/docs/markdown/autoapi/algokit_utils/applications/app_client/index.md b/docs/markdown/autoapi/algokit_utils/applications/app_client/index.md deleted file mode 100644 index d22bfb92..00000000 --- a/docs/markdown/autoapi/algokit_utils/applications/app_client/index.md +++ /dev/null @@ -1,618 +0,0 @@ -# algokit_utils.applications.app_client - -## Attributes - -| [`CreateOnComplete`](#algokit_utils.applications.app_client.CreateOnComplete) | | -|---------------------------------------------------------------------------------|----| - -## Classes - -| [`AppClientCompilationResult`](#algokit_utils.applications.app_client.AppClientCompilationResult) | Result of compiling an application's TEAL code. | -|-------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------| -| [`AppClientCompilationParams`](#algokit_utils.applications.app_client.AppClientCompilationParams) | Parameters for compiling an application's TEAL code. | -| [`CommonAppCallParams`](#algokit_utils.applications.app_client.CommonAppCallParams) | Common configuration for app call transaction parameters | -| [`AppClientCreateSchema`](#algokit_utils.applications.app_client.AppClientCreateSchema) | Schema for application creation. | -| [`CommonAppCallCreateParams`](#algokit_utils.applications.app_client.CommonAppCallCreateParams) | Common configuration for app create call transaction parameters. | -| [`FundAppAccountParams`](#algokit_utils.applications.app_client.FundAppAccountParams) | Parameters for funding an application's account. | -| [`AppClientBareCallParams`](#algokit_utils.applications.app_client.AppClientBareCallParams) | Parameters for bare application calls. | -| [`AppClientBareCallCreateParams`](#algokit_utils.applications.app_client.AppClientBareCallCreateParams) | Parameters for creating application with bare call. | -| [`BaseAppClientMethodCallParams`](#algokit_utils.applications.app_client.BaseAppClientMethodCallParams) | Base parameters for application method calls. | -| [`AppClientMethodCallParams`](#algokit_utils.applications.app_client.AppClientMethodCallParams) | Parameters for application method calls. | -| [`AppClientMethodCallCreateParams`](#algokit_utils.applications.app_client.AppClientMethodCallCreateParams) | Parameters for creating application with method call | -| [`AppClientParams`](#algokit_utils.applications.app_client.AppClientParams) | Full parameters for creating an app client | -| [`AppClient`](#algokit_utils.applications.app_client.AppClient) | A client for interacting with an Algorand smart contract application. | - -## Functions - -| [`get_constant_block_offset`](#algokit_utils.applications.app_client.get_constant_block_offset)(→ int) | Calculate the offset after constant blocks in TEAL program. | -|----------------------------------------------------------------------------------------------------------|---------------------------------------------------------------| - -## Module Contents - -### algokit_utils.applications.app_client.get_constant_block_offset(program: bytes) → int - -Calculate the offset after constant blocks in TEAL program. - -Analyzes a compiled TEAL program to find the ending offset position after any bytecblock and intcblock operations. - -* **Parameters:** - **program** – The compiled TEAL program as bytes -* **Returns:** - The maximum offset position after any constant block operations - -### algokit_utils.applications.app_client.CreateOnComplete - -### *class* algokit_utils.applications.app_client.AppClientCompilationResult - -Result of compiling an application’s TEAL code. - -Contains the compiled approval and clear state programs along with optional compilation artifacts. - -#### approval_program *: bytes* - -The compiled approval program bytes - -#### clear_state_program *: bytes* - -The compiled clear state program bytes - -#### compiled_approval *: [algokit_utils.models.application.CompiledTeal](../../models/application/index.md#algokit_utils.models.application.CompiledTeal) | None* *= None* - -Optional compilation artifacts for approval program - -#### compiled_clear *: [algokit_utils.models.application.CompiledTeal](../../models/application/index.md#algokit_utils.models.application.CompiledTeal) | None* *= None* - -Optional compilation artifacts for clear state program - -### *class* algokit_utils.applications.app_client.AppClientCompilationParams - -Bases: `TypedDict` - -Parameters for compiling an application’s TEAL code. - -* **Variables:** - * **deploy_time_params** – Optional template parameters to use during compilation - * **updatable** – Optional flag indicating if app should be updatable - * **deletable** – Optional flag indicating if app should be deletable - -#### deploy_time_params *: algokit_utils.models.state.TealTemplateParams | None* - -#### updatable *: bool | None* - -#### deletable *: bool | None* - -### *class* algokit_utils.applications.app_client.CommonAppCallParams - -Common configuration for app call transaction parameters - -#### account_references *: list[str] | None* *= None* - -List of account addresses to reference - -#### app_references *: list[int] | None* *= None* - -List of app IDs to reference - -#### asset_references *: list[int] | None* *= None* - -List of asset IDs to reference - -#### box_references *: list[[algokit_utils.models.state.BoxReference](../../models/state/index.md#algokit_utils.models.state.BoxReference) | algokit_utils.models.state.BoxIdentifier] | None* *= None* - -List of box references to include - -#### extra_fee *: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None* *= None* - -Additional fee to add to transaction - -#### lease *: bytes | None* *= None* - -Transaction lease value - -#### max_fee *: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None* *= None* - -Maximum fee allowed for transaction - -#### note *: bytes | None* *= None* - -Custom note for the transaction - -#### rekey_to *: str | None* *= None* - -Address to rekey account to - -#### sender *: str | None* *= None* - -Sender address override - -#### signer *: algosdk.atomic_transaction_composer.TransactionSigner | None* *= None* - -Custom transaction signer - -#### static_fee *: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None* *= None* - -Fixed fee for transaction - -#### validity_window *: int | None* *= None* - -Number of rounds valid - -#### first_valid_round *: int | None* *= None* - -First valid round number - -#### last_valid_round *: int | None* *= None* - -Last valid round number - -#### on_complete *: algosdk.transaction.OnComplete | None* *= None* - -Optional on complete action - -### *class* algokit_utils.applications.app_client.AppClientCreateSchema - -Schema for application creation. - -#### extra_program_pages *: int | None* *= None* - -Optional number of extra program pages - -#### schema *: [algokit_utils.transactions.transaction_composer.AppCreateSchema](../../transactions/transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppCreateSchema) | None* *= None* - -Optional application creation schema - -### *class* algokit_utils.applications.app_client.CommonAppCallCreateParams - -Bases: [`AppClientCreateSchema`](#algokit_utils.applications.app_client.AppClientCreateSchema), [`CommonAppCallParams`](#algokit_utils.applications.app_client.CommonAppCallParams) - -Common configuration for app create call transaction parameters. - -#### on_complete *: CreateOnComplete | None* *= None* - -Optional on complete action - -### *class* algokit_utils.applications.app_client.FundAppAccountParams - -Bases: [`CommonAppCallParams`](#algokit_utils.applications.app_client.CommonAppCallParams) - -Parameters for funding an application’s account. - -#### amount *: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount)* - -Amount to fund - -#### close_remainder_to *: str | None* *= None* - -Optional address to close remainder to - -### *class* algokit_utils.applications.app_client.AppClientBareCallParams - -Bases: [`CommonAppCallParams`](#algokit_utils.applications.app_client.CommonAppCallParams) - -Parameters for bare application calls. - -#### args *: list[bytes] | None* *= None* - -Optional arguments - -### *class* algokit_utils.applications.app_client.AppClientBareCallCreateParams - -Bases: [`CommonAppCallCreateParams`](#algokit_utils.applications.app_client.CommonAppCallCreateParams) - -Parameters for creating application with bare call. - -#### on_complete *: CreateOnComplete | None* *= None* - -Optional on complete action - -### *class* algokit_utils.applications.app_client.BaseAppClientMethodCallParams - -Bases: `Generic`[`ArgsT`, `MethodT`], [`CommonAppCallParams`](#algokit_utils.applications.app_client.CommonAppCallParams) - -Base parameters for application method calls. - -#### method *: MethodT* - -Method to call - -#### args *: ArgsT | None* *= None* - -Arguments to pass to the application method call - -### *class* algokit_utils.applications.app_client.AppClientMethodCallParams - -Bases: [`BaseAppClientMethodCallParams`](#algokit_utils.applications.app_client.BaseAppClientMethodCallParams)[`collections.abc.Sequence`[`algokit_utils.applications.abi.ABIValue | algokit_utils.applications.abi.ABIStruct | algokit_utils.transactions.transaction_composer.AppMethodCallTransactionArgument | None`], `str`] - -Parameters for application method calls. - -### *class* algokit_utils.applications.app_client.AppClientMethodCallCreateParams - -Bases: [`AppClientCreateSchema`](#algokit_utils.applications.app_client.AppClientCreateSchema), [`AppClientMethodCallParams`](#algokit_utils.applications.app_client.AppClientMethodCallParams) - -Parameters for creating application with method call - -#### on_complete *: CreateOnComplete | None* *= None* - -Optional on complete action - -### *class* algokit_utils.applications.app_client.AppClientParams - -Full parameters for creating an app client - -#### app_spec *: [algokit_utils.applications.app_spec.arc56.Arc56Contract](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.Arc56Contract) | [algokit_utils.applications.app_spec.arc32.Arc32Contract](../app_spec/arc32/index.md#algokit_utils.applications.app_spec.arc32.Arc32Contract) | str* - -The application specification - -#### algorand *: [algokit_utils.algorand.AlgorandClient](../../algorand/index.md#algokit_utils.algorand.AlgorandClient)* - -The Algorand client - -#### app_id *: int* - -The application ID - -#### app_name *: str | None* *= None* - -The application name - -#### default_sender *: str | None* *= None* - -The default sender address - -#### default_signer *: algosdk.atomic_transaction_composer.TransactionSigner | None* *= None* - -The default transaction signer - -#### approval_source_map *: algosdk.source_map.SourceMap | None* *= None* - -The approval source map - -#### clear_source_map *: algosdk.source_map.SourceMap | None* *= None* - -The clear source map - -### *class* algokit_utils.applications.app_client.AppClient(params: [AppClientParams](#algokit_utils.applications.app_client.AppClientParams)) - -A client for interacting with an Algorand smart contract application. - -Provides a high-level interface for interacting with Algorand smart contracts, including -methods for calling application methods, managing state, and handling transactions. - -* **Parameters:** - **params** – Parameters for creating the app client -* **Example:** - ```python - params = AppClientParams( - app_spec=Arc56Contract.from_json(app_spec_json), - algorand=algorand, - app_id=1234567890, - app_name="My App", - default_sender="SENDERADDRESS", - default_signer=TransactionSigner( - account="SIGNERACCOUNT", - private_key="SIGNERPRIVATEKEY", - ), - approval_source_map=SourceMap( - source="APPROVALSOURCE", - ), - clear_source_map=SourceMap( - source="CLEARSOURCE", - ), - ) - client = AppClient(params) - ``` - -#### *property* algorand *: [algokit_utils.algorand.AlgorandClient](../../algorand/index.md#algokit_utils.algorand.AlgorandClient)* - -Get the Algorand client instance. - -* **Returns:** - The Algorand client used by this app client - -#### *property* app_id *: int* - -Get the application ID. - -* **Returns:** - The ID of the Algorand application - -#### *property* app_address *: str* - -Get the application’s Algorand address. - -* **Returns:** - The Algorand address associated with this application - -#### *property* app_name *: str* - -Get the application name. - -* **Returns:** - The name of the application - -#### *property* app_spec *: [algokit_utils.applications.app_spec.arc56.Arc56Contract](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.Arc56Contract)* - -Get the application specification. - -* **Returns:** - The ARC-56 contract specification for this application - -#### *property* state *: \_StateAccessor* - -Get the state accessor. - -* **Returns:** - The state accessor for this application - -#### *property* params *: \_MethodParamsBuilder* - -Get the method parameters builder. - -* **Returns:** - The method parameters builder for this application -* **Example:** - ```python - # Create a transaction in the future using Algorand Client - my_method_call = app_client.params.call(AppClientMethodCallParams( - method='my_method', - args=[123, 'hello'])) - # ... - await algorand.send.AppMethodCall(my_method_call) - # Define a nested transaction as an ABI argument - my_method_call = app_client.params.call(AppClientMethodCallParams( - method='my_method', - args=[123, 'hello'])) - app_client.send.call(AppClientMethodCallParams(method='my_method2', args=[my_method_call])) - ``` - -#### *property* send *: \_TransactionSender* - -Get the transaction sender. - -* **Returns:** - The transaction sender for this application - -#### *property* create_transaction *: \_TransactionCreator* - -Get the transaction creator. - -* **Returns:** - The transaction creator for this application - -#### *static* normalise_app_spec(app_spec: [algokit_utils.applications.app_spec.arc56.Arc56Contract](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.Arc56Contract) | [algokit_utils.applications.app_spec.arc32.Arc32Contract](../app_spec/arc32/index.md#algokit_utils.applications.app_spec.arc32.Arc32Contract) | str) → [algokit_utils.applications.app_spec.arc56.Arc56Contract](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.Arc56Contract) - -Normalize an application specification to ARC-56 format. - -* **Parameters:** - **app_spec** – The application specification to normalize. Can be raw arc32 or arc56 json, - or an Arc32Contract or Arc56Contract instance -* **Returns:** - The normalized ARC-56 contract specification -* **Raises:** - **ValueError** – If the app spec format is invalid -* **Example:** - ```python - spec = AppClient.normalise_app_spec(app_spec_json) - ``` - -#### *static* from_network(app_spec: [algokit_utils.applications.app_spec.arc56.Arc56Contract](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.Arc56Contract) | [algokit_utils.applications.app_spec.arc32.Arc32Contract](../app_spec/arc32/index.md#algokit_utils.applications.app_spec.arc32.Arc32Contract) | str, algorand: [algokit_utils.algorand.AlgorandClient](../../algorand/index.md#algokit_utils.algorand.AlgorandClient), app_name: str | None = None, default_sender: str | None = None, default_signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None, approval_source_map: algosdk.source_map.SourceMap | None = None, clear_source_map: algosdk.source_map.SourceMap | None = None) → [AppClient](#algokit_utils.applications.app_client.AppClient) - -Create an AppClient instance from network information. - -* **Parameters:** - * **app_spec** – The application specification - * **algorand** – The Algorand client instance - * **app_name** – Optional application name - * **default_sender** – Optional default sender address - * **default_signer** – Optional default transaction signer - * **approval_source_map** – Optional approval program source map - * **clear_source_map** – Optional clear program source map -* **Returns:** - A new AppClient instance -* **Raises:** - **Exception** – If no app ID is found for the network -* **Example:** - ```python - client = AppClient.from_network( - app_spec=Arc56Contract.from_json(app_spec_json), - algorand=algorand, - app_name="My App", - default_sender="SENDERADDRESS", - default_signer=TransactionSigner( - account="SIGNERACCOUNT", - private_key="SIGNERPRIVATEKEY", - ), - approval_source_map=SourceMap( - source="APPROVALSOURCE", - ), - clear_source_map=SourceMap( - source="CLEARSOURCE", - ), - ) - ``` - -#### *static* from_creator_and_name(creator_address: str, app_name: str, app_spec: [algokit_utils.applications.app_spec.arc56.Arc56Contract](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.Arc56Contract) | [algokit_utils.applications.app_spec.arc32.Arc32Contract](../app_spec/arc32/index.md#algokit_utils.applications.app_spec.arc32.Arc32Contract) | str, algorand: [algokit_utils.algorand.AlgorandClient](../../algorand/index.md#algokit_utils.algorand.AlgorandClient), default_sender: str | None = None, default_signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None, approval_source_map: algosdk.source_map.SourceMap | None = None, clear_source_map: algosdk.source_map.SourceMap | None = None, ignore_cache: bool | None = None, app_lookup_cache: [algokit_utils.applications.app_deployer.ApplicationLookup](../app_deployer/index.md#algokit_utils.applications.app_deployer.ApplicationLookup) | None = None) → [AppClient](#algokit_utils.applications.app_client.AppClient) - -Create an AppClient instance from creator address and application name. - -* **Parameters:** - * **creator_address** – The address of the application creator - * **app_name** – The name of the application - * **app_spec** – The application specification - * **algorand** – The Algorand client instance - * **default_sender** – Optional default sender address - * **default_signer** – Optional default transaction signer - * **approval_source_map** – Optional approval program source map - * **clear_source_map** – Optional clear program source map - * **ignore_cache** – Optional flag to ignore cache - * **app_lookup_cache** – Optional app lookup cache -* **Returns:** - A new AppClient instance -* **Raises:** - **ValueError** – If the app is not found for the creator and name -* **Example:** - ```python - client = AppClient.from_creator_and_name( - creator_address="CREATORADDRESS", - app_name="APPNAME", - app_spec=Arc56Contract.from_json(app_spec_json), - algorand=algorand, - ) - ``` - -#### *static* compile(app_spec: [algokit_utils.applications.app_spec.arc56.Arc56Contract](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.Arc56Contract), app_manager: [algokit_utils.applications.app_manager.AppManager](../app_manager/index.md#algokit_utils.applications.app_manager.AppManager), compilation_params: [AppClientCompilationParams](#algokit_utils.applications.app_client.AppClientCompilationParams) | None = None) → [AppClientCompilationResult](#algokit_utils.applications.app_client.AppClientCompilationResult) - -Compile the application’s TEAL code. - -* **Parameters:** - * **app_spec** – The application specification - * **app_manager** – The application manager instance - * **compilation_params** – Optional compilation parameters -* **Returns:** - The compilation result -* **Raises:** - **ValueError** – If attempting to compile without source or byte code - -#### compile_app(compilation_params: [AppClientCompilationParams](#algokit_utils.applications.app_client.AppClientCompilationParams) | None = None) → [AppClientCompilationResult](#algokit_utils.applications.app_client.AppClientCompilationResult) - -Compile the application’s TEAL code. - -* **Parameters:** - **compilation_params** – Optional compilation parameters -* **Returns:** - The compilation result - -#### clone(app_name: str | None = \_MISSING, default_sender: str | None = \_MISSING, default_signer: algosdk.atomic_transaction_composer.TransactionSigner | None = \_MISSING, approval_source_map: algosdk.source_map.SourceMap | None = \_MISSING, clear_source_map: algosdk.source_map.SourceMap | None = \_MISSING) → [AppClient](#algokit_utils.applications.app_client.AppClient) - -Create a cloned AppClient instance with optionally overridden parameters. - -* **Parameters:** - * **app_name** – Optional new application name - * **default_sender** – Optional new default sender - * **default_signer** – Optional new default signer - * **approval_source_map** – Optional new approval source map - * **clear_source_map** – Optional new clear source map -* **Returns:** - A new AppClient instance -* **Example:** - ```python - client = AppClient(params) - cloned_client = client.clone(app_name="Cloned App", default_sender="NEW_SENDER") - ``` - -#### export_source_maps() → [algokit_utils.models.application.AppSourceMaps](../../models/application/index.md#algokit_utils.models.application.AppSourceMaps) - -Export the application’s source maps. - -* **Returns:** - The application’s source maps -* **Raises:** - **ValueError** – If source maps haven’t been loaded - -#### import_source_maps(source_maps: [algokit_utils.models.application.AppSourceMaps](../../models/application/index.md#algokit_utils.models.application.AppSourceMaps)) → None - -Import source maps for the application. - -* **Parameters:** - **source_maps** – The source maps to import -* **Raises:** - **ValueError** – If source maps are invalid or missing - -#### get_local_state(address: str) → dict[str, [algokit_utils.models.application.AppState](../../models/application/index.md#algokit_utils.models.application.AppState)] - -Get local state for an account. - -* **Parameters:** - **address** – The account address -* **Returns:** - The account’s local state for this application - -#### get_global_state() → dict[str, [algokit_utils.models.application.AppState](../../models/application/index.md#algokit_utils.models.application.AppState)] - -Get the application’s global state. - -* **Returns:** - The application’s global state -* **Example:** - ```python - global_state = client.get_global_state() - ``` - -#### get_box_names() → list[[algokit_utils.models.state.BoxName](../../models/state/index.md#algokit_utils.models.state.BoxName)] - -Get all box names for the application. - -* **Returns:** - List of box names -* **Example:** - ```python - box_names = client.get_box_names() - ``` - -#### get_box_value(name: algokit_utils.models.state.BoxIdentifier) → bytes - -Get the value of a box. - -* **Parameters:** - **name** – The box identifier -* **Returns:** - The box value as bytes -* **Example:** - ```python - box_value = client.get_box_value(box_name) - ``` - -#### get_box_value_from_abi_type(name: algokit_utils.models.state.BoxIdentifier, abi_type: algokit_utils.applications.abi.ABIType) → algokit_utils.applications.abi.ABIValue - -Get a box value decoded according to an ABI type. - -* **Parameters:** - * **name** – The box identifier - * **abi_type** – The ABI type to decode as -* **Returns:** - The decoded box value -* **Example:** - ```python - box_value = client.get_box_value_from_abi_type(box_name, abi_type) - ``` - -#### get_box_values(filter_func: collections.abc.Callable[[[algokit_utils.models.state.BoxName](../../models/state/index.md#algokit_utils.models.state.BoxName)], bool] | None = None) → list[[algokit_utils.models.state.BoxValue](../../models/state/index.md#algokit_utils.models.state.BoxValue)] - -Get values for multiple boxes. - -* **Parameters:** - **filter_func** – Optional function to filter box names -* **Returns:** - List of box values -* **Example:** - ```python - box_values = client.get_box_values() - ``` - -#### get_box_values_from_abi_type(abi_type: algokit_utils.applications.abi.ABIType, filter_func: collections.abc.Callable[[[algokit_utils.models.state.BoxName](../../models/state/index.md#algokit_utils.models.state.BoxName)], bool] | None = None) → list[[algokit_utils.applications.abi.BoxABIValue](../abi/index.md#algokit_utils.applications.abi.BoxABIValue)] - -Get multiple box values decoded according to an ABI type. - -* **Parameters:** - * **abi_type** – The ABI type to decode as - * **filter_func** – Optional function to filter box names -* **Returns:** - List of decoded box values -* **Example:** - ```python - box_values = client.get_box_values_from_abi_type(abi_type) - ``` - -#### fund_app_account(params: [FundAppAccountParams](#algokit_utils.applications.app_client.FundAppAccountParams), send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → [algokit_utils.transactions.transaction_sender.SendSingleTransactionResult](../../transactions/transaction_sender/index.md#algokit_utils.transactions.transaction_sender.SendSingleTransactionResult) - -Fund the application’s account. - -* **Parameters:** - * **params** – The funding parameters - * **send_params** – Send parameters, defaults to None -* **Returns:** - The transaction result -* **Example:** - ```python - result = client.fund_app_account(params) - ``` diff --git a/docs/markdown/autoapi/algokit_utils/applications/app_deployer/index.md b/docs/markdown/autoapi/algokit_utils/applications/app_deployer/index.md deleted file mode 100644 index 34f3f3e8..00000000 --- a/docs/markdown/autoapi/algokit_utils/applications/app_deployer/index.md +++ /dev/null @@ -1,243 +0,0 @@ -# algokit_utils.applications.app_deployer - -## Attributes - -| [`APP_DEPLOY_NOTE_DAPP`](#algokit_utils.applications.app_deployer.APP_DEPLOY_NOTE_DAPP) | | -|-------------------------------------------------------------------------------------------|----| - -## Classes - -| [`AppDeploymentMetaData`](#algokit_utils.applications.app_deployer.AppDeploymentMetaData) | Metadata about an application stored in a transaction note during creation. | -|---------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------| -| [`ApplicationReference`](#algokit_utils.applications.app_deployer.ApplicationReference) | Information about an Algorand app | -| [`ApplicationMetaData`](#algokit_utils.applications.app_deployer.ApplicationMetaData) | Complete metadata about a deployed app | -| [`ApplicationLookup`](#algokit_utils.applications.app_deployer.ApplicationLookup) | Cache of {py:class}\`ApplicationMetaData\` for a specific creator | -| [`AppDeployParams`](#algokit_utils.applications.app_deployer.AppDeployParams) | Parameters for deploying an app | -| [`AppDeployResult`](#algokit_utils.applications.app_deployer.AppDeployResult) | The result of a deployment | -| [`AppDeployer`](#algokit_utils.applications.app_deployer.AppDeployer) | Manages deployment and deployment metadata of applications | - -## Module Contents - -### algokit_utils.applications.app_deployer.APP_DEPLOY_NOTE_DAPP *: str* *= 'ALGOKIT_DEPLOYER'* - -### *class* algokit_utils.applications.app_deployer.AppDeploymentMetaData - -Metadata about an application stored in a transaction note during creation. - -#### name *: str* - -#### version *: str* - -#### deletable *: bool | None* - -#### updatable *: bool | None* - -#### dictify() → dict[str, str | bool] - -### *class* algokit_utils.applications.app_deployer.ApplicationReference - -Information about an Algorand app - -#### app_id *: int* - -#### app_address *: str* - -### *class* algokit_utils.applications.app_deployer.ApplicationMetaData - -Complete metadata about a deployed app - -#### reference *: [ApplicationReference](#algokit_utils.applications.app_deployer.ApplicationReference)* - -#### deploy_metadata *: [AppDeploymentMetaData](#algokit_utils.applications.app_deployer.AppDeploymentMetaData)* - -#### created_round *: int* - -#### updated_round *: int* - -#### deleted *: bool* *= False* - -#### *property* app_id *: int* - -#### *property* app_address *: str* - -#### *property* name *: str* - -#### *property* version *: str* - -#### *property* deletable *: bool | None* - -#### *property* updatable *: bool | None* - -### *class* algokit_utils.applications.app_deployer.ApplicationLookup - -Cache of {py:class}\`ApplicationMetaData\` for a specific creator - -Can be used as an argument to {py:class}\`ApplicationClient\` to reduce the number of calls when deploying multiple -apps or discovering multiple app_ids - -#### creator *: str* - -#### apps *: dict[str, [ApplicationMetaData](#algokit_utils.applications.app_deployer.ApplicationMetaData)]* - -### *class* algokit_utils.applications.app_deployer.AppDeployParams - -Parameters for deploying an app - -#### metadata *: [AppDeploymentMetaData](#algokit_utils.applications.app_deployer.AppDeploymentMetaData)* - -The deployment metadata - -#### deploy_time_params *: algokit_utils.models.state.TealTemplateParams | None* *= None* - -Optional template parameters to use during compilation - -#### on_schema_break *: Literal['replace', 'fail', 'append'] | [algokit_utils.applications.enums.OnSchemaBreak](../enums/index.md#algokit_utils.applications.enums.OnSchemaBreak) | None* *= None* - -Optional on schema break action - -#### on_update *: Literal['update', 'replace', 'fail', 'append'] | [algokit_utils.applications.enums.OnUpdate](../enums/index.md#algokit_utils.applications.enums.OnUpdate) | None* *= None* - -Optional on update action - -#### create_params *: [algokit_utils.transactions.transaction_composer.AppCreateParams](../../transactions/transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppCreateParams) | [algokit_utils.transactions.transaction_composer.AppCreateMethodCallParams](../../transactions/transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppCreateMethodCallParams)* - -The creation parameters - -#### update_params *: [algokit_utils.transactions.transaction_composer.AppUpdateParams](../../transactions/transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppUpdateParams) | [algokit_utils.transactions.transaction_composer.AppUpdateMethodCallParams](../../transactions/transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppUpdateMethodCallParams)* - -The update parameters - -#### delete_params *: [algokit_utils.transactions.transaction_composer.AppDeleteParams](../../transactions/transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppDeleteParams) | [algokit_utils.transactions.transaction_composer.AppDeleteMethodCallParams](../../transactions/transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppDeleteMethodCallParams)* - -The deletion parameters - -#### existing_deployments *: [ApplicationLookup](#algokit_utils.applications.app_deployer.ApplicationLookup) | None* *= None* - -Optional existing deployments - -#### ignore_cache *: bool* *= False* - -Whether to ignore the cache - -#### max_fee *: int | None* *= None* - -Optional maximum fee - -#### send_params *: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None* *= None* - -Optional send parameters - -### *class* algokit_utils.applications.app_deployer.AppDeployResult - -The result of a deployment - -#### app *: [ApplicationMetaData](#algokit_utils.applications.app_deployer.ApplicationMetaData)* - -The application metadata - -#### operation_performed *: [algokit_utils.applications.enums.OperationPerformed](../enums/index.md#algokit_utils.applications.enums.OperationPerformed)* - -The operation performed - -#### create_result *: [algokit_utils.transactions.transaction_sender.SendAppCreateTransactionResult](../../transactions/transaction_sender/index.md#algokit_utils.transactions.transaction_sender.SendAppCreateTransactionResult)[[algokit_utils.applications.abi.ABIReturn](../abi/index.md#algokit_utils.applications.abi.ABIReturn)] | None* *= None* - -The create result - -#### update_result *: [algokit_utils.transactions.transaction_sender.SendAppUpdateTransactionResult](../../transactions/transaction_sender/index.md#algokit_utils.transactions.transaction_sender.SendAppUpdateTransactionResult)[[algokit_utils.applications.abi.ABIReturn](../abi/index.md#algokit_utils.applications.abi.ABIReturn)] | None* *= None* - -The update result - -#### delete_result *: [algokit_utils.transactions.transaction_sender.SendAppTransactionResult](../../transactions/transaction_sender/index.md#algokit_utils.transactions.transaction_sender.SendAppTransactionResult)[[algokit_utils.applications.abi.ABIReturn](../abi/index.md#algokit_utils.applications.abi.ABIReturn)] | None* *= None* - -The delete result - -### *class* algokit_utils.applications.app_deployer.AppDeployer(app_manager: [algokit_utils.applications.app_manager.AppManager](../app_manager/index.md#algokit_utils.applications.app_manager.AppManager), transaction_sender: [algokit_utils.transactions.transaction_sender.AlgorandClientTransactionSender](../../transactions/transaction_sender/index.md#algokit_utils.transactions.transaction_sender.AlgorandClientTransactionSender), indexer: algosdk.v2client.indexer.IndexerClient | None = None) - -Manages deployment and deployment metadata of applications - -* **Parameters:** - * **app_manager** – The app manager to use - * **transaction_sender** – The transaction sender to use - * **indexer** – The indexer to use -* **Example:** - ```python - deployer = AppDeployer(app_manager, transaction_sender, indexer) - ``` - -#### deploy(deployment: [AppDeployParams](#algokit_utils.applications.app_deployer.AppDeployParams)) → [AppDeployResult](#algokit_utils.applications.app_deployer.AppDeployResult) - -Idempotently deploy (create if not exists, update if changed) an app against the given name for the given -creator account, including deploy-time TEAL template placeholder substitutions (if specified). - -To understand the architecture decisions behind this functionality please see -[https://github.com/algorandfoundation/algokit-cli/blob/main/docs/architecture-decisions/2023-01-12_smart-contract-deployment.md](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/architecture-decisions/2023-01-12_smart-contract-deployment.md) - -**Note:** When using the return from this function be sure to check operation_performed to get access to -return properties like transaction, confirmation and delete_result. - -**Note:** if there is a breaking state schema change to an existing app (and on_schema_break is set to -‘replace’) the existing app will be deleted and re-created. - -**Note:** if there is an update (different TEAL code) to an existing app (and on_update is set to ‘replace’) -the existing app will be deleted and re-created. - -* **Parameters:** - **deployment** – The arguments to control the app deployment -* **Returns:** - The result of the deployment -* **Raises:** - **ValueError** – If the app spec format is invalid -* **Example:** - ```python - deployer.deploy(AppDeployParams( - create_params=AppCreateParams( - sender='SENDER_ADDRESS', - approval_program='APPROVAL PROGRAM', - clear_state_program='CLEAR PROGRAM', - schema={ - 'global_byte_slices': 0, - 'global_ints': 0, - 'local_byte_slices': 0, - 'local_ints': 0 - } - ), - update_params=AppUpdateParams( - sender='SENDER_ADDRESS' - ), - delete_params=AppDeleteParams( - sender='SENDER_ADDRESS' - ), - metadata=AppDeploymentMetaData( - name='my_app', - version='2.0', - updatable=False, - deletable=False - ), - on_schema_break=OnSchemaBreak.AppendApp, - on_update=OnUpdate.AppendApp - ) - ) - ``` - -#### get_creator_apps_by_name(\*, creator_address: str, ignore_cache: bool = False) → [ApplicationLookup](#algokit_utils.applications.app_deployer.ApplicationLookup) - -Returns a lookup of name => app metadata (id, address, …metadata) for all apps created by the given account -that have an [ARC-2]([https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0002.md](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0002.md)) AppDeployNote as -the transaction note of the app creation transaction. - -This function caches the result for the given creator account so that subsequent calls won’t require an indexer -lookup. - -If the AppManager instance wasn’t created with an indexer client, this function will throw an error. - -* **Parameters:** - * **creator_address** – The address of the account that is the creator of the apps you want to search for - * **ignore_cache** – Whether or not to ignore the cache and force a lookup, default: use the cache -* **Returns:** - A name-based lookup of the app metadata -* **Raises:** - **ValueError** – If the app spec format is invalid -* **Example:** - ```python - result = await deployer.get_creator_apps_by_name(creator) - ``` diff --git a/docs/markdown/autoapi/algokit_utils/applications/app_factory/index.md b/docs/markdown/autoapi/algokit_utils/applications/app_factory/index.md deleted file mode 100644 index 19bafbf1..00000000 --- a/docs/markdown/autoapi/algokit_utils/applications/app_factory/index.md +++ /dev/null @@ -1,325 +0,0 @@ -# algokit_utils.applications.app_factory - -## Classes - -| [`AppFactoryParams`](#algokit_utils.applications.app_factory.AppFactoryParams) | | -|--------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------| -| [`AppFactoryCreateParams`](#algokit_utils.applications.app_factory.AppFactoryCreateParams) | Parameters for creating application with bare call. | -| [`AppFactoryCreateMethodCallParams`](#algokit_utils.applications.app_factory.AppFactoryCreateMethodCallParams) | Parameters for creating application with method call | -| [`AppFactoryCreateMethodCallResult`](#algokit_utils.applications.app_factory.AppFactoryCreateMethodCallResult) | Base class for transaction results. | -| [`SendAppFactoryTransactionResult`](#algokit_utils.applications.app_factory.SendAppFactoryTransactionResult) | Result of an application transaction. | -| [`SendAppUpdateFactoryTransactionResult`](#algokit_utils.applications.app_factory.SendAppUpdateFactoryTransactionResult) | Result of updating an application. | -| [`SendAppCreateFactoryTransactionResult`](#algokit_utils.applications.app_factory.SendAppCreateFactoryTransactionResult) | Result of creating a new application. | -| [`AppFactoryDeployResult`](#algokit_utils.applications.app_factory.AppFactoryDeployResult) | Result from deploying an application via AppFactory | -| [`AppFactory`](#algokit_utils.applications.app_factory.AppFactory) | ARC-56/ARC-32 app factory that, for a given app spec, allows you to create | - -## Module Contents - -### *class* algokit_utils.applications.app_factory.AppFactoryParams - -#### algorand *: [algokit_utils.algorand.AlgorandClient](../../algorand/index.md#algokit_utils.algorand.AlgorandClient)* - -#### app_spec *: [algokit_utils.applications.app_spec.arc56.Arc56Contract](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.Arc56Contract) | algokit_utils._legacy_v2.application_specification.ApplicationSpecification | str* - -#### app_name *: str | None* *= None* - -#### default_sender *: str | None* *= None* - -#### default_signer *: algosdk.atomic_transaction_composer.TransactionSigner | None* *= None* - -#### version *: str | None* *= None* - -#### compilation_params *: [algokit_utils.applications.app_client.AppClientCompilationParams](../app_client/index.md#algokit_utils.applications.app_client.AppClientCompilationParams) | None* *= None* - -### *class* algokit_utils.applications.app_factory.AppFactoryCreateParams - -Bases: [`algokit_utils.applications.app_client.AppClientBareCallCreateParams`](../app_client/index.md#algokit_utils.applications.app_client.AppClientBareCallCreateParams) - -Parameters for creating application with bare call. - -#### on_complete *: algokit_utils.applications.app_client.CreateOnComplete | None* *= None* - -Optional on complete action - -### *class* algokit_utils.applications.app_factory.AppFactoryCreateMethodCallParams - -Bases: [`algokit_utils.applications.app_client.AppClientMethodCallCreateParams`](../app_client/index.md#algokit_utils.applications.app_client.AppClientMethodCallCreateParams) - -Parameters for creating application with method call - -### *class* algokit_utils.applications.app_factory.AppFactoryCreateMethodCallResult - -Bases: [`algokit_utils.transactions.transaction_sender.SendSingleTransactionResult`](../../transactions/transaction_sender/index.md#algokit_utils.transactions.transaction_sender.SendSingleTransactionResult), `Generic`[`ABIReturnT`] - -Base class for transaction results. - -Represents the result of sending a single transaction. - -#### app_id *: int* - -#### app_address *: str* - -#### compiled_approval *: Any | None* *= None* - -#### compiled_clear *: Any | None* *= None* - -#### abi_return *: ABIReturnT | None* *= None* - -### *class* algokit_utils.applications.app_factory.SendAppFactoryTransactionResult - -Bases: [`algokit_utils.transactions.transaction_sender.SendAppTransactionResult`](../../transactions/transaction_sender/index.md#algokit_utils.transactions.transaction_sender.SendAppTransactionResult)[[`algokit_utils.applications.abi.Arc56ReturnValueType`](../abi/index.md#algokit_utils.applications.abi.Arc56ReturnValueType)] - -Result of an application transaction. - -Contains the ABI return value if applicable. - -### *class* algokit_utils.applications.app_factory.SendAppUpdateFactoryTransactionResult - -Bases: [`algokit_utils.transactions.transaction_sender.SendAppUpdateTransactionResult`](../../transactions/transaction_sender/index.md#algokit_utils.transactions.transaction_sender.SendAppUpdateTransactionResult)[[`algokit_utils.applications.abi.Arc56ReturnValueType`](../abi/index.md#algokit_utils.applications.abi.Arc56ReturnValueType)] - -Result of updating an application. - -Contains the compiled approval and clear programs. - -### *class* algokit_utils.applications.app_factory.SendAppCreateFactoryTransactionResult - -Bases: [`algokit_utils.transactions.transaction_sender.SendAppCreateTransactionResult`](../../transactions/transaction_sender/index.md#algokit_utils.transactions.transaction_sender.SendAppCreateTransactionResult)[[`algokit_utils.applications.abi.Arc56ReturnValueType`](../abi/index.md#algokit_utils.applications.abi.Arc56ReturnValueType)] - -Result of creating a new application. - -Contains the app ID and address of the newly created application. - -### *class* algokit_utils.applications.app_factory.AppFactoryDeployResult - -Result from deploying an application via AppFactory - -#### app *: [algokit_utils.applications.app_deployer.ApplicationMetaData](../app_deployer/index.md#algokit_utils.applications.app_deployer.ApplicationMetaData)* - -The application metadata - -#### operation_performed *: algokit_utils.applications.app_deployer.OperationPerformed* - -The operation performed - -#### create_result *: [SendAppCreateFactoryTransactionResult](#algokit_utils.applications.app_factory.SendAppCreateFactoryTransactionResult) | None* *= None* - -The create result - -#### update_result *: [SendAppUpdateFactoryTransactionResult](#algokit_utils.applications.app_factory.SendAppUpdateFactoryTransactionResult) | None* *= None* - -The update result - -#### delete_result *: [SendAppFactoryTransactionResult](#algokit_utils.applications.app_factory.SendAppFactoryTransactionResult) | None* *= None* - -The delete result - -#### *classmethod* from_deploy_result(response: [algokit_utils.applications.app_deployer.AppDeployResult](../app_deployer/index.md#algokit_utils.applications.app_deployer.AppDeployResult), deploy_params: [algokit_utils.applications.app_deployer.AppDeployParams](../app_deployer/index.md#algokit_utils.applications.app_deployer.AppDeployParams), app_spec: [algokit_utils.applications.app_spec.arc56.Arc56Contract](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.Arc56Contract), app_compilation_data: [algokit_utils.applications.app_client.AppClientCompilationResult](../app_client/index.md#algokit_utils.applications.app_client.AppClientCompilationResult) | None = None) → typing_extensions.Self - -Construct an AppFactoryDeployResult from a deployment result. - -* **Parameters:** - * **response** – The deployment response. - * **deploy_params** – The deployment parameters. - * **app_spec** – The application specification. - * **app_compilation_data** – Optional app compilation data. -* **Returns:** - An instance of AppFactoryDeployResult. - -### *class* algokit_utils.applications.app_factory.AppFactory(params: [AppFactoryParams](#algokit_utils.applications.app_factory.AppFactoryParams)) - -ARC-56/ARC-32 app factory that, for a given app spec, allows you to create -and deploy one or more app instances and to create one or more app clients -to interact with those (or other) app instances. - -* **Parameters:** - **params** – The parameters for the factory -* **Example:** - ```python - factory = AppFactory(AppFactoryParams( - algorand=AlgorandClient.mainnet(), - app_spec=app_spec, - ) - ) - ``` - -#### *property* app_name *: str* - -The name of the app - -#### *property* app_spec *: [algokit_utils.applications.app_spec.arc56.Arc56Contract](../app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.Arc56Contract)* - -The app spec - -#### *property* algorand *: [algokit_utils.algorand.AlgorandClient](../../algorand/index.md#algokit_utils.algorand.AlgorandClient)* - -The algorand client - -#### *property* params *: \_MethodParamsBuilder* - -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. - -* **Example:** - ```python - Create a transaction in the future using Algorand Client - create_app_params = app_factory.params.create( - AppFactoryCreateMethodCallParams( - method=’create_method’, - args=[123, ‘hello’] - ) - ) - # … - algorand.send.app_create_method_call(create_app_params) - ``` -* **Example:** - ```python - Define a nested transaction as an ABI argument - create_app_params = appFactory.params.create( - AppFactoryCreateMethodCallParams( - method=’create_method’, - args=[123, ‘hello’] - ) - ) - app_client.send.call( - AppClientMethodCallParams( - method=’my_method’, - args=[create_app_params] - ) - ) - ``` - -#### *property* send *: \_TransactionSender* - -Get the transaction sender. - -* **Returns:** - The \_TransactionSender instance. - -#### *property* create_transaction *: \_TransactionCreator* - -Get the transaction creator. - -* **Returns:** - The \_TransactionCreator instance. - -#### deploy(\*, on_update: algokit_utils.applications.app_deployer.OnUpdate | None = None, on_schema_break: algokit_utils.applications.app_deployer.OnSchemaBreak | None = None, create_params: [algokit_utils.applications.app_client.AppClientMethodCallCreateParams](../app_client/index.md#algokit_utils.applications.app_client.AppClientMethodCallCreateParams) | [algokit_utils.applications.app_client.AppClientBareCallCreateParams](../app_client/index.md#algokit_utils.applications.app_client.AppClientBareCallCreateParams) | None = None, update_params: [algokit_utils.applications.app_client.AppClientMethodCallParams](../app_client/index.md#algokit_utils.applications.app_client.AppClientMethodCallParams) | [algokit_utils.applications.app_client.AppClientBareCallParams](../app_client/index.md#algokit_utils.applications.app_client.AppClientBareCallParams) | None = None, delete_params: [algokit_utils.applications.app_client.AppClientMethodCallParams](../app_client/index.md#algokit_utils.applications.app_client.AppClientMethodCallParams) | [algokit_utils.applications.app_client.AppClientBareCallParams](../app_client/index.md#algokit_utils.applications.app_client.AppClientBareCallParams) | None = None, existing_deployments: [algokit_utils.applications.app_deployer.ApplicationLookup](../app_deployer/index.md#algokit_utils.applications.app_deployer.ApplicationLookup) | None = None, ignore_cache: bool = False, app_name: str | None = None, send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None, compilation_params: [algokit_utils.applications.app_client.AppClientCompilationParams](../app_client/index.md#algokit_utils.applications.app_client.AppClientCompilationParams) | None = None) → tuple[[algokit_utils.applications.app_client.AppClient](../app_client/index.md#algokit_utils.applications.app_client.AppClient), [AppFactoryDeployResult](#algokit_utils.applications.app_factory.AppFactoryDeployResult)] - -Idempotently deploy (create if not exists, update if changed) an app against the given name for the given -creator account, including deploy-time TEAL template placeholder substitutions (if specified). - -**Note:** When using the return from this function be sure to check operationPerformed to get access to -various return properties like transaction, confirmation and deleteResult. - -**Note:** if there is a breaking state schema change to an existing app (and onSchemaBreak is set to -‘replace’) the existing app will be deleted and re-created. - -**Note:** if there is an update (different TEAL code) to an existing app (and onUpdate is set to -‘replace’) the existing app will be deleted and re-created. - -* **Parameters:** - * **on_update** – The action to take if there is an update to the app - * **on_schema_break** – The action to take if there is a breaking state schema change to the app - * **create_params** – The arguments to create the app - * **update_params** – The arguments to update the app - * **delete_params** – The arguments to delete the app - * **existing_deployments** – The existing deployments to use - * **ignore_cache** – Whether to ignore the cache - * **app_name** – The name of the app - * **send_params** – The parameters for the send call - * **compilation_params** – The parameters for the compilation -* **Returns:** - The app client and the result of the deployment -* **Example:** - ```python - app_client, result = factory.deploy({ - create_params=AppClientMethodCallCreateParams( - sender='SENDER_ADDRESS', - approval_program='APPROVAL PROGRAM', - clear_state_program='CLEAR PROGRAM', - schema={ - "global_byte_slices": 0, - "global_ints": 0, - "local_byte_slices": 0, - "local_ints": 0 - } - ), - update_params=AppClientMethodCallParams( - sender='SENDER_ADDRESS' - ), - delete_params=AppClientMethodCallParams( - sender='SENDER_ADDRESS' - ), - compilation_params=AppClientCompilationParams( - updatable=False, - deletable=False - ), - app_name='my_app', - on_schema_break=OnSchemaBreak.AppendApp, - on_update=OnUpdate.AppendApp - }) - ``` - -#### get_app_client_by_id(app_id: int, app_name: str | None = None, default_sender: str | None = None, default_signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None, approval_source_map: algosdk.source_map.SourceMap | None = None, clear_source_map: algosdk.source_map.SourceMap | None = None) → [algokit_utils.applications.app_client.AppClient](../app_client/index.md#algokit_utils.applications.app_client.AppClient) - -Returns a new AppClient client for an app instance of the given ID. - -* **Parameters:** - * **app_id** – The id of the app - * **app_name** – The name of the app - * **default_sender** – The default sender address - * **default_signer** – The default signer - * **approval_source_map** – The approval source map - * **clear_source_map** – The clear source map -* **Return AppClient:** - The app client -* **Example:** - ```python - app_client = factory.get_app_client_by_id(app_id=123) - ``` - -#### get_app_client_by_creator_and_name(creator_address: str, app_name: str, default_sender: str | None = None, default_signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None, ignore_cache: bool | None = None, app_lookup_cache: [algokit_utils.applications.app_deployer.ApplicationLookup](../app_deployer/index.md#algokit_utils.applications.app_deployer.ApplicationLookup) | None = None, approval_source_map: algosdk.source_map.SourceMap | None = None, clear_source_map: algosdk.source_map.SourceMap | None = None) → [algokit_utils.applications.app_client.AppClient](../app_client/index.md#algokit_utils.applications.app_client.AppClient) - -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). - -* **Parameters:** - * **creator_address** – The creator address - * **app_name** – The name of the app - * **default_sender** – The default sender address - * **default_signer** – The default signer - * **ignore_cache** – Whether to ignore the cache and force a lookup - * **app_lookup_cache** – Optional cache of existing app deployments to use instead of querying the indexer - * **approval_source_map** – Optional source map for the approval program - * **clear_source_map** – Optional source map for the clear state program -* **Returns:** - An AppClient instance configured for the resolved application -* **Example:** - ```python - app_client = factory.get_app_client_by_creator_and_name( - creator_address='SENDER_ADDRESS', - app_name='my_app' - ) - ``` - -#### export_source_maps() → [algokit_utils.models.application.AppSourceMaps](../../models/application/index.md#algokit_utils.models.application.AppSourceMaps) - -#### import_source_maps(source_maps: [algokit_utils.models.application.AppSourceMaps](../../models/application/index.md#algokit_utils.models.application.AppSourceMaps)) → None - -Import the provided source maps into the factory. - -* **Parameters:** - **source_maps** – An AppSourceMaps instance containing the approval and clear source maps. - -#### compile(compilation_params: [algokit_utils.applications.app_client.AppClientCompilationParams](../app_client/index.md#algokit_utils.applications.app_client.AppClientCompilationParams) | None = None) → [algokit_utils.applications.app_client.AppClientCompilationResult](../app_client/index.md#algokit_utils.applications.app_client.AppClientCompilationResult) - -Compile the app’s TEAL code. - -* **Parameters:** - **compilation_params** – The compilation parameters -* **Return AppClientCompilationResult:** - The compilation result -* **Example:** - ```python - compilation_result = factory.compile() - ``` diff --git a/docs/markdown/autoapi/algokit_utils/applications/app_manager/index.md b/docs/markdown/autoapi/algokit_utils/applications/app_manager/index.md deleted file mode 100644 index bdbd70e7..00000000 --- a/docs/markdown/autoapi/algokit_utils/applications/app_manager/index.md +++ /dev/null @@ -1,332 +0,0 @@ -# algokit_utils.applications.app_manager - -## Attributes - -| [`UPDATABLE_TEMPLATE_NAME`](#algokit_utils.applications.app_manager.UPDATABLE_TEMPLATE_NAME) | The name of the TEAL template variable for deploy-time immutability control. | -|------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------| -| [`DELETABLE_TEMPLATE_NAME`](#algokit_utils.applications.app_manager.DELETABLE_TEMPLATE_NAME) | The name of the TEAL template variable for deploy-time permanence control. | - -## Classes - -| [`AppManager`](#algokit_utils.applications.app_manager.AppManager) | A manager class for interacting with Algorand applications. | -|----------------------------------------------------------------------|---------------------------------------------------------------| - -## Module Contents - -### algokit_utils.applications.app_manager.UPDATABLE_TEMPLATE_NAME *= 'TMPL_UPDATABLE'* - -The name of the TEAL template variable for deploy-time immutability control. - -### algokit_utils.applications.app_manager.DELETABLE_TEMPLATE_NAME *= 'TMPL_DELETABLE'* - -The name of the TEAL template variable for deploy-time permanence control. - -### *class* algokit_utils.applications.app_manager.AppManager(algod_client: algosdk.v2client.algod.AlgodClient) - -A manager class for interacting with Algorand applications. - -Provides functionality for compiling TEAL code, managing application state, -and interacting with application boxes. - -* **Parameters:** - **algod_client** – The Algorand client instance to use for interacting with the network -* **Example:** - ```python - app_manager = AppManager(algod_client) - ``` - -#### compile_teal(teal_code: str) → [algokit_utils.models.application.CompiledTeal](../../models/application/index.md#algokit_utils.models.application.CompiledTeal) - -Compile TEAL source code. - -* **Parameters:** - **teal_code** – The TEAL source code to compile -* **Returns:** - The compiled TEAL code and associated metadata - -#### compile_teal_template(teal_template_code: str, template_params: algokit_utils.models.state.TealTemplateParams | None = None, deployment_metadata: collections.abc.Mapping[str, bool | None] | None = None) → [algokit_utils.models.application.CompiledTeal](../../models/application/index.md#algokit_utils.models.application.CompiledTeal) - -Compile a TEAL template with parameters. - -* **Parameters:** - * **teal_template_code** – The TEAL template code to compile - * **template_params** – Parameters to substitute in the template - * **deployment_metadata** – Deployment control parameters -* **Returns:** - The compiled TEAL code and associated metadata -* **Example:** - ```python - app_manager = AppManager(algod_client) - teal_template_code = - # This is a TEAL template - # It can contain template variables like {TMPL_UPDATABLE} and {TMPL_DELETABLE} - - compiled_teal = app_manager.compile_teal_template(teal_template_code) - ``` - -#### get_compilation_result(teal_code: str) → [algokit_utils.models.application.CompiledTeal](../../models/application/index.md#algokit_utils.models.application.CompiledTeal) | None - -Get cached compilation result for TEAL code if available. - -* **Parameters:** - **teal_code** – The TEAL source code -* **Returns:** - The cached compilation result if available, None otherwise -* **Example:** - ```python - app_manager = AppManager(algod_client) - teal_code = "RETURN 1" - compiled_teal = app_manager.compile_teal(teal_code) - compilation_result = app_manager.get_compilation_result(teal_code) - ``` - -#### get_by_id(app_id: int) → [algokit_utils.models.application.AppInformation](../../models/application/index.md#algokit_utils.models.application.AppInformation) - -Get information about an application by ID. - -* **Parameters:** - **app_id** – The application ID -* **Returns:** - Information about the application -* **Example:** - ```python - app_manager = AppManager(algod_client) - app_id = 1234567890 - app_info = app_manager.get_by_id(app_id) - ``` - -#### get_global_state(app_id: int) → dict[str, [algokit_utils.models.application.AppState](../../models/application/index.md#algokit_utils.models.application.AppState)] - -Get the global state of an application. - -* **Parameters:** - **app_id** – The application ID -* **Returns:** - The application’s global state -* **Example:** - ```python - app_manager = AppManager(algod_client) - app_id = 123 - global_state = app_manager.get_global_state(app_id) - ``` - -#### get_local_state(app_id: int, address: str) → dict[str, [algokit_utils.models.application.AppState](../../models/application/index.md#algokit_utils.models.application.AppState)] - -Get the local state for an account in an application. - -* **Parameters:** - * **app_id** – The application ID - * **address** – The account address -* **Returns:** - The account’s local state for the application -* **Raises:** - **ValueError** – If local state is not found -* **Example:** - ```python - app_manager = AppManager(algod_client) - app_id = 123 - address = "SENDER_ADDRESS" - local_state = app_manager.get_local_state(app_id, address) - ``` - -#### get_box_names(app_id: int) → list[[algokit_utils.models.state.BoxName](../../models/state/index.md#algokit_utils.models.state.BoxName)] - -Get names of all boxes for an application. - -If the box name can’t be decoded from UTF-8, the string representation of the bytes is returned. - -* **Parameters:** - **app_id** – The application ID -* **Returns:** - List of box names -* **Example:** - ```python - app_manager = AppManager(algod_client) - app_id = 123 - box_names = app_manager.get_box_names(app_id) - ``` - -#### get_box_value(app_id: int, box_name: algokit_utils.models.state.BoxIdentifier) → bytes - -Get the value stored in a box. - -* **Parameters:** - * **app_id** – The application ID - * **box_name** – The box identifier -* **Returns:** - The box value as bytes -* **Example:** - ```python - app_manager = AppManager(algod_client) - app_id = 123 - box_name = "BOX_NAME" - box_value = app_manager.get_box_value(app_id, box_name) - ``` - -#### get_box_values(app_id: int, box_names: list[algokit_utils.models.state.BoxIdentifier]) → list[bytes] - -Get values for multiple boxes. - -* **Parameters:** - * **app_id** – The application ID - * **box_names** – List of box identifiers -* **Returns:** - List of box values as bytes -* **Example:** - ```python - app_manager = AppManager(algod_client) - app_id = 123 - box_names = ["BOX_NAME_1", "BOX_NAME_2"] - box_values = app_manager.get_box_values(app_id, box_names) - ``` - -#### get_box_value_from_abi_type(app_id: int, box_name: algokit_utils.models.state.BoxIdentifier, abi_type: algokit_utils.applications.abi.ABIType) → algokit_utils.applications.abi.ABIValue - -Get and decode a box value using an ABI type. - -* **Parameters:** - * **app_id** – The application ID - * **box_name** – The box identifier - * **abi_type** – The ABI type to decode with -* **Returns:** - The decoded box value -* **Raises:** - **ValueError** – If decoding fails -* **Example:** - ```python - app_manager = AppManager(algod_client) - app_id = 123 - box_name = "BOX_NAME" - abi_type = ABIType.UINT - box_value = app_manager.get_box_value_from_abi_type(app_id, box_name, abi_type) - ``` - -#### get_box_values_from_abi_type(app_id: int, box_names: list[algokit_utils.models.state.BoxIdentifier], abi_type: algokit_utils.applications.abi.ABIType) → list[algokit_utils.applications.abi.ABIValue] - -Get and decode multiple box values using an ABI type. - -* **Parameters:** - * **app_id** – The application ID - * **box_names** – List of box identifiers - * **abi_type** – The ABI type to decode with -* **Returns:** - List of decoded box values -* **Example:** - ```python - app_manager = AppManager(algod_client) - app_id = 123 - box_names = ["BOX_NAME_1", "BOX_NAME_2"] - abi_type = ABIType.UINT - box_values = app_manager.get_box_values_from_abi_type(app_id, box_names, abi_type) - ``` - -#### *static* get_box_reference(box_id: algokit_utils.models.state.BoxIdentifier | [algokit_utils.models.state.BoxReference](../../models/state/index.md#algokit_utils.models.state.BoxReference)) → tuple[int, bytes] - -Get standardized box reference from various identifier types. - -* **Parameters:** - **box_id** – The box identifier -* **Returns:** - Tuple of (app_id, box_name_bytes) -* **Raises:** - **ValueError** – If box identifier type is invalid -* **Example:** - ```python - app_manager = AppManager(algod_client) - app_id = 123 - box_name = "BOX_NAME" - box_reference = app_manager.get_box_reference(box_name) - ``` - -#### *static* get_abi_return(confirmation: algosdk.v2client.algod.AlgodResponseType, method: algosdk.abi.Method | None = None) → [algokit_utils.applications.abi.ABIReturn](../abi/index.md#algokit_utils.applications.abi.ABIReturn) | None - -Get the ABI return value from a transaction confirmation. - -* **Parameters:** - * **confirmation** – The transaction confirmation - * **method** – The ABI method -* **Returns:** - The parsed ABI return value, or None if not available -* **Example:** - ```python - app_manager = AppManager(algod_client) - app_id = 123 - method = "METHOD_NAME" - confirmation = algod_client.pending_transaction_info(tx_id) - abi_return = app_manager.get_abi_return(confirmation, method) - ``` - -#### *static* decode_app_state(state: list[dict[str, Any]]) → dict[str, [algokit_utils.models.application.AppState](../../models/application/index.md#algokit_utils.models.application.AppState)] - -Decode application state from raw format. - -* **Parameters:** - **state** – The raw application state -* **Returns:** - Decoded application state -* **Raises:** - **ValueError** – If unknown state data type is encountered -* **Example:** - ```python - app_manager = AppManager(algod_client) - app_id = 123 - state = app_manager.get_global_state(app_id) - decoded_state = app_manager.decode_app_state(state) - ``` - -#### *static* replace_template_variables(program: str, template_values: algokit_utils.models.state.TealTemplateParams) → str - -Replace template variables in TEAL code. - -* **Parameters:** - * **program** – The TEAL program code - * **template_values** – Template variable values to substitute -* **Returns:** - TEAL code with substituted values -* **Raises:** - **ValueError** – If template value type is unexpected -* **Example:** - ```python - app_manager = AppManager(algod_client) - app_id = 123 - program = "RETURN 1" - template_values = {"TMPL_UPDATABLE": True, "TMPL_DELETABLE": True} - updated_program = app_manager.replace_template_variables(program, template_values) - ``` - -#### *static* replace_teal_template_deploy_time_control_params(teal_template_code: str, params: collections.abc.Mapping[str, bool | None]) → str - -Replace deploy-time control parameters in TEAL template. - -* **Parameters:** - * **teal_template_code** – The TEAL template code - * **params** – The deploy-time control parameters -* **Returns:** - TEAL code with substituted control parameters -* **Raises:** - **ValueError** – If template variables not found in code -* **Example:** - ```python - app_manager = AppManager(algod_client) - app_id = 123 - teal_template_code = "RETURN 1" - params = {"TMPL_UPDATABLE": True, "TMPL_DELETABLE": True} - updated_teal_code = app_manager.replace_teal_template_deploy_time_control_params( - teal_template_code, params - ) - ``` - -#### *static* strip_teal_comments(teal_code: str) → str - -Strip comments from TEAL code. - -* **Parameters:** - **teal_code** – The TEAL code to strip comments from -* **Returns:** - The TEAL code with comments stripped -* **Example:** - ```python - app_manager = AppManager(algod_client) - teal_code = "RETURN 1" - stripped_teal_code = app_manager.strip_teal_comments(teal_code) - ``` diff --git a/docs/markdown/autoapi/algokit_utils/applications/app_spec/arc32/index.md b/docs/markdown/autoapi/algokit_utils/applications/app_spec/arc32/index.md deleted file mode 100644 index db8e5a64..00000000 --- a/docs/markdown/autoapi/algokit_utils/applications/app_spec/arc32/index.md +++ /dev/null @@ -1,157 +0,0 @@ -# algokit_utils.applications.app_spec.arc32 - -## Attributes - -| [`AppSpecStateDict`](#algokit_utils.applications.app_spec.arc32.AppSpecStateDict) | Type defining Application Specification state entries | -|-------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------| -| [`OnCompleteActionName`](#algokit_utils.applications.app_spec.arc32.OnCompleteActionName) | String literals representing on completion transaction types | -| [`MethodConfigDict`](#algokit_utils.applications.app_spec.arc32.MethodConfigDict) | Dictionary of dict[OnCompletionActionName, CallConfig] representing allowed actions for each on completion type | -| [`DefaultArgumentType`](#algokit_utils.applications.app_spec.arc32.DefaultArgumentType) | Literal values describing the types of default argument sources | -| [`StateDict`](#algokit_utils.applications.app_spec.arc32.StateDict) | | - -## Classes - -| [`CallConfig`](#algokit_utils.applications.app_spec.arc32.CallConfig) | Describes the type of calls a method can be used for based on {py:class}\`algosdk.transaction.OnComplete\` type | -|-----------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------| -| [`StructArgDict`](#algokit_utils.applications.app_spec.arc32.StructArgDict) | dict() -> new empty dictionary | -| [`DefaultArgumentDict`](#algokit_utils.applications.app_spec.arc32.DefaultArgumentDict) | DefaultArgument is a container for any arguments that may | -| [`MethodHints`](#algokit_utils.applications.app_spec.arc32.MethodHints) | MethodHints provides hints to the caller about how to call the method | -| [`Arc32Contract`](#algokit_utils.applications.app_spec.arc32.Arc32Contract) | ARC-0032 application specification | - -## Module Contents - -### *type* algokit_utils.applications.app_spec.arc32.AppSpecStateDict *= dict[str, dict[str, dict]]* - -Type defining Application Specification state entries - -### *class* algokit_utils.applications.app_spec.arc32.CallConfig - -Bases: `enum.IntFlag` - -Describes the type of calls a method can be used for based on {py:class}\`algosdk.transaction.OnComplete\` type - -#### NEVER *= 0* - -Never handle the specified on completion type - -#### CALL *= 1* - -Only handle the specified on completion type for application calls - -#### CREATE *= 2* - -Only handle the specified on completion type for application create calls - -#### ALL *= 3* - -Handle the specified on completion type for both create and normal application calls - -### *class* algokit_utils.applications.app_spec.arc32.StructArgDict - -Bases: `TypedDict` - -dict() -> new empty dictionary -dict(mapping) -> new dictionary initialized from a mapping object’s - -> (key, value) pairs - -dict(iterable) -> new dictionary initialized as if via: -: d = {} - for k, v in iterable: -
- > d[k] = v - -dict( - -``` -** -``` - -kwargs) -> new dictionary initialized with the name=value pairs -: in the keyword argument list. For example: dict(one=1, two=2) - -#### name *: str* - -#### elements *: list[list[str]]* - -### *type* algokit_utils.applications.app_spec.arc32.OnCompleteActionName *= Literal['no_op', 'opt_in', 'close_out', 'clear_state', 'update_application', 'delete_application']* - -String literals representing on completion transaction types - -### *type* algokit_utils.applications.app_spec.arc32.MethodConfigDict *= dict[OnCompleteActionName, [CallConfig](#algokit_utils.applications.app_spec.arc32.CallConfig)]* - -Dictionary of dict[OnCompletionActionName, CallConfig] representing allowed actions for each on completion type - -### *type* algokit_utils.applications.app_spec.arc32.DefaultArgumentType *= Literal['abi-method', 'local-state', 'global-state', 'constant']* - -Literal values describing the types of default argument sources - -### *class* algokit_utils.applications.app_spec.arc32.DefaultArgumentDict - -Bases: `TypedDict` - -DefaultArgument is a container for any arguments that may -be resolved prior to calling some target method - -#### source *: DefaultArgumentType* - -#### data *: int | str | bytes | algosdk.abi.method.MethodDict* - -### algokit_utils.applications.app_spec.arc32.StateDict - -### *class* algokit_utils.applications.app_spec.arc32.MethodHints - -MethodHints provides hints to the caller about how to call the method - -#### read_only *: bool* *= False* - -#### structs *: dict[str, [StructArgDict](#algokit_utils.applications.app_spec.arc32.StructArgDict)]* - -#### default_arguments *: dict[str, [DefaultArgumentDict](#algokit_utils.applications.app_spec.arc32.DefaultArgumentDict)]* - -#### call_config *: MethodConfigDict* - -#### empty() → bool - -#### dictify() → dict[str, Any] - -#### *static* undictify(data: dict[str, Any]) → [MethodHints](#algokit_utils.applications.app_spec.arc32.MethodHints) - -### *class* algokit_utils.applications.app_spec.arc32.Arc32Contract - -ARC-0032 application specification - -See <[https://github.com/algorandfoundation/ARCs/pull/150](https://github.com/algorandfoundation/ARCs/pull/150)> - -#### approval_program *: str* - -#### clear_program *: str* - -#### contract *: algosdk.abi.Contract* - -#### hints *: dict[str, [MethodHints](#algokit_utils.applications.app_spec.arc32.MethodHints)]* - -#### schema *: StateDict* - -#### global_state_schema *: algosdk.transaction.StateSchema* - -#### local_state_schema *: algosdk.transaction.StateSchema* - -#### bare_call_config *: MethodConfigDict* - -#### dictify() → dict - -#### to_json(indent: int | None = None) → str - -#### *static* from_json(application_spec: str) → [Arc32Contract](#algokit_utils.applications.app_spec.arc32.Arc32Contract) - -#### export(directory: pathlib.Path | str | None = None) → None - -Write out the artifacts generated by the application to disk. - -Writes the approval program, clear program, contract specification and application specification -to files in the specified directory. - -* **Parameters:** - **directory** – Path to the directory where the artifacts should be written. If not specified, - uses the current working directory diff --git a/docs/markdown/autoapi/algokit_utils/applications/app_spec/arc56/index.md b/docs/markdown/autoapi/algokit_utils/applications/app_spec/arc56/index.md deleted file mode 100644 index 14168ec5..00000000 --- a/docs/markdown/autoapi/algokit_utils/applications/app_spec/arc56/index.md +++ /dev/null @@ -1,723 +0,0 @@ -# algokit_utils.applications.app_spec.arc56 - -## Classes - -| [`StructField`](#algokit_utils.applications.app_spec.arc56.StructField) | Represents a field in a struct type. | -|-------------------------------------------------------------------------------------|------------------------------------------------------------------------| -| [`CallEnum`](#algokit_utils.applications.app_spec.arc56.CallEnum) | Enum representing different call types for application transactions. | -| [`CreateEnum`](#algokit_utils.applications.app_spec.arc56.CreateEnum) | Enum representing different create types for application transactions. | -| [`BareActions`](#algokit_utils.applications.app_spec.arc56.BareActions) | Represents bare call and create actions for an application. | -| [`ByteCode`](#algokit_utils.applications.app_spec.arc56.ByteCode) | Represents the approval and clear program bytecode. | -| [`Compiler`](#algokit_utils.applications.app_spec.arc56.Compiler) | Enum representing different compiler types. | -| [`CompilerVersion`](#algokit_utils.applications.app_spec.arc56.CompilerVersion) | Represents compiler version information. | -| [`CompilerInfo`](#algokit_utils.applications.app_spec.arc56.CompilerInfo) | Information about the compiler used. | -| [`Network`](#algokit_utils.applications.app_spec.arc56.Network) | Network-specific application information. | -| [`ScratchVariables`](#algokit_utils.applications.app_spec.arc56.ScratchVariables) | Information about scratch space variables. | -| [`Source`](#algokit_utils.applications.app_spec.arc56.Source) | Source code for approval and clear programs. | -| [`Global`](#algokit_utils.applications.app_spec.arc56.Global) | Global state schema. | -| [`Local`](#algokit_utils.applications.app_spec.arc56.Local) | Local state schema. | -| [`Schema`](#algokit_utils.applications.app_spec.arc56.Schema) | Application state schema. | -| [`TemplateVariables`](#algokit_utils.applications.app_spec.arc56.TemplateVariables) | Template variable information. | -| [`EventArg`](#algokit_utils.applications.app_spec.arc56.EventArg) | Event argument information. | -| [`Event`](#algokit_utils.applications.app_spec.arc56.Event) | Event information. | -| [`Actions`](#algokit_utils.applications.app_spec.arc56.Actions) | Method actions information. | -| [`DefaultValue`](#algokit_utils.applications.app_spec.arc56.DefaultValue) | Default value information for method arguments. | -| [`MethodArg`](#algokit_utils.applications.app_spec.arc56.MethodArg) | Method argument information. | -| [`Boxes`](#algokit_utils.applications.app_spec.arc56.Boxes) | Box storage requirements. | -| [`Recommendations`](#algokit_utils.applications.app_spec.arc56.Recommendations) | Method execution recommendations. | -| [`Returns`](#algokit_utils.applications.app_spec.arc56.Returns) | Method return information. | -| [`Method`](#algokit_utils.applications.app_spec.arc56.Method) | Method information. | -| [`PcOffsetMethod`](#algokit_utils.applications.app_spec.arc56.PcOffsetMethod) | PC offset method types. | -| [`SourceInfo`](#algokit_utils.applications.app_spec.arc56.SourceInfo) | Source code location information. | -| [`StorageKey`](#algokit_utils.applications.app_spec.arc56.StorageKey) | Storage key information. | -| [`StorageMap`](#algokit_utils.applications.app_spec.arc56.StorageMap) | Storage map information. | -| [`Keys`](#algokit_utils.applications.app_spec.arc56.Keys) | Storage keys for different storage types. | -| [`Maps`](#algokit_utils.applications.app_spec.arc56.Maps) | Storage maps for different storage types. | -| [`State`](#algokit_utils.applications.app_spec.arc56.State) | Application state information. | -| [`ProgramSourceInfo`](#algokit_utils.applications.app_spec.arc56.ProgramSourceInfo) | Program source information. | -| [`SourceInfoModel`](#algokit_utils.applications.app_spec.arc56.SourceInfoModel) | Source information for approval and clear programs. | -| [`Arc56Contract`](#algokit_utils.applications.app_spec.arc56.Arc56Contract) | ARC-0056 application specification. | - -## Module Contents - -### *class* algokit_utils.applications.app_spec.arc56.StructField - -Represents a field in a struct type. - -#### name *: str* - -The name of the struct field - -#### type *: list[[StructField](#algokit_utils.applications.app_spec.arc56.StructField)] | str* - -The type of the struct field, either a string or list of StructFields - -#### *static* from_dict(data: dict[str, Any]) → [StructField](#algokit_utils.applications.app_spec.arc56.StructField) - -### *class* algokit_utils.applications.app_spec.arc56.CallEnum - -Bases: `str`, `enum.Enum` - -Enum representing different call types for application transactions. - -#### CLEAR_STATE *= 'ClearState'* - -#### CLOSE_OUT *= 'CloseOut'* - -#### DELETE_APPLICATION *= 'DeleteApplication'* - -#### NO_OP *= 'NoOp'* - -#### OPT_IN *= 'OptIn'* - -#### UPDATE_APPLICATION *= 'UpdateApplication'* - -### *class* algokit_utils.applications.app_spec.arc56.CreateEnum - -Bases: `str`, `enum.Enum` - -Enum representing different create types for application transactions. - -#### DELETE_APPLICATION *= 'DeleteApplication'* - -#### NO_OP *= 'NoOp'* - -#### OPT_IN *= 'OptIn'* - -### *class* algokit_utils.applications.app_spec.arc56.BareActions - -Represents bare call and create actions for an application. - -#### call *: list[[CallEnum](#algokit_utils.applications.app_spec.arc56.CallEnum)]* - -The list of allowed call actions - -#### create *: list[[CreateEnum](#algokit_utils.applications.app_spec.arc56.CreateEnum)]* - -The list of allowed create actions - -#### *static* from_dict(data: dict[str, Any]) → [BareActions](#algokit_utils.applications.app_spec.arc56.BareActions) - -### *class* algokit_utils.applications.app_spec.arc56.ByteCode - -Represents the approval and clear program bytecode. - -#### approval *: str* - -The base64 encoded approval program bytecode - -#### clear *: str* - -The base64 encoded clear program bytecode - -#### *static* from_dict(data: dict[str, Any]) → [ByteCode](#algokit_utils.applications.app_spec.arc56.ByteCode) - -### *class* algokit_utils.applications.app_spec.arc56.Compiler - -Bases: `str`, `enum.Enum` - -Enum representing different compiler types. - -#### ALGOD *= 'algod'* - -#### PUYA *= 'puya'* - -### *class* algokit_utils.applications.app_spec.arc56.CompilerVersion - -Represents compiler version information. - -#### commit_hash *: str | None* *= None* - -The git commit hash of the compiler - -#### major *: int | None* *= None* - -The major version number - -#### minor *: int | None* *= None* - -The minor version number - -#### patch *: int | None* *= None* - -The patch version number - -#### *static* from_dict(data: dict[str, Any]) → [CompilerVersion](#algokit_utils.applications.app_spec.arc56.CompilerVersion) - -### *class* algokit_utils.applications.app_spec.arc56.CompilerInfo - -Information about the compiler used. - -#### compiler *: [Compiler](#algokit_utils.applications.app_spec.arc56.Compiler)* - -The type of compiler used - -#### compiler_version *: [CompilerVersion](#algokit_utils.applications.app_spec.arc56.CompilerVersion)* - -Version information for the compiler - -#### *static* from_dict(data: dict[str, Any]) → [CompilerInfo](#algokit_utils.applications.app_spec.arc56.CompilerInfo) - -### *class* algokit_utils.applications.app_spec.arc56.Network - -Network-specific application information. - -#### app_id *: int* - -The application ID on the network - -#### *static* from_dict(data: dict[str, Any]) → [Network](#algokit_utils.applications.app_spec.arc56.Network) - -### *class* algokit_utils.applications.app_spec.arc56.ScratchVariables - -Information about scratch space variables. - -#### slot *: int* - -The scratch slot number - -#### type *: str* - -The type of the scratch variable - -#### *static* from_dict(data: dict[str, Any]) → [ScratchVariables](#algokit_utils.applications.app_spec.arc56.ScratchVariables) - -### *class* algokit_utils.applications.app_spec.arc56.Source - -Source code for approval and clear programs. - -#### approval *: str* - -The base64 encoded approval program source - -#### clear *: str* - -The base64 encoded clear program source - -#### *static* from_dict(data: dict[str, Any]) → [Source](#algokit_utils.applications.app_spec.arc56.Source) - -#### get_decoded_approval() → str - -Get decoded approval program source. - -* **Returns:** - Decoded approval program source code - -#### get_decoded_clear() → str - -Get decoded clear program source. - -* **Returns:** - Decoded clear program source code - -### *class* algokit_utils.applications.app_spec.arc56.Global - -Global state schema. - -#### bytes *: int* - -The number of byte slices in global state - -#### ints *: int* - -The number of integers in global state - -#### *static* from_dict(data: dict[str, Any]) → [Global](#algokit_utils.applications.app_spec.arc56.Global) - -### *class* algokit_utils.applications.app_spec.arc56.Local - -Local state schema. - -#### bytes *: int* - -The number of byte slices in local state - -#### ints *: int* - -The number of integers in local state - -#### *static* from_dict(data: dict[str, Any]) → [Local](#algokit_utils.applications.app_spec.arc56.Local) - -### *class* algokit_utils.applications.app_spec.arc56.Schema - -Application state schema. - -#### global_state *: [Global](#algokit_utils.applications.app_spec.arc56.Global)* - -The global state schema - -#### local_state *: [Local](#algokit_utils.applications.app_spec.arc56.Local)* - -The local state schema - -#### *static* from_dict(data: dict[str, Any]) → [Schema](#algokit_utils.applications.app_spec.arc56.Schema) - -### *class* algokit_utils.applications.app_spec.arc56.TemplateVariables - -Template variable information. - -#### type *: str* - -The type of the template variable - -#### value *: str | None* *= None* - -The optional value of the template variable - -#### *static* from_dict(data: dict[str, Any]) → [TemplateVariables](#algokit_utils.applications.app_spec.arc56.TemplateVariables) - -### *class* algokit_utils.applications.app_spec.arc56.EventArg - -Event argument information. - -#### type *: str* - -The type of the event argument - -#### desc *: str | None* *= None* - -The optional description of the argument - -#### name *: str | None* *= None* - -The optional name of the argument - -#### struct *: str | None* *= None* - -The optional struct type name - -#### *static* from_dict(data: dict[str, Any]) → [EventArg](#algokit_utils.applications.app_spec.arc56.EventArg) - -### *class* algokit_utils.applications.app_spec.arc56.Event - -Event information. - -#### args *: list[[EventArg](#algokit_utils.applications.app_spec.arc56.EventArg)]* - -The list of event arguments - -#### name *: str* - -The name of the event - -#### desc *: str | None* *= None* - -The optional description of the event - -#### *static* from_dict(data: dict[str, Any]) → [Event](#algokit_utils.applications.app_spec.arc56.Event) - -### *class* algokit_utils.applications.app_spec.arc56.Actions - -Method actions information. - -#### call *: list[[CallEnum](#algokit_utils.applications.app_spec.arc56.CallEnum)] | None* *= None* - -The optional list of allowed call actions - -#### create *: list[[CreateEnum](#algokit_utils.applications.app_spec.arc56.CreateEnum)] | None* *= None* - -The optional list of allowed create actions - -#### *static* from_dict(data: dict[str, Any]) → [Actions](#algokit_utils.applications.app_spec.arc56.Actions) - -### *class* algokit_utils.applications.app_spec.arc56.DefaultValue - -Default value information for method arguments. - -#### data *: str* - -The default value data - -#### source *: Literal['box', 'global', 'local', 'literal', 'method']* - -The source of the default value - -#### type *: str | None* *= None* - -The optional type of the default value - -#### *static* from_dict(data: dict[str, Any]) → [DefaultValue](#algokit_utils.applications.app_spec.arc56.DefaultValue) - -### *class* algokit_utils.applications.app_spec.arc56.MethodArg - -Method argument information. - -#### type *: str* - -The type of the argument - -#### default_value *: [DefaultValue](#algokit_utils.applications.app_spec.arc56.DefaultValue) | None* *= None* - -The optional default value - -#### desc *: str | None* *= None* - -The optional description - -#### name *: str | None* *= None* - -The optional name - -#### struct *: str | None* *= None* - -The optional struct type name - -#### *static* from_dict(data: dict[str, Any]) → [MethodArg](#algokit_utils.applications.app_spec.arc56.MethodArg) - -### *class* algokit_utils.applications.app_spec.arc56.Boxes - -Box storage requirements. - -#### key *: str* - -The box key - -#### read_bytes *: int* - -The number of bytes to read - -#### write_bytes *: int* - -The number of bytes to write - -#### app *: int | None* *= None* - -The optional application ID - -#### *static* from_dict(data: dict[str, Any]) → [Boxes](#algokit_utils.applications.app_spec.arc56.Boxes) - -### *class* algokit_utils.applications.app_spec.arc56.Recommendations - -Method execution recommendations. - -#### accounts *: list[str] | None* *= None* - -The optional list of accounts - -#### apps *: list[int] | None* *= None* - -The optional list of applications - -#### assets *: list[int] | None* *= None* - -The optional list of assets - -#### boxes *: [Boxes](#algokit_utils.applications.app_spec.arc56.Boxes) | None* *= None* - -The optional box storage requirements - -#### inner_transaction_count *: int | None* *= None* - -The optional inner transaction count - -#### *static* from_dict(data: dict[str, Any]) → [Recommendations](#algokit_utils.applications.app_spec.arc56.Recommendations) - -### *class* algokit_utils.applications.app_spec.arc56.Returns - -Method return information. - -#### type *: str* - -The type of the return value - -#### desc *: str | None* *= None* - -The optional description - -#### struct *: str | None* *= None* - -The optional struct type name - -#### *static* from_dict(data: dict[str, Any]) → [Returns](#algokit_utils.applications.app_spec.arc56.Returns) - -### *class* algokit_utils.applications.app_spec.arc56.Method - -Method information. - -#### actions *: [Actions](#algokit_utils.applications.app_spec.arc56.Actions)* - -The allowed actions - -#### args *: list[[MethodArg](#algokit_utils.applications.app_spec.arc56.MethodArg)]* - -The method arguments - -#### name *: str* - -The method name - -#### returns *: [Returns](#algokit_utils.applications.app_spec.arc56.Returns)* - -The return information - -#### desc *: str | None* *= None* - -The optional description - -#### events *: list[[Event](#algokit_utils.applications.app_spec.arc56.Event)] | None* *= None* - -The optional list of events - -#### readonly *: bool | None* *= None* - -The optional readonly flag - -#### recommendations *: [Recommendations](#algokit_utils.applications.app_spec.arc56.Recommendations) | None* *= None* - -The optional execution recommendations - -#### to_abi_method() → algosdk.abi.Method - -Convert to ABI method. - -* **Raises:** - **ValueError** – If underlying ABI method is not initialized -* **Returns:** - ABI method - -#### *static* from_dict(data: dict[str, Any]) → [Method](#algokit_utils.applications.app_spec.arc56.Method) - -### *class* algokit_utils.applications.app_spec.arc56.PcOffsetMethod - -Bases: `str`, `enum.Enum` - -PC offset method types. - -#### CBLOCKS *= 'cblocks'* - -#### NONE *= 'none'* - -### *class* algokit_utils.applications.app_spec.arc56.SourceInfo - -Source code location information. - -#### pc *: list[int]* - -The list of program counter values - -#### error_message *: str | None* *= None* - -The optional error message - -#### source *: str | None* *= None* - -The optional source code - -#### teal *: int | None* *= None* - -The optional TEAL version - -#### *static* from_dict(data: dict[str, Any]) → [SourceInfo](#algokit_utils.applications.app_spec.arc56.SourceInfo) - -### *class* algokit_utils.applications.app_spec.arc56.StorageKey - -Storage key information. - -#### key *: str* - -The storage key - -#### key_type *: str* - -The type of the key - -#### value_type *: str* - -The type of the value - -#### desc *: str | None* *= None* - -The optional description - -#### *static* from_dict(data: dict[str, Any]) → [StorageKey](#algokit_utils.applications.app_spec.arc56.StorageKey) - -### *class* algokit_utils.applications.app_spec.arc56.StorageMap - -Storage map information. - -#### key_type *: str* - -The type of the map keys - -#### value_type *: str* - -The type of the map values - -#### desc *: str | None* *= None* - -The optional description - -#### prefix *: str | None* *= None* - -The optional key prefix - -#### *static* from_dict(data: dict[str, Any]) → [StorageMap](#algokit_utils.applications.app_spec.arc56.StorageMap) - -### *class* algokit_utils.applications.app_spec.arc56.Keys - -Storage keys for different storage types. - -#### box *: dict[str, [StorageKey](#algokit_utils.applications.app_spec.arc56.StorageKey)]* - -The box storage keys - -#### global_state *: dict[str, [StorageKey](#algokit_utils.applications.app_spec.arc56.StorageKey)]* - -The global state storage keys - -#### local_state *: dict[str, [StorageKey](#algokit_utils.applications.app_spec.arc56.StorageKey)]* - -The local state storage keys - -#### *static* from_dict(data: dict[str, Any]) → [Keys](#algokit_utils.applications.app_spec.arc56.Keys) - -### *class* algokit_utils.applications.app_spec.arc56.Maps - -Storage maps for different storage types. - -#### box *: dict[str, [StorageMap](#algokit_utils.applications.app_spec.arc56.StorageMap)]* - -The box storage maps - -#### global_state *: dict[str, [StorageMap](#algokit_utils.applications.app_spec.arc56.StorageMap)]* - -The global state storage maps - -#### local_state *: dict[str, [StorageMap](#algokit_utils.applications.app_spec.arc56.StorageMap)]* - -The local state storage maps - -#### *static* from_dict(data: dict[str, Any]) → [Maps](#algokit_utils.applications.app_spec.arc56.Maps) - -### *class* algokit_utils.applications.app_spec.arc56.State - -Application state information. - -#### keys *: [Keys](#algokit_utils.applications.app_spec.arc56.Keys)* - -The storage keys - -#### maps *: [Maps](#algokit_utils.applications.app_spec.arc56.Maps)* - -The storage maps - -#### schema *: [Schema](#algokit_utils.applications.app_spec.arc56.Schema)* - -The state schema - -#### *static* from_dict(data: dict[str, Any]) → [State](#algokit_utils.applications.app_spec.arc56.State) - -### *class* algokit_utils.applications.app_spec.arc56.ProgramSourceInfo - -Program source information. - -#### pc_offset_method *: [PcOffsetMethod](#algokit_utils.applications.app_spec.arc56.PcOffsetMethod)* - -The PC offset method - -#### source_info *: list[[SourceInfo](#algokit_utils.applications.app_spec.arc56.SourceInfo)]* - -The list of source info entries - -#### *static* from_dict(data: dict[str, Any]) → [ProgramSourceInfo](#algokit_utils.applications.app_spec.arc56.ProgramSourceInfo) - -### *class* algokit_utils.applications.app_spec.arc56.SourceInfoModel - -Source information for approval and clear programs. - -#### approval *: [ProgramSourceInfo](#algokit_utils.applications.app_spec.arc56.ProgramSourceInfo)* - -The approval program source info - -#### clear *: [ProgramSourceInfo](#algokit_utils.applications.app_spec.arc56.ProgramSourceInfo)* - -The clear program source info - -#### *static* from_dict(data: dict[str, Any]) → [SourceInfoModel](#algokit_utils.applications.app_spec.arc56.SourceInfoModel) - -### *class* algokit_utils.applications.app_spec.arc56.Arc56Contract - -ARC-0056 application specification. - -See [https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0056.md](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0056.md) - -#### arcs *: list[int]* - -The list of supported ARC version numbers - -#### bare_actions *: [BareActions](#algokit_utils.applications.app_spec.arc56.BareActions)* - -The bare call and create actions - -#### methods *: list[[Method](#algokit_utils.applications.app_spec.arc56.Method)]* - -The list of contract methods - -#### name *: str* - -The contract name - -#### state *: [State](#algokit_utils.applications.app_spec.arc56.State)* - -The contract state information - -#### structs *: dict[str, list[[StructField](#algokit_utils.applications.app_spec.arc56.StructField)]]* - -The contract struct definitions - -#### byte_code *: [ByteCode](#algokit_utils.applications.app_spec.arc56.ByteCode) | None* *= None* - -The optional bytecode for approval and clear programs - -#### compiler_info *: [CompilerInfo](#algokit_utils.applications.app_spec.arc56.CompilerInfo) | None* *= None* - -The optional compiler information - -#### desc *: str | None* *= None* - -The optional contract description - -#### events *: list[[Event](#algokit_utils.applications.app_spec.arc56.Event)] | None* *= None* - -The optional list of contract events - -#### networks *: dict[str, [Network](#algokit_utils.applications.app_spec.arc56.Network)] | None* *= None* - -The optional network deployment information - -#### scratch_variables *: dict[str, [ScratchVariables](#algokit_utils.applications.app_spec.arc56.ScratchVariables)] | None* *= None* - -The optional scratch variable information - -#### source *: [Source](#algokit_utils.applications.app_spec.arc56.Source) | None* *= None* - -The optional source code - -#### source_info *: [SourceInfoModel](#algokit_utils.applications.app_spec.arc56.SourceInfoModel) | None* *= None* - -The optional source code information - -#### template_variables *: dict[str, [TemplateVariables](#algokit_utils.applications.app_spec.arc56.TemplateVariables)] | None* *= None* - -The optional template variable information - -#### *static* from_dict(application_spec: dict) → [Arc56Contract](#algokit_utils.applications.app_spec.arc56.Arc56Contract) - -Create Arc56Contract from dictionary. - -* **Parameters:** - **application_spec** – Dictionary containing contract specification -* **Returns:** - Arc56Contract instance - -#### *static* from_json(application_spec: str) → [Arc56Contract](#algokit_utils.applications.app_spec.arc56.Arc56Contract) - -#### *static* from_arc32(arc32_application_spec: str | [algokit_utils.applications.app_spec.arc32.Arc32Contract](../arc32/index.md#algokit_utils.applications.app_spec.arc32.Arc32Contract)) → [Arc56Contract](#algokit_utils.applications.app_spec.arc56.Arc56Contract) - -#### *static* get_abi_struct_from_abi_tuple(decoded_tuple: Any, struct_fields: list[[StructField](#algokit_utils.applications.app_spec.arc56.StructField)], structs: dict[str, list[[StructField](#algokit_utils.applications.app_spec.arc56.StructField)]]) → dict[str, Any] - -#### to_json(indent: int | None = None) → str - -#### dictify() → dict - -#### get_arc56_method(method_name_or_signature: str) → [Method](#algokit_utils.applications.app_spec.arc56.Method) diff --git a/docs/markdown/autoapi/algokit_utils/applications/app_spec/index.md b/docs/markdown/autoapi/algokit_utils/applications/app_spec/index.md deleted file mode 100644 index 7a37b142..00000000 --- a/docs/markdown/autoapi/algokit_utils/applications/app_spec/index.md +++ /dev/null @@ -1,6 +0,0 @@ -# algokit_utils.applications.app_spec - -## Submodules - -* [algokit_utils.applications.app_spec.arc32](arc32/index.md) -* [algokit_utils.applications.app_spec.arc56](arc56/index.md) diff --git a/docs/markdown/autoapi/algokit_utils/applications/enums/index.md b/docs/markdown/autoapi/algokit_utils/applications/enums/index.md deleted file mode 100644 index ac63173b..00000000 --- a/docs/markdown/autoapi/algokit_utils/applications/enums/index.md +++ /dev/null @@ -1,72 +0,0 @@ -# algokit_utils.applications.enums - -## Classes - -| [`OnSchemaBreak`](#algokit_utils.applications.enums.OnSchemaBreak) | Action to take if an Application's schema has breaking changes | -|------------------------------------------------------------------------------|------------------------------------------------------------------| -| [`OnUpdate`](#algokit_utils.applications.enums.OnUpdate) | Action to take if an Application has been updated | -| [`OperationPerformed`](#algokit_utils.applications.enums.OperationPerformed) | Describes the actions taken during deployment | - -## Module Contents - -### *class* algokit_utils.applications.enums.OnSchemaBreak(\*args, \*\*kwds) - -Bases: `enum.Enum` - -Action to take if an Application’s schema has breaking changes - -#### Fail *= 0* - -Fail the deployment - -#### ReplaceApp *= 2* - -Create a new Application and delete the old Application in a single transaction - -#### AppendApp *= 3* - -Create a new Application - -### *class* algokit_utils.applications.enums.OnUpdate(\*args, \*\*kwds) - -Bases: `enum.Enum` - -Action to take if an Application has been updated - -#### Fail *= 0* - -Fail the deployment - -#### UpdateApp *= 1* - -Update the Application with the new approval and clear programs - -#### ReplaceApp *= 2* - -Create a new Application and delete the old Application in a single transaction - -#### AppendApp *= 3* - -Create a new application - -### *class* algokit_utils.applications.enums.OperationPerformed(\*args, \*\*kwds) - -Bases: `enum.Enum` - -Describes the actions taken during deployment - -#### Nothing *= 0* - -An existing Application was found - -#### Create *= 1* - -No existing Application was found, created a new Application - -#### Update *= 2* - -An existing Application was found, but was out of date, updated to latest version - -#### Replace *= 3* - -An existing Application was found, but was out of date, created a new Application and deleted the original diff --git a/docs/markdown/autoapi/algokit_utils/applications/index.md b/docs/markdown/autoapi/algokit_utils/applications/index.md deleted file mode 100644 index 8f94c76d..00000000 --- a/docs/markdown/autoapi/algokit_utils/applications/index.md +++ /dev/null @@ -1,11 +0,0 @@ -# algokit_utils.applications - -## Submodules - -* [algokit_utils.applications.abi](abi/index.md) -* [algokit_utils.applications.app_client](app_client/index.md) -* [algokit_utils.applications.app_deployer](app_deployer/index.md) -* [algokit_utils.applications.app_factory](app_factory/index.md) -* [algokit_utils.applications.app_manager](app_manager/index.md) -* [algokit_utils.applications.app_spec](app_spec/index.md) -* [algokit_utils.applications.enums](enums/index.md) diff --git a/docs/markdown/autoapi/algokit_utils/assets/asset_manager/index.md b/docs/markdown/autoapi/algokit_utils/assets/asset_manager/index.md deleted file mode 100644 index 62078a31..00000000 --- a/docs/markdown/autoapi/algokit_utils/assets/asset_manager/index.md +++ /dev/null @@ -1,215 +0,0 @@ -# algokit_utils.assets.asset_manager - -## Classes - -| [`AccountAssetInformation`](#algokit_utils.assets.asset_manager.AccountAssetInformation) | Information about an account's holding of a particular asset. | -|--------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------| -| [`AssetInformation`](#algokit_utils.assets.asset_manager.AssetInformation) | Information about an Algorand Standard Asset (ASA). | -| [`BulkAssetOptInOutResult`](#algokit_utils.assets.asset_manager.BulkAssetOptInOutResult) | Result from performing a bulk opt-in or bulk opt-out for an account against a series of assets. | -| [`AssetManager`](#algokit_utils.assets.asset_manager.AssetManager) | A manager for Algorand Standard Assets (ASAs). | - -## Module Contents - -### *class* algokit_utils.assets.asset_manager.AccountAssetInformation - -Information about an account’s holding of a particular asset. - -#### asset_id *: int* - -The ID of the asset - -#### balance *: int* - -The amount of the asset held by the account - -#### frozen *: bool* - -Whether the asset is frozen for this account - -#### round *: int* - -The round this information was retrieved at - -### *class* algokit_utils.assets.asset_manager.AssetInformation - -Information about an Algorand Standard Asset (ASA). - -#### asset_id *: int* - -The ID of the asset - -#### creator *: str* - -The address of the account that created the asset - -#### total *: int* - -The total amount of the smallest divisible units that were created of the asset - -#### decimals *: int* - -The amount of decimal places the asset was created with - -#### default_frozen *: bool | None* *= None* - -Whether the asset was frozen by default for all accounts, defaults to None - -#### manager *: str | None* *= None* - -The address of the optional account that can manage the configuration of the asset and destroy it, -defaults to None - -#### reserve *: str | None* *= None* - -The address of the optional account that holds the reserve (uncirculated supply) units of the asset, -defaults to None - -#### freeze *: str | None* *= None* - -The address of the optional account that can be used to freeze or unfreeze holdings of this asset, -defaults to None - -#### clawback *: str | None* *= None* - -The address of the optional account that can clawback holdings of this asset from any account, -defaults to None - -#### unit_name *: str | None* *= None* - -The optional name of the unit of this asset (e.g. ticker name), defaults to None - -#### unit_name_b64 *: bytes | None* *= None* - -The optional name of the unit of this asset as bytes, defaults to None - -#### asset_name *: str | None* *= None* - -The optional name of the asset, defaults to None - -#### asset_name_b64 *: bytes | None* *= None* - -The optional name of the asset as bytes, defaults to None - -#### url *: str | None* *= None* - -The optional URL where more information about the asset can be retrieved, defaults to None - -#### url_b64 *: bytes | None* *= None* - -The optional URL where more information about the asset can be retrieved as bytes, defaults to None - -#### metadata_hash *: bytes | None* *= None* - -The 32-byte hash of some metadata that is relevant to the asset and/or asset holders, defaults to None - -### *class* algokit_utils.assets.asset_manager.BulkAssetOptInOutResult - -Result from performing a bulk opt-in or bulk opt-out for an account against a series of assets. - -* **Variables:** - * **asset_id** – The ID of the asset opted into / out of - * **transaction_id** – The transaction ID of the resulting opt in / out - -#### asset_id *: int* - -The ID of the asset opted into / out of - -#### transaction_id *: str* - -The transaction ID of the resulting opt in / out - -### *class* algokit_utils.assets.asset_manager.AssetManager(algod_client: algosdk.v2client.algod.AlgodClient, new_group: collections.abc.Callable[[], [algokit_utils.transactions.transaction_composer.TransactionComposer](../../transactions/transaction_composer/index.md#algokit_utils.transactions.transaction_composer.TransactionComposer)]) - -A manager for Algorand Standard Assets (ASAs). - -* **Parameters:** - * **algod_client** – An algod client - * **new_group** – A function that creates a new TransactionComposer transaction group -* **Example:** - ```python - asset_manager = AssetManager(algod_client) - ``` - -#### get_by_id(asset_id: int) → [AssetInformation](#algokit_utils.assets.asset_manager.AssetInformation) - -Returns the current asset information for the asset with the given ID. - -* **Parameters:** - **asset_id** – The ID of the asset -* **Returns:** - The asset information -* **Example:** - ```python - asset_manager = AssetManager(algod_client) - asset_info = asset_manager.get_by_id(1234567890) - ``` - -#### get_account_information(sender: str | [algokit_utils.models.account.SigningAccount](../../models/account/index.md#algokit_utils.models.account.SigningAccount) | algosdk.atomic_transaction_composer.TransactionSigner, asset_id: int) → [AccountAssetInformation](#algokit_utils.assets.asset_manager.AccountAssetInformation) - -Returns the given sender account’s asset holding for a given asset. - -* **Parameters:** - * **sender** – The address of the sender/account to look up - * **asset_id** – The ID of the asset to return a holding for -* **Returns:** - The account asset holding information -* **Example:** - ```python - asset_manager = AssetManager(algod_client) - account_asset_info = asset_manager.get_account_information(sender, asset_id) - ``` - -#### bulk_opt_in(account: str, asset_ids: list[int], signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None, rekey_to: str | None = None, note: bytes | None = None, lease: bytes | None = None, static_fee: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None = None, extra_fee: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None = None, max_fee: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None = None, validity_window: int | None = None, first_valid_round: int | None = None, last_valid_round: int | None = None, send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → list[[BulkAssetOptInOutResult](#algokit_utils.assets.asset_manager.BulkAssetOptInOutResult)] - -Opt an account in to a list of Algorand Standard Assets. - -* **Parameters:** - * **account** – The account to opt-in - * **asset_ids** – The list of asset IDs to opt-in to - * **signer** – The signer to use for the transaction, defaults to None - * **rekey_to** – The address to rekey the account to, defaults to None - * **note** – The note to include in the transaction, defaults to None - * **lease** – The lease to include in the transaction, defaults to None - * **static_fee** – The static fee to include in the transaction, defaults to None - * **extra_fee** – The extra fee to include in the transaction, defaults to None - * **max_fee** – The maximum fee to include in the transaction, defaults to None - * **validity_window** – The validity window to include in the transaction, defaults to None - * **first_valid_round** – The first valid round to include in the transaction, defaults to None - * **last_valid_round** – The last valid round to include in the transaction, defaults to None - * **send_params** – The send parameters to use for the transaction, defaults to None -* **Returns:** - An array of records matching asset ID to transaction ID of the opt in -* **Example:** - ```python - asset_manager = AssetManager(algod_client) - results = asset_manager.bulk_opt_in(account, asset_ids) - ``` - -#### bulk_opt_out(\*, account: str, asset_ids: list[int], ensure_zero_balance: bool = True, signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None, rekey_to: str | None = None, note: bytes | None = None, lease: bytes | None = None, static_fee: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None = None, extra_fee: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None = None, max_fee: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount) | None = None, validity_window: int | None = None, first_valid_round: int | None = None, last_valid_round: int | None = None, send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → list[[BulkAssetOptInOutResult](#algokit_utils.assets.asset_manager.BulkAssetOptInOutResult)] - -Opt an account out of a list of Algorand Standard Assets. - -* **Parameters:** - * **account** – The account to opt-out - * **asset_ids** – The list of asset IDs to opt-out of - * **ensure_zero_balance** – Whether to check if the account has a zero balance first, defaults to True - * **signer** – The signer to use for the transaction, defaults to None - * **rekey_to** – The address to rekey the account to, defaults to None - * **note** – The note to include in the transaction, defaults to None - * **lease** – The lease to include in the transaction, defaults to None - * **static_fee** – The static fee to include in the transaction, defaults to None - * **extra_fee** – The extra fee to include in the transaction, defaults to None - * **max_fee** – The maximum fee to include in the transaction, defaults to None - * **validity_window** – The validity window to include in the transaction, defaults to None - * **first_valid_round** – The first valid round to include in the transaction, defaults to None - * **last_valid_round** – The last valid round to include in the transaction, defaults to None - * **send_params** – The send parameters to use for the transaction, defaults to None -* **Raises:** - **ValueError** – If ensure_zero_balance is True and account has non-zero balance or is not opted in -* **Returns:** - An array of records matching asset ID to transaction ID of the opt out -* **Example:** - ```python - asset_manager = AssetManager(algod_client) - results = asset_manager.bulk_opt_out(account, asset_ids) - ``` diff --git a/docs/markdown/autoapi/algokit_utils/assets/index.md b/docs/markdown/autoapi/algokit_utils/assets/index.md deleted file mode 100644 index 5091632c..00000000 --- a/docs/markdown/autoapi/algokit_utils/assets/index.md +++ /dev/null @@ -1,5 +0,0 @@ -# algokit_utils.assets - -## Submodules - -* [algokit_utils.assets.asset_manager](asset_manager/index.md) diff --git a/docs/markdown/autoapi/algokit_utils/clients/client_manager/index.md b/docs/markdown/autoapi/algokit_utils/clients/client_manager/index.md deleted file mode 100644 index 4495386b..00000000 --- a/docs/markdown/autoapi/algokit_utils/clients/client_manager/index.md +++ /dev/null @@ -1,461 +0,0 @@ -# algokit_utils.clients.client_manager - -## Classes - -| [`AlgoSdkClients`](#algokit_utils.clients.client_manager.AlgoSdkClients) | Container for Algorand SDK client instances. | -|----------------------------------------------------------------------------|------------------------------------------------| -| [`NetworkDetail`](#algokit_utils.clients.client_manager.NetworkDetail) | Details about an Algorand network. | -| [`ClientManager`](#algokit_utils.clients.client_manager.ClientManager) | Manager for Algorand SDK clients. | - -## Module Contents - -### *class* algokit_utils.clients.client_manager.AlgoSdkClients(algod: algosdk.v2client.algod.AlgodClient, indexer: algosdk.v2client.indexer.IndexerClient | None = None, kmd: algosdk.kmd.KMDClient | None = None) - -Container for Algorand SDK client instances. - -Holds references to Algod, Indexer and KMD clients. - -* **Parameters:** - * **algod** – Algod client instance - * **indexer** – Optional Indexer client instance - * **kmd** – Optional KMD client instance - -#### algod - -#### indexer *= None* - -#### kmd *= None* - -### *class* algokit_utils.clients.client_manager.NetworkDetail - -Details about an Algorand network. - -Contains network type flags and genesis information. - -#### is_testnet *: bool* - -Whether the network is a testnet - -#### is_mainnet *: bool* - -Whether the network is a mainnet - -#### is_localnet *: bool* - -Whether the network is a localnet - -#### genesis_id *: str* - -The genesis ID of the network - -#### genesis_hash *: str* - -The genesis hash of the network - -### *class* algokit_utils.clients.client_manager.ClientManager(clients_or_configs: [algokit_utils.models.network.AlgoClientConfigs](../../models/network/index.md#algokit_utils.models.network.AlgoClientConfigs) | [AlgoSdkClients](#algokit_utils.clients.client_manager.AlgoSdkClients), algorand_client: [algokit_utils.algorand.AlgorandClient](../../algorand/index.md#algokit_utils.algorand.AlgorandClient)) - -Manager for Algorand SDK clients. - -Provides access to Algod, Indexer and KMD clients and helper methods for working with them. - -* **Parameters:** - * **clients_or_configs** – Either client instances or client configurations - * **algorand_client** – AlgorandClient instance -* **Example:** - ```python - # Algod only - client_manager = ClientManager(algod_client) - # Algod and Indexer - client_manager = ClientManager(algod_client, indexer_client) - # Algod config only - client_manager = ClientManager(ClientManager.get_algod_config_from_environment()) - # Algod and Indexer config - client_manager = ClientManager(ClientManager.get_algod_config_from_environment(), - ClientManager.get_indexer_config_from_environment()) - ``` - -#### *property* algod *: algosdk.v2client.algod.AlgodClient* - -Returns an algosdk Algod API client. - -* **Returns:** - Algod client instance - -#### *property* indexer *: algosdk.v2client.indexer.IndexerClient* - -Returns an algosdk Indexer API client. - -* **Raises:** - **ValueError** – If no Indexer client is configured -* **Returns:** - Indexer client instance - -#### *property* indexer_if_present *: algosdk.v2client.indexer.IndexerClient | None* - -Returns the Indexer client if configured, otherwise None. - -* **Returns:** - Indexer client instance or None - -#### *property* kmd *: algosdk.kmd.KMDClient* - -Returns an algosdk KMD API client. - -* **Raises:** - **ValueError** – If no KMD client is configured -* **Returns:** - KMD client instance - -#### network() → [NetworkDetail](#algokit_utils.clients.client_manager.NetworkDetail) - -Get details about the connected Algorand network. - -* **Returns:** - Network details including type and genesis information -* **Example:** - ```python - client_manager = ClientManager(algod_client) - network_detail = client_manager.network() - ``` - -#### is_localnet() → bool - -Check if connected to a local network. - -* **Returns:** - True if connected to a local network - -#### is_testnet() → bool - -Check if connected to TestNet. - -* **Returns:** - True if connected to TestNet - -#### is_mainnet() → bool - -Check if connected to MainNet. - -* **Returns:** - True if connected to MainNet - -#### get_testnet_dispenser(auth_token: str | None = None, request_timeout: int | None = None) → [algokit_utils.clients.dispenser_api_client.TestNetDispenserApiClient](../dispenser_api_client/index.md#algokit_utils.clients.dispenser_api_client.TestNetDispenserApiClient) - -Get a TestNet dispenser API client. - -* **Parameters:** - * **auth_token** – Optional authentication token - * **request_timeout** – Optional request timeout in seconds -* **Returns:** - TestNet dispenser client instance - -#### get_app_factory(app_spec: [algokit_utils.applications.app_spec.arc56.Arc56Contract](../../applications/app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.Arc56Contract) | algokit_utils._legacy_v2.application_specification.ApplicationSpecification | str, app_name: str | None = None, default_sender: str | None = None, default_signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None, version: str | None = None, compilation_params: [algokit_utils.applications.app_client.AppClientCompilationParams](../../applications/app_client/index.md#algokit_utils.applications.app_client.AppClientCompilationParams) | None = None) → [algokit_utils.applications.app_factory.AppFactory](../../applications/app_factory/index.md#algokit_utils.applications.app_factory.AppFactory) - -Get an application factory for deploying smart contracts. - -* **Parameters:** - * **app_spec** – Application specification - * **app_name** – Optional application name - * **default_sender** – Optional default sender address - * **default_signer** – Optional default transaction signer - * **version** – Optional version string - * **compilation_params** – Optional compilation parameters -* **Raises:** - **ValueError** – If no Algorand client is configured -* **Returns:** - Application factory instance - -#### get_app_client_by_id(app_spec: [algokit_utils.applications.app_spec.arc56.Arc56Contract](../../applications/app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.Arc56Contract) | algokit_utils._legacy_v2.application_specification.ApplicationSpecification | str, app_id: int, app_name: str | None = None, default_sender: str | None = None, default_signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None, approval_source_map: algosdk.source_map.SourceMap | None = None, clear_source_map: algosdk.source_map.SourceMap | None = None) → [algokit_utils.applications.app_client.AppClient](../../applications/app_client/index.md#algokit_utils.applications.app_client.AppClient) - -Get an application client for an existing application by ID. - -* **Parameters:** - * **app_spec** – Application specification - * **app_id** – Application ID - * **app_name** – Optional application name - * **default_sender** – Optional default sender address - * **default_signer** – Optional default transaction signer - * **approval_source_map** – Optional approval program source map - * **clear_source_map** – Optional clear program source map -* **Raises:** - **ValueError** – If no Algorand client is configured -* **Returns:** - Application client instance - -#### get_app_client_by_network(app_spec: [algokit_utils.applications.app_spec.arc56.Arc56Contract](../../applications/app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.Arc56Contract) | algokit_utils._legacy_v2.application_specification.ApplicationSpecification | str, app_name: str | None = None, default_sender: str | None = None, default_signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None, approval_source_map: algosdk.source_map.SourceMap | None = None, clear_source_map: algosdk.source_map.SourceMap | None = None) → [algokit_utils.applications.app_client.AppClient](../../applications/app_client/index.md#algokit_utils.applications.app_client.AppClient) - -Get an application client for an existing application by network. - -* **Parameters:** - * **app_spec** – Application specification - * **app_name** – Optional application name - * **default_sender** – Optional default sender address - * **default_signer** – Optional default transaction signer - * **approval_source_map** – Optional approval program source map - * **clear_source_map** – Optional clear program source map -* **Raises:** - **ValueError** – If no Algorand client is configured -* **Returns:** - Application client instance - -#### get_app_client_by_creator_and_name(creator_address: str, app_name: str, app_spec: [algokit_utils.applications.app_spec.arc56.Arc56Contract](../../applications/app_spec/arc56/index.md#algokit_utils.applications.app_spec.arc56.Arc56Contract) | algokit_utils._legacy_v2.application_specification.ApplicationSpecification | str, default_sender: str | None = None, default_signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None, ignore_cache: bool | None = None, app_lookup_cache: [algokit_utils.applications.app_deployer.ApplicationLookup](../../applications/app_deployer/index.md#algokit_utils.applications.app_deployer.ApplicationLookup) | None = None, approval_source_map: algosdk.source_map.SourceMap | None = None, clear_source_map: algosdk.source_map.SourceMap | None = None) → [algokit_utils.applications.app_client.AppClient](../../applications/app_client/index.md#algokit_utils.applications.app_client.AppClient) - -Get an application client by creator address and name. - -* **Parameters:** - * **creator_address** – Creator address - * **app_name** – Application name - * **app_spec** – Application specification - * **default_sender** – Optional default sender address - * **default_signer** – Optional default transaction signer - * **ignore_cache** – Optional flag to ignore cache - * **app_lookup_cache** – Optional app lookup cache - * **approval_source_map** – Optional approval program source map - * **clear_source_map** – Optional clear program source map -* **Returns:** - Application client instance - -#### *static* get_algod_client(config: [algokit_utils.models.network.AlgoClientNetworkConfig](../../models/network/index.md#algokit_utils.models.network.AlgoClientNetworkConfig)) → algosdk.v2client.algod.AlgodClient - -Get an Algod client from config or environment. - -* **Parameters:** - **config** – Optional client configuration -* **Returns:** - Algod client instance - -#### *static* get_algod_client_from_environment() → algosdk.v2client.algod.AlgodClient - -Get an Algod client from environment variables. - -* **Returns:** - Algod client instance - -#### *static* get_kmd_client(config: [algokit_utils.models.network.AlgoClientNetworkConfig](../../models/network/index.md#algokit_utils.models.network.AlgoClientNetworkConfig)) → algosdk.kmd.KMDClient - -Get a KMD client from config or environment. - -* **Parameters:** - **config** – Optional client configuration -* **Returns:** - KMD client instance - -#### *static* get_kmd_client_from_environment() → algosdk.kmd.KMDClient - -Get a KMD client from environment variables. - -* **Returns:** - KMD client instance - -#### *static* get_indexer_client(config: [algokit_utils.models.network.AlgoClientNetworkConfig](../../models/network/index.md#algokit_utils.models.network.AlgoClientNetworkConfig)) → algosdk.v2client.indexer.IndexerClient - -Get an Indexer client from config or environment. - -* **Parameters:** - **config** – Optional client configuration -* **Returns:** - Indexer client instance - -#### *static* get_indexer_client_from_environment() → algosdk.v2client.indexer.IndexerClient - -Get an Indexer client from environment variables. - -* **Returns:** - Indexer client instance - -#### *static* genesis_id_is_localnet(genesis_id: str | None) → bool - -Check if a genesis ID indicates a local network. - -* **Parameters:** - **genesis_id** – Genesis ID to check -* **Returns:** - True if genesis ID indicates a local network -* **Example:** - ```python - ClientManager.genesis_id_is_localnet("devnet-v1") - ``` - -#### get_typed_app_client_by_creator_and_name(typed_client: type[TypedAppClientT], \*, creator_address: str, app_name: str, default_sender: str | None = None, default_signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None, ignore_cache: bool | None = None, app_lookup_cache: [algokit_utils.applications.app_deployer.ApplicationLookup](../../applications/app_deployer/index.md#algokit_utils.applications.app_deployer.ApplicationLookup) | None = None) → TypedAppClientT - -Get a typed application client by creator address and name. - -* **Parameters:** - * **typed_client** – Typed client class - * **creator_address** – Creator address - * **app_name** – Application name - * **default_sender** – Optional default sender address - * **default_signer** – Optional default transaction signer - * **ignore_cache** – Optional flag to ignore cache - * **app_lookup_cache** – Optional app lookup cache -* **Raises:** - **ValueError** – If no Algorand client is configured -* **Returns:** - Typed application client instance -* **Example:** - ```python - client_manager = ClientManager(algod_client) - typed_app_client = client_manager.get_typed_app_client_by_creator_and_name( - typed_client=MyAppClient, - creator_address="creator_address", - app_name="app_name", - ) - ``` - -#### get_typed_app_client_by_id(typed_client: type[TypedAppClientT], \*, app_id: int, app_name: str | None = None, default_sender: str | None = None, default_signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None, approval_source_map: algosdk.source_map.SourceMap | None = None, clear_source_map: algosdk.source_map.SourceMap | None = None) → TypedAppClientT - -Get a typed application client by ID. - -* **Parameters:** - * **typed_client** – Typed client class - * **app_id** – Application ID - * **app_name** – Optional application name - * **default_sender** – Optional default sender address - * **default_signer** – Optional default transaction signer - * **approval_source_map** – Optional approval program source map - * **clear_source_map** – Optional clear program source map -* **Raises:** - **ValueError** – If no Algorand client is configured -* **Returns:** - Typed application client instance -* **Example:** - ```python - client_manager = ClientManager(algod_client) - typed_app_client = client_manager.get_typed_app_client_by_id( - typed_client=MyAppClient, - app_id=1234567890, - ) - ``` - -#### get_typed_app_client_by_network(typed_client: type[TypedAppClientT], \*, app_name: str | None = None, default_sender: str | None = None, default_signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None, approval_source_map: algosdk.source_map.SourceMap | None = None, clear_source_map: algosdk.source_map.SourceMap | None = None) → TypedAppClientT - -Returns a new typed client, resolves the app ID for the current network. - -Uses 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. - -* **Parameters:** - * **typed_client** – The typed client class to instantiate - * **app_name** – Optional application name - * **default_sender** – Optional default sender address - * **default_signer** – Optional default transaction signer - * **approval_source_map** – Optional approval program source map - * **clear_source_map** – Optional clear program source map -* **Raises:** - **ValueError** – If no Algorand client is configured -* **Returns:** - The typed client instance -* **Example:** - ```python - client_manager = ClientManager(algod_client) - typed_app_client = client_manager.get_typed_app_client_by_network( - typed_client=MyAppClient, - app_name="app_name", - ) - ``` - -#### get_typed_app_factory(typed_factory: type[TypedFactoryT], \*, app_name: str | None = None, default_sender: str | None = None, default_signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None, version: str | None = None, compilation_params: [algokit_utils.applications.app_client.AppClientCompilationParams](../../applications/app_client/index.md#algokit_utils.applications.app_client.AppClientCompilationParams) | None = None) → TypedFactoryT - -Get a typed application factory. - -* **Parameters:** - * **typed_factory** – Typed factory class - * **app_name** – Optional application name - * **default_sender** – Optional default sender address - * **default_signer** – Optional default transaction signer - * **version** – Optional version string - * **compilation_params** – Optional compilation parameters -* **Raises:** - **ValueError** – If no Algorand client is configured -* **Returns:** - Typed application factory instance -* **Example:** - ```python - client_manager = ClientManager(algod_client) - typed_app_factory = client_manager.get_typed_app_factory( - typed_factory=MyAppFactory, - app_name="app_name", - ) - ``` - -#### *static* get_config_from_environment_or_localnet() → [algokit_utils.models.network.AlgoClientConfigs](../../models/network/index.md#algokit_utils.models.network.AlgoClientConfigs) - -Retrieve client configuration from environment variables or fallback to localnet defaults. - -If ALGOD_SERVER is set in environment variables, it will use environment configuration, -otherwise it will use default localnet configuration. - -* **Returns:** - Configuration for algod, indexer, and optionally kmd -* **Example:** - ```python - client_manager = ClientManager(algod_client) - config = client_manager.get_config_from_environment_or_localnet() - ``` - -#### *static* get_default_localnet_config(config_or_port: Literal['algod', 'indexer', 'kmd'] | int) → [algokit_utils.models.network.AlgoClientNetworkConfig](../../models/network/index.md#algokit_utils.models.network.AlgoClientNetworkConfig) - -Get default configuration for local network services. - -* **Parameters:** - **config_or_port** – Service name or port number -* **Returns:** - Client configuration for local network -* **Example:** - ```python - client_manager = ClientManager(algod_client) - config = client_manager.get_default_localnet_config("algod") - ``` - -#### *static* get_algod_config_from_environment() → [algokit_utils.models.network.AlgoClientNetworkConfig](../../models/network/index.md#algokit_utils.models.network.AlgoClientNetworkConfig) - -Retrieve the algod configuration from environment variables. -Will raise an error if ALGOD_SERVER environment variable is not set - -* **Returns:** - Algod client configuration -* **Example:** - ```python - client_manager = ClientManager(algod_client) - config = client_manager.get_algod_config_from_environment() - ``` - -#### *static* get_indexer_config_from_environment() → [algokit_utils.models.network.AlgoClientNetworkConfig](../../models/network/index.md#algokit_utils.models.network.AlgoClientNetworkConfig) - -Retrieve the indexer configuration from environment variables. -Will raise an error if INDEXER_SERVER environment variable is not set - -* **Returns:** - Indexer client configuration -* **Example:** - ```python - client_manager = ClientManager(algod_client) - config = client_manager.get_indexer_config_from_environment() - ``` - -#### *static* get_kmd_config_from_environment() → [algokit_utils.models.network.AlgoClientNetworkConfig](../../models/network/index.md#algokit_utils.models.network.AlgoClientNetworkConfig) - -Retrieve the kmd configuration from environment variables. - -* **Returns:** - KMD client configuration -* **Example:** - ```python - client_manager = ClientManager(algod_client) - config = client_manager.get_kmd_config_from_environment() - ``` - -#### *static* get_algonode_config(network: Literal['testnet', 'mainnet'], config: Literal['algod', 'indexer']) → [algokit_utils.models.network.AlgoClientNetworkConfig](../../models/network/index.md#algokit_utils.models.network.AlgoClientNetworkConfig) - -Returns the Algorand configuration to point to the free tier of the AlgoNode service. - -* **Parameters:** - * **network** – Which network to connect to - TestNet or MainNet - * **config** – Which algod config to return - Algod or Indexer -* **Returns:** - Configuration for the specified network and service -* **Example:** - ```python - client_manager = ClientManager(algod_client) - config = client_manager.get_algonode_config("testnet", "algod") - ``` diff --git a/docs/markdown/autoapi/algokit_utils/clients/dispenser_api_client/index.md b/docs/markdown/autoapi/algokit_utils/clients/dispenser_api_client/index.md deleted file mode 100644 index ef0920f3..00000000 --- a/docs/markdown/autoapi/algokit_utils/clients/dispenser_api_client/index.md +++ /dev/null @@ -1,110 +0,0 @@ -# algokit_utils.clients.dispenser_api_client - -## Attributes - -| [`DISPENSER_ASSETS`](#algokit_utils.clients.dispenser_api_client.DISPENSER_ASSETS) | | -|--------------------------------------------------------------------------------------------------------|----| -| [`DISPENSER_REQUEST_TIMEOUT`](#algokit_utils.clients.dispenser_api_client.DISPENSER_REQUEST_TIMEOUT) | | -| [`DISPENSER_ACCESS_TOKEN_KEY`](#algokit_utils.clients.dispenser_api_client.DISPENSER_ACCESS_TOKEN_KEY) | | - -## Classes - -| [`DispenserApiConfig`](#algokit_utils.clients.dispenser_api_client.DispenserApiConfig) | | -|------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| [`DispenserAssetName`](#algokit_utils.clients.dispenser_api_client.DispenserAssetName) | Enum where members are also (and must be) ints | -| [`DispenserAsset`](#algokit_utils.clients.dispenser_api_client.DispenserAsset) | | -| [`DispenserFundResponse`](#algokit_utils.clients.dispenser_api_client.DispenserFundResponse) | | -| [`DispenserLimitResponse`](#algokit_utils.clients.dispenser_api_client.DispenserLimitResponse) | | -| [`TestNetDispenserApiClient`](#algokit_utils.clients.dispenser_api_client.TestNetDispenserApiClient) | Client for interacting with the [AlgoKit TestNet Dispenser API]([https://github.com/algorandfoundation/algokit/blob/main/docs/testnet_api.md](https://github.com/algorandfoundation/algokit/blob/main/docs/testnet_api.md)). | - -## Module Contents - -### *class* algokit_utils.clients.dispenser_api_client.DispenserApiConfig - -#### BASE_URL *= 'https://api.dispenser.algorandfoundation.tools'* - -### *class* algokit_utils.clients.dispenser_api_client.DispenserAssetName - -Bases: `enum.IntEnum` - -Enum where members are also (and must be) ints - -#### ALGO *= 0* - -### *class* algokit_utils.clients.dispenser_api_client.DispenserAsset - -#### asset_id *: int* - -The ID of the asset - -#### decimals *: int* - -The amount of decimal places the asset was created with - -#### description *: str* - -The description of the asset - -### *class* algokit_utils.clients.dispenser_api_client.DispenserFundResponse - -#### tx_id *: str* - -The transaction ID of the funded transaction - -#### amount *: int* - -The amount of Algos funded - -### *class* algokit_utils.clients.dispenser_api_client.DispenserLimitResponse - -#### amount *: int* - -The amount of Algos that can be funded - -### algokit_utils.clients.dispenser_api_client.DISPENSER_ASSETS - -### algokit_utils.clients.dispenser_api_client.DISPENSER_REQUEST_TIMEOUT *= 15* - -### algokit_utils.clients.dispenser_api_client.DISPENSER_ACCESS_TOKEN_KEY *= 'ALGOKIT_DISPENSER_ACCESS_TOKEN'* - -### *class* algokit_utils.clients.dispenser_api_client.TestNetDispenserApiClient(auth_token: str | None = None, request_timeout: int = DISPENSER_REQUEST_TIMEOUT) - -Client for interacting with the [AlgoKit TestNet Dispenser API]([https://github.com/algorandfoundation/algokit/blob/main/docs/testnet_api.md](https://github.com/algorandfoundation/algokit/blob/main/docs/testnet_api.md)). -To get started create a new access token via algokit dispenser login –ci -and pass it to the client constructor as auth_token. -Alternatively set the access token as environment variable ALGOKIT_DISPENSER_ACCESS_TOKEN, -and it will be auto loaded. If both are set, the constructor argument takes precedence. - -Default request timeout is 15 seconds. Modify by passing request_timeout to the constructor. - -#### auth_token *: str* - -#### request_timeout *= 15* - -#### fund(address: str, amount: int) → [DispenserFundResponse](#algokit_utils.clients.dispenser_api_client.DispenserFundResponse) - -#### fund(address: str, amount: int, asset_id: int | None = None) → [DispenserFundResponse](#algokit_utils.clients.dispenser_api_client.DispenserFundResponse) - -Fund an account with Algos from the dispenser API - -* **Parameters:** - * **address** – The address to fund - * **amount** – The amount of Algos to fund - * **asset_id** – The asset ID to fund (deprecated) -* **Returns:** - The transaction ID of the funded transaction -* **Raises:** - **Exception** – If the dispenser API request fails -* **Example:** - ```python - dispenser_client = TestNetDispenserApiClient() - dispenser_client.fund(address="SENDER_ADDRESS", amount=1000000) - ``` - -#### refund(refund_txn_id: str) → None - -Register a refund for a transaction with the dispenser API - -#### get_limit(address: str) → [DispenserLimitResponse](#algokit_utils.clients.dispenser_api_client.DispenserLimitResponse) - -Get current limit for an account with Algos from the dispenser API diff --git a/docs/markdown/autoapi/algokit_utils/clients/index.md b/docs/markdown/autoapi/algokit_utils/clients/index.md deleted file mode 100644 index 8ae2dbc7..00000000 --- a/docs/markdown/autoapi/algokit_utils/clients/index.md +++ /dev/null @@ -1,6 +0,0 @@ -# algokit_utils.clients - -## Submodules - -* [algokit_utils.clients.client_manager](client_manager/index.md) -* [algokit_utils.clients.dispenser_api_client](dispenser_api_client/index.md) diff --git a/docs/markdown/autoapi/algokit_utils/config/index.md b/docs/markdown/autoapi/algokit_utils/config/index.md deleted file mode 100644 index cf0dbc83..00000000 --- a/docs/markdown/autoapi/algokit_utils/config/index.md +++ /dev/null @@ -1,97 +0,0 @@ -# algokit_utils.config - -## Attributes - -| [`ALGOKIT_PROJECT_ROOT`](#algokit_utils.config.ALGOKIT_PROJECT_ROOT) | | -|----------------------------------------------------------------------------|----| -| [`ALGOKIT_CONFIG_FILENAME`](#algokit_utils.config.ALGOKIT_CONFIG_FILENAME) | | -| [`config`](#algokit_utils.config.config) | | - -## Classes - -| [`AlgoKitLogger`](#algokit_utils.config.AlgoKitLogger) | Instances of the Logger class represent a single logging channel. A | -|------------------------------------------------------------|----------------------------------------------------------------------------| -| [`UpdatableConfig`](#algokit_utils.config.UpdatableConfig) | Class to manage and update configuration settings for the AlgoKit project. | - -## Module Contents - -### algokit_utils.config.ALGOKIT_PROJECT_ROOT - -### algokit_utils.config.ALGOKIT_CONFIG_FILENAME *= '.algokit.toml'* - -### *class* algokit_utils.config.AlgoKitLogger(name: str = 'algokit-utils-py', level: int = logging.NOTSET) - -Bases: `logging.Logger` - -Instances of the Logger class represent a single logging channel. A -“logging channel” indicates an area of an application. Exactly how an -“area” is defined is up to the application developer. Since an -application can have any number of areas, logging channels are identified -by a unique string. Application areas can be nested (e.g. an area -of “input processing” might include sub-areas “read CSV files”, “read -XLS files” and “read Gnumeric files”). To cater for this natural nesting, -channel names are organized into a namespace hierarchy where levels are -separated by periods, much like the Java or Python package namespace. So -in the instance given above, channel names might be “input” for the upper -level, and “input.csv”, “input.xls” and “input.gnu” for the sub-levels. -There is no arbitrary limit to the depth of nesting. - -#### *classmethod* get_null_logger() → logging.Logger - -Return a logger that does nothing (a null logger). - -### *class* algokit_utils.config.UpdatableConfig - -Class to manage and update configuration settings for the AlgoKit project. - -Attributes: -: debug (bool): Indicates whether debug mode is enabled. - project_root (Path | None): The path to the project root directory. - trace_all (bool): Indicates whether to trace all operations. - trace_buffer_size_mb (int | float): The size of the trace buffer in megabytes. - max_search_depth (int): The maximum depth to search for a specific file. - populate_app_call_resources (bool): Whether to populate app call resources. - logger (logging.Logger): The logger instance to use. Defaults to an AlgoKitLogger instance. - -#### *property* logger *: logging.Logger* - -Returns the logger instance. - -#### *property* debug *: bool* - -Returns the debug status. - -#### *property* project_root *: pathlib.Path | None* - -Returns the project root path. - -#### *property* trace_all *: bool* - -Indicates whether simulation traces for all operations should be stored. - -#### *property* trace_buffer_size_mb *: int | float* - -Returns the size of the trace buffer in megabytes. - -#### *property* populate_app_call_resource *: bool* - -Indicates whether or not to populate app call resources. - -#### with_debug(func: collections.abc.Callable[[], str | None]) → None - -Executes a function with debug mode temporarily enabled. - -#### configure(\*, debug: bool | None = None, project_root: pathlib.Path | None = None, trace_all: bool = False, trace_buffer_size_mb: float = 256, max_search_depth: int = 10, populate_app_call_resources: bool = True, logger: logging.Logger | None = None) → None - -Configures various settings for the application. - -* **Parameters:** - * **debug** – Whether debug mode is enabled. - * **project_root** – The path to the project root directory. - * **trace_all** – Whether to trace all operations. Defaults to False. - * **trace_buffer_size_mb** – The trace buffer size in megabytes. Defaults to 256. - * **max_search_depth** – The maximum depth to search for a specific file. Defaults to 10. - * **populate_app_call_resources** – Whether to populate app call resources. Defaults to True. - * **logger** – A custom logger to use. Defaults to AlgoKitLogger instance. - -### algokit_utils.config.config diff --git a/docs/markdown/autoapi/algokit_utils/errors/index.md b/docs/markdown/autoapi/algokit_utils/errors/index.md deleted file mode 100644 index 47a58848..00000000 --- a/docs/markdown/autoapi/algokit_utils/errors/index.md +++ /dev/null @@ -1,5 +0,0 @@ -# algokit_utils.errors - -## Submodules - -* [algokit_utils.errors.logic_error](logic_error/index.md) diff --git a/docs/markdown/autoapi/algokit_utils/errors/logic_error/index.md b/docs/markdown/autoapi/algokit_utils/errors/logic_error/index.md deleted file mode 100644 index f5039daf..00000000 --- a/docs/markdown/autoapi/algokit_utils/errors/logic_error/index.md +++ /dev/null @@ -1,76 +0,0 @@ -# algokit_utils.errors.logic_error - -## Exceptions - -| [`LogicError`](#algokit_utils.errors.logic_error.LogicError) | Common base class for all non-exit exceptions. | -|----------------------------------------------------------------|--------------------------------------------------| - -## Classes - -| [`LogicErrorData`](#algokit_utils.errors.logic_error.LogicErrorData) | dict() -> new empty dictionary | -|------------------------------------------------------------------------|----------------------------------| - -## Functions - -| [`parse_logic_error`](#algokit_utils.errors.logic_error.parse_logic_error)(→ LogicErrorData | None) | | -|-------------------------------------------------------------------------------------------------------|----| - -## Module Contents - -### *class* algokit_utils.errors.logic_error.LogicErrorData - -Bases: `TypedDict` - -dict() -> new empty dictionary -dict(mapping) -> new dictionary initialized from a mapping object’s - -> (key, value) pairs - -dict(iterable) -> new dictionary initialized as if via: -: d = {} - for k, v in iterable: -
- > d[k] = v - -dict( - -``` -** -``` - -kwargs) -> new dictionary initialized with the name=value pairs -: in the keyword argument list. For example: dict(one=1, two=2) - -#### transaction_id *: str* - -#### message *: str* - -#### pc *: int* - -### algokit_utils.errors.logic_error.parse_logic_error(error_str: str) → [LogicErrorData](#algokit_utils.errors.logic_error.LogicErrorData) | None - -### *exception* algokit_utils.errors.logic_error.LogicError(\*, logic_error_str: str, program: str, source_map: AlgoSourceMap | None, transaction_id: str, message: str, pc: int, logic_error: Exception | None = None, traces: list[[algokit_utils.models.simulate.SimulationTrace](../../models/simulate/index.md#algokit_utils.models.simulate.SimulationTrace)] | None = None, get_line_for_pc: collections.abc.Callable[[int], int | None] | None = None) - -Bases: `Exception` - -Common base class for all non-exit exceptions. - -#### logic_error *= None* - -#### logic_error_str - -#### source_map - -#### lines - -#### transaction_id - -#### message - -#### pc - -#### traces *= None* - -#### line_no - -#### trace(lines: int = 5) → str diff --git a/docs/markdown/autoapi/algokit_utils/index.md b/docs/markdown/autoapi/algokit_utils/index.md deleted file mode 100644 index 1b2f3707..00000000 --- a/docs/markdown/autoapi/algokit_utils/index.md +++ /dev/null @@ -1,24 +0,0 @@ -# algokit_utils - -AlgoKit Python Utilities - a set of utilities for building solutions on Algorand - -This module provides commonly used utilities and types at the root level for convenience. -For more specific functionality, import directly from the relevant submodules: - -> from algokit_utils.accounts import KmdAccountManager -> from algokit_utils.applications import AppClient -> from algokit_utils.applications.app_spec import Arc52Contract -> etc. - -## Submodules - -* [algokit_utils.accounts](accounts/index.md) -* [algokit_utils.algorand](algorand/index.md) -* [algokit_utils.applications](applications/index.md) -* [algokit_utils.assets](assets/index.md) -* [algokit_utils.clients](clients/index.md) -* [algokit_utils.config](config/index.md) -* [algokit_utils.errors](errors/index.md) -* [algokit_utils.models](models/index.md) -* [algokit_utils.protocols](protocols/index.md) -* [algokit_utils.transactions](transactions/index.md) diff --git a/docs/markdown/autoapi/algokit_utils/models/account/index.md b/docs/markdown/autoapi/algokit_utils/models/account/index.md deleted file mode 100644 index e9fbbc04..00000000 --- a/docs/markdown/autoapi/algokit_utils/models/account/index.md +++ /dev/null @@ -1,160 +0,0 @@ -# algokit_utils.models.account - -## Attributes - -| [`DISPENSER_ACCOUNT_NAME`](#algokit_utils.models.account.DISPENSER_ACCOUNT_NAME) | | -|------------------------------------------------------------------------------------|----| - -## Classes - -| [`TransactionSignerAccount`](#algokit_utils.models.account.TransactionSignerAccount) | A basic transaction signer account. | -|----------------------------------------------------------------------------------------|-----------------------------------------------------------------| -| [`SigningAccount`](#algokit_utils.models.account.SigningAccount) | Holds the private key and address for an account. | -| [`MultisigMetadata`](#algokit_utils.models.account.MultisigMetadata) | Metadata for a multisig account. | -| [`MultiSigAccount`](#algokit_utils.models.account.MultiSigAccount) | Account wrapper that supports partial or full multisig signing. | -| [`LogicSigAccount`](#algokit_utils.models.account.LogicSigAccount) | Account wrapper that supports logic sig signing. | - -## Module Contents - -### algokit_utils.models.account.DISPENSER_ACCOUNT_NAME *= 'DISPENSER'* - -### *class* algokit_utils.models.account.TransactionSignerAccount - -A basic transaction signer account. - -#### address *: str* - -#### signer *: algosdk.atomic_transaction_composer.TransactionSigner* - -### *class* algokit_utils.models.account.SigningAccount - -Holds the private key and address for an account. - -Provides access to the account’s private key, address, public key and transaction signer. - -#### private_key *: str* - -Base64 encoded private key - -#### address *: str* *= ''* - -Address for this account - -#### *property* public_key *: bytes* - -The public key for this account. - -* **Returns:** - The public key as bytes - -#### *property* signer *: algosdk.atomic_transaction_composer.AccountTransactionSigner* - -Get an AccountTransactionSigner for this account. - -* **Returns:** - A transaction signer for this account - -#### *static* new_account() → [SigningAccount](#algokit_utils.models.account.SigningAccount) - -Create a new random account. - -* **Returns:** - A new Account instance - -### *class* algokit_utils.models.account.MultisigMetadata - -Metadata for a multisig account. - -Contains the version, threshold and addresses for a multisig account. - -#### version *: int* - -#### threshold *: int* - -#### addresses *: list[str]* - -### *class* algokit_utils.models.account.MultiSigAccount(multisig_params: [MultisigMetadata](#algokit_utils.models.account.MultisigMetadata), signing_accounts: list[[SigningAccount](#algokit_utils.models.account.SigningAccount)]) - -Account wrapper that supports partial or full multisig signing. - -Provides functionality to manage and sign transactions for a multisig account. - -* **Parameters:** - * **multisig_params** – The parameters for the multisig account - * **signing_accounts** – The list of accounts that can sign - -#### *property* multisig *: algosdk.transaction.Multisig* - -Get the underlying algosdk.transaction.Multisig object instance. - -* **Returns:** - The algosdk.transaction.Multisig object instance - -#### *property* params *: [MultisigMetadata](#algokit_utils.models.account.MultisigMetadata)* - -Get the parameters for the multisig account. - -* **Returns:** - The multisig account parameters - -#### *property* signing_accounts *: list[[SigningAccount](#algokit_utils.models.account.SigningAccount)]* - -Get the list of accounts that are present to sign. - -* **Returns:** - The list of signing accounts - -#### *property* address *: str* - -Get the address of the multisig account. - -* **Returns:** - The multisig account address - -#### *property* signer *: algosdk.atomic_transaction_composer.TransactionSigner* - -Get the transaction signer for this multisig account. - -* **Returns:** - The multisig transaction signer - -#### sign(transaction: algosdk.transaction.Transaction) → algosdk.transaction.MultisigTransaction - -Sign the given transaction with all present signers. - -* **Parameters:** - **transaction** – Either a transaction object or a raw, partially signed transaction -* **Returns:** - The transaction signed by the present signers - -### *class* algokit_utils.models.account.LogicSigAccount(program: bytes, args: list[bytes] | None) - -Account wrapper that supports logic sig signing. - -Provides functionality to manage and sign transactions for a logic sig account. - -#### *property* lsig *: algosdk.transaction.LogicSigAccount* - -Get the underlying algosdk.transaction.LogicSigAccount object instance. - -* **Returns:** - The algosdk.transaction.LogicSigAccount object instance - -#### *property* address *: str* - -Get the address of the logic sig account. - -If the LogicSig is delegated to another account, this will return the address of that account. - -If the LogicSig is not delegated to another account, this will return an escrow address that is the hash of -the LogicSig’s program code. - -* **Returns:** - The logic sig account address - -#### *property* signer *: algosdk.atomic_transaction_composer.LogicSigTransactionSigner* - -Get the transaction signer for this multisig account. - -* **Returns:** - The multisig transaction signer diff --git a/docs/markdown/autoapi/algokit_utils/models/amount/index.md b/docs/markdown/autoapi/algokit_utils/models/amount/index.md deleted file mode 100644 index 8b53ceca..00000000 --- a/docs/markdown/autoapi/algokit_utils/models/amount/index.md +++ /dev/null @@ -1,103 +0,0 @@ -# algokit_utils.models.amount - -## Attributes - -| [`ALGORAND_MIN_TX_FEE`](#algokit_utils.models.amount.ALGORAND_MIN_TX_FEE) | | -|-----------------------------------------------------------------------------|----| - -## Classes - -| [`AlgoAmount`](#algokit_utils.models.amount.AlgoAmount) | Wrapper class to ensure safe, explicit conversion between µAlgo, Algo and numbers. | -|-----------------------------------------------------------|--------------------------------------------------------------------------------------| - -## Functions - -| [`algo`](#algokit_utils.models.amount.algo)(→ AlgoAmount) | Create an AlgoAmount object representing the given number of Algo. | -|-----------------------------------------------------------------------------------|--------------------------------------------------------------------------| -| [`micro_algo`](#algokit_utils.models.amount.micro_algo)(→ AlgoAmount) | Create an AlgoAmount object representing the given number of µAlgo. | -| [`transaction_fees`](#algokit_utils.models.amount.transaction_fees)(→ AlgoAmount) | Calculate the total transaction fees for a given number of transactions. | - -## Module Contents - -### *class* algokit_utils.models.amount.AlgoAmount(\*, micro_algo: int) - -### *class* algokit_utils.models.amount.AlgoAmount(\*, algo: int | decimal.Decimal) - -Wrapper class to ensure safe, explicit conversion between µAlgo, Algo and numbers. - -* **Example:** - ```python - amount = AlgoAmount(algo=1) - amount = AlgoAmount.from_algo(1) - amount = AlgoAmount(micro_algo=1_000_000) - amount = AlgoAmount.from_micro_algo(1_000_000) - ``` - -#### *property* micro_algo *: int* - -Return the amount as a number in µAlgo. - -* **Returns:** - The amount in µAlgo. - -#### *property* algo *: decimal.Decimal* - -Return the amount as a number in Algo. - -* **Returns:** - The amount in Algo. - -#### *static* from_algo(amount: int | decimal.Decimal) → [AlgoAmount](#algokit_utils.models.amount.AlgoAmount) - -Create an AlgoAmount object representing the given number of Algo. - -* **Parameters:** - **amount** – The amount in Algo. -* **Returns:** - An AlgoAmount instance. -* **Example:** - ```python - amount = AlgoAmount.from_algo(1) - ``` - -#### *static* from_micro_algo(amount: int) → [AlgoAmount](#algokit_utils.models.amount.AlgoAmount) - -Create an AlgoAmount object representing the given number of µAlgo. - -* **Parameters:** - **amount** – The amount in µAlgo. -* **Returns:** - An AlgoAmount instance. -* **Example:** - ```python - amount = AlgoAmount.from_micro_algo(1_000_000) - ``` - -### algokit_utils.models.amount.algo(algo: int) → [AlgoAmount](#algokit_utils.models.amount.AlgoAmount) - -Create an AlgoAmount object representing the given number of Algo. - -* **Parameters:** - **algo** – The number of Algo to create an AlgoAmount object for. -* **Returns:** - An AlgoAmount object representing the given number of Algo. - -### algokit_utils.models.amount.micro_algo(micro_algo: int) → [AlgoAmount](#algokit_utils.models.amount.AlgoAmount) - -Create an AlgoAmount object representing the given number of µAlgo. - -* **Parameters:** - **micro_algo** – The number of µAlgo to create an AlgoAmount object for. -* **Returns:** - An AlgoAmount object representing the given number of µAlgo. - -### algokit_utils.models.amount.ALGORAND_MIN_TX_FEE - -### algokit_utils.models.amount.transaction_fees(number_of_transactions: int) → [AlgoAmount](#algokit_utils.models.amount.AlgoAmount) - -Calculate the total transaction fees for a given number of transactions. - -* **Parameters:** - **number_of_transactions** – The number of transactions to calculate the fees for. -* **Returns:** - The total transaction fees. diff --git a/docs/markdown/autoapi/algokit_utils/models/application/index.md b/docs/markdown/autoapi/algokit_utils/models/application/index.md deleted file mode 100644 index 3ac8e148..00000000 --- a/docs/markdown/autoapi/algokit_utils/models/application/index.md +++ /dev/null @@ -1,126 +0,0 @@ -# algokit_utils.models.application - -## Classes - -| [`AppState`](#algokit_utils.models.application.AppState) | | -|----------------------------------------------------------------------------------|-------------------------------------| -| [`AppInformation`](#algokit_utils.models.application.AppInformation) | | -| [`CompiledTeal`](#algokit_utils.models.application.CompiledTeal) | The compiled teal code | -| [`AppCompilationResult`](#algokit_utils.models.application.AppCompilationResult) | The compiled teal code | -| [`AppSourceMaps`](#algokit_utils.models.application.AppSourceMaps) | The source maps for the application | - -## Module Contents - -### *class* algokit_utils.models.application.AppState - -#### key_raw *: bytes* - -The key of the state as raw bytes - -#### key_base64 *: str* - -The key of the state - -#### value_raw *: bytes | None* - -The value of the state as raw bytes - -#### value_base64 *: str | None* - -The value of the state as base64 encoded string - -#### value *: str | int* - -The value of the state as a string or integer - -### *class* algokit_utils.models.application.AppInformation - -#### app_id *: int* - -The ID of the application - -#### app_address *: str* - -The address of the application - -#### approval_program *: bytes* - -The approval program - -#### clear_state_program *: bytes* - -The clear state program - -#### creator *: str* - -The creator of the application - -#### global_state *: dict[str, [AppState](#algokit_utils.models.application.AppState)]* - -The global state of the application - -#### local_ints *: int* - -The number of local ints - -#### local_byte_slices *: int* - -The number of local byte slices - -#### global_ints *: int* - -The number of global ints - -#### global_byte_slices *: int* - -The number of global byte slices - -#### extra_program_pages *: int | None* - -The number of extra program pages - -### *class* algokit_utils.models.application.CompiledTeal - -The compiled teal code - -#### teal *: str* - -The teal code - -#### compiled *: str* - -The compiled teal code - -#### compiled_hash *: str* - -The compiled hash - -#### compiled_base64_to_bytes *: bytes* - -The compiled base64 to bytes - -#### source_map *: algosdk.source_map.SourceMap | None* - -### *class* algokit_utils.models.application.AppCompilationResult - -The compiled teal code - -#### compiled_approval *: [CompiledTeal](#algokit_utils.models.application.CompiledTeal)* - -The compiled approval program - -#### compiled_clear *: [CompiledTeal](#algokit_utils.models.application.CompiledTeal)* - -The compiled clear state program - -### *class* algokit_utils.models.application.AppSourceMaps - -The source maps for the application - -#### approval_source_map *: algosdk.source_map.SourceMap | None* *= None* - -The source map for the approval program - -#### clear_source_map *: algosdk.source_map.SourceMap | None* *= None* - -The source map for the clear state program diff --git a/docs/markdown/autoapi/algokit_utils/models/index.md b/docs/markdown/autoapi/algokit_utils/models/index.md deleted file mode 100644 index e0f53185..00000000 --- a/docs/markdown/autoapi/algokit_utils/models/index.md +++ /dev/null @@ -1,11 +0,0 @@ -# algokit_utils.models - -## Submodules - -* [algokit_utils.models.account](account/index.md) -* [algokit_utils.models.amount](amount/index.md) -* [algokit_utils.models.application](application/index.md) -* [algokit_utils.models.network](network/index.md) -* [algokit_utils.models.simulate](simulate/index.md) -* [algokit_utils.models.state](state/index.md) -* [algokit_utils.models.transaction](transaction/index.md) diff --git a/docs/markdown/autoapi/algokit_utils/models/network/index.md b/docs/markdown/autoapi/algokit_utils/models/network/index.md deleted file mode 100644 index 8b67ed9f..00000000 --- a/docs/markdown/autoapi/algokit_utils/models/network/index.md +++ /dev/null @@ -1,36 +0,0 @@ -# algokit_utils.models.network - -## Classes - -| [`AlgoClientNetworkConfig`](#algokit_utils.models.network.AlgoClientNetworkConfig) | Connection details for connecting to an {py:class}\`algosdk.v2client.algod.AlgodClient\` or | -|--------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------| -| [`AlgoClientConfigs`](#algokit_utils.models.network.AlgoClientConfigs) | | - -## Module Contents - -### *class* algokit_utils.models.network.AlgoClientNetworkConfig - -Connection details for connecting to an {py:class}\`algosdk.v2client.algod.AlgodClient\` or -{py:class}\`algosdk.v2client.indexer.IndexerClient\` - -#### server *: str* - -URL for the service e.g. http://localhost or https://testnet-api.algonode.cloud - -#### token *: str | None* *= None* - -API Token to authenticate with the service e.g ‘4001’ or ‘8980’ - -#### port *: str | int | None* *= None* - -#### full_url() → str - -Returns the full URL for the service - -### *class* algokit_utils.models.network.AlgoClientConfigs - -#### algod_config *: [AlgoClientNetworkConfig](#algokit_utils.models.network.AlgoClientNetworkConfig)* - -#### indexer_config *: [AlgoClientNetworkConfig](#algokit_utils.models.network.AlgoClientNetworkConfig) | None* - -#### kmd_config *: [AlgoClientNetworkConfig](#algokit_utils.models.network.AlgoClientNetworkConfig) | None* diff --git a/docs/markdown/autoapi/algokit_utils/models/simulate/index.md b/docs/markdown/autoapi/algokit_utils/models/simulate/index.md deleted file mode 100644 index 7c1fec4c..00000000 --- a/docs/markdown/autoapi/algokit_utils/models/simulate/index.md +++ /dev/null @@ -1,18 +0,0 @@ -# algokit_utils.models.simulate - -## Classes - -| [`SimulationTrace`](#algokit_utils.models.simulate.SimulationTrace) | | -|-----------------------------------------------------------------------|----| - -## Module Contents - -### *class* algokit_utils.models.simulate.SimulationTrace - -#### app_budget_added *: int | None* - -#### app_budget_consumed *: int | None* - -#### failure_message *: str | None* - -#### exec_trace *: dict[str, object]* diff --git a/docs/markdown/autoapi/algokit_utils/models/state/index.md b/docs/markdown/autoapi/algokit_utils/models/state/index.md deleted file mode 100644 index 45e79f27..00000000 --- a/docs/markdown/autoapi/algokit_utils/models/state/index.md +++ /dev/null @@ -1,70 +0,0 @@ -# algokit_utils.models.state - -## Attributes - -| [`TealTemplateParams`](#algokit_utils.models.state.TealTemplateParams) | | -|--------------------------------------------------------------------------|----| -| [`BoxIdentifier`](#algokit_utils.models.state.BoxIdentifier) | | - -## Classes - -| [`BoxName`](#algokit_utils.models.state.BoxName) | The name of the box | -|------------------------------------------------------------|-----------------------------------------------------------------------| -| [`BoxValue`](#algokit_utils.models.state.BoxValue) | The value of the box | -| [`DataTypeFlag`](#algokit_utils.models.state.DataTypeFlag) | Enum where members are also (and must be) ints | -| [`BoxReference`](#algokit_utils.models.state.BoxReference) | Represents a box reference with a foreign app index and the box name. | - -## Module Contents - -### *class* algokit_utils.models.state.BoxName - -The name of the box - -#### name *: str* - -The name of the box as a string. -If the name can’t be decoded from UTF-8, the string representation of the bytes is returned instead. - -#### name_raw *: bytes* - -The name of the box as raw bytes - -#### name_base64 *: str* - -The name of the box as a base64 encoded string - -### *class* algokit_utils.models.state.BoxValue - -The value of the box - -#### name *: [BoxName](#algokit_utils.models.state.BoxName)* - -The name of the box - -#### value *: bytes* - -The value of the box as raw bytes - -### *class* algokit_utils.models.state.DataTypeFlag - -Bases: `enum.IntEnum` - -Enum where members are also (and must be) ints - -#### BYTES *= 1* - -#### UINT *= 2* - -### *type* algokit_utils.models.state.TealTemplateParams *= Mapping[str, str | int | bytes] | dict[str, str | int | bytes]* - -### *type* algokit_utils.models.state.BoxIdentifier *= str | bytes | AccountTransactionSigner* - -### *class* algokit_utils.models.state.BoxReference(app_id: int, name: bytes | str) - -Bases: `algosdk.box_reference.BoxReference` - -Represents a box reference with a foreign app index and the box name. - -Args: -: app_index (int): index of the application in the foreign app array - name (bytes): key for the box in bytes diff --git a/docs/markdown/autoapi/algokit_utils/models/transaction/index.md b/docs/markdown/autoapi/algokit_utils/models/transaction/index.md deleted file mode 100644 index c1baf228..00000000 --- a/docs/markdown/autoapi/algokit_utils/models/transaction/index.md +++ /dev/null @@ -1,87 +0,0 @@ -# algokit_utils.models.transaction - -## Attributes - -| [`Arc2TransactionNote`](#algokit_utils.models.transaction.Arc2TransactionNote) | | -|----------------------------------------------------------------------------------|----| -| [`TransactionNoteData`](#algokit_utils.models.transaction.TransactionNoteData) | | -| [`TransactionNote`](#algokit_utils.models.transaction.TransactionNote) | | - -## Classes - -| [`BaseArc2Note`](#algokit_utils.models.transaction.BaseArc2Note) | Base ARC-0002 transaction note structure | -|----------------------------------------------------------------------------------|----------------------------------------------------------------------------------| -| [`StringFormatArc2Note`](#algokit_utils.models.transaction.StringFormatArc2Note) | ARC-0002 note for string-based formats (m/b/u) | -| [`JsonFormatArc2Note`](#algokit_utils.models.transaction.JsonFormatArc2Note) | ARC-0002 note for JSON format | -| [`TransactionWrapper`](#algokit_utils.models.transaction.TransactionWrapper) | Wrapper around algosdk.transaction.Transaction with optional property validators | -| [`SendParams`](#algokit_utils.models.transaction.SendParams) | Parameters for sending a transaction | - -## Module Contents - -### *class* algokit_utils.models.transaction.BaseArc2Note - -Bases: `TypedDict` - -Base ARC-0002 transaction note structure - -#### dapp_name *: str* - -### *class* algokit_utils.models.transaction.StringFormatArc2Note - -Bases: [`BaseArc2Note`](#algokit_utils.models.transaction.BaseArc2Note) - -ARC-0002 note for string-based formats (m/b/u) - -#### format *: Literal['m', 'b', 'u']* - -#### data *: str* - -### *class* algokit_utils.models.transaction.JsonFormatArc2Note - -Bases: [`BaseArc2Note`](#algokit_utils.models.transaction.BaseArc2Note) - -ARC-0002 note for JSON format - -#### format *: Literal['j']* - -#### data *: str | dict[str, Any] | list[Any] | int | None* - -### algokit_utils.models.transaction.Arc2TransactionNote - -### algokit_utils.models.transaction.TransactionNoteData - -### algokit_utils.models.transaction.TransactionNote - -### *class* algokit_utils.models.transaction.TransactionWrapper(transaction: algosdk.transaction.Transaction) - -Wrapper around algosdk.transaction.Transaction with optional property validators - -#### *property* raw *: algosdk.transaction.Transaction* - -#### *property* payment *: algosdk.transaction.PaymentTxn* - -#### *property* keyreg *: algosdk.transaction.KeyregTxn* - -#### *property* asset_config *: algosdk.transaction.AssetConfigTxn* - -#### *property* asset_transfer *: algosdk.transaction.AssetTransferTxn* - -#### *property* asset_freeze *: algosdk.transaction.AssetFreezeTxn* - -#### *property* application_call *: algosdk.transaction.ApplicationCallTxn* - -#### *property* state_proof *: algosdk.transaction.StateProofTxn* - -### *class* algokit_utils.models.transaction.SendParams - -Bases: `TypedDict` - -Parameters for sending a transaction - -#### max_rounds_to_wait *: int | None* - -#### suppress_log *: bool | None* - -#### populate_app_call_resources *: bool | None* - -#### cover_app_call_inner_transaction_fees *: bool | None* diff --git a/docs/markdown/autoapi/algokit_utils/protocols/account/index.md b/docs/markdown/autoapi/algokit_utils/protocols/account/index.md deleted file mode 100644 index 190f37ab..00000000 --- a/docs/markdown/autoapi/algokit_utils/protocols/account/index.md +++ /dev/null @@ -1,23 +0,0 @@ -# algokit_utils.protocols.account - -## Classes - -| [`TransactionSignerAccountProtocol`](#algokit_utils.protocols.account.TransactionSignerAccountProtocol) | An account that has a transaction signer. | -|-----------------------------------------------------------------------------------------------------------|---------------------------------------------| - -## Module Contents - -### *class* algokit_utils.protocols.account.TransactionSignerAccountProtocol - -Bases: `Protocol` - -An account that has a transaction signer. -Implemented by SigningAccount, LogicSigAccount, MultiSigAccount and TransactionSignerAccount abstractions. - -#### *property* address *: str* - -The address of the account. - -#### *property* signer *: algosdk.atomic_transaction_composer.TransactionSigner* - -The transaction signer for the account. diff --git a/docs/markdown/autoapi/algokit_utils/protocols/index.md b/docs/markdown/autoapi/algokit_utils/protocols/index.md deleted file mode 100644 index 8796fff2..00000000 --- a/docs/markdown/autoapi/algokit_utils/protocols/index.md +++ /dev/null @@ -1,6 +0,0 @@ -# algokit_utils.protocols - -## Submodules - -* [algokit_utils.protocols.account](account/index.md) -* [algokit_utils.protocols.typed_clients](typed_clients/index.md) diff --git a/docs/markdown/autoapi/algokit_utils/protocols/typed_clients/index.md b/docs/markdown/autoapi/algokit_utils/protocols/typed_clients/index.md deleted file mode 100644 index 751ea934..00000000 --- a/docs/markdown/autoapi/algokit_utils/protocols/typed_clients/index.md +++ /dev/null @@ -1,97 +0,0 @@ -# algokit_utils.protocols.typed_clients - -## Classes - -| [`TypedAppClientProtocol`](#algokit_utils.protocols.typed_clients.TypedAppClientProtocol) | Base class for protocol classes. | -|---------------------------------------------------------------------------------------------|------------------------------------| -| [`TypedAppFactoryProtocol`](#algokit_utils.protocols.typed_clients.TypedAppFactoryProtocol) | Base class for protocol classes. | - -## Module Contents - -### *class* algokit_utils.protocols.typed_clients.TypedAppClientProtocol(\*, app_id: int, app_name: str | None = None, default_sender: str | None = None, default_signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None, algorand: [algokit_utils.algorand.AlgorandClient](../../algorand/index.md#algokit_utils.algorand.AlgorandClient), approval_source_map: algosdk.source_map.SourceMap | None = None, clear_source_map: algosdk.source_map.SourceMap | None = None) - -Bases: `Protocol` - -Base class for protocol classes. - -Protocol classes are defined as: - -```default -class Proto(Protocol): - def meth(self) -> int: - ... -``` - -Such classes are primarily used with static type checkers that recognize -structural subtyping (static duck-typing). - -For example: - -```default -class C: - def meth(self) -> int: - return 0 - -def func(x: Proto) -> int: - return x.meth() - -func(C()) # Passes static type check -``` - -See PEP 544 for details. Protocol classes decorated with -@typing.runtime_checkable act as simple-minded runtime protocols that check -only the presence of given attributes, ignoring their type signatures. -Protocol classes can be generic, they are defined as: - -```default -class GenProto[T](Protocol): - def meth(self) -> T: - ... -``` - -#### *classmethod* from_creator_and_name(\*, creator_address: str, app_name: str, default_sender: str | None = None, default_signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None, ignore_cache: bool | None = None, app_lookup_cache: [algokit_utils.applications.app_deployer.ApplicationLookup](../../applications/app_deployer/index.md#algokit_utils.applications.app_deployer.ApplicationLookup) | None = None, algorand: [algokit_utils.algorand.AlgorandClient](../../algorand/index.md#algokit_utils.algorand.AlgorandClient)) → typing_extensions.Self - -#### *classmethod* from_network(\*, app_name: str | None = None, default_sender: str | None = None, default_signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None, approval_source_map: algosdk.source_map.SourceMap | None = None, clear_source_map: algosdk.source_map.SourceMap | None = None, algorand: [algokit_utils.algorand.AlgorandClient](../../algorand/index.md#algokit_utils.algorand.AlgorandClient)) → typing_extensions.Self - -### *class* algokit_utils.protocols.typed_clients.TypedAppFactoryProtocol(algorand: [algokit_utils.algorand.AlgorandClient](../../algorand/index.md#algokit_utils.algorand.AlgorandClient), \*\*kwargs: Any) - -Bases: `Protocol`, `Generic`[`CreateParamsT`, `UpdateParamsT`, `DeleteParamsT`] - -Base class for protocol classes. - -Protocol classes are defined as: - -```default -class Proto(Protocol): - def meth(self) -> int: - ... -``` - -Such classes are primarily used with static type checkers that recognize -structural subtyping (static duck-typing). - -For example: - -```default -class C: - def meth(self) -> int: - return 0 - -def func(x: Proto) -> int: - return x.meth() - -func(C()) # Passes static type check -``` - -See PEP 544 for details. Protocol classes decorated with -@typing.runtime_checkable act as simple-minded runtime protocols that check -only the presence of given attributes, ignoring their type signatures. -Protocol classes can be generic, they are defined as: - -```default -class GenProto[T](Protocol): - def meth(self) -> T: - ... -``` - -#### deploy(\*, on_update: algokit_utils.applications.app_deployer.OnUpdate | None = None, on_schema_break: algokit_utils.applications.app_deployer.OnSchemaBreak | None = None, create_params: CreateParamsT | None = None, update_params: UpdateParamsT | None = None, delete_params: DeleteParamsT | None = None, existing_deployments: [algokit_utils.applications.app_deployer.ApplicationLookup](../../applications/app_deployer/index.md#algokit_utils.applications.app_deployer.ApplicationLookup) | None = None, ignore_cache: bool = False, app_name: str | None = None, send_params: algokit_utils.models.SendParams | None = None, compilation_params: [algokit_utils.applications.app_client.AppClientCompilationParams](../../applications/app_client/index.md#algokit_utils.applications.app_client.AppClientCompilationParams) | None = None) → tuple[[TypedAppClientProtocol](#algokit_utils.protocols.typed_clients.TypedAppClientProtocol), [algokit_utils.applications.app_factory.AppFactoryDeployResult](../../applications/app_factory/index.md#algokit_utils.applications.app_factory.AppFactoryDeployResult)] diff --git a/docs/markdown/autoapi/algokit_utils/transactions/index.md b/docs/markdown/autoapi/algokit_utils/transactions/index.md deleted file mode 100644 index 7455d34c..00000000 --- a/docs/markdown/autoapi/algokit_utils/transactions/index.md +++ /dev/null @@ -1,7 +0,0 @@ -# algokit_utils.transactions - -## Submodules - -* [algokit_utils.transactions.transaction_composer](transaction_composer/index.md) -* [algokit_utils.transactions.transaction_creator](transaction_creator/index.md) -* [algokit_utils.transactions.transaction_sender](transaction_sender/index.md) diff --git a/docs/markdown/autoapi/algokit_utils/transactions/transaction_composer/index.md b/docs/markdown/autoapi/algokit_utils/transactions/transaction_composer/index.md deleted file mode 100644 index 8cba03a7..00000000 --- a/docs/markdown/autoapi/algokit_utils/transactions/transaction_composer/index.md +++ /dev/null @@ -1,1158 +0,0 @@ -# algokit_utils.transactions.transaction_composer - -## Attributes - -| [`ErrorTransformer`](#algokit_utils.transactions.transaction_composer.ErrorTransformer) | | -|-------------------------------------------------------------------------------------------------------------------------|----| -| [`MethodCallParams`](#algokit_utils.transactions.transaction_composer.MethodCallParams) | | -| [`AppMethodCallTransactionArgument`](#algokit_utils.transactions.transaction_composer.AppMethodCallTransactionArgument) | | -| [`TxnParams`](#algokit_utils.transactions.transaction_composer.TxnParams) | | - -## Classes - -| [`PaymentParams`](#algokit_utils.transactions.transaction_composer.PaymentParams) | Parameters for a payment transaction. | -|---------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------| -| [`AssetCreateParams`](#algokit_utils.transactions.transaction_composer.AssetCreateParams) | Parameters for creating a new asset. | -| [`AssetConfigParams`](#algokit_utils.transactions.transaction_composer.AssetConfigParams) | Parameters for configuring an existing asset. | -| [`AssetFreezeParams`](#algokit_utils.transactions.transaction_composer.AssetFreezeParams) | Parameters for freezing an asset. | -| [`AssetDestroyParams`](#algokit_utils.transactions.transaction_composer.AssetDestroyParams) | Parameters for destroying an asset. | -| [`OnlineKeyRegistrationParams`](#algokit_utils.transactions.transaction_composer.OnlineKeyRegistrationParams) | Parameters for online key registration. | -| [`OfflineKeyRegistrationParams`](#algokit_utils.transactions.transaction_composer.OfflineKeyRegistrationParams) | Parameters for offline key registration. | -| [`AssetTransferParams`](#algokit_utils.transactions.transaction_composer.AssetTransferParams) | Parameters for transferring an asset. | -| [`AssetOptInParams`](#algokit_utils.transactions.transaction_composer.AssetOptInParams) | Parameters for opting into an asset. | -| [`AssetOptOutParams`](#algokit_utils.transactions.transaction_composer.AssetOptOutParams) | Parameters for opting out of an asset. | -| [`AppCallParams`](#algokit_utils.transactions.transaction_composer.AppCallParams) | Parameters for calling an application. | -| [`AppCreateSchema`](#algokit_utils.transactions.transaction_composer.AppCreateSchema) | dict() -> new empty dictionary | -| [`AppCreateParams`](#algokit_utils.transactions.transaction_composer.AppCreateParams) | Parameters for creating an application. | -| [`AppUpdateParams`](#algokit_utils.transactions.transaction_composer.AppUpdateParams) | Parameters for updating an application. | -| [`AppDeleteParams`](#algokit_utils.transactions.transaction_composer.AppDeleteParams) | Parameters for deleting an application. | -| [`AppCallMethodCallParams`](#algokit_utils.transactions.transaction_composer.AppCallMethodCallParams) | Parameters for a regular ABI method call. | -| [`AppCreateMethodCallParams`](#algokit_utils.transactions.transaction_composer.AppCreateMethodCallParams) | Parameters for an ABI method call that creates an application. | -| [`AppUpdateMethodCallParams`](#algokit_utils.transactions.transaction_composer.AppUpdateMethodCallParams) | Parameters for an ABI method call that updates an application. | -| [`AppDeleteMethodCallParams`](#algokit_utils.transactions.transaction_composer.AppDeleteMethodCallParams) | Parameters for an ABI method call that deletes an application. | -| [`BuiltTransactions`](#algokit_utils.transactions.transaction_composer.BuiltTransactions) | Set of transactions built by TransactionComposer. | -| [`TransactionComposerBuildResult`](#algokit_utils.transactions.transaction_composer.TransactionComposerBuildResult) | Result of building transactions with TransactionComposer. | -| [`SendAtomicTransactionComposerResults`](#algokit_utils.transactions.transaction_composer.SendAtomicTransactionComposerResults) | Results from sending an AtomicTransactionComposer transaction group. | -| [`TransactionComposer`](#algokit_utils.transactions.transaction_composer.TransactionComposer) | A class for composing and managing Algorand transactions. | - -## Functions - -| [`calculate_extra_program_pages`](#algokit_utils.transactions.transaction_composer.calculate_extra_program_pages)(→ int) | Calculate minimum number of extra_pages required for provided approval and clear programs | -|------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------| -| [`populate_app_call_resources`](#algokit_utils.transactions.transaction_composer.populate_app_call_resources)(...) | Populate application call resources based on simulation results. | -| [`prepare_group_for_sending`](#algokit_utils.transactions.transaction_composer.prepare_group_for_sending)(...) | Take an existing Atomic Transaction Composer and return a new one with changes applied to the transactions | -| [`send_atomic_transaction_composer`](#algokit_utils.transactions.transaction_composer.send_atomic_transaction_composer)(...) | Send an AtomicTransactionComposer transaction group. | - -## Module Contents - -### algokit_utils.transactions.transaction_composer.ErrorTransformer - -### *class* algokit_utils.transactions.transaction_composer.PaymentParams - -Bases: `_CommonTxnParams` - -Parameters for a payment transaction. - -#### receiver *: str* - -The account that will receive the ALGO - -#### amount *: [algokit_utils.models.amount.AlgoAmount](../../models/amount/index.md#algokit_utils.models.amount.AlgoAmount)* - -Amount to send - -#### close_remainder_to *: str | None* *= None* - -If given, close the sender account and send the remaining balance to this address, defaults to None - -### *class* algokit_utils.transactions.transaction_composer.AssetCreateParams - -Bases: `_CommonTxnParams` - -Parameters for creating a new asset. - -#### total *: int* - -The total amount of the smallest divisible unit to create - -#### asset_name *: str | None* *= None* - -The full name of the asset - -#### unit_name *: str | None* *= None* - -The short ticker name for the asset - -#### url *: str | None* *= None* - -The metadata URL for the asset - -#### decimals *: int | None* *= None* - -The amount of decimal places the asset should have - -#### default_frozen *: bool | None* *= None* - -Whether the asset is frozen by default in the creator address - -#### manager *: str | None* *= None* - -The address that can change the manager, reserve, clawback, and freeze addresses - -#### reserve *: str | None* *= None* - -The address that holds the uncirculated supply - -#### freeze *: str | None* *= None* - -The address that can freeze the asset in any account - -#### clawback *: str | None* *= None* - -The address that can clawback the asset from any account - -#### metadata_hash *: bytes | None* *= None* - -Hash of the metadata contained in the metadata URL - -### *class* algokit_utils.transactions.transaction_composer.AssetConfigParams - -Bases: `_CommonTxnParams` - -Parameters for configuring an existing asset. - -#### asset_id *: int* - -The ID of the asset - -#### manager *: str | None* *= None* - -The address that can change the manager, reserve, clawback, and freeze addresses, defaults to None - -#### reserve *: str | None* *= None* - -The address that holds the uncirculated supply, defaults to None - -#### freeze *: str | None* *= None* - -The address that can freeze the asset in any account, defaults to None - -#### clawback *: str | None* *= None* - -The address that can clawback the asset from any account, defaults to None - -### *class* algokit_utils.transactions.transaction_composer.AssetFreezeParams - -Bases: `_CommonTxnParams` - -Parameters for freezing an asset. - -#### asset_id *: int* - -The ID of the asset - -#### account *: str* - -The account to freeze or unfreeze - -#### frozen *: bool* - -Whether the assets in the account should be frozen - -### *class* algokit_utils.transactions.transaction_composer.AssetDestroyParams - -Bases: `_CommonTxnParams` - -Parameters for destroying an asset. - -#### asset_id *: int* - -The ID of the asset - -### *class* algokit_utils.transactions.transaction_composer.OnlineKeyRegistrationParams - -Bases: `_CommonTxnParams` - -Parameters for online key registration. - -#### vote_key *: str* - -The root participation public key - -#### selection_key *: str* - -The VRF public key - -#### vote_first *: int* - -The first round that the participation key is valid - -#### vote_last *: int* - -The last round that the participation key is valid - -#### vote_key_dilution *: int* - -The dilution for the 2-level participation key - -#### state_proof_key *: bytes | None* *= None* - -The 64 byte state proof public key commitment, defaults to None - -### *class* algokit_utils.transactions.transaction_composer.OfflineKeyRegistrationParams - -Bases: `_CommonTxnParams` - -Parameters for offline key registration. - -#### prevent_account_from_ever_participating_again *: bool* - -Whether to prevent the account from ever participating again - -### *class* algokit_utils.transactions.transaction_composer.AssetTransferParams - -Bases: `_CommonTxnParams` - -Parameters for transferring an asset. - -#### asset_id *: int* - -The ID of the asset - -#### amount *: int* - -The amount of the asset to transfer (smallest divisible unit) - -#### receiver *: str* - -The account to send the asset to - -#### clawback_target *: str | None* *= None* - -The account to take the asset from, defaults to None - -#### close_asset_to *: str | None* *= None* - -The account to close the asset to, defaults to None - -### *class* algokit_utils.transactions.transaction_composer.AssetOptInParams - -Bases: `_CommonTxnParams` - -Parameters for opting into an asset. - -#### asset_id *: int* - -The ID of the asset - -### *class* algokit_utils.transactions.transaction_composer.AssetOptOutParams - -Bases: `_CommonTxnParams` - -Parameters for opting out of an asset. - -#### asset_id *: int* - -The ID of the asset - -#### creator *: str* - -The creator address of the asset - -### *class* algokit_utils.transactions.transaction_composer.AppCallParams - -Bases: `_CommonTxnParams` - -Parameters for calling an application. - -#### on_complete *: algosdk.transaction.OnComplete* - -The OnComplete action, defaults to None - -#### app_id *: int | None* *= None* - -The ID of the application, defaults to None - -#### approval_program *: str | bytes | None* *= None* - -The program to execute for all OnCompletes other than ClearState, defaults to None - -#### clear_state_program *: str | bytes | None* *= None* - -The program to execute for ClearState OnComplete, defaults to None - -#### schema *: dict[str, int] | None* *= None* - -The state schema for the app, defaults to None - -#### args *: list[bytes] | None* *= None* - -Application arguments, defaults to None - -#### account_references *: list[str] | None* *= None* - -Account references, defaults to None - -#### app_references *: list[int] | None* *= None* - -App references, defaults to None - -#### asset_references *: list[int] | None* *= None* - -Asset references, defaults to None - -#### extra_pages *: int | None* *= None* - -Number of extra pages required for the programs, defaults to None - -#### box_references *: list[[algokit_utils.models.state.BoxReference](../../models/state/index.md#algokit_utils.models.state.BoxReference) | algokit_utils.models.state.BoxIdentifier] | None* *= None* - -Box references, defaults to None - -### *class* algokit_utils.transactions.transaction_composer.AppCreateSchema - -Bases: `TypedDict` - -dict() -> new empty dictionary -dict(mapping) -> new dictionary initialized from a mapping object’s - -> (key, value) pairs - -dict(iterable) -> new dictionary initialized as if via: -: d = {} - for k, v in iterable: -
- > d[k] = v - -dict( - -``` -** -``` - -kwargs) -> new dictionary initialized with the name=value pairs -: in the keyword argument list. For example: dict(one=1, two=2) - -#### global_ints *: int* - -The number of global ints in the schema - -#### global_byte_slices *: int* - -The number of global byte slices in the schema - -#### local_ints *: int* - -The number of local ints in the schema - -#### local_byte_slices *: int* - -The number of local byte slices in the schema - -### *class* algokit_utils.transactions.transaction_composer.AppCreateParams - -Bases: `_CommonTxnParams` - -Parameters for creating an application. - -#### approval_program *: str | bytes* - -The program to execute for all OnCompletes other than ClearState - -#### clear_state_program *: str | bytes* - -The program to execute for ClearState OnComplete - -#### schema *: [AppCreateSchema](#algokit_utils.transactions.transaction_composer.AppCreateSchema) | None* *= None* - -The state schema for the app, defaults to None - -#### on_complete *: algosdk.transaction.OnComplete | None* *= None* - -The OnComplete action, defaults to None - -#### args *: list[bytes] | None* *= None* - -Application arguments, defaults to None - -#### account_references *: list[str] | None* *= None* - -Account references, defaults to None - -#### app_references *: list[int] | None* *= None* - -App references, defaults to None - -#### asset_references *: list[int] | None* *= None* - -Asset references, defaults to None - -#### box_references *: list[[algokit_utils.models.state.BoxReference](../../models/state/index.md#algokit_utils.models.state.BoxReference) | algokit_utils.models.state.BoxIdentifier] | None* *= None* - -Box references, defaults to None - -#### extra_program_pages *: int | None* *= None* - -Number of extra pages required for the programs, defaults to None - -### *class* algokit_utils.transactions.transaction_composer.AppUpdateParams - -Bases: `_CommonTxnParams` - -Parameters for updating an application. - -#### app_id *: int* - -The ID of the application - -#### approval_program *: str | bytes* - -The program to execute for all OnCompletes other than ClearState - -#### clear_state_program *: str | bytes* - -The program to execute for ClearState OnComplete - -#### args *: list[bytes] | None* *= None* - -Application arguments, defaults to None - -#### account_references *: list[str] | None* *= None* - -Account references, defaults to None - -#### app_references *: list[int] | None* *= None* - -App references, defaults to None - -#### asset_references *: list[int] | None* *= None* - -Asset references, defaults to None - -#### box_references *: list[[algokit_utils.models.state.BoxReference](../../models/state/index.md#algokit_utils.models.state.BoxReference) | algokit_utils.models.state.BoxIdentifier] | None* *= None* - -Box references, defaults to None - -#### on_complete *: algosdk.transaction.OnComplete | None* *= None* - -The OnComplete action, defaults to None - -### *class* algokit_utils.transactions.transaction_composer.AppDeleteParams - -Bases: `_CommonTxnParams` - -Parameters for deleting an application. - -#### app_id *: int* - -The ID of the application - -#### args *: list[bytes] | None* *= None* - -Application arguments, defaults to None - -#### account_references *: list[str] | None* *= None* - -Account references, defaults to None - -#### app_references *: list[int] | None* *= None* - -App references, defaults to None - -#### asset_references *: list[int] | None* *= None* - -Asset references, defaults to None - -#### box_references *: list[[algokit_utils.models.state.BoxReference](../../models/state/index.md#algokit_utils.models.state.BoxReference) | algokit_utils.models.state.BoxIdentifier] | None* *= None* - -Box references, defaults to None - -#### on_complete *: algosdk.transaction.OnComplete* - -The OnComplete action, defaults to DeleteApplicationOC - -### *class* algokit_utils.transactions.transaction_composer.AppCallMethodCallParams - -Bases: `_BaseAppMethodCall` - -Parameters for a regular ABI method call. - -#### app_id *: int* - -The ID of the application - -#### on_complete *: algosdk.transaction.OnComplete | None* *= None* - -The OnComplete action, defaults to None - -### *class* algokit_utils.transactions.transaction_composer.AppCreateMethodCallParams - -Bases: `_BaseAppMethodCall` - -Parameters for an ABI method call that creates an application. - -#### approval_program *: str | bytes* - -The program to execute for all OnCompletes other than ClearState - -#### clear_state_program *: str | bytes* - -The program to execute for ClearState OnComplete - -#### schema *: [AppCreateSchema](#algokit_utils.transactions.transaction_composer.AppCreateSchema) | None* *= None* - -The state schema for the app, defaults to None - -#### on_complete *: algosdk.transaction.OnComplete | None* *= None* - -The OnComplete action (cannot be ClearState), defaults to None - -#### extra_program_pages *: int | None* *= None* - -Number of extra pages required for the programs, defaults to None - -### *class* algokit_utils.transactions.transaction_composer.AppUpdateMethodCallParams - -Bases: `_BaseAppMethodCall` - -Parameters for an ABI method call that updates an application. - -#### app_id *: int* - -The ID of the application - -#### approval_program *: str | bytes* - -The program to execute for all OnCompletes other than ClearState - -#### clear_state_program *: str | bytes* - -The program to execute for ClearState OnComplete - -#### on_complete *: algosdk.transaction.OnComplete* - -The OnComplete action - -### *class* algokit_utils.transactions.transaction_composer.AppDeleteMethodCallParams - -Bases: `_BaseAppMethodCall` - -Parameters for an ABI method call that deletes an application. - -#### app_id *: int* - -The ID of the application - -#### on_complete *: algosdk.transaction.OnComplete* - -The OnComplete action - -### algokit_utils.transactions.transaction_composer.MethodCallParams - -### algokit_utils.transactions.transaction_composer.AppMethodCallTransactionArgument - -### algokit_utils.transactions.transaction_composer.TxnParams - -### *class* algokit_utils.transactions.transaction_composer.BuiltTransactions - -Set of transactions built by TransactionComposer. - -#### transactions *: list[algosdk.transaction.Transaction]* - -The built transactions - -#### method_calls *: dict[int, algosdk.abi.Method]* - -Map of transaction index to ABI method - -#### signers *: dict[int, algosdk.atomic_transaction_composer.TransactionSigner]* - -Map of transaction index to TransactionSigner - -### *class* algokit_utils.transactions.transaction_composer.TransactionComposerBuildResult - -Result of building transactions with TransactionComposer. - -#### atc *: algosdk.atomic_transaction_composer.AtomicTransactionComposer* - -The AtomicTransactionComposer instance - -#### transactions *: list[algosdk.atomic_transaction_composer.TransactionWithSigner]* - -The list of transactions with signers - -#### method_calls *: dict[int, algosdk.abi.Method]* - -Map of transaction index to ABI method - -### *class* algokit_utils.transactions.transaction_composer.SendAtomicTransactionComposerResults - -Results from sending an AtomicTransactionComposer transaction group. - -#### group_id *: str* - -The group ID if this was a transaction group - -#### confirmations *: list[algosdk.v2client.algod.AlgodResponseType]* - -The confirmation info for each transaction - -#### tx_ids *: list[str]* - -The transaction IDs that were sent - -#### transactions *: list[[algokit_utils.models.transaction.TransactionWrapper](../../models/transaction/index.md#algokit_utils.models.transaction.TransactionWrapper)]* - -The transactions that were sent - -#### returns *: list[[algokit_utils.applications.abi.ABIReturn](../../applications/abi/index.md#algokit_utils.applications.abi.ABIReturn)]* - -The ABI return values from any ABI method calls - -#### simulate_response *: dict[str, Any] | None* *= None* - -The simulation response if simulation was performed, defaults to None - -### algokit_utils.transactions.transaction_composer.calculate_extra_program_pages(approval: bytes | None, clear: bytes | None) → int - -Calculate minimum number of extra_pages required for provided approval and clear programs - -### algokit_utils.transactions.transaction_composer.populate_app_call_resources(atc: algosdk.atomic_transaction_composer.AtomicTransactionComposer, algod: algosdk.v2client.algod.AlgodClient) → algosdk.atomic_transaction_composer.AtomicTransactionComposer - -Populate application call resources based on simulation results. - -* **Parameters:** - * **atc** – The AtomicTransactionComposer containing transactions - * **algod** – Algod client for simulation -* **Returns:** - Modified AtomicTransactionComposer with populated resources - -### algokit_utils.transactions.transaction_composer.prepare_group_for_sending(atc: algosdk.atomic_transaction_composer.AtomicTransactionComposer, algod: algosdk.v2client.algod.AlgodClient, populate_app_call_resources: bool | None = None, cover_app_call_inner_transaction_fees: bool | None = None, additional_atc_context: AdditionalAtcContext | None = None) → algosdk.atomic_transaction_composer.AtomicTransactionComposer - -Take an existing Atomic Transaction Composer and return a new one with changes applied to the transactions -based on the supplied parameters to prepare it for sending. -Please note, that before calling .execute() on the returned ATC, you must call .build_group(). - -* **Parameters:** - * **atc** – The AtomicTransactionComposer containing transactions - * **algod** – Algod client for simulation - * **populate_app_call_resources** – Whether to populate app call resources - * **cover_app_call_inner_transaction_fees** – Whether to cover inner txn fees - * **additional_atc_context** – Additional context for the AtomicTransactionComposer -* **Returns:** - Modified AtomicTransactionComposer ready for sending - -### algokit_utils.transactions.transaction_composer.send_atomic_transaction_composer(atc: algosdk.atomic_transaction_composer.AtomicTransactionComposer, algod: algosdk.v2client.algod.AlgodClient, \*, max_rounds_to_wait: int | None = 5, skip_waiting: bool = False, suppress_log: bool | None = None, populate_app_call_resources: bool | None = None, cover_app_call_inner_transaction_fees: bool | None = None, additional_atc_context: AdditionalAtcContext | None = None) → [SendAtomicTransactionComposerResults](#algokit_utils.transactions.transaction_composer.SendAtomicTransactionComposerResults) - -Send an AtomicTransactionComposer transaction group. - -Executes a group of transactions atomically using the AtomicTransactionComposer. - -* **Parameters:** - * **atc** – The AtomicTransactionComposer instance containing the transaction group to send - * **algod** – The Algod client to use for sending the transactions - * **max_rounds_to_wait** – Maximum number of rounds to wait for confirmation, defaults to 5 - * **skip_waiting** – If True, don’t wait for transaction confirmation, defaults to False - * **suppress_log** – If True, suppress logging, defaults to None - * **populate_app_call_resources** – If True, populate app call resources, defaults to None - * **cover_app_call_inner_transaction_fees** – If True, cover app call inner transaction fees, defaults to None - * **additional_atc_context** – Additional context for the AtomicTransactionComposer -* **Returns:** - Results from sending the transaction group -* **Raises:** - * **Exception** – If there is an error sending the transactions - * **error** – If there is an error from the Algorand node - -### *class* algokit_utils.transactions.transaction_composer.TransactionComposer(algod: algosdk.v2client.algod.AlgodClient, get_signer: collections.abc.Callable[[str], algosdk.atomic_transaction_composer.TransactionSigner], get_suggested_params: collections.abc.Callable[[], algosdk.transaction.SuggestedParams] | None = None, default_validity_window: int | None = None, app_manager: [algokit_utils.applications.app_manager.AppManager](../../applications/app_manager/index.md#algokit_utils.applications.app_manager.AppManager) | None = None, error_transformers: list[ErrorTransformer] | None = None) - -A class for composing and managing Algorand transactions. - -Provides a high-level interface for building and executing transaction groups using the Algosdk library. -Supports various transaction types including payments, asset operations, application calls, and key registrations. - -* **Parameters:** - * **algod** – An instance of AlgodClient used to get suggested params and send transactions - * **get_signer** – A function that takes an address and returns a TransactionSigner for that address - * **get_suggested_params** – Optional function to get suggested transaction parameters, - defaults to using algod.suggested_params() - * **default_validity_window** – Optional default validity window for transactions in rounds, defaults to 10 - * **app_manager** – Optional AppManager instance for compiling TEAL programs, defaults to None - * **error_transformers** – Optional list of error transformers to use when an error is caught in simulate or send - -#### register_error_transformer(transformer: ErrorTransformer) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Register a function that will be used to transform an error caught when simulating or sending. - -* **Parameters:** - **transformer** – The error transformer function -* **Returns:** - The composer so you can chain method calls - -#### add_transaction(transaction: algosdk.transaction.Transaction, signer: algosdk.atomic_transaction_composer.TransactionSigner | None = None) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Add a raw transaction to the composer. - -* **Parameters:** - * **transaction** – The transaction to add - * **signer** – Optional transaction signer, defaults to getting signer from transaction sender -* **Returns:** - The transaction composer instance for chaining -* **Example:** - ```python - composer.add_transaction(transaction) - ``` - -#### add_payment(params: [PaymentParams](#algokit_utils.transactions.transaction_composer.PaymentParams)) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Add a payment transaction. - -* **Example:** - ```python - params = PaymentParams( - sender="SENDER_ADDRESS", - receiver="RECEIVER_ADDRESS", - amount=AlgoAmount.from_algo(1), - close_remainder_to="CLOSE_ADDRESS" - ... (see PaymentParams for more options) - ) - composer.add_payment(params) - ``` -* **Parameters:** - **params** – The payment transaction parameters -* **Returns:** - The transaction composer instance for chaining - -#### add_asset_create(params: [AssetCreateParams](#algokit_utils.transactions.transaction_composer.AssetCreateParams)) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Add an asset creation transaction. - -* **Example:** - ```python - params = AssetCreateParams( - sender="SENDER_ADDRESS", - total=1000, - asset_name="MyAsset", - unit_name="MA", - url="https://example.com", - decimals=0, - default_frozen=False, - manager="MANAGER_ADDRESS", - reserve="RESERVE_ADDRESS", - freeze="FREEZE_ADDRESS", - clawback="CLAWBACK_ADDRESS" - ... (see AssetCreateParams for more options) - composer.add_asset_create(params) - ``` -* **Parameters:** - **params** – The asset creation parameters -* **Returns:** - The transaction composer instance for chaining - -#### add_asset_config(params: [AssetConfigParams](#algokit_utils.transactions.transaction_composer.AssetConfigParams)) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Add an asset configuration transaction. - -* **Example:** - ```python - params = AssetConfigParams( - sender="SENDER_ADDRESS", - asset_id=123456, - manager="NEW_MANAGER_ADDRESS", - reserve="NEW_RESERVE_ADDRESS", - freeze="NEW_FREEZE_ADDRESS", - clawback="NEW_CLAWBACK_ADDRESS" - ... (see AssetConfigParams for more options) - ) - composer.add_asset_config(params) - ``` -* **Parameters:** - **params** – The asset configuration parameters -* **Returns:** - The transaction composer instance for chaining - -#### add_asset_freeze(params: [AssetFreezeParams](#algokit_utils.transactions.transaction_composer.AssetFreezeParams)) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Add an asset freeze transaction. - -* **Example:** - ```python - params = AssetFreezeParams( - sender="SENDER_ADDRESS", - asset_id=123456, - account="ACCOUNT_TO_FREEZE", - frozen=True - ... (see AssetFreezeParams for more options) - ) - composer.add_asset_freeze(params) - ``` -* **Parameters:** - **params** – The asset freeze parameters -* **Returns:** - The transaction composer instance for chaining - -#### add_asset_destroy(params: [AssetDestroyParams](#algokit_utils.transactions.transaction_composer.AssetDestroyParams)) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Add an asset destruction transaction. - -* **Example:** - ```python - params = AssetDestroyParams( - sender="SENDER_ADDRESS", - asset_id=123456 - ... (see AssetDestroyParams for more options) - composer.add_asset_destroy(params) - ``` -* **Parameters:** - **params** – The asset destruction parameters -* **Returns:** - The transaction composer instance for chaining - -#### add_asset_transfer(params: [AssetTransferParams](#algokit_utils.transactions.transaction_composer.AssetTransferParams)) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Add an asset transfer transaction. - -* **Example:** - ```python - params = AssetTransferParams( - sender="SENDER_ADDRESS", - asset_id=123456, - amount=10, - receiver="RECEIVER_ADDRESS", - clawback_target="CLAWBACK_TARGET_ADDRESS", - close_asset_to="CLOSE_ADDRESS" - ... (see AssetTransferParams for more options) - composer.add_asset_transfer(params) - ``` -* **Parameters:** - **params** – The asset transfer parameters -* **Returns:** - The transaction composer instance for chaining - -#### add_asset_opt_in(params: [AssetOptInParams](#algokit_utils.transactions.transaction_composer.AssetOptInParams)) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Add an asset opt-in transaction. - -* **Example:** - ```python - params = AssetOptInParams( - sender="SENDER_ADDRESS", - asset_id=123456 - ... (see AssetOptInParams for more options) - ) - composer.add_asset_opt_in(params) - ``` -* **Parameters:** - **params** – The asset opt-in parameters -* **Returns:** - The transaction composer instance for chaining - -#### add_asset_opt_out(params: [AssetOptOutParams](#algokit_utils.transactions.transaction_composer.AssetOptOutParams)) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Add an asset opt-out transaction. - -* **Example:** - ```python - params = AssetOptOutParams( - sender="SENDER_ADDRESS", - asset_id=123456, - creator="CREATOR_ADDRESS" - ... (see AssetOptOutParams for more options) - composer.add_asset_opt_out(params) - ``` -* **Parameters:** - **params** – The asset opt-out parameters -* **Returns:** - The transaction composer instance for chaining - -#### add_app_create(params: [AppCreateParams](#algokit_utils.transactions.transaction_composer.AppCreateParams)) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Add an application creation transaction. - -* **Example:** - ```python - params = AppCreateParams( - sender="SENDER_ADDRESS", - approval_program="TEAL_APPROVAL_CODE", - clear_state_program="TEAL_CLEAR_CODE", - schema={'global_ints': 1, 'global_byte_slices': 1, 'local_ints': 1, 'local_byte_slices': 1}, - on_complete=OnComplete.NoOpOC, - args=[b'arg1'], - account_references=["ACCOUNT1"], - app_references=[789], - asset_references=[123], - box_references=[], - extra_program_pages=0 - ... (see AppCreateParams for more options) - ) - composer.add_app_create(params) - ``` -* **Parameters:** - **params** – The application creation parameters -* **Returns:** - The transaction composer instance for chaining - -#### add_app_update(params: [AppUpdateParams](#algokit_utils.transactions.transaction_composer.AppUpdateParams)) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Add an application update transaction. - -* **Example:** - ```python - params = AppUpdateParams( - sender="SENDER_ADDRESS", - app_id=789, - approval_program="TEAL_NEW_APPROVAL_CODE", - clear_state_program="TEAL_NEW_CLEAR_CODE", - args=[b'new_arg1'], - account_references=["ACCOUNT1"], - app_references=[789], - asset_references=[123], - box_references=[], - on_complete=OnComplete.UpdateApplicationOC - ... (see AppUpdateParams for more options) - composer.add_app_update(params) - ``` -* **Parameters:** - **params** – The application update parameters -* **Returns:** - The transaction composer instance for chaining - -#### add_app_delete(params: [AppDeleteParams](#algokit_utils.transactions.transaction_composer.AppDeleteParams)) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Add an application deletion transaction. - -* **Example:** - ```python - params = AppDeleteParams( - sender="SENDER_ADDRESS", - app_id=789, - args=[b'delete_arg'], - account_references=["ACCOUNT1"], - app_references=[789], - asset_references=[123], - box_references=[], - on_complete=OnComplete.DeleteApplicationOC - ... (see AppDeleteParams for more options) - composer.add_app_delete(params) - ``` -* **Parameters:** - **params** – The application deletion parameters -* **Returns:** - The transaction composer instance for chaining - -#### add_app_call(params: [AppCallParams](#algokit_utils.transactions.transaction_composer.AppCallParams)) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Add an application call transaction. - -* **Example:** - ```python - params = AppCallParams( - sender="SENDER_ADDRESS", - on_complete=OnComplete.NoOpOC, - app_id=789, - approval_program="TEAL_APPROVAL_CODE", - clear_state_program="TEAL_CLEAR_CODE", - schema={'global_ints': 1, 'global_byte_slices': 1, 'local_ints': 1, 'local_byte_slices': 1}, - ... (see AppCallParams for more options) - ) - composer.add_app_call(params) - ``` -* **Parameters:** - **params** – The application call parameters -* **Returns:** - The transaction composer instance for chaining - -#### add_app_create_method_call(params: [AppCreateMethodCallParams](#algokit_utils.transactions.transaction_composer.AppCreateMethodCallParams)) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Add an application creation method call transaction. - -* **Parameters:** - **params** – The application creation method call parameters -* **Returns:** - The transaction composer instance for chaining -* **Example:** - ```python - # Basic example - method = algosdk.abi.Method( - name="method", - args=[...], - returns="string" - ) - composer.add_app_create_method_call( - AppCreateMethodCallParams( - sender="CREATORADDRESS", - approval_program="TEALCODE", - clear_state_program="TEALCODE", - method=method, - args=["arg1_value"] - ) - ) - - # Advanced example - method = ABIMethod( - name="method", - args=[{"name": "arg1", "type": "string"}], - returns={"type": "string"} - ) - composer.add_app_create_method_call( - AppCreateMethodCallParams( - sender="CREATORADDRESS", - method=method, - args=["arg1_value"], - approval_program="TEALCODE", - clear_state_program="TEALCODE", - schema={ - "global_ints": 1, - "global_byte_slices": 2, - "local_ints": 3, - "local_byte_slices": 4 - }, - extra_pages=1, - on_complete=OnComplete.OptInOC, - args=[bytes([1, 2, 3, 4])], - account_references=["ACCOUNT_1"], - app_references=[123, 1234], - asset_references=[12345], - box_references=["box1", {"app_id": 1234, "name": "box2"}], - lease="lease", - note="note", - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount.from_micro_algos(1000), - static_fee=AlgoAmount.from_micro_algos(1000), - max_fee=AlgoAmount.from_micro_algos(3000) - ) - ) - ``` - -#### add_app_update_method_call(params: [AppUpdateMethodCallParams](#algokit_utils.transactions.transaction_composer.AppUpdateMethodCallParams)) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Add an application update method call transaction. - -* **Parameters:** - **params** – The application update method call parameters -* **Returns:** - The transaction composer instance for chaining - -#### add_app_delete_method_call(params: [AppDeleteMethodCallParams](#algokit_utils.transactions.transaction_composer.AppDeleteMethodCallParams)) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Add an application deletion method call transaction. - -* **Parameters:** - **params** – The application deletion method call parameters -* **Returns:** - The transaction composer instance for chaining - -#### add_app_call_method_call(params: [AppCallMethodCallParams](#algokit_utils.transactions.transaction_composer.AppCallMethodCallParams)) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Add an application call method call transaction. - -* **Parameters:** - **params** – The application call method call parameters -* **Returns:** - The transaction composer instance for chaining - -#### add_online_key_registration(params: [OnlineKeyRegistrationParams](#algokit_utils.transactions.transaction_composer.OnlineKeyRegistrationParams)) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Add an online key registration transaction. - -* **Parameters:** - **params** – The online key registration parameters -* **Returns:** - The transaction composer instance for chaining - -#### add_offline_key_registration(params: [OfflineKeyRegistrationParams](#algokit_utils.transactions.transaction_composer.OfflineKeyRegistrationParams)) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Add an offline key registration transaction. - -* **Parameters:** - **params** – The offline key registration parameters -* **Returns:** - The transaction composer instance for chaining - -#### add_atc(atc: algosdk.atomic_transaction_composer.AtomicTransactionComposer) → [TransactionComposer](#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Add an existing AtomicTransactionComposer’s transactions. - -* **Parameters:** - **atc** – The AtomicTransactionComposer to add -* **Returns:** - The transaction composer instance for chaining -* **Example:** - ```python - atc = AtomicTransactionComposer() - atc.add_transaction(TransactionWithSigner(transaction, signer)) - composer.add_atc(atc) - ``` - -#### count() → int - -Get the total number of transactions. - -* **Returns:** - The number of transactions - -#### build() → [TransactionComposerBuildResult](#algokit_utils.transactions.transaction_composer.TransactionComposerBuildResult) - -Build the transaction group. - -* **Returns:** - The built transaction group result - -#### rebuild() → [TransactionComposerBuildResult](#algokit_utils.transactions.transaction_composer.TransactionComposerBuildResult) - -Rebuild the transaction group from scratch. - -* **Returns:** - The rebuilt transaction group result - -#### build_transactions() → [BuiltTransactions](#algokit_utils.transactions.transaction_composer.BuiltTransactions) - -Build and return the transactions without executing them. - -* **Returns:** - The built transactions result - -#### execute(\*, max_rounds_to_wait: int | None = None) → [SendAtomicTransactionComposerResults](#algokit_utils.transactions.transaction_composer.SendAtomicTransactionComposerResults) - -#### send(params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → [SendAtomicTransactionComposerResults](#algokit_utils.transactions.transaction_composer.SendAtomicTransactionComposerResults) - -Send the transaction group to the network. - -* **Parameters:** - **params** – Parameters for the send operation -* **Returns:** - The transaction send results -* **Raises:** - **self._transform_error** – If the transaction fails (may be transformed by error transformers) - -#### simulate(allow_more_logs: bool | None = None, allow_empty_signatures: bool | None = None, allow_unnamed_resources: bool | None = None, extra_opcode_budget: int | None = None, exec_trace_config: algosdk.v2client.models.SimulateTraceConfig | None = None, simulation_round: int | None = None, skip_signatures: bool | None = None) → [SendAtomicTransactionComposerResults](#algokit_utils.transactions.transaction_composer.SendAtomicTransactionComposerResults) - -Simulate transaction group execution with configurable validation rules. - -* **Parameters:** - * **allow_more_logs** – Whether to allow more logs than the standard limit - * **allow_empty_signatures** – Whether to allow transactions with empty signatures - * **allow_unnamed_resources** – Whether to allow unnamed resources. - * **extra_opcode_budget** – Additional opcode budget to allocate - * **exec_trace_config** – Configuration for execution tracing - * **simulation_round** – Round number to simulate at - * **skip_signatures** – Whether to skip signature validation -* **Returns:** - The simulation results -* **Example:** - ```python - result = composer.simulate(extra_opcode_budget=1000, skip_signatures=True, ...) - ``` - -#### *static* arc2_note(note: algokit_utils.models.transaction.Arc2TransactionNote) → bytes - -Create an encoded transaction note that follows the ARC-2 spec. - -[https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0002.md](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0002.md) - -* **Parameters:** - **note** – The ARC-2 note to encode -* **Returns:** - The encoded note bytes -* **Raises:** - **ValueError** – If the dapp_name is invalid diff --git a/docs/markdown/autoapi/algokit_utils/transactions/transaction_creator/index.md b/docs/markdown/autoapi/algokit_utils/transactions/transaction_creator/index.md deleted file mode 100644 index 9635b6e4..00000000 --- a/docs/markdown/autoapi/algokit_utils/transactions/transaction_creator/index.md +++ /dev/null @@ -1,666 +0,0 @@ -# algokit_utils.transactions.transaction_creator - -## Classes - -| [`AlgorandClientTransactionCreator`](#algokit_utils.transactions.transaction_creator.AlgorandClientTransactionCreator) | A creator for Algorand transactions. | -|--------------------------------------------------------------------------------------------------------------------------|----------------------------------------| - -## Module Contents - -### *class* algokit_utils.transactions.transaction_creator.AlgorandClientTransactionCreator(new_group: collections.abc.Callable[[], [algokit_utils.transactions.transaction_composer.TransactionComposer](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.TransactionComposer)]) - -A creator for Algorand transactions. - -Provides methods to create various types of Algorand transactions including payments, -asset operations, application calls and key registrations. - -* **Parameters:** - **new_group** – A lambda that starts a new TransactionComposer transaction group -* **Example:** - ```python - creator = AlgorandClientTransactionCreator(lambda: TransactionComposer()) - creator.payment(PaymentParams(sender="sender", receiver="receiver", amount=AlgoAmount.from_algo(1))) - ``` - -#### *property* payment *: collections.abc.Callable[[[algokit_utils.transactions.transaction_composer.PaymentParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.PaymentParams)], algosdk.transaction.Transaction]* - -Create a payment transaction to transfer Algo between accounts. - -* **Example:** - ```python - #Basic example - creator = AlgorandClientTransactionCreator(lambda: TransactionComposer()) - creator.payment(PaymentParams(sender="sender", receiver="receiver", amount=AlgoAmount.from_algo(4))) - ``` -* **Example:** - ```python - #Advanced example - creator.payment(PaymentParams( - sender="SENDERADDRESS", - receiver="RECEIVERADDRESS", - amount=AlgoAmount.from_algo(4), - close_remainder_to="CLOSEREMAINDERTOADDRESS", - lease="lease", - note=b"note", - rekey_to="REKEYTOADDRESS", - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount.from_micro_algo(1000), - static_fee=AlgoAmount.from_micro_algo(1000), - max_fee=AlgoAmount.from_micro_algo(3000) - )) - ``` - -#### *property* asset_create *: collections.abc.Callable[[[algokit_utils.transactions.transaction_composer.AssetCreateParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AssetCreateParams)], algosdk.transaction.Transaction]* - -Create a create Algorand Standard Asset transaction. - -* **Example:** - ```python - #Basic example - creator = AlgorandClientTransactionCreator(lambda: TransactionComposer()) - params = AssetCreateParams(sender="SENDER_ADDRESS", total=1000) - txn = creator.asset_create(params) - ``` -* **Example:** - ```python - #Advanced example - creator.asset_create(AssetCreateParams( - sender="SENDER_ADDRESS", - total=1000, - asset_name="MyAsset", - unit_name="MA", - url="https://example.com/asset", - decimals=0, - default_frozen=False, - manager="MANAGER_ADDRESS", - reserve="RESERVE_ADDRESS", - freeze="FREEZE_ADDRESS", - clawback="CLAWBACK_ADDRESS", - lease="lease", - note=b"note", - rekey_to="REKEYTOADDRESS", - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount.from_micro_algo(1000), - static_fee=AlgoAmount.from_micro_algo(1000), - max_fee=AlgoAmount.from_micro_algo(3000) - )) - ``` - -#### *property* asset_config *: collections.abc.Callable[[[algokit_utils.transactions.transaction_composer.AssetConfigParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AssetConfigParams)], algosdk.transaction.Transaction]* - -Create an asset config transaction to reconfigure an existing Algorand Standard Asset. - -* **Example:** - ```python - #Basic example - creator = AlgorandClientTransactionCreator(lambda: TransactionComposer()) - params = AssetConfigParams(sender="SENDER_ADDRESS", asset_id=123456, manager="NEW_MANAGER_ADDRESS") - txn = creator.asset_config(params) - ``` -* **Example:** - ```python - #Advanced example - creator.asset_config(AssetConfigParams( - sender="SENDER_ADDRESS", - asset_id=123456, - manager="NEW_MANAGER_ADDRESS", - reserve="NEW_RESERVE_ADDRESS", - freeze="NEW_FREEZE_ADDRESS", - clawback="NEW_CLAWBACK_ADDRESS", - lease="lease", - note=b"note", - rekey_to="REKEYTOADDRESS", - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount.from_micro_algo(1000), - static_fee=AlgoAmount.from_micro_algo(1000), - max_fee=AlgoAmount.from_micro_algo(3000) - )) - ``` - -#### *property* asset_freeze *: collections.abc.Callable[[[algokit_utils.transactions.transaction_composer.AssetFreezeParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AssetFreezeParams)], algosdk.transaction.Transaction]* - -Create an Algorand Standard Asset freeze transaction. - -* **Example:** - ```python - #Basic example - creator = AlgorandClientTransactionCreator(lambda: TransactionComposer()) - params = AssetFreezeParams(sender="SENDER_ADDRESS", - asset_id=123456, - account="ACCOUNT_TO_FREEZE", - frozen=True) - txn = creator.asset_freeze(params) - ``` -* **Example:** - ```python - #Advanced example - creator.asset_freeze(AssetFreezeParams( - sender="SENDER_ADDRESS", - asset_id=123456, - account="ACCOUNT_TO_FREEZE", - frozen=True, - lease="lease", - note=b"note", - rekey_to="REKEYTOADDRESS", - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount.from_micro_algo(1000), - static_fee=AlgoAmount.from_micro_algo(1000), - max_fee=AlgoAmount.from_micro_algo(3000) - )) - ``` - -#### *property* asset_destroy *: collections.abc.Callable[[[algokit_utils.transactions.transaction_composer.AssetDestroyParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AssetDestroyParams)], algosdk.transaction.Transaction]* - -Create an Algorand Standard Asset destroy transaction. - -* **Example:** - ```python - #Basic example - creator = AlgorandClientTransactionCreator(lambda: TransactionComposer()) - params = AssetDestroyParams(sender="SENDER_ADDRESS", asset_id=123456) - txn = creator.asset_destroy(params) - ``` -* **Example:** - ```python - #Advanced example - creator.asset_destroy(AssetDestroyParams( - sender="SENDER_ADDRESS", - asset_id=123456, - lease="lease", - note=b"note", - rekey_to="REKEYTOADDRESS", - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount.from_micro_algo(1000), - static_fee=AlgoAmount.from_micro_algo(1000), - max_fee=AlgoAmount.from_micro_algo(3000) - )) - ``` - -#### *property* asset_transfer *: collections.abc.Callable[[[algokit_utils.transactions.transaction_composer.AssetTransferParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AssetTransferParams)], algosdk.transaction.Transaction]* - -Create an Algorand Standard Asset transfer transaction. - -* **Example:** - ```python - #Basic example - creator = AlgorandClientTransactionCreator(lambda: TransactionComposer()) - params = AssetTransferParams(sender="SENDER_ADDRESS", - asset_id=123456, - amount=10, - receiver="RECEIVER_ADDRESS") - txn = creator.asset_transfer(params) - ``` -* **Example:** - ```python - #Advanced example - creator.asset_transfer(AssetTransferParams( - sender="SENDER_ADDRESS", - asset_id=123456, - amount=10, - receiver="RECEIVER_ADDRESS", - clawback_target="CLAWBACK_TARGET_ADDRESS", - close_asset_to="CLOSE_ASSET_TO_ADDRESS", - lease="lease", - note=b"note", - rekey_to="REKEYTOADDRESS", - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount.from_micro_algo(1000), - static_fee=AlgoAmount.from_micro_algo(1000), - max_fee=AlgoAmount.from_micro_algo(3000) - )) - ``` - -#### *property* asset_opt_in *: collections.abc.Callable[[[algokit_utils.transactions.transaction_composer.AssetOptInParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AssetOptInParams)], algosdk.transaction.Transaction]* - -Create an Algorand Standard Asset opt-in transaction. - -* **Example:** - ```python - # Basic example - creator = AlgorandClientTransactionCreator(lambda: TransactionComposer()) - params = AssetOptInParams(sender="SENDER_ADDRESS", asset_id=123456) - txn = creator.asset_opt_in(params) - ``` -* **Example:** - ```python - # Advanced example - creator.asset_opt_in(AssetOptInParams( - sender="SENDER_ADDRESS", - asset_id=123456, - lease="lease", - note=b"note", - rekey_to="REKEYTOADDRESS", - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount.from_micro_algo(1000), - static_fee=AlgoAmount.from_micro_algo(1000), - max_fee=AlgoAmount.from_micro_algo(3000) - )) - ``` - -#### *property* asset_opt_out *: collections.abc.Callable[[[algokit_utils.transactions.transaction_composer.AssetOptOutParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AssetOptOutParams)], algosdk.transaction.Transaction]* - -Create an asset opt-out transaction. - -* **Example:** - ```python - #Basic example - creator = AlgorandClientTransactionCreator(lambda: TransactionComposer()) - params = AssetOptOutParams(sender="SENDER_ADDRESS", asset_id=123456, creator="CREATOR_ADDRESS") - txn = creator.asset_opt_out(params) - ``` -* **Example:** - ```python - #Advanced example - creator.asset_opt_out(AssetOptOutParams( - sender="SENDER_ADDRESS", - asset_id=123456, - creator="CREATOR_ADDRESS", - lease="lease", - note=b"note", - rekey_to="REKEYTOADDRESS", - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount.from_micro_algo(1000), - static_fee=AlgoAmount.from_micro_algo(1000), - max_fee=AlgoAmount.from_micro_algo(3000) - )) - ``` - -#### *property* app_create *: collections.abc.Callable[[[algokit_utils.transactions.transaction_composer.AppCreateParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppCreateParams)], algosdk.transaction.Transaction]* - -Create an application create transaction. - -* **Example:** - ```python - #Basic example - creator = AlgorandClientTransactionCreator(lambda: TransactionComposer()) - params = AppCreateParams( - sender="SENDER_ADDRESS", - approval_program="TEAL_APPROVAL_CODE", - clear_state_program="TEAL_CLEAR_CODE", - schema={ - 'global_ints': 1, - 'global_byte_slices': 1, - 'local_ints': 1, - 'local_byte_slices': 1 - } - ) - txn = creator.app_create(params) - ``` -* **Example:** - ```python - #Advanced example - creator.app_create(AppCreateParams( - sender="SENDER_ADDRESS", - approval_program="TEAL_APPROVAL_CODE", - clear_state_program="TEAL_CLEAR_CODE", - schema={'global_ints': 1, 'global_byte_slices': 1, 'local_ints': 1, 'local_byte_slices': 1}, - on_complete=OnComplete.NoOpOC, - args=[b'arg1', b'arg2'], - account_references=["ACCOUNT1"], - app_references=[789], - asset_references=[123], - box_references=[], - extra_program_pages=0, - lease="lease", - note=b"note", - rekey_to="REKEYTOADDRESS", - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount.from_micro_algo(1000), - static_fee=AlgoAmount.from_micro_algo(1000), - max_fee=AlgoAmount.from_micro_algo(3000) - )) - ``` - -#### *property* app_update *: collections.abc.Callable[[[algokit_utils.transactions.transaction_composer.AppUpdateParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppUpdateParams)], algosdk.transaction.Transaction]* - -Create an application update transaction. - -* **Example:** - ```python - #Basic example - creator = AlgorandClientTransactionCreator(lambda: TransactionComposer()) - txn = creator.app_update(AppUpdateParams(sender="SENDER_ADDRESS", - app_id=789, - approval_program="TEAL_NEW_APPROVAL_CODE", - clear_state_program="TEAL_NEW_CLEAR_CODE", - args=[b'new_arg1', b'new_arg2'])) - ``` -* **Example:** - ```python - #Advanced example - creator.app_update(AppUpdateParams( - sender="SENDER_ADDRESS", - app_id=789, - approval_program="TEAL_NEW_APPROVAL_CODE", - clear_state_program="TEAL_NEW_CLEAR_CODE", - args=[b'new_arg1', b'new_arg2'], - account_references=["ACCOUNT1"], - app_references=[789], - asset_references=[123], - box_references=[], - on_complete=OnComplete.UpdateApplicationOC, - lease="lease", - note=b"note", - rekey_to="REKEYTOADDRESS", - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount.from_micro_algo(1000), - static_fee=AlgoAmount.from_micro_algo(1000), - max_fee=AlgoAmount.from_micro_algo(3000) - )) - ``` - -#### *property* app_delete *: collections.abc.Callable[[[algokit_utils.transactions.transaction_composer.AppDeleteParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppDeleteParams)], algosdk.transaction.Transaction]* - -Create an application delete transaction. - -* **Example:** - ```python - #Basic example - creator = AlgorandClientTransactionCreator(lambda: TransactionComposer()) - params = AppDeleteParams(sender="SENDER_ADDRESS", app_id=789, args=[b'delete_arg']) - txn = creator.app_delete(params) - ``` -* **Example:** - ```python - #Advanced example - creator.app_delete(AppDeleteParams( - sender="SENDER_ADDRESS", - app_id=789, - args=[b'delete_arg'], - account_references=["ACCOUNT1"], - app_references=[789], - asset_references=[123], - box_references=[], - on_complete=OnComplete.DeleteApplicationOC, - lease="lease", - note=b"note", - rekey_to="REKEYTOADDRESS", - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount.from_micro_algo(1000), - static_fee=AlgoAmount.from_micro_algo(1000), - max_fee=AlgoAmount.from_micro_algo(3000) - )) - ``` - -#### *property* app_call *: collections.abc.Callable[[[algokit_utils.transactions.transaction_composer.AppCallParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppCallParams)], algosdk.transaction.Transaction]* - -Create an application call transaction. - -* **Example:** - ```python - #Basic example - creator = AlgorandClientTransactionCreator(lambda: TransactionComposer()) - params = AppCallParams( - sender="SENDER_ADDRESS", - on_complete=OnComplete.NoOpOC, - app_id=789, - approval_program="TEAL_APPROVAL_CODE", - clear_state_program="TEAL_CLEAR_CODE", - schema={ - 'global_ints': 1, - 'global_byte_slices': 1, - 'local_ints': 1, - 'local_byte_slices': 1 - }, - args=[b'arg1', b'arg2'], - account_references=["ACCOUNT1"], - app_references=[789], - asset_references=[123], - extra_pages=0, - box_references=[] - ) - txn = creator.app_call(params) - ``` -* **Example:** - ```python - #Advanced example - creator.app_call(AppCallParams( - sender="SENDER_ADDRESS", - on_complete=OnComplete.NoOpOC, - app_id=789, - approval_program="TEAL_APPROVAL_CODE", - clear_state_program="TEAL_CLEAR_CODE", - schema={'global_ints': 1, 'global_byte_slices': 1, 'local_ints': 1, 'local_byte_slices': 1}, - args=[b'arg1', b'arg2'], - account_references=["ACCOUNT1"], - app_references=[789], - asset_references=[123], - extra_pages=0, - box_references=[], - lease="lease", - note=b"note", - rekey_to="REKEYTOADDRESS", - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount.from_micro_algo(1000), - static_fee=AlgoAmount.from_micro_algo(1000), - max_fee=AlgoAmount.from_micro_algo(3000) - )) - ``` - -#### *property* app_create_method_call *: collections.abc.Callable[[[algokit_utils.transactions.transaction_composer.AppCreateMethodCallParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppCreateMethodCallParams)], [algokit_utils.transactions.transaction_composer.BuiltTransactions](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.BuiltTransactions)]* - -Create an application create call with ABI method call transaction. - -* **Example:** - ```python - #Basic example - creator = AlgorandClientTransactionCreator(lambda: TransactionComposer()) - params = AppCreateMethodCallParams(sender="SENDER_ADDRESS", app_id=0, method=some_abi_method_object) - built_txns = creator.app_create_method_call(params) - ``` -* **Example:** - ```python - #Advanced example - creator.app_create_method_call(AppCreateMethodCallParams( - sender="SENDER_ADDRESS", - app_id=0, - method=some_abi_method_object, - args=[b'method_arg'], - account_references=["ACCOUNT1"], - app_references=[789], - asset_references=[123], - box_references=[], - schema={'global_ints': 1, 'global_byte_slices': 1, 'local_ints': 1, 'local_byte_slices': 1}, - approval_program="TEAL_APPROVAL_CODE", - clear_state_program="TEAL_CLEAR_CODE", - on_complete=OnComplete.NoOpOC, - extra_program_pages=0, - lease="lease", - note=b"note", - rekey_to="REKEYTOADDRESS", - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount.from_micro_algo(1000), - static_fee=AlgoAmount.from_micro_algo(1000), - max_fee=AlgoAmount.from_micro_algo(3000) - )) - ``` - -#### *property* app_update_method_call *: collections.abc.Callable[[[algokit_utils.transactions.transaction_composer.AppUpdateMethodCallParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppUpdateMethodCallParams)], [algokit_utils.transactions.transaction_composer.BuiltTransactions](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.BuiltTransactions)]* - -Create an application update call with ABI method call transaction. - -* **Example:** - ```python - #Basic example - creator = AlgorandClientTransactionCreator(lambda: TransactionComposer()) - params = AppUpdateMethodCallParams(sender="SENDER_ADDRESS", app_id=789, method=some_abi_method_object) - built_txns = creator.app_update_method_call(params) - ``` -* **Example:** - ```python - #Advanced example - creator.app_update_method_call(AppUpdateMethodCallParams( - sender="SENDER_ADDRESS", - app_id=789, - method=some_abi_method_object, - args=[b'method_arg'], - account_references=["ACCOUNT1"], - app_references=[789], - asset_references=[123], - box_references=[], - schema={'global_ints': 1, 'global_byte_slices': 1, 'local_ints': 1, 'local_byte_slices': 1}, - approval_program="TEAL_NEW_APPROVAL_CODE", - clear_state_program="TEAL_NEW_CLEAR_CODE", - on_complete=OnComplete.UpdateApplicationOC, - lease="lease", - note=b"note", - rekey_to="REKEYTOADDRESS", - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount.from_micro_algo(1000), - static_fee=AlgoAmount.from_micro_algo(1000), - max_fee=AlgoAmount.from_micro_algo(3000) - )) - ``` - -#### *property* app_delete_method_call *: collections.abc.Callable[[[algokit_utils.transactions.transaction_composer.AppDeleteMethodCallParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppDeleteMethodCallParams)], [algokit_utils.transactions.transaction_composer.BuiltTransactions](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.BuiltTransactions)]* - -Create an application delete call with ABI method call transaction. - -* **Example:** - ```python - #Basic example - creator = AlgorandClientTransactionCreator(lambda: TransactionComposer()) - params = AppDeleteMethodCallParams(sender="SENDER_ADDRESS", app_id=789, method=some_abi_method_object) - built_txns = creator.app_delete_method_call(params) - ``` -* **Example:** - ```python - #Advanced example - creator.app_delete_method_call(AppDeleteMethodCallParams( - sender="SENDER_ADDRESS", - app_id=789, - method=some_abi_method_object, - args=[b'method_arg'], - account_references=["ACCOUNT1"], - app_references=[789], - asset_references=[123], - box_references=[], - lease="lease", - note=b"note", - rekey_to="REKEYTOADDRESS", - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount.from_micro_algo(1000), - static_fee=AlgoAmount.from_micro_algo(1000), - max_fee=AlgoAmount.from_micro_algo(3000) - )) - ``` - -#### *property* app_call_method_call *: collections.abc.Callable[[[algokit_utils.transactions.transaction_composer.AppCallMethodCallParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppCallMethodCallParams)], [algokit_utils.transactions.transaction_composer.BuiltTransactions](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.BuiltTransactions)]* - -Create an application call with ABI method call transaction. - -* **Example:** - ```python - #Basic example - creator = AlgorandClientTransactionCreator(lambda: TransactionComposer()) - params = AppCallMethodCallParams(sender="SENDER_ADDRESS", app_id=789, method=some_abi_method_object) - built_txns = creator.app_call_method_call(params) - ``` -* **Example:** - ```python - Advanced example - creator.app_call_method_call(AppCallMethodCallParams( - ``` - - > sender=”SENDER_ADDRESS”, - > app_id=789, - > method=some_abi_method_object, - > args=[b’method_arg’], - > account_references=[“ACCOUNT1”], - > app_references=[789], - > asset_references=[123], - > box_references=[], - > lease=”lease”, - > note=b”note”, - > rekey_to=”REKEYTOADDRESS”, - > first_valid_round=1000, - > validity_window=10, - > extra_fee=AlgoAmount.from_micro_algo(1000), - > static_fee=AlgoAmount.from_micro_algo(1000), - > max_fee=AlgoAmount.from_micro_algo(3000) - - )) - -#### *property* online_key_registration *: collections.abc.Callable[[[algokit_utils.transactions.transaction_composer.OnlineKeyRegistrationParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.OnlineKeyRegistrationParams)], algosdk.transaction.Transaction]* - -Create an online key registration transaction. - -* **Example:** - ```python - #Basic example - creator = AlgorandClientTransactionCreator(lambda: TransactionComposer()) - params = OnlineKeyRegistrationParams( - sender="SENDER_ADDRESS", - vote_key="VOTE_KEY", - selection_key="SELECTION_KEY", - vote_first=1000, - vote_last=2000, - vote_key_dilution=10, - state_proof_key=b"state_proof_key_bytes" - ) - txn = creator.online_key_registration(params) - ``` -* **Example:** - ```python - #Advanced example - creator.online_key_registration(OnlineKeyRegistrationParams( - sender="SENDER_ADDRESS", - vote_key="VOTE_KEY", - selection_key="SELECTION_KEY", - vote_first=1000, - vote_last=2000, - vote_key_dilution=10, - state_proof_key=b"state_proof_key_bytes", - lease="lease", - note=b"note", - rekey_to="REKEYTOADDRESS", - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount.from_micro_algo(1000), - static_fee=AlgoAmount.from_micro_algo(1000), - max_fee=AlgoAmount.from_micro_algo(3000) - )) - ``` - -#### *property* offline_key_registration *: collections.abc.Callable[[[algokit_utils.transactions.transaction_composer.OfflineKeyRegistrationParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.OfflineKeyRegistrationParams)], algosdk.transaction.Transaction]* - -Create an offline key registration transaction. - -* **Example:** - ```python - #Basic example - creator = AlgorandClientTransactionCreator(lambda: TransactionComposer()) - txn = creator.offline_key_registration(OfflineKeyRegistrationParams(sender="SENDER_ADDRESS", - prevent_account_from_ever_participating_again=True)) - ``` -* **Example:** - ```python - #Advanced example - creator.offline_key_registration(OfflineKeyRegistrationParams( - sender="SENDER_ADDRESS", - prevent_account_from_ever_participating_again=True, - lease="lease", - note=b"note", - rekey_to="REKEYTOADDRESS", - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount.from_micro_algo(1000), - static_fee=AlgoAmount.from_micro_algo(1000), - max_fee=AlgoAmount.from_micro_algo(3000) - )) - ``` diff --git a/docs/markdown/autoapi/algokit_utils/transactions/transaction_sender/index.md b/docs/markdown/autoapi/algokit_utils/transactions/transaction_sender/index.md deleted file mode 100644 index 87a807de..00000000 --- a/docs/markdown/autoapi/algokit_utils/transactions/transaction_sender/index.md +++ /dev/null @@ -1,975 +0,0 @@ -# algokit_utils.transactions.transaction_sender - -## Classes - -| [`SendSingleTransactionResult`](#algokit_utils.transactions.transaction_sender.SendSingleTransactionResult) | Base class for transaction results. | -|-----------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------| -| [`SendSingleAssetCreateTransactionResult`](#algokit_utils.transactions.transaction_sender.SendSingleAssetCreateTransactionResult) | Result of creating a new ASA (Algorand Standard Asset). | -| [`SendAppTransactionResult`](#algokit_utils.transactions.transaction_sender.SendAppTransactionResult) | Result of an application transaction. | -| [`SendAppUpdateTransactionResult`](#algokit_utils.transactions.transaction_sender.SendAppUpdateTransactionResult) | Result of updating an application. | -| [`SendAppCreateTransactionResult`](#algokit_utils.transactions.transaction_sender.SendAppCreateTransactionResult) | Result of creating a new application. | -| [`AlgorandClientTransactionSender`](#algokit_utils.transactions.transaction_sender.AlgorandClientTransactionSender) | Orchestrates sending transactions for AlgorandClient. | - -## Module Contents - -### *class* algokit_utils.transactions.transaction_sender.SendSingleTransactionResult - -Base class for transaction results. - -Represents the result of sending a single transaction. - -#### transaction *: [algokit_utils.models.transaction.TransactionWrapper](../../models/transaction/index.md#algokit_utils.models.transaction.TransactionWrapper)* - -The last transaction - -#### confirmation *: algosdk.v2client.algod.AlgodResponseType* - -The last confirmation - -#### group_id *: str* - -The group ID - -#### tx_id *: str | None* *= None* - -The transaction ID - -#### tx_ids *: list[str]* - -The full array of transaction IDs - -#### transactions *: list[[algokit_utils.models.transaction.TransactionWrapper](../../models/transaction/index.md#algokit_utils.models.transaction.TransactionWrapper)]* - -The full array of transactions - -#### confirmations *: list[algosdk.v2client.algod.AlgodResponseType]* - -The full array of confirmations - -#### returns *: list[[algokit_utils.applications.abi.ABIReturn](../../applications/abi/index.md#algokit_utils.applications.abi.ABIReturn)] | None* *= None* - -The ABI return value if applicable - -#### *classmethod* from_composer_result(result: [algokit_utils.transactions.transaction_composer.SendAtomicTransactionComposerResults](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.SendAtomicTransactionComposerResults), \*, is_abi: bool = False, index: int = -1) → typing_extensions.Self - -### *class* algokit_utils.transactions.transaction_sender.SendSingleAssetCreateTransactionResult - -Bases: [`SendSingleTransactionResult`](#algokit_utils.transactions.transaction_sender.SendSingleTransactionResult) - -Result of creating a new ASA (Algorand Standard Asset). - -Contains the asset ID of the newly created asset. - -#### asset_id *: int* - -The ID of the newly created asset - -### *class* algokit_utils.transactions.transaction_sender.SendAppTransactionResult - -Bases: [`SendSingleTransactionResult`](#algokit_utils.transactions.transaction_sender.SendSingleTransactionResult), `Generic`[`ABIReturnT`] - -Result of an application transaction. - -Contains the ABI return value if applicable. - -#### abi_return *: ABIReturnT | None* *= None* - -The ABI return value if applicable - -### *class* algokit_utils.transactions.transaction_sender.SendAppUpdateTransactionResult - -Bases: [`SendAppTransactionResult`](#algokit_utils.transactions.transaction_sender.SendAppTransactionResult)[`ABIReturnT`] - -Result of updating an application. - -Contains the compiled approval and clear programs. - -#### compiled_approval *: Any | None* *= None* - -The compiled approval program - -#### compiled_clear *: Any | None* *= None* - -The compiled clear state program - -### *class* algokit_utils.transactions.transaction_sender.SendAppCreateTransactionResult - -Bases: [`SendAppUpdateTransactionResult`](#algokit_utils.transactions.transaction_sender.SendAppUpdateTransactionResult)[`ABIReturnT`] - -Result of creating a new application. - -Contains the app ID and address of the newly created application. - -#### app_id *: int* - -The ID of the newly created application - -#### app_address *: str* - -The address of the newly created application - -### *class* algokit_utils.transactions.transaction_sender.AlgorandClientTransactionSender(new_group: collections.abc.Callable[[], [algokit_utils.transactions.transaction_composer.TransactionComposer](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.TransactionComposer)], asset_manager: [algokit_utils.assets.asset_manager.AssetManager](../../assets/asset_manager/index.md#algokit_utils.assets.asset_manager.AssetManager), app_manager: [algokit_utils.applications.app_manager.AppManager](../../applications/app_manager/index.md#algokit_utils.applications.app_manager.AppManager), algod_client: algosdk.v2client.algod.AlgodClient) - -Orchestrates sending transactions for AlgorandClient. - -Provides methods to send various types of transactions including payments, -asset operations, and application calls. - -#### new_group() → [algokit_utils.transactions.transaction_composer.TransactionComposer](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.TransactionComposer) - -Create a new transaction group. - -* **Returns:** - A new TransactionComposer instance -* **Example:** - ```python - sender = AlgorandClientTransactionSender(new_group, asset_manager, app_manager, algod_client) - composer = sender.new_group() - composer(PaymentParams(sender="sender", receiver="receiver", amount=AlgoAmount(algo=1))) - composer.send() - ``` - -#### payment(params: [algokit_utils.transactions.transaction_composer.PaymentParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.PaymentParams), send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → [SendSingleTransactionResult](#algokit_utils.transactions.transaction_sender.SendSingleTransactionResult) - -Send a payment transaction to transfer Algo between accounts. - -* **Parameters:** - * **params** – Payment transaction parameters - * **send_params** – Send parameters -* **Returns:** - Result of the payment transaction -* **Example:** - ```python - result = algorand.send.payment(PaymentParams( - sender="SENDERADDRESS", - receiver="RECEIVERADDRESS", - amount=AlgoAmount(algo=4), - )) - ``` - - ```python - # Advanced example - result = algorand.send.payment(PaymentParams( - amount=AlgoAmount(algo=4), - receiver="RECEIVERADDRESS", - sender="SENDERADDRESS", - close_remainder_to="CLOSEREMAINDERTOADDRESS", - lease="lease", - note="note", - rekey_to="REKEYTOADDRESS", - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount(micro_algo=1000), - static_fee=AlgoAmount(micro_algo=1000), - max_fee=AlgoAmount(micro_algo=3000), - signer=transactionSigner - ), send_params=SendParams( - max_rounds_to_wait_for_confirmation=5, - suppress_log=True, - )) - ``` - -#### asset_create(params: [algokit_utils.transactions.transaction_composer.AssetCreateParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AssetCreateParams), send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → [SendSingleAssetCreateTransactionResult](#algokit_utils.transactions.transaction_sender.SendSingleAssetCreateTransactionResult) - -Create a new Algorand Standard Asset. - -* **Parameters:** - * **params** – Asset creation parameters - * **send_params** – Send parameters -* **Returns:** - Result containing the new asset ID -* **Example:** - ```python - result = algorand.send.asset_create(AssetCreateParams( - sender="SENDERADDRESS", - asset_name="ASSETNAME", - unit_name="UNITNAME", - total=1000, - )) - ``` - - ```python - # Advanced example - result = algorand.send.asset_create(AssetCreateParams( - sender="CREATORADDRESS", - total=100, - decimals=2, - asset_name="asset", - unit_name="unit", - url="url", - metadata_hash="metadataHash", - default_frozen=False, - manager="MANAGERADDRESS", - reserve="RESERVEADDRESS", - freeze="FREEZEADDRESS", - clawback="CLAWBACKADDRESS", - lease="lease", - note="note", - # You wouldn't normally set this field - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount(micro_algo=1000), - static_fee=AlgoAmount(micro_algo=1000), - # Max fee doesn't make sense with extraFee AND staticFee - # already specified, but here for completeness - max_fee=AlgoAmount(micro_algo=3000), - # Signer only needed if you want to provide one, - # generally you'd register it with AlgorandClient - # against the sender and not need to pass it in - signer=transactionSigner - ), send_params=SendParams( - max_rounds_to_wait_for_confirmation=5, - suppress_log=True, - )) - ``` - -#### asset_config(params: [algokit_utils.transactions.transaction_composer.AssetConfigParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AssetConfigParams), send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → [SendSingleTransactionResult](#algokit_utils.transactions.transaction_sender.SendSingleTransactionResult) - -Configure an existing Algorand Standard Asset. - -* **Parameters:** - * **params** – Asset configuration parameters - * **send_params** – Send parameters -* **Returns:** - Result of the configuration transaction -* **Example:** - ```python - result = algorand.send.asset_config(AssetConfigParams( - sender="MANAGERADDRESS", - asset_id=123456, - manager="MANAGERADDRESS", - reserve="RESERVEADDRESS", - freeze="FREEZEADDRESS", - clawback="CLAWBACKADDRESS", - lease="lease", - note="note", - # You wouldn't normally set this field - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount(micro_algo=1000), - static_fee=AlgoAmount(micro_algo=1000), - # Max fee doesn't make sense with extraFee AND staticFee - # already specified, but here for completeness - max_fee=AlgoAmount(micro_algo=3000), - # Signer only needed if you want to provide one, - # generally you'd register it with AlgorandClient - # against the sender and not need to pass it in - signer=transactionSigner - ), send_params=SendParams( - max_rounds_to_wait_for_confirmation=5, - suppress_log=True, - )) - ``` - -#### asset_freeze(params: [algokit_utils.transactions.transaction_composer.AssetFreezeParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AssetFreezeParams), send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → [SendSingleTransactionResult](#algokit_utils.transactions.transaction_sender.SendSingleTransactionResult) - -Freeze or unfreeze an Algorand Standard Asset for an account. - -* **Parameters:** - * **params** – Asset freeze parameters - * **send_params** – Send parameters -* **Returns:** - Result of the freeze transaction -* **Example:** - ```python - result = algorand.send.asset_freeze(AssetFreezeParams( - sender="MANAGERADDRESS", - asset_id=123456, - account="ACCOUNTADDRESS", - frozen=True, - )) - ``` - - ```python - # Advanced example - result = algorand.send.asset_freeze(AssetFreezeParams( - sender="MANAGERADDRESS", - asset_id=123456, - account="ACCOUNTADDRESS", - frozen=True, - lease="lease", - note="note", - # You wouldn't normally set this field - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount(micro_algo=1000), - static_fee=AlgoAmount(micro_algo=1000), - # Max fee doesn't make sense with extraFee AND staticFee - # already specified, but here for completeness - max_fee=AlgoAmount(micro_algo=3000), - # Signer only needed if you want to provide one, - # generally you'd register it with AlgorandClient - # against the sender and not need to pass it in - signer=transactionSigner - ), send_params=SendParams( - max_rounds_to_wait_for_confirmation=5, - suppress_log=True, - )) - ``` - -#### asset_destroy(params: [algokit_utils.transactions.transaction_composer.AssetDestroyParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AssetDestroyParams), send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → [SendSingleTransactionResult](#algokit_utils.transactions.transaction_sender.SendSingleTransactionResult) - -Destroys an Algorand Standard Asset. - -* **Parameters:** - * **params** – Asset destruction parameters - * **send_params** – Send parameters -* **Returns:** - Result of the destroy transaction -* **Example:** - ```python - result = algorand.send.asset_destroy(AssetDestroyParams( - sender="MANAGERADDRESS", - asset_id=123456, - )) - ``` - - ```python - # Advanced example - result = algorand.send.asset_destroy(AssetDestroyParams( - sender="MANAGERADDRESS", - asset_id=123456, - lease="lease", - note="note", - # You wouldn't normally set this field - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount(micro_algo=1000), - static_fee=AlgoAmount(micro_algo=1000), - # Max fee doesn't make sense with extraFee AND staticFee - # already specified, but here for completeness - max_fee=AlgoAmount(micro_algo=3000), - # Signer only needed if you want to provide one, - # generally you'd register it with AlgorandClient - # against the sender and not need to pass it in - signer=transactionSigner - ), send_params=SendParams( - max_rounds_to_wait_for_confirmation=5, - suppress_log=True, - )) - ``` - -#### asset_transfer(params: [algokit_utils.transactions.transaction_composer.AssetTransferParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AssetTransferParams), send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → [SendSingleTransactionResult](#algokit_utils.transactions.transaction_sender.SendSingleTransactionResult) - -Transfer an Algorand Standard Asset. - -* **Parameters:** - * **params** – Asset transfer parameters - * **send_params** – Send parameters -* **Returns:** - Result of the transfer transaction -* **Example:** - ```python - result = algorand.send.asset_transfer(AssetTransferParams( - sender="HOLDERADDRESS", - asset_id=123456, - amount=1, - receiver="RECEIVERADDRESS", - )) - ``` - - ```python - # Advanced example (with clawback) - result = algorand.send.asset_transfer(AssetTransferParams( - sender="CLAWBACKADDRESS", - asset_id=123456, - amount=1, - receiver="RECEIVERADDRESS", - clawback_target="HOLDERADDRESS", - # This field needs to be used with caution - close_asset_to="ADDRESSTOCLOSETO", - lease="lease", - note="note", - # You wouldn't normally set this field - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount(micro_algo=1000), - static_fee=AlgoAmount(micro_algo=1000), - # Max fee doesn't make sense with extraFee AND staticFee - # already specified, but here for completeness - max_fee=AlgoAmount(micro_algo=3000), - # Signer only needed if you want to provide one, - # generally you'd register it with AlgorandClient - # against the sender and not need to pass it in - signer=transactionSigner - ), send_params=SendParams( - max_rounds_to_wait_for_confirmation=5, - suppress_log=True, - )) - ``` - -#### asset_opt_in(params: [algokit_utils.transactions.transaction_composer.AssetOptInParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AssetOptInParams), send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → [SendSingleTransactionResult](#algokit_utils.transactions.transaction_sender.SendSingleTransactionResult) - -Opt an account into an Algorand Standard Asset. - -* **Parameters:** - * **params** – Asset opt-in parameters - * **send_params** – Send parameters -* **Returns:** - Result of the opt-in transaction -* **Example:** - ```python - result = algorand.send.asset_opt_in(AssetOptInParams( - sender="SENDERADDRESS", - asset_id=123456, - )) - ``` - - ```python - # Advanced example - result = algorand.send.asset_opt_in(AssetOptInParams( - sender="SENDERADDRESS", - asset_id=123456, - lease="lease", - note="note", - # You wouldn't normally set this field - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount(micro_algo=1000), - static_fee=AlgoAmount(micro_algo=1000), - # Max fee doesn't make sense with extraFee AND staticFee - # already specified, but here for completeness - max_fee=AlgoAmount(micro_algo=3000), - # Signer only needed if you want to provide one, - # generally you'd register it with AlgorandClient - # against the sender and not need to pass it in - signer=transactionSigner - ), send_params=SendParams( - max_rounds_to_wait_for_confirmation=5, - suppress_log=True, - )) - ``` - -#### asset_opt_out(params: [algokit_utils.transactions.transaction_composer.AssetOptOutParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AssetOptOutParams), send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None, \*, ensure_zero_balance: bool = True) → [SendSingleTransactionResult](#algokit_utils.transactions.transaction_sender.SendSingleTransactionResult) - -Opt an account out of an Algorand Standard Asset. - -* **Parameters:** - * **params** – Asset opt-out parameters - * **send_params** – Send parameters - * **ensure_zero_balance** – Check if account has zero balance before opt-out, defaults to True -* **Raises:** - **ValueError** – If account has non-zero balance or is not opted in -* **Returns:** - Result of the opt-out transaction -* **Example:** - ```python - result = algorand.send.asset_opt_out(AssetOptOutParams( - sender="SENDERADDRESS", - creator="CREATORADDRESS", - asset_id=123456, - ensure_zero_balance=True, - )) - ``` - - ```python - # Advanced example - result = algorand.send.asset_opt_out(AssetOptOutParams( - sender="SENDERADDRESS", - asset_id=123456, - creator="CREATORADDRESS", - ensure_zero_balance=True, - lease="lease", - note="note", - # You wouldn't normally set this field - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount(micro_algo=1000), - static_fee=AlgoAmount(micro_algo=1000), - # Max fee doesn't make sense with extraFee AND staticFee - # already specified, but here for completeness - max_fee=AlgoAmount(micro_algo=3000), - # Signer only needed if you want to provide one, - # generally you'd register it with AlgorandClient - # against the sender and not need to pass it in - signer=transactionSigner - ), send_params=SendParams( - max_rounds_to_wait_for_confirmation=5, - suppress_log=True, - )) - ``` - -#### app_create(params: [algokit_utils.transactions.transaction_composer.AppCreateParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppCreateParams), send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → [SendAppCreateTransactionResult](#algokit_utils.transactions.transaction_sender.SendAppCreateTransactionResult)[[algokit_utils.applications.abi.ABIReturn](../../applications/abi/index.md#algokit_utils.applications.abi.ABIReturn)] - -Create a new application. - -* **Parameters:** - * **params** – Application creation parameters - * **send_params** – Send parameters -* **Returns:** - Result containing the new application ID and address -* **Example:** - ```python - result = algorand.send.app_create(AppCreateParams( - sender="CREATORADDRESS", - approval_program="TEALCODE", - clear_state_program="TEALCODE", - )) - ``` - - ```python - # Advanced example - result = algorand.send.app_create(AppCreateParams( - sender="CREATORADDRESS", - approval_program="TEALCODE", - clear_state_program="TEALCODE", - )) - # algorand.send.appCreate(AppCreateParams( - # sender='CREATORADDRESS', - # approval_program="TEALCODE", - # clear_state_program="TEALCODE", - # schema={ - # "global_ints": 1, - # "global_byte_slices": 2, - # "local_ints": 3, - # "local_byte_slices": 4 - # }, - # extra_program_pages: 1, - # on_complete: algosdk.transaction.OnComplete.OptInOC, - # args: [b'some_bytes'] - # account_references: ["ACCOUNT_1"] - # app_references: [123, 1234] - # asset_references: [12345] - # box_references: ["box1", {app_id: 1234, name: "box2"}] - # lease: 'lease', - # note: 'note', - # # You wouldn't normally set this field - # first_valid_round: 1000, - # validity_window: 10, - # extra_fee: AlgoAmount(micro_algo=1000), - # static_fee: AlgoAmount(micro_algo=1000), - # # Max fee doesn't make sense with extraFee AND staticFee - # # already specified, but here for completeness - # max_fee: AlgoAmount(micro_algo=3000), - # # Signer only needed if you want to provide one, - # # generally you'd register it with AlgorandClient - # # against the sender and not need to pass it in - # signer: transactionSigner - #}, send_params=SendParams( - # max_rounds_to_wait_for_confirmation=5, - # suppress_log=True, - #)) - ``` - -#### app_update(params: [algokit_utils.transactions.transaction_composer.AppUpdateParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppUpdateParams), send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → [SendAppUpdateTransactionResult](#algokit_utils.transactions.transaction_sender.SendAppUpdateTransactionResult)[[algokit_utils.applications.abi.ABIReturn](../../applications/abi/index.md#algokit_utils.applications.abi.ABIReturn)] - -Update an application. - -* **Parameters:** - * **params** – Application update parameters - * **send_params** – Send parameters -* **Returns:** - Result containing the compiled programs -* **Example:** - ```python - # Basic example - algorand.send.app_update(AppUpdateParams( - sender="CREATORADDRESS", - approval_program="TEALCODE", - clear_state_program="TEALCODE", - )) - # Advanced example - algorand.send.app_update(AppUpdateParams( - sender="CREATORADDRESS", - approval_program="TEALCODE", - clear_state_program="TEALCODE", - on_complete=OnComplete.UpdateApplicationOC, - args=[b'some_bytes'], - account_references=["ACCOUNT_1"], - app_references=[123, 1234], - asset_references=[12345], - box_references=[...], - lease="lease", - note="note", - # You wouldn't normally set this field - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount(micro_algo=1000), - static_fee=AlgoAmount(micro_algo=1000), - # Max fee doesn't make sense with extraFee AND staticFee - # already specified, but here for completeness - max_fee=AlgoAmount(micro_algo=3000), - # Signer only needed if you want to provide one, - # generally you'd register it with AlgorandClient - # against the sender and not need to pass it in - signer=transactionSigner - ), send_params=SendParams( - max_rounds_to_wait_for_confirmation=5, - suppress_log=True, - )) - ``` - -#### app_delete(params: [algokit_utils.transactions.transaction_composer.AppDeleteParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppDeleteParams), send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → [SendAppTransactionResult](#algokit_utils.transactions.transaction_sender.SendAppTransactionResult)[[algokit_utils.applications.abi.ABIReturn](../../applications/abi/index.md#algokit_utils.applications.abi.ABIReturn)] - -Delete an application. - -* **Parameters:** - * **params** – Application deletion parameters - * **send_params** – Send parameters -* **Returns:** - Result of the deletion transaction -* **Example:** - ```python - # Basic example - algorand.send.app_delete(AppDeleteParams( - sender="CREATORADDRESS", - app_id=123456, - )) - # Advanced example - algorand.send.app_delete(AppDeleteParams( - sender="CREATORADDRESS", - on_complete=OnComplete.DeleteApplicationOC, - args=[b'some_bytes'], - account_references=["ACCOUNT_1"], - app_references=[123, 1234], - asset_references=[12345], - box_references=[...], - lease="lease", - note="note", - # You wouldn't normally set this field - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount(micro_algo=1000), - static_fee=AlgoAmount(micro_algo=1000), - # Max fee doesn't make sense with extraFee AND staticFee - # already specified, but here for completeness - max_fee=AlgoAmount(micro_algo=3000), - # Signer only needed if you want to provide one, - # generally you'd register it with AlgorandClient - # against the sender and not need to pass it in - signer=transactionSigner, - ), send_params=SendParams( - max_rounds_to_wait_for_confirmation=5, - suppress_log=True, - )) - ``` - -#### app_call(params: [algokit_utils.transactions.transaction_composer.AppCallParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppCallParams), send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → [SendAppTransactionResult](#algokit_utils.transactions.transaction_sender.SendAppTransactionResult)[[algokit_utils.applications.abi.ABIReturn](../../applications/abi/index.md#algokit_utils.applications.abi.ABIReturn)] - -Call an application. - -* **Parameters:** - * **params** – Application call parameters - * **send_params** – Send parameters -* **Returns:** - Result containing any ABI return value -* **Example:** - ```python - # Basic example - algorand.send.app_call(AppCallParams( - sender="CREATORADDRESS", - app_id=123456, - )) - # Advanced example - algorand.send.app_call(AppCallParams( - sender="CREATORADDRESS", - on_complete=OnComplete.OptInOC, - args=[b'some_bytes'], - account_references=["ACCOUNT_1"], - app_references=[123, 1234], - asset_references=[12345], - box_references=[...], - lease="lease", - note="note", - # You wouldn't normally set this field - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount(micro_algo=1000), - static_fee=AlgoAmount(micro_algo=1000), - # Max fee doesn't make sense with extraFee AND staticFee - # already specified, but here for completeness - max_fee=AlgoAmount(micro_algo=3000), - # Signer only needed if you want to provide one, - # generally you'd register it with AlgorandClient - # against the sender and not need to pass it in - signer=transactionSigner, - ), send_params=SendParams( - max_rounds_to_wait_for_confirmation=5, - suppress_log=True, - )) - ``` - -#### app_create_method_call(params: [algokit_utils.transactions.transaction_composer.AppCreateMethodCallParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppCreateMethodCallParams), send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → [SendAppCreateTransactionResult](#algokit_utils.transactions.transaction_sender.SendAppCreateTransactionResult)[[algokit_utils.applications.abi.ABIReturn](../../applications/abi/index.md#algokit_utils.applications.abi.ABIReturn)] - -Call an application’s create method. - -* **Parameters:** - * **params** – Method call parameters for application creation - * **send_params** – Send parameters -* **Returns:** - Result containing the new application ID and address -* **Example:** - ```python - # Note: you may prefer to use `algorand.client` to get an app client for more advanced functionality. - # - # @param params The parameters for the app creation transaction - # Basic example - method = algorand.abi.Method( - name='method', - args=[b'arg1'], - returns='string' - ) - result = algorand.send.app_create_method_call({ sender: 'CREATORADDRESS', - approval_program: 'TEALCODE', - clear_state_program: 'TEALCODE', - method: method, - args: ["arg1_value"] }) - created_app_id = result.app_id - ... - # Advanced example - method = algorand.abi.Method( - name='method', - args=[b'arg1'], - returns='string' - ) - result = algorand.send.app_create_method_call({ - sender: 'CREATORADDRESS', - method: method, - args: ["arg1_value"], - approval_program: "TEALCODE", - clear_state_program: "TEALCODE", - schema: { - "global_ints": 1, - "global_byte_slices": 2, - "local_ints": 3, - "local_byte_slices": 4 - }, - extra_program_pages: 1, - on_complete: algosdk.transaction.OnComplete.OptInOC, - args: [new Uint8Array(1, 2, 3, 4)], - account_references: ["ACCOUNT_1"], - app_references: [123, 1234], - asset_references: [12345], - box_references: [...], - lease: 'lease', - note: 'note', - # You wouldn't normally set this field - first_valid_round: 1000, - validity_window: 10, - extra_fee: AlgoAmount(micro_algo=1000), - static_fee: AlgoAmount(micro_algo=1000), - # Max fee doesn't make sense with extraFee AND staticFee - # already specified, but here for completeness - max_fee: AlgoAmount(micro_algo=3000), - # Signer only needed if you want to provide one, - # generally you'd register it with AlgorandClient - # against the sender and not need to pass it in - signer: transactionSigner, - }, send_params=SendParams( - max_rounds_to_wait_for_confirmation=5, - suppress_log=True, - )) - ``` - -#### app_update_method_call(params: [algokit_utils.transactions.transaction_composer.AppUpdateMethodCallParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppUpdateMethodCallParams), send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → [SendAppUpdateTransactionResult](#algokit_utils.transactions.transaction_sender.SendAppUpdateTransactionResult)[[algokit_utils.applications.abi.ABIReturn](../../applications/abi/index.md#algokit_utils.applications.abi.ABIReturn)] - -Call an application’s update method. - -* **Parameters:** - * **params** – Method call parameters for application update - * **send_params** – Send parameters -* **Returns:** - Result containing the compiled programs -* **Example:** - ```python - # Basic example: - method = algorand.abi.Method( - name=”updateMethod”, - args=[{“type”: “string”, “name”: “arg1”}], - returns=”string” - ) - params = AppUpdateMethodCallParams( - sender=”CREATORADDRESS”, - app_id=123, - method=method, - args=[“new_value”], - approval_program=”TEALCODE”, - clear_state_program=”TEALCODE” - ) - result = algorand.send.app_update_method_call(params) - print(result.compiled_approval, result.compiled_clear) - ``` - - ```python - # Advanced example: - method = algorand.abi.Method( - name=”updateMethod”, - args=[{“type”: “string”, “name”: “arg1”}, {“type”: “uint64”, “name”: “arg2”}], - returns=”string” - ) - params = AppUpdateMethodCallParams( - sender=”CREATORADDRESS”, - app_id=456, - method=method, - args=[“new_value”, 42], - approval_program=”TEALCODE_ADVANCED”, - clear_state_program=”TEALCLEAR_ADVANCED”, - account_references=[“ACCOUNT1”, “ACCOUNT2”], - app_references=[789], - asset_references=[101112] - ) - result = algorand.send.app_update_method_call(params) - print(result.compiled_approval, result.compiled_clear) - ``` - -#### app_delete_method_call(params: [algokit_utils.transactions.transaction_composer.AppDeleteMethodCallParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppDeleteMethodCallParams), send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → [SendAppTransactionResult](#algokit_utils.transactions.transaction_sender.SendAppTransactionResult)[[algokit_utils.applications.abi.ABIReturn](../../applications/abi/index.md#algokit_utils.applications.abi.ABIReturn)] - -Call an application’s delete method. - -* **Parameters:** - * **params** – Method call parameters for application deletion - * **send_params** – Send parameters -* **Returns:** - Result of the deletion transaction -* **Example:** - ```python - # Basic example: - method = algorand.abi.Method( - name=”deleteMethod”, - args=[], - returns=”void” - ) - params = AppDeleteMethodCallParams( - sender=”CREATORADDRESS”, - app_id=123, - method=method - ) - result = algorand.send.app_delete_method_call(params) - print(result.tx_id) - ``` - - ```python - # Advanced example: - method = algorand.abi.Method( - name=”deleteMethod”, - args=[{“type”: “uint64”, “name”: “confirmation”}], - returns=”void” - ) - params = AppDeleteMethodCallParams( - sender=”CREATORADDRESS”, - app_id=123, - method=method, - args=[1], - account_references=[“ACCOUNT1”], - app_references=[456] - ) - result = algorand.send.app_delete_method_call(params) - print(result.tx_id) - ``` - -#### app_call_method_call(params: [algokit_utils.transactions.transaction_composer.AppCallMethodCallParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.AppCallMethodCallParams), send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → [SendAppTransactionResult](#algokit_utils.transactions.transaction_sender.SendAppTransactionResult)[[algokit_utils.applications.abi.ABIReturn](../../applications/abi/index.md#algokit_utils.applications.abi.ABIReturn)] - -Call an application’s call method. - -* **Parameters:** - * **params** – Method call parameters - * **send_params** – Send parameters -* **Returns:** - Result containing any ABI return value -* **Example:** - ```python - # Basic example: - method = algorand.abi.Method( - name=”callMethod”, - args=[{“type”: “uint64”, “name”: “arg1”}], - returns=”uint64” - ) - params = AppCallMethodCallParams( - sender=”CALLERADDRESS”, - app_id=123, - method=method, - args=[12345] - ) - result = algorand.send.app_call_method_call(params) - print(result.abi_return) - ``` - - ```python - # Advanced example: - method = algorand.abi.Method( - name=”callMethod”, - args=[{“type”: “uint64”, “name”: “arg1”}, {“type”: “string”, “name”: “arg2”}], - returns=”uint64” - ) - params = AppCallMethodCallParams( - sender=”CALLERADDRESS”, - app_id=123, - method=method, - args=[12345, “extra”], - account_references=[“ACCOUNT1”], - asset_references=[101112], - app_references=[789] - ) - result = algorand.send.app_call_method_call(params) - print(result.abi_return) - ``` - -#### online_key_registration(params: [algokit_utils.transactions.transaction_composer.OnlineKeyRegistrationParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.OnlineKeyRegistrationParams), send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → [SendSingleTransactionResult](#algokit_utils.transactions.transaction_sender.SendSingleTransactionResult) - -Register an online key. - -* **Parameters:** - * **params** – Key registration parameters - * **send_params** – Send parameters -* **Returns:** - Result of the registration transaction -* **Example:** - ```python - # Basic example: - params = OnlineKeyRegistrationParams( - sender=”ACCOUNTADDRESS”, - vote_key=”VOTEKEY”, - selection_key=”SELECTIONKEY”, - vote_first=1000, - vote_last=2000, - vote_key_dilution=10 - ) - result = algorand.send.online_key_registration(params) - print(result.tx_id) - ``` - - ```python - # Advanced example: - params = OnlineKeyRegistrationParams( - sender=”ACCOUNTADDRESS”, - vote_key=”VOTEKEY”, - selection_key=”SELECTIONKEY”, - vote_first=1000, - vote_last=2100, - vote_key_dilution=10, - state_proof_key=b’’ * 64 - ) - result = algorand.send.online_key_registration(params) - print(result.tx_id) - ``` - -#### offline_key_registration(params: [algokit_utils.transactions.transaction_composer.OfflineKeyRegistrationParams](../transaction_composer/index.md#algokit_utils.transactions.transaction_composer.OfflineKeyRegistrationParams), send_params: [algokit_utils.models.transaction.SendParams](../../models/transaction/index.md#algokit_utils.models.transaction.SendParams) | None = None) → [SendSingleTransactionResult](#algokit_utils.transactions.transaction_sender.SendSingleTransactionResult) - -Register an offline key. - -* **Parameters:** - * **params** – Key registration parameters - * **send_params** – Send parameters -* **Returns:** - Result of the registration transaction -* **Example:** - ```python - # Basic example: - params = OfflineKeyRegistrationParams( - sender=”ACCOUNTADDRESS”, - prevent_account_from_ever_participating_again=True - ) - result = algorand.send.offline_key_registration(params) - print(result.tx_id) - ``` - - ```python - # Advanced example: - params = OfflineKeyRegistrationParams( - sender=”ACCOUNTADDRESS”, - prevent_account_from_ever_participating_again=True, - note=b’Offline registration’ - ) - result = algorand.send.offline_key_registration(params) - print(result.tx_id) - ``` diff --git a/docs/markdown/autoapi/index.md b/docs/markdown/autoapi/index.md deleted file mode 100644 index 69409179..00000000 --- a/docs/markdown/autoapi/index.md +++ /dev/null @@ -1,44 +0,0 @@ -# API Reference - -This page contains auto-generated API reference documentation [1](#f1). - -* [algokit_utils](algokit_utils/index.md) - * [algokit_utils.accounts](algokit_utils/accounts/index.md) - * [algokit_utils.accounts.account_manager](algokit_utils/accounts/account_manager/index.md) - * [algokit_utils.accounts.kmd_account_manager](algokit_utils/accounts/kmd_account_manager/index.md) - * [algokit_utils.algorand](algokit_utils/algorand/index.md) - * [algokit_utils.applications](algokit_utils/applications/index.md) - * [algokit_utils.applications.abi](algokit_utils/applications/abi/index.md) - * [algokit_utils.applications.app_client](algokit_utils/applications/app_client/index.md) - * [algokit_utils.applications.app_deployer](algokit_utils/applications/app_deployer/index.md) - * [algokit_utils.applications.app_factory](algokit_utils/applications/app_factory/index.md) - * [algokit_utils.applications.app_manager](algokit_utils/applications/app_manager/index.md) - * [algokit_utils.applications.app_spec](algokit_utils/applications/app_spec/index.md) - * [algokit_utils.applications.app_spec.arc32](algokit_utils/applications/app_spec/arc32/index.md) - * [algokit_utils.applications.app_spec.arc56](algokit_utils/applications/app_spec/arc56/index.md) - * [algokit_utils.applications.enums](algokit_utils/applications/enums/index.md) - * [algokit_utils.assets](algokit_utils/assets/index.md) - * [algokit_utils.assets.asset_manager](algokit_utils/assets/asset_manager/index.md) - * [algokit_utils.clients](algokit_utils/clients/index.md) - * [algokit_utils.clients.client_manager](algokit_utils/clients/client_manager/index.md) - * [algokit_utils.clients.dispenser_api_client](algokit_utils/clients/dispenser_api_client/index.md) - * [algokit_utils.config](algokit_utils/config/index.md) - * [algokit_utils.errors](algokit_utils/errors/index.md) - * [algokit_utils.errors.logic_error](algokit_utils/errors/logic_error/index.md) - * [algokit_utils.models](algokit_utils/models/index.md) - * [algokit_utils.models.account](algokit_utils/models/account/index.md) - * [algokit_utils.models.amount](algokit_utils/models/amount/index.md) - * [algokit_utils.models.application](algokit_utils/models/application/index.md) - * [algokit_utils.models.network](algokit_utils/models/network/index.md) - * [algokit_utils.models.simulate](algokit_utils/models/simulate/index.md) - * [algokit_utils.models.state](algokit_utils/models/state/index.md) - * [algokit_utils.models.transaction](algokit_utils/models/transaction/index.md) - * [algokit_utils.protocols](algokit_utils/protocols/index.md) - * [algokit_utils.protocols.account](algokit_utils/protocols/account/index.md) - * [algokit_utils.protocols.typed_clients](algokit_utils/protocols/typed_clients/index.md) - * [algokit_utils.transactions](algokit_utils/transactions/index.md) - * [algokit_utils.transactions.transaction_composer](algokit_utils/transactions/transaction_composer/index.md) - * [algokit_utils.transactions.transaction_creator](algokit_utils/transactions/transaction_creator/index.md) - * [algokit_utils.transactions.transaction_sender](algokit_utils/transactions/transaction_sender/index.md) - -* **[1]** Created with [sphinx-autoapi](https://github.com/readthedocs/sphinx-autoapi) diff --git a/docs/markdown/capabilities/account.md b/docs/markdown/capabilities/account.md deleted file mode 100644 index bd146aa5..00000000 --- a/docs/markdown/capabilities/account.md +++ /dev/null @@ -1,215 +0,0 @@ -# Account management - -Account management is one of the core capabilities provided by AlgoKit Utils. It allows you to create mnemonic, rekeyed, multisig, transaction signer, idempotent KMD and environment variable injected accounts that can be used to sign transactions as well as representing a sender address at the same time. This significantly simplifies management of transaction signing. - -## `AccountManager` - -The [`AccountManager`](../autoapi/algokit_utils/accounts/account_manager/index.md#algokit_utils.accounts.account_manager.AccountManager) is a class that is used to get, create, and fund accounts and perform account-related actions such as funding. The `AccountManager` also keeps track of signers for each address so when using the [`TransactionComposer`](transaction-composer.md) to send transactions, a signer function does not need to manually be specified for each transaction - instead it can be inferred from the sender address automatically! - -To get an instance of `AccountManager`, you can use either [`AlgorandClient`](algorand-client.md) via `algorand.account` or instantiate it directly: - -```python -from algokit_utils import AccountManager - -account_manager = AccountManager(client_manager) -``` - -## `TransactionSignerAccountProtocol` - -The core internal type that holds information about a signer/sender pair for a transaction is [`TransactionSignerAccountProtocol`](../autoapi/algokit_utils/protocols/account/index.md#algokit_utils.protocols.account.TransactionSignerAccountProtocol), which represents an `algosdk.transaction.TransactionSigner` (`signer`) along with a sender address (`address`) as the encoded string address. - -The following conform to `TransactionSignerAccountProtocol`: - -- [`TransactionSignerAccount`](../autoapi/algokit_utils/models/account/index.md#algokit_utils.models.account.TransactionSignerAccount) - a basic transaction signer account that holds an address and a signer conforming to `TransactionSignerAccountProtocol` -- [`SigningAccount`](../autoapi/algokit_utils/models/account/index.md#algokit_utils.models.account.SigningAccount) - an abstraction that used to be available under `Account` in previous versions of AlgoKit Utils. Renamed for consistency with equivalent `ts` version. Holds private key and conforms to `TransactionSignerAccountProtocol` -- [`LogicSigAccount`](../autoapi/algokit_utils/models/account/index.md#algokit_utils.models.account.LogicSigAccount) - a wrapper class around `algosdk` logicsig abstractions conforming to `TransactionSignerAccountProtocol` -- `MultisigAccount` - a wrapper class around `algosdk` multisig abstractions conforming to `TransactionSignerAccountProtocol` - -## Registering a signer - -The `AccountManager` keeps track of which signer is associated with a given sender address. This is used by [`AlgorandClient`](algorand-client.md) to automatically sign transactions by that sender. Any of the [methods]() within `AccountManager` that return an account will automatically register the signer with the sender. - -There are two methods that can be used for this, `set_signer_from_account`, which takes any number of [account based objects]() that combine signer and sender (`TransactionSignerAccount` | `SigningAccount` | `LogicSigAccount` | `MultisigAccount`), or `set_signer` which takes the sender address and the `TransactionSigner`: - -```python -algorand.account - .set_signer_from_account(TransactionSignerAccount(your_address, your_signer)) - .set_signer_from_account(SigningAccount.new_account()) - .set_signer_from_account( - LogicSigAccount(algosdk.transaction.LogicSigAccount(program, args)) - ) - .set_signer_from_account( - MultisigAccount( - MultisigMetadata( - version = 1, - threshold = 1, - addresses = ["ADDRESS1...", "ADDRESS2..."] - ), - [account1, account2] - ) - ) - .set_signer("SENDERADDRESS", transaction_signer) -``` - -## Default signer - -If you want to have a default signer that is used to sign transactions without a registered signer (rather than throwing an exception) then you can [`set_default_signer`](../autoapi/algokit_utils/accounts/account_manager/index.md#algokit_utils.accounts.account_manager.AccountManager.set_default_signer): - -```python -algorand.account.set_default_signer(my_default_signer) -``` - -## Get a signer - -[`AlgorandClient`](algorand-client.md) will automatically retrieve a signer when signing a transaction, but if you need to get a `TransactionSigner` externally to do something more custom then you can [`get_signer`](../autoapi/algokit_utils/accounts/account_manager/index.md#algokit_utils.accounts.account_manager.AccountManager.get_signer) for a given sender address: - -```python -signer = algorand.account.get_signer("SENDER_ADDRESS") -``` - -If there is no signer registered for that sender address it will either return the default signer ([if registered]()) or throw an exception. - -## Accounts - -In order to get/register accounts for signing operations you can use the following methods on [`AccountManager`]() (expressed here as `algorand.account` to denote the syntax via an [`AlgorandClient`](algorand-client.md)): - -- [`from_environment`](../autoapi/algokit_utils/accounts/account_manager/index.md#algokit_utils.accounts.account_manager.AccountManager.from_environment) - Registers and returns an account with private key loaded by convention based on the given name identifier - either by idempotently creating the account in KMD or from environment variable via `process.env['{NAME}_MNEMONIC']` and (optionally) `process.env['{NAME}_SENDER']` (if account is rekeyed) - - This allows you to have powerful code that will automatically create and fund an account by name locally and when deployed against TestNet/MainNet will automatically resolve from environment variables, without having to have different code - - Note: `fund_with` allows you to control how many Algo are seeded into an account created in KMD -- [`from_mnemonic`](../autoapi/algokit_utils/accounts/account_manager/index.md#algokit_utils.accounts.account_manager.AccountManager.from_mnemonic) - Registers and returns an account with secret key loaded by taking the mnemonic secret -- [`multisig`](../autoapi/algokit_utils/accounts/account_manager/index.md#algokit_utils.accounts.account_manager.AccountManager.multisig) - Registers and returns a multisig account with one or more signing keys loaded -- [`rekeyed`](../autoapi/algokit_utils/accounts/account_manager/index.md#algokit_utils.accounts.account_manager.AccountManager.rekeyed) - Registers and returns an account representing the given rekeyed sender/signer combination -- [`random`](../autoapi/algokit_utils/accounts/account_manager/index.md#algokit_utils.accounts.account_manager.AccountManager.random) - Returns a new, cryptographically randomly generated account with private key loaded -- [`from_kmd`](../autoapi/algokit_utils/accounts/account_manager/index.md#algokit_utils.accounts.account_manager.AccountManager.from_kmd) - Returns an account with private key loaded from the given KMD wallet (identified by name) -- [`logicsig`](../autoapi/algokit_utils/accounts/account_manager/index.md#algokit_utils.accounts.account_manager.AccountManager.logicsig) - Returns an account that represents a logic signature - -### Underlying account classes - -While `TransactionSignerAccount` is the main class used to represent an account that can sign, there are underlying account classes that can underpin the signer within the transaction signer account. - -- [`TransactionSignerAccount`](../autoapi/algokit_utils/models/account/index.md#algokit_utils.models.account.TransactionSignerAccount) - A default class conforming to `TransactionSignerAccountProtocol` that holds an address and a signer -- [`SigningAccount`](../autoapi/algokit_utils/models/account/index.md#algokit_utils.models.account.SigningAccount) - An abstraction around `algosdk.Account` that supports rekeyed accounts -- [`LogicSigAccount`](../autoapi/algokit_utils/models/account/index.md#algokit_utils.models.account.LogicSigAccount) - An abstraction around `algosdk.LogicSigAccount` and `algosdk.LogicSig` that supports logic sig signing. Exposes access to the underlying algosdk `algosdk.transaction.LogicSigAccount` object instance via `lsig` property. -- `MultisigAccount` - An abstraction around `algosdk.MultisigMetadata`, `algosdk.makeMultiSigAccountTransactionSigner`, `algosdk.multisigAddress`, `algosdk.signMultisigTransaction` and `algosdk.appendSignMultisigTransaction` that supports multisig accounts with one or more signers present. Exposes access to the underlying algosdk `algosdk.transaction.Multisig` object instance via `multisig` property. - -### Dispenser - -- [`dispenser_from_environment`](../autoapi/algokit_utils/accounts/account_manager/index.md#algokit_utils.accounts.account_manager.AccountManager.dispenser_from_environment) - Returns an account (with private key loaded) that can act as a dispenser from environment variables, or against default LocalNet if no environment variables present -- [`localnet_dispenser`](../autoapi/algokit_utils/accounts/account_manager/index.md#algokit_utils.accounts.account_manager.AccountManager.localnet_dispenser) - Returns an account with private key loaded that can act as a dispenser for the default LocalNet dispenser account - -## Rekey account - -One of the unique features of Algorand is the ability to change the private key that can authorise transactions for an account. This is called [rekeying](https://dev.algorand.co/concepts/accounts/rekeying). - -> [!WARNING] -> Rekeying should be done with caution as a rekey transaction can result in permanent loss of control of an account. - -You can issue a transaction to rekey an account by using the [`rekey_account`](../autoapi/algokit_utils/accounts/account_manager/index.md#algokit_utils.accounts.account_manager.AccountManager.rekey_account) function: - -- `account: string | TransactionSignerAccount` - The account address or signing account of the account that will be rekeyed -- `rekeyTo: string | TransactionSignerAccount` - The account address or signing account of the account that will be used to authorise transactions for the rekeyed account going forward. If a signing account is provided that will now be tracked as the signer for `account` in the `AccountManager` instance. -- An `options` object, which has: - - [Common transaction parameters](algorand-client.md#transaction-parameters) - - [Execution parameters](algorand-client.md#sending-a-single-transaction) - -You can also pass in `rekeyTo` as a [common transaction parameter](algorand-client.md#transaction-parameters) to any transaction. - -### Examples - -```python -# Basic example (with string addresses) - -algorand.account.rekey_account({ - account: "ACCOUNTADDRESS", - rekey_to: "NEWADDRESS", -}) - -# Basic example (with signer accounts) - -algorand.account.rekey_account({ - account: account1, - rekey_to: new_signer_account, -}) - -# Advanced example - -algorand.account.rekey_account({ - account: "ACCOUNTADDRESS", - rekey_to: "NEWADDRESS", - lease: "lease", - note: "note", - first_valid_round: 1000, - validity_window: 10, - extra_fee: AlgoAmount.from_micro_algos(1000), - static_fee: AlgoAmount.from_micro_algos(1000), - # Max fee doesn't make sense with extra_fee AND static_fee - # already specified, but here for completeness - max_fee: AlgoAmount.from_micro_algos(3000), - max_rounds_to_wait_for_confirmation: 5, - suppress_log: True, -}) - - -# Using a rekeyed account - -Note: if a signing account is passed into `algorand.account.rekey_account` then you don't need to call `rekeyed_account` to register the new signer - -rekeyed_account = algorand.account.rekey_account(account, new_account) -# rekeyed_account can be used to sign transactions on behalf of account... -``` - -## KMD account management - -When running LocalNet, you have an instance of the [Key Management Daemon](https://github.com/algorand/go-algorand/blob/master/daemon/kmd/README.md), which is useful for: - -- Accessing the private key of the default accounts that are pre-seeded with Algo so that other accounts can be funded and it’s possible to use LocalNet -- Idempotently creating new accounts against a name that will stay intact while the LocalNet instance is running without you needing to store private keys anywhere (i.e. completely automated) - -The KMD SDK is fairly low level so to make use of it there is a fair bit of boilerplate code that’s needed. This code has been abstracted away into the `KmdAccountManager` class. - -To get an instance of the `KmdAccountManager` class you can access it from [`AlgorandClient`](algorand-client.md) via `algorand.account.kmd` or instantiate it directly (passing in a [`ClientManager`](client.md)): - -```python -from algokit_utils import KmdAccountManager - -kmd_account_manager = KmdAccountManager(client_manager) -``` - -The methods that are available are: - -- [`get_wallet_account`](../autoapi/algokit_utils/accounts/kmd_account_manager/index.md#algokit_utils.accounts.kmd_account_manager.KmdAccountManager.get_wallet_account) - Returns an Algorand signing account with private key loaded from the given KMD wallet (identified by name). -- [`get_or_create_wallet_account`](../autoapi/algokit_utils/accounts/kmd_account_manager/index.md#algokit_utils.accounts.kmd_account_manager.KmdAccountManager.get_or_create_wallet_account) - Gets an account with private key loaded from a KMD wallet of the given name, or alternatively creates one with funds in it via a KMD wallet of the given name. -- [`get_localnet_dispenser_account`](../autoapi/algokit_utils/accounts/kmd_account_manager/index.md#algokit_utils.accounts.kmd_account_manager.KmdAccountManager.get_localnet_dispenser_account) - Returns an Algorand account with private key loaded for the default LocalNet dispenser account (that can be used to fund other accounts) - -```python -# Get a wallet account that seeded the LocalNet network -default_dispenser_account = kmd_account_manager.get_wallet_account( - "unencrypted-default-wallet", - lambda a: a["status"] != "Offline" and a["amount"] > 1_000_000_000 -) -# Same as above, but dedicated method call for convenience -localnet_dispenser_account = kmd_account_manager.get_localnet_dispenser_account() -# Idempotently get (if exists) or create (if it doesn't exist yet) an account by name using KMD -# if creating it then fund it with 2 ALGO from the default dispenser account -new_account = kmd_account_manager.get_or_create_wallet_account( - "account1", - AlgoAmount.from_algos(2) -) -# This will return the same account as above since the name matches -existing_account = kmd_account_manager.get_or_create_wallet_account( - "account1" -) -``` - -Some of this functionality is directly exposed from [`AccountManager`](), which has the added benefit of registering the account as a signer so they can be automatically used to sign transactions when using via [`AlgorandClient`](algorand-client.md): - -```python -# Get and register LocalNet dispenser -localnet_dispenser = algorand.account.localnet_dispenser() -# Get and register a dispenser by environment variable, or if not set then LocalNet dispenser via KMD -dispenser = algorand.account.dispenser_from_environment() -# Get an account from KMD idempotently by name. In this case we'll get the default dispenser account -dispenser_via_kmd = algorand.account.from_kmd('unencrypted-default-wallet', lambda a: a.status != 'Offline' and a.amount > 1_000_000_000) -# Get / create and register account from KMD idempotently by name -fresh_account_via_kmd = algorand.account.kmd.get_or_create_wallet_account('account1', AlgoAmount.from_algos(2)) -``` diff --git a/docs/markdown/capabilities/algorand-client.md b/docs/markdown/capabilities/algorand-client.md deleted file mode 100644 index fc4d56f0..00000000 --- a/docs/markdown/capabilities/algorand-client.md +++ /dev/null @@ -1,212 +0,0 @@ -# Algorand client - -`AlgorandClient` is a client class that brokers easy access to Algorand functionality. It’s the [default entrypoint](../index.md#id3) into AlgoKit Utils functionality. - -The main entrypoint to the bulk of the functionality in AlgoKit Utils is the `AlgorandClient` class, most of the time you can get started by typing `AlgorandClient.` and choosing one of the static initialisation methods to create an [`algokit_utils.algorand.AlgorandClient`](../autoapi/algokit_utils/algorand/index.md#algokit_utils.algorand.AlgorandClient), e.g.: - -```python -# Point to the network configured through environment variables or -# if no environment variables it will point to the default LocalNet -# configuration -algorand = AlgorandClient.from_environment() -# Point to default LocalNet configuration -algorand = AlgorandClient.default_localnet() -# Point to TestNet using AlgoNode free tier -algorand = AlgorandClient.testnet() -# Point to MainNet using AlgoNode free tier -algorand = AlgorandClient.mainnet() -# Point to a pre-created algod client -algorand = AlgorandClient.from_clients(algod=algod) -# Point to pre-created algod, indexer and kmd clients -algorand = AlgorandClient.from_clients(algod=algod, indexer=indexer, kmd=kmd) -# Point to custom configuration for algod -algorand = AlgorandClient.from_config(algod_config=algod_config) -# Point to custom configuration for algod, indexer and kmd -algorand = AlgorandClient.from_config( - algod_config=algod_config, - indexer_config=indexer_config, - kmd_config=kmd_config -) -``` - -## Accessing SDK clients - -Once you have an `AlgorandClient` instance, you can access the SDK clients for the various Algorand APIs via the `algorand.client` property. - -```py -algorand = AlgorandClient.default_localnet() - -algod_client = algorand.client.algod -indexer_client = algorand.client.indexer -kmd_client = algorand.client.kmd -``` - -## Accessing manager class instances - -The `AlgorandClient` has a number of manager class instances that help you quickly use intellisense to get access to advanced functionality. - -- [`AccountManager`](account.md) via `algorand.account`, there are also some chainable convenience methods which wrap specific methods in `AccountManager`: - - `algorand.setDefaultSigner(signer)` - - - `algorand.setSignerFromAccount(account)` - - - `algorand.setSigner(sender, signer)` -- [`AssetManager`](asset.md) via `algorand.asset` -- [`ClientManager`](client.md) via `algorand.client` - -## Creating and issuing transactions - -`AlgorandClient` exposes a series of methods that allow you to create, execute, and compose groups of transactions (all via the [`TransactionComposer`](transaction-composer.md)). - -### Creating transactions - -You can compose a transaction via `algorand.create_transaction.`, which gives you an instance of the `algokit_utils.transactions.AlgorandClientTransactionCreator` class. Intellisense will guide you on the different options. - -The signature for the calls to send a single transaction usually look like: - -```python -algorand.create_transaction.{method}(params=TxnParams(...), send_params=SendParams(...)) -> Transaction: -``` - -- `TxnParams` is a union type that can be any of the Algorand transaction types, exact dataclasses can be imported from `algokit_utils` and consist of: - - `AppCallParams`, - - `AppCreateParams`, - - `AppDeleteParams`, - - `AppUpdateParams`, - - `AssetConfigParams`, - - `AssetCreateParams`, - - `AssetDestroyParams`, - - `AssetFreezeParams`, - - `AssetOptInParams`, - - `AssetOptOutParams`, - - `AssetTransferParams`, - - `OfflineKeyRegistrationParams`, - - `OnlineKeyRegistrationParams`, - - `PaymentParams`, -- `SendParams` is a typed dictionary exposing setting to apply during send operation: - - `max_rounds_to_wait_for_confirmation: int | None` - The number of rounds to wait for confirmation. By default until the latest lastValid has past. - - `suppress_log: bool | None` - Whether to suppress log messages from transaction send, default: do not suppress. - - `populate_app_call_resources: bool | None` - Whether to use simulate to automatically populate app call resources in the txn objects. Defaults to `Config.populateAppCallResources`. - - `cover_app_call_inner_transaction_fees: bool | None` - Whether to use simulate to automatically calculate required app call inner transaction fees and cover them in the parent app call transaction fee - -The return type for the ABI method call methods are slightly different: - -```python -algorand.createTransaction.app{call_type}_method_call(params=MethodCallParams(...), send_params=SendParams(...)) -> BuiltTransactions -``` - -MethodCallParams is a union type that can be any of the Algorand method call types, exact dataclasses can be imported from `algokit_utils` and consist of: - -- `AppCreateMethodCallParams`, -- `AppCallMethodCallParams`, -- `AppDeleteMethodCallParams`, -- `AppUpdateMethodCallParams`, - -Where `BuiltTransactions` looks like this: - -```python -@dataclass(frozen=True) -class BuiltTransactions: - transactions: list[algosdk.transaction.Transaction] - method_calls: dict[int, Method] - signers: dict[int, TransactionSigner] -``` - -This signifies the fact that an ABI method call can actually result in multiple transactions (which in turn may have different signers), that you need ABI metadata to be able to extract the return value from the transaction result. - -### Sending a single transaction - -You can compose a single transaction via `algorand.send...`, which gives you an instance of the `algokit_utils.transactions.AlgorandClientTransactionSender` class. Intellisense will guide you on the different options. - -Further documentation is present in the related capabilities: - -- [App management](app.md) -- [Asset management](asset.md) -- [Algo transfers](transfer.md) - -The signature for the calls to send a single transaction usually look like: - -`algorand.send.{method}(params=TxnParams, send_params=SendParams) -> SingleSendTransactionResult` - -- To get intellisense on the params, use your IDE’s intellisense keyboard shortcut (e.g. ctrl+space). -- `TxnParams` is a union type that can be any of the Algorand transaction types, exact dataclasses can be imported from `algokit_utils`. -- `algokit_utils.transactions.SendParams` a typed dictionary exposing setting to apply during send operation. -- `algokit_utils.transactions.SendSingleTransactionResult` is all of the information that is relevant when [sending a single transaction to the network](transaction.md#transaction-results) - -Generally, the functions to immediately send a single transaction will emit log messages before and/or after sending the transaction. You can opt-out of this by sending `suppressLog: true`. - -### Composing a group of transactions - -You can compose a group of transactions for execution by using the `new_group()` method on `AlgorandClient` and then use the various `.add_{Type}()` methods on [`TransactionComposer`](transaction-composer.md) to add a series of transactions. - -```python -result = (algorand - .new_group() - .add_payment( - PaymentParams( - sender="SENDERADDRESS", - receiver="RECEIVERADDRESS", - amount=1_000_000 # 1 Algo in microAlgos - ) - ) - .add_asset_opt_in( - AssetOptInParams( - sender="SENDERADDRESS", - asset_id=12345 - ) - ) - .send()) -``` - -`new_group()` returns a new [`TransactionComposer`](transaction-composer.md) instance, which can also return the group of transactions, simulate them and other things. - -### Transaction parameters - -To create a transaction you instantiate a relevant Transaction parameters dataclass from `algokit_utils.transactions import *` or `from algokit_utils import PaymentParams, AssetOptInParams, etc`. - -All transaction parameters share the following common base parameters: - -- `sender: str` - The address of the account sending the transaction. -- `signer: algosdk.TransactionSigner | TransactionSignerAccount | None` - The function used to sign transaction(s); if not specified then an attempt will be made to find a registered signer for the given `sender` or use a default signer (if configured). -- `rekey_to: string | None` - Change the signing key of the sender to the given address. **Warning:** Please be careful with this parameter and be sure to read the [official rekey guidance](https://dev.algorand.co/concepts/accounts/rekeying). -- `note: bytes | str | None` - Note to attach to the transaction. Max of 1000 bytes. -- `lease: bytes | str | None` - Prevent multiple transactions with the same lease being included within the validity window. A [lease](https://dev.algorand.co/concepts/transactions/leases) enforces a mutually exclusive transaction (useful to prevent double-posting and other scenarios). -- Fee management - - `static_fee: AlgoAmount | None` - The static transaction fee. In most cases you want to use `extra_fee` unless setting the fee to 0 to be covered by another transaction. - - `extra_fee: AlgoAmount | None` - The fee to pay IN ADDITION to the suggested fee. Useful for covering inner transaction fees. - - `max_fee: AlgoAmount | None` - Throw an error if the fee for the transaction is more than this amount; prevents overspending on fees during high congestion periods. -- Round validity management - - `validity_window: int | None` - How many rounds the transaction should be valid for, if not specified then the registered default validity window will be used. - - `first_valid_round: int | None` - Set the first round this transaction is valid. If left undefined, the value from algod will be used. We recommend you only set this when you intentionally want this to be some time in the future. - - `last_valid_round: int | None` - The last round this transaction is valid. It is recommended to use `validity_window` instead. - -Then on top of that the base type gets extended for the specific type of transaction you are issuing. These are all defined as part of [`TransactionComposer`](transaction-composer.md) and we recommend reading these docs, especially when leveraging either `populate_app_call_resources` or `cover_app_call_inner_transaction_fees`. - -### Transaction configuration - -AlgorandClient caches network provided transaction values for you automatically to reduce network traffic. It has a set of default configurations that control this behaviour, but you have the ability to override and change the configuration of this behaviour: - -- `algorand.set_default_validity_window(validity_window)` - Set the default validity window (number of rounds from the current known round that the transaction will be valid to be accepted for), having a smallish value for this is usually ideal to avoid transactions that are valid for a long future period and may be submitted even after you think it failed to submit if waiting for a particular number of rounds for the transaction to be successfully submitted. The validity window defaults to `10`, except localnet environments where it’s set to `1000`. -- `algorand.set_suggested_params(suggested_params, until?)` - Set the suggested network parameters to use (optionally until the given time) -- `algorand.set_suggested_params_timeout(timeout)` - Set the timeout that is used to cache the suggested network parameters (by default 3 seconds) -- `algorand.get_suggested_params()` - Get the current suggested network parameters object, either the cached value, or if the cache has expired a fresh value - -### Error handling - -AlgorandClient provides error transformer functionality to enhance error messages and debugging information when transactions fail. Error transformers allow you to register custom functions that can transform generic blockchain errors into more meaningful, application-specific error messages. - -#### Registering Error Transformers - -```python -def my_error_transformer(error: Exception) -> Exception: - """Transform generic errors into more meaningful ones.""" - if "asset missing" in str(error).lower(): - return Exception("Asset not found: Please check the asset ID") - return error # Return unchanged if not applicable - -# Register globally for all transaction groups -algorand.register_error_transformer(my_error_transformer) - -# Unregister when no longer needed -algorand.unregister_error_transformer(my_error_transformer) -``` - -Error transformers registered at the `AlgorandClient` level will be applied to all transaction groups created from that client instance. For more detailed documentation on error transformers, including examples and best practices, see the [Transaction Composer Error Transformers](transaction-composer.md#error-transformers) section. diff --git a/docs/markdown/capabilities/amount.md b/docs/markdown/capabilities/amount.md deleted file mode 100644 index cf169c75..00000000 --- a/docs/markdown/capabilities/amount.md +++ /dev/null @@ -1,55 +0,0 @@ -# Algo amount handling - -Algo amount handling is one of the core capabilities provided by AlgoKit Utils. It allows you to reliably and tersely specify amounts of microAlgo and Algo and safely convert between them. - -Any AlgoKit Utils function that needs an Algo amount will take an `AlgoAmount` object, which ensures that there is never any confusion about what value is being passed around. Whenever an AlgoKit Utils function calls into an underlying algosdk function, or if you need to take an `AlgoAmount` and pass it into an underlying algosdk function (per the [modularity principle](../index.md#core-principles)) you can safely and explicitly convert to microAlgo or Algo. - -To see some usage examples check out the automated tests. Alternatively, you can see the reference documentation for `AlgoAmount`. - -## `AlgoAmount` - -The `AlgoAmount` class provides a safe wrapper around an underlying amount of microAlgo where any value entering or existing the `AlgoAmount` class must be explicitly stated to be in microAlgo or Algo. This makes it much safer to handle Algo amounts rather than passing them around as raw numbers where it’s easy to make a (potentially costly!) mistake and not perform a conversion when one is needed (or perform one when it shouldn’t be!). - -To import the AlgoAmount class you can access it via: - -```python -from algokit_utils import AlgoAmount -``` - -### Creating an `AlgoAmount` - -There are a few ways to create an `AlgoAmount`: - -- Algo - - Constructor: `AlgoAmount(algo=10)` - - Static helper: `AlgoAmount.from_algo(10)` -- microAlgo - - Constructor: `AlgoAmount(micro_algo=10_000)` - - Static helper: `AlgoAmount.from_micro_algo(10_000)` - -### Extracting a value from `AlgoAmount` - -The `AlgoAmount` class has properties to return Algo and microAlgo: - -- `amount.algo` - Returns the value in Algo as a python `Decimal` object -- `amount.micro_algo` - Returns the value in microAlgo as an integer - -`AlgoAmount` will coerce to an integer automatically (in microAlgo) when using `int(amount)`, which allows you to use `AlgoAmount` objects in comparison operations such as `<` and `>=` etc. - -You can also call `str(amount)` or use an `AlgoAmount` directly in string interpolation to convert it to a nice user-facing formatted amount expressed in microAlgo. - -### Additional Features - -The `AlgoAmount` class supports arithmetic operations: - -- Addition: `amount1 + amount2` -- Subtraction: `amount1 - amount2` -- Comparison operations: `<`, `<=`, `>`, `>=`, `==`, `!=` - -Example: - -```python -amount1 = AlgoAmount(algo=1) -amount2 = AlgoAmount(micro_algo=500_000) -total = amount1 + amount2 # Results in 1.5 Algo -``` diff --git a/docs/markdown/capabilities/app-client.md b/docs/markdown/capabilities/app-client.md deleted file mode 100644 index 54b3a359..00000000 --- a/docs/markdown/capabilities/app-client.md +++ /dev/null @@ -1,356 +0,0 @@ -# App client and App factory - -> [!NOTE] -> This page covers the untyped app client, but we recommend using typed clients (coming soon), which will give you a better developer experience with strong typing specific to the app itself. - -App client and App factory are higher-order use case capabilities provided by AlgoKit Utils that builds on top of the core capabilities, particularly [App deployment](app-deploy.md) and [App management](app.md). They allow you to access high productivity application clients that work with [ARC-56](https://github.com/algorandfoundation/ARCs/pull/258) and [ARC-32](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0032.md) application spec defined smart contracts, which you can use to create, update, delete, deploy and call a smart contract and access state data for it. - -> [!NOTE] -> If you are confused about when to use the factory vs client the mental model is: use the client if you know the app ID, use the factory if you don’t know the app ID (deferred knowledge or the instance doesn’t exist yet on the blockchain) or you have multiple app IDs - -## `AppFactory` - -The `AppFactory` is a class that, for a given app spec, allows you to create and deploy one or more app instances and to create one or more app clients to interact with those (or other) app instances. - -To get an instance of `AppFactory` you can use `AlgorandClient` via `algorand.get_app_factory`: - -```python -# Minimal example -factory = algorand.get_app_factory( - app_spec="{/* ARC-56 or ARC-32 compatible JSON */}", -) - -# Advanced example -factory = algorand.get_app_factory( - app_spec=parsed_arc32_or_arc56_app_spec, - default_sender="SENDERADDRESS", - app_name="OverriddenAppName", - version="2.0.0", - compilation_params={ - "updatable": True, - "deletable": False, - "deploy_time_params": { "ONE": 1, "TWO": "value" }, - } -) -``` - -## `AppClient` - -The `AppClient` is a class that, for a given app spec, allows you to manage calls and state for a specific deployed instance of an app (with a known app ID). - -To get an instance of `AppClient` you can use either `AlgorandClient` or instantiate it directly: - -```python -# Minimal examples -app_client = AppClient.from_creator_and_name( - app_spec="{/* ARC-56 or ARC-32 compatible JSON */}", - creator_address="CREATORADDRESS", - algorand=algorand, -) - -app_client = AppClient( - AppClientParams( - app_spec="{/* ARC-56 or ARC-32 compatible JSON */}", - app_id=12345, - algorand=algorand, - ) -) - -app_client = AppClient.from_network( - app_spec="{/* ARC-56 or ARC-32 compatible JSON */}", - algorand=algorand, -) - -# Advanced example -app_client = AppClient( - AppClientParams( - app_spec=parsed_app_spec, - app_id=12345, - algorand=algorand, - app_name="OverriddenAppName", - default_sender="SENDERADDRESS", - approval_source_map=approval_teal_source_map, - clear_source_map=clear_teal_source_map, - ) -) -``` - -You can access `app_id`, `app_address`, `app_name` and `app_spec` as properties on the `AppClient`. - -## Dynamically creating clients for a given app spec - -The `AppFactory` allows you to conveniently create multiple `AppClient` instances on-the-fly with information pre-populated. - -This is possible via two methods on the app factory: - -- `factory.get_app_client_by_id(app_id, ...)` - Returns a new `AppClient` for an app instance of the given ID. Automatically populates app_name, default_sender and source maps from the factory if not specified. -- `factory.get_app_client_by_creator_and_name(creator_address, app_name, ...)` - Returns a new `AppClient`, resolving the app by creator address and name using AlgoKit app deployment semantics. Automatically populates app_name, default_sender and source maps from the factory if not specified. - -```python -app_client1 = factory.get_app_client_by_id(app_id=12345) -app_client2 = factory.get_app_client_by_id(app_id=12346) -app_client3 = factory.get_app_client_by_id( - app_id=12345, - default_sender="SENDER2ADDRESS" -) - -app_client4 = factory.get_app_client_by_creator_and_name( - creator_address="CREATORADDRESS" -) -app_client5 = factory.get_app_client_by_creator_and_name( - creator_address="CREATORADDRESS", - app_name="NonDefaultAppName" -) -app_client6 = factory.get_app_client_by_creator_and_name( - creator_address="CREATORADDRESS", - app_name="NonDefaultAppName", - ignore_cache=True, # Perform fresh indexer lookups - default_sender="SENDER2ADDRESS" -) -``` - -## Creating and deploying an app - -Once you have an app factory you can perform the following actions: - -- `factory.send.bare.create(...)` - Signs and sends a transaction to create an app and returns the result of that call and an `AppClient` instance for the created app -- `factory.deploy(...)` - Uses the creator address and app name pattern to find if the app has already been deployed or not and either creates, updates or replaces that app based on the deployment rules (i.e. it’s an idempotent deployment) and returns the result of the deployment and an `AppClient` instance for the created/updated/existing app. - -> See `API docs` for details on parameter signatures. - -### Create - -The create method is a wrapper over the `app_create` (bare calls) and `app_create_method_call` (ABI method calls) methods, with the following differences: - -- You don’t need to specify the `approval_program`, `clear_state_program`, or `schema` because these are all specified or calculated from the app spec -- `sender` is optional and if not specified then the `default_sender` from the `AppFactory` constructor is used -- `deploy_time_params`, `updatable` and `deletable` can be passed in to control deploy-time parameter replacements and deploy-time immutability and permanence control. Note these are consolidated under the `compilation_params` `TypedDict`, see `API docs` for details. - -```python -# Use no-argument bare-call -result, app_client = factory.send.bare.create() - -# Specify parameters for bare-call and override other parameters -result, app_client = factory.send.bare.create( - params=AppClientBareCallParams( - args=[bytes([1, 2, 3, 4])], - static_fee=AlgoAmount.from_microalgos(3000), - on_complete=OnComplete.OptIn, - ), - compilation_params={ - "deploy_time_params": { - "ONE": 1, - "TWO": "two", - }, - "updatable": True, - "deletable": False, - } -) - -# Specify parameters for ABI method call -result, app_client = factory.send.create( - AppClientMethodCallParams( - method="create_application", - args=[1, "something"] - ) -) -``` - -## Updating and deleting an app - -Deploy method aside, the ability to make update and delete calls happens after there is an instance of an app created via `AppClient`. The semantics of this are no different than other calls, with the caveat that the update call is a bit different since the code will be compiled when constructing the update params and the update calls thus optionally takes compilation parameters (`compilation_params`) for deploy-time parameter replacements and deploy-time immutability and permanence control. - -## Calling the app - -You can construct a params object, transaction(s) and sign and send a transaction to call the app that a given `AppClient` instance is pointing to. - -This is done via the following properties: - -- `app_client.params.{method}(params)` - Params for an ABI method call -- `app_client.params.bare.{method}(params)` - Params for a bare call -- `app_client.create_transaction.{method}(params)` - Transaction(s) for an ABI method call -- `app_client.create_transaction.bare.{method}(params)` - Transaction for a bare call -- `app_client.send.{method}(params)` - Sign and send an ABI method call -- `app_client.send.bare.{method}(params)` - Sign and send a bare call - -Where `{method}` is one of: - -- `update` - An update call -- `opt_in` - An opt-in call -- `delete` - A delete application call -- `clear_state` - A clear state call (note: calls the clear program and only applies to bare calls) -- `close_out` - A close-out call -- `call` - A no-op call (or other call if `on_complete` is specified to anything other than update) - -```python -call1 = app_client.send.update( - AppClientMethodCallParams( - method="update_abi", - args=["string_io"], - ), - compilation_params={"deploy_time_params": deploy_time_params} -) - -call2 = app_client.send.delete( - AppClientMethodCallParams( - method="delete_abi", - args=["string_io"] - ) -) - -call3 = app_client.send.opt_in( - AppClientMethodCallParams(method="opt_in") -) - -call4 = app_client.send.bare.clear_state() - -transaction = app_client.create_transaction.bare.close_out( - AppClientBareCallParams( - args=[bytes([1, 2, 3])] - ) -) - -params = app_client.params.opt_in( - AppClientMethodCallParams(method="optin") -) -``` - -## Funding the app account - -Often there is a need to fund an app account to cover minimum balance requirements for boxes and other scenarios. There is an app client method that will do this for you via `fund_app_account(params)`. - -The input parameters are: - -- A `FundAppAccountParams` object, which has the same properties as a payment transaction except `receiver` is not required and `sender` is optional (if not specified then it will be set to the app client’s default sender if configured). - -Note: If you are passing the funding payment in as an ABI argument so it can be validated by the ABI method then you’ll want to get the funding call as a transaction, e.g.: - -```python -result = app_client.send.call( - AppClientMethodCallParams( - method="bootstrap", - args=[ - app_client.create_transaction.fund_app_account( - FundAppAccountParams( - amount=AlgoAmount.from_microalgos(200_000) - ) - ) - ], - box_references=["Box1"] - ) -) -``` - -You can also get the funding call as a params object via `app_client.params.fund_app_account(params)`. - -## Reading state - -`AppClient` has a number of mechanisms to read state (global, local and box storage) from the app instance. - -### App spec methods - -The ARC-56 app spec can specify detailed information about the encoding format of state values and as such allows for a more advanced ability to automatically read state values and decode them as their high-level language types rather than the limited `int` / `bytes` / `str` ability that the generic methods give you. - -You can access this functionality via: - -- `app_client.state.global_state.{method}()` - Global state -- `app_client.state.local_state(address).{method}()` - Local state -- `app_client.state.box.{method}()` - Box storage - -Where `{method}` is one of: - -- `get_all()` - Returns all single-key state values in a dict keyed by the key name and the value a decoded ABI value. -- `get_value(name)` - Returns a single state value for the current app with the value a decoded ABI value. -- `get_map_value(map_name, key)` - Returns a single value from the given map for the current app with the value a decoded ABI value. Key can either be bytes with the binary value of the key value on-chain (without the map prefix) or the high level (decoded) value that will be encoded to bytes for the app spec specified `key_type` -- `get_map(map_name)` - Returns all map values for the given map in a key=>value dict. It’s recommended that this is only done when you have a unique `prefix` for the map otherwise there’s a high risk that incorrect values will be included in the map. - -```python -values = app_client.state.global_state.get_all() -value = app_client.state.local_state("ADDRESS").get_value("value1") -map_value = app_client.state.box.get_map_value("map1", "mapKey") -map_dict = app_client.state.global_state.get_map("myMap") -``` - -### Generic methods - -There are various methods defined that let you read state from the smart contract app: - -- `get_global_state()` - Gets the current global state using `algorand.app.get_global_state`. -- `get_local_state(address: str)` - Gets the current local state for the given account address using `algorand.app.get_local_state`. -- `get_box_names()` - Gets the current box names using `algorand.app.get_box_names`. -- `get_box_value(name)` - Gets the current value of the given box using `algorand.app.get_box_value`. -- `get_box_value_from_abi_type(name)` - Gets the current value of the given box from an ABI type using `algorand.app.get_box_value_from_abi_type`. -- `get_box_values(filter)` - Gets the current values of the boxes using `algorand.app.get_box_values`. -- `get_box_values_from_abi_type(type, filter)` - Gets the current values of the boxes from an ABI type using `algorand.app.get_box_values_from_abi_type`. - -```python -global_state = app_client.get_global_state() -local_state = app_client.get_local_state("ACCOUNTADDRESS") - -box_name: BoxReference = BoxReference(app_id=app_client.app_id, name="my-box") -box_name2: BoxReference = BoxReference(app_id=app_client.app_id, name="my-box2") - -box_names = app_client.get_box_names() -box_value = app_client.get_box_value(box_name) -box_values = app_client.get_box_values([box_name, box_name2]) -box_abi_value = app_client.get_box_value_from_abi_type( - box_name, - algosdk.ABIStringType -) -box_abi_values = app_client.get_box_values_from_abi_type( - [box_name, box_name2], - algosdk.ABIStringType -) -``` - -## Handling logic errors and diagnosing errors - -Often when calling a smart contract during development you will get logic errors that cause an exception to throw. This may be because of a failing assertion, a lack of fees, exhaustion of opcode budget, or any number of other reasons. - -When this occurs, you will generally get an error that looks something like: `TransactionPool.Remember: transaction {TRANSACTION_ID}: logic eval error: {ERROR_MESSAGE}. Details: pc={PROGRAM_COUNTER_VALUE}, opcodes={LIST_OF_OP_CODES}`. - -The information in that error message can be parsed and when combined with the [source map from compilation](app-deploy.md#compilation-and-template-substitution) you can expose debugging information that makes it much easier to understand what’s happening. The ARC-56 app spec, if provided, can also specify human-readable error messages against certain program counter values and further augment the error message. - -The app client and app factory automatically provide this functionality for all smart contract calls through an automatically registered error transformer. This error transformer: - -- Parses logic errors from blockchain responses -- Applies source map information when available to provide line numbers and context -- Filters errors to only handle those relevant to the specific application -- For new applications (app_id=0), compares program bytecode to ensure error handling is applied to the correct application instance - -They also expose a function that can be used for any custom calls you manually construct and need to add into your own try/catch `expose_logic_error(e: Error, is_clear: bool = False)`. - -For more information about error transformers and how to create custom ones, see the [Transaction Composer Error Transformers](transaction-composer.md#error-transformers) documentation. - -When an error is thrown then the resulting error that is re-thrown will be a [`LogicError`](../autoapi/algokit_utils/errors/logic_error/index.md#algokit_utils.errors.logic_error.LogicError), which has the following fields: - -- `logic_error: Exception` - The original logic error exception -- `logic_error_str: str` - The string representation of the logic error -- `program: str` - The TEAL program source code -- `source_map: AlgoSourceMap | None` - The source map if available -- `transaction_id: str` - The transaction ID that triggered the error -- `message: str` - Combined error message with debugging information -- `pc: int` - The program counter value where error occurred -- `traces: list[SimulationTrace] | None` - Simulation traces if debug enabled -- `line_no: int | None` - The line number in the TEAL source code -- `lines: list[str]` - The TEAL program split into individual lines - -Note: This information will only show if the app client / app factory has a source map. This will occur if: - -- You have called `create`, `update` or `deploy` -- You have called `import_source_maps(source_maps)` and provided the source maps (which you can get by calling `export_source_maps()` after variously calling `create`, `update`, or `deploy` and it returns a serialisable value) -- You had source maps present in an app factory and then used it to [create an app client]() (they are automatically passed through) - -If you want to go a step further and automatically issue a [simulated transaction](https://algorand.github.io/js-algorand-sdk/classes/modelsv2.SimulateTransactionResult.html) and get trace information when there is an error when an ABI method is called you can turn on debug mode: - -```python -config.configure(debug=True) -``` - -If you do that then the exception will have the `traces` property within the underlying exception will have key information from the simulation within it and this will get populated into the `led.traces` property of the thrown error. - -When this debug flag is set, it will also emit debugging symbols to allow break-point debugging of the calls if the [project root is also configured](debugging.md). - -## Default arguments - -If an ABI method call specifies default argument values for any of its arguments you can pass in `None` for the value of that argument for the default value to be automatically populated. diff --git a/docs/markdown/capabilities/app-deploy.md b/docs/markdown/capabilities/app-deploy.md deleted file mode 100644 index 1363162d..00000000 --- a/docs/markdown/capabilities/app-deploy.md +++ /dev/null @@ -1,258 +0,0 @@ -# App deployment - -AlgoKit contains advanced smart contract deployment capabilities that allow you to have idempotent (safely retryable) deployment of a named app, including deploy-time immutability and permanence control and TEAL template substitution. This allows you to control the smart contract development lifecycle of a single-instance app across multiple environments (e.g. LocalNet, TestNet, MainNet). - -It’s optional to use this functionality, since you can construct your own deployment logic using create / update / delete calls and your own mechanism to maintaining app metadata (like app IDs etc.), but this capability is an opinionated out-of-the-box solution that takes care of the heavy lifting for you. - -App deployment is a higher-order use case capability provided by AlgoKit Utils that builds on top of the core capabilities, particularly [App management](app.md). - -To see some usage examples check out the [automated tests](https://github.com/algorandfoundation/algokit-utils-py/blob/main/tests/test_deploy_scenarios.py). - -## Smart contract development lifecycle - -The design behind the deployment capability is unique. The architecture design behind app deployment is articulated in an [architecture decision record](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/architecture-decisions/2023-01-12_smart-contract-deployment.md). While the implementation will naturally evolve over time and diverge from this record, the principles and design goals behind the design are comprehensively explained. - -Namely, it described the concept of a smart contract development lifecycle: - -1. Development - 1. **Write** smart contracts - 2. **Transpile** smart contracts with development-time parameters (code configuration) to TEAL Templates - 3. **Verify** the TEAL Templates maintain [output stability](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/articles/output_stability.md) and any other static code quality checks -2. Deployment - 1. **Substitute** deploy-time parameters into TEAL Templates to create final TEAL code - 2. **Compile** the TEAL to create byte code using algod - 3. **Deploy** the byte code to one or more Algorand networks (e.g. LocalNet, TestNet, MainNet) to create Deployed Application(s) -3. Runtime - 1. **Validate** the deployed app via automated testing of the smart contracts to provide confidence in their correctness - 2. **Call** deployed smart contract with runtime parameters to utilise it - -![App deployment lifecycle](../images/lifecycle.jpg) - -The App deployment capability provided by AlgoKit Utils helps implement **#2 Deployment**. - -Furthermore, the implementation contains the following implementation characteristics per the original architecture design: - -- Deploy-time parameters can be provided and substituted into a TEAL Template by convention (by replacing `TMPL_{KEY}`) -- Contracts can be built by any smart contract framework that supports [ARC-56](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0056.md) and [ARC-32](https://github.com/algorandfoundation/ARCs/pull/150), which also means the deployment language can be different to the development language e.g. you can deploy a Python smart contract with TypeScript for instance -- There is explicit control of the immutability (updatability / upgradeability) and permanence (deletability) of the smart contract, which can be varied per environment to allow for easier development and testing in non-MainNet environments (by replacing `TMPL_UPDATABLE` and `TMPL_DELETABLE` at deploy-time by convention, if present) -- Contracts are resolvable by a string “name” for a given creator to allow automated determination of whether that contract had been deployed previously or not, but can also be resolved by ID instead - -This design allows you to have the same deployment code across environments without having to specify an ID for each environment. This makes it really easy to apply [continuous delivery](https://continuousdelivery.com/) practices to your smart contract deployment and make the deployment process completely automated. - -## `AppDeployer` - -The `AppDeployer` is a class that is used to manage app deployments and deployment metadata. - -To get an instance of `AppDeployer` you can use either [`AlgorandClient`](algorand-client.md) via `algorand.appDeployer` or instantiate it directly (passing in an [`AppManager`](app.md#appmanager), [`AlgorandClientTransactionSender`](algorand-client.md#sending-a-single-transaction) and optionally an indexer client instance): - -```python -from algokit_utils.app_deployer import AppDeployer - -app_deployer = AppDeployer(app_manager, transaction_sender, indexer) -``` - -## Deployment metadata - -When AlgoKit performs a deployment of an app it creates metadata to describe that deployment and includes this metadata in an [ARC-2](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0002.md) transaction note on any creation and update transactions. - -The deployment metadata is defined in `AppDeployMetadata`, which is an object with: - -- `name: str` - The unique name identifier of the app within the creator account -- `version: str` - The version of app that is / will be deployed; can be an arbitrary string, but we recommend using [semver](https://semver.org/) -- `deletable: bool | None` - Whether or not the app is deletable (`true`) / permanent (`false`) / unspecified (`None`) -- `updatable: bool | None` - Whether or not the app is updatable (`true`) / immutable (`false`) / unspecified (`None`) - -An example of the ARC-2 transaction note that is attached as an app creation / update transaction note to specify this metadata is: - -```default -ALGOKIT_DEPLOYER:j{name:"MyApp",version:"1.0",updatable:true,deletable:false} -``` - -> NOTE: Starting from v3.0.0, AlgoKit Utils no longer automatically increments the contract version by default. It is the user’s responsibility to explicitly manage versioning of their smart contracts (if desired). - -## Lookup deployed apps by name - -In order to resolve what apps have been previously deployed and their metadata, AlgoKit provides a method that does a series of indexer lookups and returns a map of name to app metadata via `get_creator_apps_by_name(creator_address)`. - -```python -app_lookup = algorand.app_deployer.get_creator_apps_by_name("CREATORADDRESS") -app1_metadata = app_lookup.apps["app1"] -``` - -This method caches the result of the lookup, since it’s a reasonably heavyweight call (N+1 indexer calls for N deployed apps by the creator). If you want to skip the cache to get a fresh version then you can pass in a second parameter `ignore_cache=True`. This should only be needed if you are performing parallel deployments outside of the current `AppDeployer` instance, since it will keep its cache updated based on its own deployments. - -The return type of `get_creator_apps_by_name` is `ApplicationLookup`, which is an object with: - -```python -@dataclasses.dataclass -class ApplicationLookup: - creator: str - apps: dict[str, ApplicationMetaData] = dataclasses.field(default_factory=dict) -``` - -The `apps` property contains a lookup by app name that resolves to the current `ApplicationMetaData`. - -> Refer to the `ApplicationLookup` for latest information on exact types. - -## Performing a deployment - -In order to perform a deployment, AlgoKit provides the `deploy` method. - -For example: - -```python -deployment_result = algorand.app_deployer.deploy( - AppDeployParams( - metadata=AppDeploymentMetaData( - name="MyApp", - version="1.0.0", - deletable=False, - updatable=False, - ), - create_params=AppCreateParams( - sender="CREATORADDRESS", - approval_program=approval_teal_template_or_byte_code, - clear_state_program=clear_state_teal_template_or_byte_code, - schema=StateSchema( - global_ints=1, - global_byte_slices=2, - local_ints=3, - local_byte_slices=4, - ), - # Other parameters if a create call is made... - ), - update_params=AppUpdateParams( - sender="SENDERADDRESS", - # Other parameters if an update call is made... - ), - delete_params=AppDeleteParams( - sender="SENDERADDRESS", - # Other parameters if a delete call is made... - ), - deploy_time_params={ - "VALUE": 1, # TEAL template variables to replace - }, - on_schema_break=OnSchemaBreak.Append, - on_update=OnUpdate.Update, - send_params=SendParams( - populate_app_call_resources=True, - # Other execution control parameters - ), - ) -) -``` - -This method performs an idempotent (safely retryable) deployment. It will detect if the app already exists and if it doesn’t it will create it. If the app does already exist then it will: - -- Detect if the app has been updated (i.e. the program logic has changed) and either fail, perform an update, deploy a new version or perform a replacement (delete old app and create new app) based on the deployment configuration. -- Detect if the app has a breaking schema change (i.e. more global or local storage is needed than were originally requested) and either fail, deploy a new version or perform a replacement (delete old app and create new app) based on the deployment configuration. - -It will automatically [add metadata to the transaction note of the create or update transactions]() that indicates the name, version, updatability and deletability of the contract. This metadata works in concert with [`appDeployer.get_creator_apps_by_name`]() to allow the app to be reliably retrieved against that creator in it’s currently deployed state. It will automatically update it’s lookup cache so subsequent calls to `get_creator_apps_by_name` or `deploy` will use the latest metadata without needing to call indexer again. - -`deploy` also automatically executes [template substitution]() including deploy-time control of permanence and immutability if the requisite template parameters are specified in the provided TEAL template. - -### Input parameters - -The first parameter `deployment` is an `AppDeployParams`, which is an object with: - -- `metadata: AppDeployMetadata` - determines the [deployment metadata]() of the deployment -- `create_params: AppCreateParams | CreateCallABI` - the parameters for an [app creation call](app.md) (raw parameters or ABI method call) -- `update_params: AppUpdateParams | UpdateCallABI` - the parameters for an [app update call](app.md) (raw parameters or ABI method call) without the `app_id`, `approval_program`, or `clear_state_program` as these are handled by the deploy logic -- `delete_params: AppDeleteParams | DeleteCallABI` - the parameters for an [app delete call](app.md) (raw parameters or ABI method call) without the `app_id` parameter -- `deploy_time_params: TealTemplateParams | None` - optional parameters for [TEAL template substitution]() - - `TealTemplateParams` is a dict that replaces `TMPL_{key}` with `value` (strings/Uint8Arrays are properly encoded) -- `on_schema_break: OnSchemaBreak | str | None` - determines `OnSchemaBreak` if schema requirements increase (values: ‘replace’, ‘fail’, ‘append’) -- `on_update: OnUpdate | str | None` - determines `OnUpdate` if contract logic changes (values: ‘update’, ‘replace’, ‘fail’, ‘append’) -- `existing_deployments: ApplicationLookup | None` - optional pre-fetched app lookup data to skip indexer queries -- `ignore_cache: bool | None` - if True, bypasses cached deployment metadata -- Additional fields from `SendParams` - transaction execution parameters - -### Idempotency - -`deploy` is idempotent which means you can safely call it again multiple times and it will only apply any changes it detects. If you call it again straight after calling it then it will do nothing. - -### Compilation and template substitution - -When compiling TEAL template code, the capabilities described in the [above design]() are present, namely the ability to supply deploy-time parameters and the ability to control immutability and permanence of the smart contract at deploy-time. - -In order for a smart contract to opt-in to use this functionality, it must have a TEAL Template that contains the following: - -- `TMPL_{key}` - Which can be replaced with a number or a string / byte array which will be automatically hexadecimal encoded (for any number of `{key}` => `{value}` pairs) -- `TMPL_UPDATABLE` - Which will be replaced with a `1` if an app should be updatable and `0` if it shouldn’t (immutable) -- `TMPL_DELETABLE` - Which will be replaced with a `1` if an app should be deletable and `0` if it shouldn’t (permanent) - -If you passed in a TEAL template for the `approval_program` or `clear_state_program` (i.e. a `str` rather than a `bytes`) then `deploy` will return the `CompiledTeal` of substituting then compiling the TEAL template(s) in the following properties of the return value: - -- `compiled_approval: CompiledTeal | None` -- `compiled_clear: CompiledTeal | None` - -Template substitution is done by executing `algorand.app.compile_teal_template(teal_template_code, template_params, deployment_metadata)`, which in turn calls the following in order and returns the compilation result per above (all of which can also be invoked directly): - -- `AppManager.strip_teal_comments(teal_code)` - Strips out any TEAL comments to reduce the payload that is sent to algod and reduce the likelihood of hitting the max payload limit -- `AppManager.replace_template_variables(teal_template_code, template_values)` - Replaces the template variables by looking for `TMPL_{key}` -- `AppManager.replace_teal_template_deploy_time_control_params(teal_template_code, params)` - If `params` is provided, it allows for deploy-time immutability and permanence control by replacing `TMPL_UPDATABLE` with `params.get("updatable")` if not `None` and replacing `TMPL_DELETABLE` with `params.get("deletable")` if not `None` -- `algorand.app.compile_teal(teal_code)` - Sends the final TEAL to algod for compilation and returns the result including the source map and caches the compilation result within the `AppManager` instance - -#### Making updatable/deletable apps - -Below is a sample in [Algorand Python SDK](https://github.com/algorandfoundation/puya) that demonstrates how to make an app updatable/deletable smart contract with the use of `TMPL_UPDATABLE` and `TMPL_DELETABLE` template parameters. - -```python -# ... your contract code ... -@arc4.baremethod(allow_actions=["UpdateApplication"]) -def update(self) -> None: - assert TemplateVar[bool]("UPDATABLE") - -@arc4.baremethod(allow_actions=["DeleteApplication"]) -def delete(self) -> None: - assert TemplateVar[bool]("DELETABLE") -# ... your contract code ... -``` - -Alternative example in [Algorand TypeScript SDK](https://github.com/algorandfoundation/puya-ts): - -```typescript -// ... your contract code ... -@baremethod({ allowActions: 'UpdateApplication' }) -public onUpdate() { - assert(TemplateVar('UPDATABLE')) -} - -@baremethod({ allowActions: 'DeleteApplication' }) -public onDelete() { - assert(TemplateVar('DELETABLE')) -} -// ... your contract code ... -``` - -With the above code, when deploying your application, you can pass in the following deploy-time parameters: - -```python -my_factory.deploy( - ... # other deployment parameters ... - compilation_params={ - "updatable": True, # resulting app will be updatable, and this metadata will be set in the ARC-2 transaction note - "deletable": False, # resulting app will not be deletable, and this metadata will be set in the ARC-2 transaction note - } -) -``` - -### Return value - -When `deploy` executes it will return a `AppDeployResult` object that describes exactly what it did and has comprehensive metadata to describe the end result of the deployed app. - -The `deploy` call itself may do one of the following (which you can determine by looking at the `operation_performed` field on the return value from the function): - -- `OperationPerformed.CREATE` - The smart contract app was created -- `OperationPerformed.UPDATE` - The smart contract app was updated -- `OperationPerformed.REPLACE` - The smart contract app was deleted and created again (in an atomic transaction) -- `OperationPerformed.NOTHING` - Nothing was done since it was detected the existing smart contract app deployment was up to date - -As well as the `operation_performed` parameter and the [optional compilation result](), the return value will have the [`ApplicationMetaData`](../autoapi/algokit_utils/applications/app_deployer/index.md#algokit_utils.applications.app_deployer.ApplicationMetaData) [fields]() present. - -Based on the value of `operation_performed`, there will be other data available in the return value: - -- If `CREATE`, `UPDATE` or `REPLACE` then it will have the relevant [`SendAppTransactionResult`](../autoapi/algokit_utils/transactions/transaction_sender/index.md#algokit_utils.transactions.transaction_sender.SendAppTransactionResult) values: - - `create_result` for create operations - - `update_result` for update operations -- If `REPLACE` then it will also have `delete_result` to capture the result of deleting the existing app diff --git a/docs/markdown/capabilities/app.md b/docs/markdown/capabilities/app.md deleted file mode 100644 index 1cb907c3..00000000 --- a/docs/markdown/capabilities/app.md +++ /dev/null @@ -1,163 +0,0 @@ -# App management - -App management is a higher-order use case capability provided by AlgoKit Utils that builds on top of the core capabilities. It allows you to create, update, delete, call (ABI and otherwise) smart contract apps and the metadata associated with them (including state and boxes). - -## `AppManager` - -The `AppManager` is a class that is used to manage app information. To get an instance of `AppManager` you can use either [`AlgorandClient`](algorand-client.md) via `algorand.app` or instantiate it directly (passing in an algod client instance): - -```python -from algokit_utils import AppManager - -app_manager = AppManager(algod_client) -``` - -## Calling apps - -### App Clients - -The recommended way of interacting with apps is via [App clients](app-client.md) and [App factory](app-client.md#appfactory). The methods shown on this page are the underlying mechanisms that app clients use and are for advanced use cases when you want more control. - -### Compilation - -The `AppManager` class allows you to compile TEAL code with caching semantics that allows you to avoid duplicate compilation and keep track of source maps from compiled code. - -```python -# Basic compilation -teal_code = "return 1" -compilation_result = app_manager.compile_teal(teal_code) - -# Get cached compilation result -cached_result = app_manager.get_compilation_result(teal_code) - -# Compile with template substitution -template_code = "int TMPL_VALUE" -template_params = {"VALUE": 1} -compilation_result = app_manager.compile_teal_template( - template_code, - template_params=template_params -) - -# Compile with deployment control (updatable/deletable) -control_template = f"""#pragma version 8 -int {UPDATABLE_TEMPLATE_NAME} -int {DELETABLE_TEMPLATE_NAME}""" -deployment_metadata = {"updatable": True, "deletable": True} -compilation_result = app_manager.compile_teal_template( - control_template, - deployment_metadata=deployment_metadata -) -``` - -The compilation result contains: - -- `teal` - Original TEAL code -- `compiled` - Base64 encoded compiled bytecode -- `compiled_hash` - Hash of compiled bytecode -- `compiled_base64_to_bytes` - Raw bytes of compiled bytecode -- `source_map` - Source map for debugging - -## Accessing state - -### Global state - -To access global state you can use: - -```python -# Get global state for app -global_state = app_manager.get_global_state(app_id) - -# Parse raw state from algod -decoded_state = AppManager.decode_app_state(raw_state) - -# Access state values -key_raw = decoded_state["value1"].key_raw # Raw bytes -key_base64 = decoded_state["value1"].key_base64 # Base64 encoded -value = decoded_state["value1"].value # Parsed value (str or int) -value_raw = decoded_state["value1"].value_raw # Raw bytes if bytes value -value_base64 = decoded_state["value1"].value_base64 # Base64 if bytes value -``` - -### Local state - -To access local state you can use: - -```python -local_state = app_manager.get_local_state(app_id, "ACCOUNT_ADDRESS") -``` - -### Boxes - -To access box storage: - -```python -# Get box names -box_names = app_manager.get_box_names(app_id) - -# Get box values -box_value = app_manager.get_box_value(app_id, box_name) -box_values = app_manager.get_box_values(app_id, [box_name1, box_name2]) - -# Get decoded ABI values -abi_value = app_manager.get_box_value_from_abi_type( - app_id, box_name, algosdk.abi.StringType() -) -abi_values = app_manager.get_box_values_from_abi_type( - app_id, [box_name1, box_name2], algosdk.abi.StringType() -) - -# Get box reference for transaction -box_ref = AppManager.get_box_reference(box_id) -``` - -## Getting app information - -To get app information: - -```python -# Get app info by ID -app_info = app_manager.get_by_id(app_id) - -# Get ABI return value from transaction -abi_return = AppManager.get_abi_return(confirmation, abi_method) -``` - -## Box references - -Box references can be specified in several ways: - -```python -# String name (encoded to bytes) -box_ref = "my_box" - -# Raw bytes -box_ref = b"my_box" - -# Account signer (uses address as name) -box_ref = account_signer - -# Box reference with app ID -box_ref = BoxReference(app_id=123, name=b"my_box") -``` - -## Common app parameters - -When interacting with apps (creating, updating, deleting, calling), there are common parameters that can be passed: - -- `app_id` - ID of the application -- `sender` - Address of transaction sender -- `signer` - Transaction signer (optional) -- `args` - Arguments to pass to the smart contract -- `account_references` - Account addresses to reference -- `app_references` - App IDs to reference -- `asset_references` - Asset IDs to reference -- `box_references` - Box references to load -- `on_complete` - On complete action -- Other common transaction parameters like `note`, `lease`, etc. - -For ABI method calls, additional parameters: - -- `method` - The ABI method to call -- `args` - ABI typed arguments to pass - -See [App client](app-client.md) for more details on constructing app calls. diff --git a/docs/markdown/capabilities/asset.md b/docs/markdown/capabilities/asset.md deleted file mode 100644 index 63a574b5..00000000 --- a/docs/markdown/capabilities/asset.md +++ /dev/null @@ -1,134 +0,0 @@ -# Assets - -The Algorand Standard Asset (ASA) management functions include creating, opting in and transferring assets, which are fundamental to asset interaction in a blockchain environment. - -## `AssetManager` - -The `AssetManager` class provides functionality for managing Algorand Standard Assets (ASAs). It can be accessed through the `AlgorandClient` via `algorand.asset` or instantiated directly: - -```python -from algokit_utils import AssetManager, TransactionComposer -from algosdk.v2client import algod - -asset_manager = AssetManager( - algod_client=algod_client, - new_group=lambda: TransactionComposer() -) -``` - -## Asset Information - -The `AssetManager` provides two key data classes for asset information: - -### `AssetInformation` - -Contains details about an Algorand Standard Asset (ASA): - -```python -@dataclass -class AssetInformation: - asset_id: int # The ID of the asset - creator: str # Address of the creator account - total: int # Total units created - decimals: int # Number of decimal places - default_frozen: bool | None = None # Whether asset is frozen by default - manager: str | None = None # Optional manager address - reserve: str | None = None # Optional reserve address - freeze: str | None = None # Optional freeze address - clawback: str | None = None # Optional clawback address - unit_name: str | None = None # Optional unit name (e.g. ticker) - asset_name: str | None = None # Optional asset name - url: str | None = None # Optional URL for more info - metadata_hash: bytes | None = None # Optional 32-byte metadata hash -``` - -### `AccountAssetInformation` - -Contains information about an account’s holding of a particular asset: - -```python -@dataclass -class AccountAssetInformation: - asset_id: int # The ID of the asset - balance: int # Amount held by the account - frozen: bool # Whether frozen for this account - round: int # Round this info was retrieved at -``` - -## Bulk Operations - -The `AssetManager` provides methods for bulk opt-in/opt-out operations: - -### Bulk Opt-In - -```python -# Basic example -result = asset_manager.bulk_opt_in( - account="ACCOUNT_ADDRESS", - asset_ids=[12345, 67890] -) - -# Advanced example with optional parameters -result = asset_manager.bulk_opt_in( - account="ACCOUNT_ADDRESS", - asset_ids=[12345, 67890], - signer=transaction_signer, - note=b"opt-in note", - lease=b"lease", - static_fee=AlgoAmount(1000), - extra_fee=AlgoAmount(500), - max_fee=AlgoAmount(2000), - validity_window=10, - send_params=SendParams(...) -) -``` - -### Bulk Opt-Out - -```python -# Basic example -result = asset_manager.bulk_opt_out( - account="ACCOUNT_ADDRESS", - asset_ids=[12345, 67890] -) - -# Advanced example with optional parameters -result = asset_manager.bulk_opt_out( - account="ACCOUNT_ADDRESS", - asset_ids=[12345, 67890], - ensure_zero_balance=True, - signer=transaction_signer, - note=b"opt-out note", - lease=b"lease", - static_fee=AlgoAmount(1000), - extra_fee=AlgoAmount(500), - max_fee=AlgoAmount(2000), - validity_window=10, - send_params=SendParams(...) -) -``` - -The bulk operations return a list of `BulkAssetOptInOutResult` objects containing: - -- `asset_id`: The ID of the asset opted into/out of -- `transaction_id`: The transaction ID of the opt-in/out - -## Get Asset Information - -### Getting Asset Parameters - -You can get the current parameters of an asset from algod using `get_by_id()`: - -```python -asset_info = asset_manager.get_by_id(12345) -``` - -### Getting Account Holdings - -You can get an account’s current holdings of an asset using `get_account_information()`: - -```python -address = "XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA" -asset_id = 12345 -account_info = asset_manager.get_account_information(address, asset_id) -``` diff --git a/docs/markdown/capabilities/client.md b/docs/markdown/capabilities/client.md deleted file mode 100644 index 6b77f579..00000000 --- a/docs/markdown/capabilities/client.md +++ /dev/null @@ -1,109 +0,0 @@ -# Client management - -Client management is one of the core capabilities provided by AlgoKit Utils. It allows you to create (auto-retry) [algod](https://dev.algorand.co/reference/rest-apis/algod), [indexer](https://dev.algorand.co/reference/rest-apis/indexer) and [kmd](https://dev.algorand.co/reference/rest-apis/kmd) clients against various networks resolved from environment or specified configuration. - -Any AlgoKit Utils function that needs one of these clients will take the underlying algosdk classes (`algosdk.v2client.algod.AlgodClient`, `algosdk.v2client.indexer.IndexerClient`, `algosdk.kmd.KMDClient`) so inline with the [Modularity](../index.md#id1) principle you can use existing logic to get instances of these clients without needing to use the Client management capability if you prefer. - -To see some usage examples check out the [automated tests](https://github.com/algorandfoundation/algokit-utils-py/blob/main/tests/test_network_clients.py). - -## `ClientManager` - -The `ClientManager` is a class that is used to manage client instances. - -To get an instance of `ClientManager` you can instantiate it directly: - -```python -from algokit_utils import ClientManager, AlgoSdkClients, AlgoClientConfigs -from algosdk.v2client.algod import AlgodClient - -# Using AlgoSdkClients -algod_client = AlgodClient(...) -algorand_client = ... # Get AlgorandClient instance from somewhere -clients = AlgoSdkClients(algod=algod_client, indexer=indexer_client, kmd=kmd_client) -client_manager = ClientManager(clients, algorand_client) - -# Using AlgoClientConfigs -algod_config = AlgoClientNetworkConfig(server="https://...", token="") -configs = AlgoClientConfigs(algod_config=algod_config) -client_manager = ClientManager(configs, algorand_client) -``` - -## Network configuration - -The network configuration is specified using the `AlgoClientConfig` type. This same type is used to specify the config for `algod`, `indexer`, and `kmd` [SDK clients](https://github.com/algorand/py-algorand-sdk). - -There are a number of ways to produce one of these configuration objects: - -- Manually specifying a dataclass, e.g. - ```python - from algokit_utils import AlgoClientNetworkConfig - - config = AlgoClientNetworkConfig( - server="https://myalgodnode.com", - token="SECRET_TOKEN" # optional - ) - ``` -- `ClientManager.get_config_from_environment_or_localnet()` - Loads the Algod client config, the Indexer client config and the Kmd config from well-known environment variables or if not found then default LocalNet; this is useful to have code that can work across multiple blockchain environments (including LocalNet), without having to change -- `ClientManager.get_algod_config_from_environment()` - Loads an Algod client config from well-known environment variables -- `ClientManager.get_indexer_config_from_environment()` - Loads an Indexer client config from well-known environment variables; useful to have code that can work across multiple blockchain environments (including LocalNet), without having to change -- `ClientManager.get_algonode_config(network)` - Loads an Algod or indexer config against [AlgoNode free tier](https://nodely.io/docs/free/start) to either MainNet or TestNet -- `ClientManager.get_default_localnet_config()` - Loads an Algod, Indexer or Kmd config against [LocalNet](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/localnet.md) using the default configuration - -## Clients - -### Creating an SDK client instance - -Once you have the configuration for a client, to get a new client you can use the following functions: - -- `ClientManager.get_algod_client(config)` - Returns an Algod client for the given configuration; the client automatically retries on transient HTTP errors -- `ClientManager.get_indexer_client(config)` - Returns an Indexer client for given configuration -- `ClientManager.get_kmd_client(config)` - Returns a Kmd client for the given configuration - -You can also shortcut needing to write the likes of `ClientManager.get_algod_client(ClientManager.get_algod_config_from_environment())` with environment shortcut methods: - -- `ClientManager.get_algod_client_from_environment()` - Returns an Algod client by loading the config from environment variables -- `ClientManager.get_indexer_client_from_environment()` - Returns an indexer client by loading the config from environment variables -- `ClientManager.get_kmd_client_from_environment()` - Returns a kmd client by loading the config from environment variables - -### Accessing SDK clients via ClientManager instance - -Once you have a `ClientManager` instance, you can access the SDK clients: - -```python -client_manager = ClientManager(algod=algod_client, indexer=indexer_client, kmd=kmd_client) - -algod_client = client_manager.algod -indexer_client = client_manager.indexer -kmd_client = client_manager.kmd -``` - -If the method to create the `ClientManager` doesn’t configure indexer or kmd (both of which are optional), then accessing those clients will trigger an error. - -### Creating a TestNet dispenser API client instance - -You can also create a [TestNet dispenser API client instance](dispenser-client.md) from `ClientManager` too. - -## Automatic retry - -When receiving an Algod or Indexer client from AlgoKit Utils, it will be a special wrapper client that handles retrying transient failures. - -## Network information - -You can get information about the current network you are connected to: - -```python -# Get network information -network = client_manager.network() -print(f"Is mainnet: {network.is_mainnet}") -print(f"Is testnet: {network.is_testnet}") -print(f"Is localnet: {network.is_localnet}") -print(f"Genesis ID: {network.genesis_id}") -print(f"Genesis hash: {network.genesis_hash}") - -# Convenience methods -is_mainnet = client_manager.is_mainnet() -is_testnet = client_manager.is_testnet() -is_localnet = client_manager.is_localnet() -``` - -The first time `network()` is called it will make a HTTP call to algod to get the network parameters, but from then on it will be cached within that `ClientManager` instance for subsequent calls. diff --git a/docs/markdown/capabilities/debugging.md b/docs/markdown/capabilities/debugging.md deleted file mode 100644 index 5a5ae95c..00000000 --- a/docs/markdown/capabilities/debugging.md +++ /dev/null @@ -1,91 +0,0 @@ -# Debugger - -The AlgoKit Python Utilities package provides a set of debugging tools that can be used to simulate and trace transactions on the Algorand blockchain. These tools and methods are optimized for developers who are building applications on Algorand and need to test and debug their smart contracts via [AlgoKit AVM Debugger extension](https://marketplace.visualstudio.com/items?itemName=algorandfoundation.algokit-avm-vscode-debugger). - -## Configuration - -The `config.py` file contains the `UpdatableConfig` class which manages and updates configuration settings for the AlgoKit project. - -- `debug`: Indicates whether debug mode is enabled. -- `project_root`: The path to the project root directory. Can be ignored if you are using `algokit_utils` inside an `algokit` compliant project (containing `.algokit.toml` file). For non algokit compliant projects, simply provide the path to the folder where you want to store sourcemaps and traces to be used with [`AlgoKit AVM Debugger`](https://github.com/algorandfoundation/algokit-avm-vscode-debugger). Alternatively you can also set the value via the `ALGOKIT_PROJECT_ROOT` environment variable. -- `trace_all`: Indicates whether to trace all operations. Defaults to false, this means that when debug mode is enabled, any (or all) application client calls performed via `algokit_utils` will store responses from `simulate` endpoint. These files are called traces, and can be used with `AlgoKit AVM Debugger` to debug TEAL source codes, transactions in the atomic group and etc. -- `trace_buffer_size_mb`: The size of the trace buffer in megabytes. By default uses 256 megabytes. When output folder containing debug trace files exceedes the size, oldest files are removed to optimize for storage consumption. -- `max_search_depth`: The maximum depth to search for a an `algokit` config file. By default it will traverse at most 10 folders searching for `.algokit.toml` file which will be used to assume algokit compliant project root path. -- `populate_app_call_resources`: Indicates whether to populate app call resources. Defaults to false, which means that when debug mode is enabled, any (or all) application client calls performed via `algokit_utils` will not populate app call resources. -- `logger`: A custom logger to use. Defaults to [`algokit_utils.config.AlgoKitLogger`](../autoapi/algokit_utils/config/index.md#algokit_utils.config.AlgoKitLogger) instance. - -The `configure` method can be used to set these attributes. - -To enable debug mode in your project you can configure it as follows: - -```python -from algokit_utils.config import config - -config.configure( - debug=True, - project_root=Path("./my-project"), - trace_all=True, - trace_buffer_size_mb=512, - max_search_depth=15, - populate_app_call_resources=True, -) -``` - -## `AlgoKitLogger` - -The `AlgoKitLogger` is a custom logger that is used to log messages in the AlgoKit project. -It is a subclass of the `logging.Logger` class and extends it to provide additional functionality. - -### Suppressing log messages per log call - -To supress log messages for individual log calls you can pass `'suppress_log':True` to the log call’s `extra` argument. - -### Suppressing log messages globally - -To supress log messages globally you can configure the config object to use a custom logger that does not log anything. - -```python -config.configure(logger=AlgoKitLogger.get_null_logger()) -``` - -## Debugging Utilities - -When debug mode is enabled, AlgoKit Utils will automatically: - -- Generate transaction traces compatible with the AVM Debugger -- Manage trace file storage with automatic cleanup -- Provide source map generation for TEAL contracts - -The following methods are provided for manual debugging operations: - -- `persist_sourcemaps`: Persists sourcemaps for given TEAL contracts as AVM Debugger-compliant artifacts. Parameters: - - `sources`: List of TEAL sources to generate sourcemaps for - - `project_root`: Project root directory for storage - - `client`: AlgodClient instance - - `with_sources`: Whether to include TEAL source files (default: True) -- `simulate_and_persist_response`: Simulates transactions and persists debug traces. Parameters: - - `atc`: AtomicTransactionComposer containing transactions - - `project_root`: Project root directory for storage - - `algod_client`: AlgodClient instance - - `buffer_size_mb`: Maximum trace storage in MB (default: 256) - - `allow_empty_signatures`: Allow unsigned transactions (default: True) - - `allow_unnamed_resources`: Allow unnamed resources (default: True) - - `extra_opcode_budget`: Additional opcode budget - - `exec_trace_config`: Custom trace configuration - - `simulation_round`: Specific round to simulate - -### Trace filename format - -The trace files are named in a specific format to provide useful information about the transactions they contain. The format is as follows: - -```default -${timestamp}_lr${last_round}_${transaction_types}.trace.avm.json -``` - -Where: - -- `timestamp`: The time when the trace file was created, in ISO 8601 format, with colons and periods removed. -- `last_round`: The last round when the simulation was performed. -- `transaction_types`: A string representing the types and counts of transactions in the atomic group. Each transaction type is represented as `${count}${type}`, and different transaction types are separated by underscores. - -For example, a trace file might be named `20220301T123456Z_lr1000_2pay_1axfer.trace.avm.json`, indicating that the trace file was created at `2022-03-01T12:34:56Z`, the last round was `1000`, and the atomic group contained 2 payment transactions and 1 asset transfer transaction. diff --git a/docs/markdown/capabilities/dispenser-client.md b/docs/markdown/capabilities/dispenser-client.md deleted file mode 100644 index b04f8ef6..00000000 --- a/docs/markdown/capabilities/dispenser-client.md +++ /dev/null @@ -1,91 +0,0 @@ -# TestNet Dispenser Client - -The TestNet Dispenser Client is a utility for interacting with the AlgoKit TestNet Dispenser API. It provides methods to fund an account, register a refund for a transaction, and get the current limit for an account. - -## Creating a Dispenser Client - -To create a Dispenser Client, you need to provide an authorization token. This can be done in two ways: - -1. Pass the token directly to the client constructor as `auth_token`. -2. Set the token as an environment variable `ALGOKIT_DISPENSER_ACCESS_TOKEN` (see [docs](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/dispenser.md#login) on how to obtain the token). - -If both methods are used, the constructor argument takes precedence. - -```python -import algokit_utils - -# With auth token -dispenser = algorand.client.get_testnet_dispenser( - auth_token="your_auth_token", -) - -# With auth token and timeout -dispenser = algorand.client.get_testnet_dispenser( - auth_token="your_auth_token", - request_timeout=2, # seconds -) - -# From environment variables -# i.e. os.environ['ALGOKIT_DISPENSER_ACCESS_TOKEN'] = 'your_auth_token' -dispenser = algorand.client.get_testnet_dispenser_from_environment() - -# Alternatively, you can construct it directly -from algokit_utils import TestNetDispenserApiClient - -# Using constructor argument -client = TestNetDispenserApiClient(auth_token="your_auth_token") - -# Using environment variable -import os -os.environ['ALGOKIT_DISPENSER_ACCESS_TOKEN'] = 'your_auth_token' -client = TestNetDispenserApiClient() -``` - -## Funding an Account - -To fund an account with Algo from the dispenser API, use the `fund` method. This method requires the receiver’s address and the amount to be funded. - -```python -response = dispenser.fund( - receiver="RECEIVER_ADDRESS", - amount=1000, # Amount in microAlgos -) -``` - -The `fund` method returns a `DispenserFundResponse` object, which contains the transaction ID (`tx_id`) and the amount funded. - -## Registering a Refund - -To register a refund for a transaction with the dispenser API, use the `refund` method. This method requires the transaction ID of the refund transaction. - -```python -dispenser.refund("transaction_id") -``` - -> Keep in mind, to perform a refund you need to perform a payment transaction yourself first by sending funds back to TestNet Dispenser, then you can invoke this refund endpoint and pass the txn_id of your refund txn. You can obtain dispenser address by inspecting the sender field of any issued fund transaction initiated via [fund](). - -## Getting Current Limit - -To get the current limit for an account with Algo from the dispenser API, use the `get_limit` method. - -```python -response = dispenser.get_limit() -``` - -The `get_limit` method returns a `DispenserLimitResponse` object, which contains the current limit amount. - -## Error Handling - -If an error occurs while making a request to the dispenser API, an exception will be raised with a message indicating the type of error. Refer to [Error Handling docs](https://github.com/algorandfoundation/algokit/blob/main/docs/testnet_api.md#error-handling) for details on how you can handle each individual error `code`. - -Here’s an example of handling errors: - -```python -try: - response = dispenser.fund( - receiver="RECEIVER_ADDRESS", - amount=1000, - ) -except Exception as e: - print(f"Error occurred: {str(e)}") -``` diff --git a/docs/markdown/capabilities/testing.md b/docs/markdown/capabilities/testing.md deleted file mode 100644 index 857c7ad8..00000000 --- a/docs/markdown/capabilities/testing.md +++ /dev/null @@ -1,204 +0,0 @@ -# Testing - -The following is a collection of useful snippets that can help you get started with testing your Algorand applications using AlgoKit utils. For the sake of simplicity, we’ll use [pytest](https://docs.pytest.org/en/latest/) in the examples below. - -## Basic Test Setup - -Here’s a basic test setup using pytest fixtures that provides common testing utilities: - -```python -import pytest -from algokit_utils import Account, SigningAccount -from algokit_utils.algorand import AlgorandClient -from algokit_utils.models.amount import AlgoAmount - -@pytest.fixture -def algorand() -> AlgorandClient: - """Get an AlgorandClient instance configured for LocalNet""" - return AlgorandClient.default_localnet() - -@pytest.fixture -def funded_account(algorand: AlgorandClient) -> SigningAccount: - """Create and fund a test account with ALGOs""" - new_account = algorand.account.random() - dispenser = algorand.account.localnet_dispenser() - algorand.account.ensure_funded( - new_account, - dispenser, - min_spending_balance=AlgoAmount.from_algos(100), - min_funding_increment=AlgoAmount.from_algos(1) - ) - algorand.set_signer(sender=new_account.address, signer=new_account.signer) - return new_account -``` - -Refer to [pytest fixture scopes](https://docs.pytest.org/en/latest/how-to/fixtures.html#fixture-scopes) for more information on how to control lifecycle of fixtures. - -## Creating Test Assets - -Here’s a helper function to create test ASAs (Algorand Standard Assets): - -```python -def generate_test_asset(algorand: AlgorandClient, sender: Account, total: int | None = None) -> int: - """Create a test asset and return its ID""" - if total is None: - total = random.randint(20, 120) - - create_result = algorand.send.asset_create( - AssetCreateParams( - sender=sender.address, - total=total, - decimals=0, - default_frozen=False, - unit_name="TST", - asset_name=f"Test Asset {random.randint(1,100)}", - url="https://example.com", - manager=sender.address, - reserve=sender.address, - freeze=sender.address, - clawback=sender.address, - ) - ) - - return int(create_result.confirmation["asset-index"]) -``` - -## Testing Application Deployments - -Here’s how one can test smart contract application deployments: - -```python -def test_app_deployment(algorand: AlgorandClient, funded_account: SigningAccount): - """Test deploying a smart contract application""" - - # Load the application spec - app_spec = Path("artifacts/application.json").read_text() - - # Create app factory - factory = algorand.client.get_app_factory( - app_spec=app_spec, - default_sender=funded_account.address - ) - - # Deploy the app - app_client, deploy_response = factory.deploy( - compilation_params={ - "deletable": True, - "updatable": True, - "deploy_time_params": {"VERSION": 1}, - }, - ) - - # Verify deployment - assert deploy_response.app.app_id > 0 - assert deploy_response.app.app_address -``` - -## Testing Asset Transfers - -Here’s how one can test ASA transfers between accounts: - -```python -def test_asset_transfer(algorand: AlgorandClient, funded_account: SigningAccount): - """Test ASA transfers between accounts""" - - # Create receiver account - receiver = algorand.account.random() - algorand.account.ensure_funded( - account_to_fund=receiver, - dispenser_account=funded_account, - min_spending_balance=AlgoAmount.from_algos(1) - ) - - # Create test asset - asset_id = generate_test_asset(algorand, funded_account, 100) - - # Opt receiver into asset - algorand.send.asset_opt_in( - AssetOptInParams( - sender=receiver.address, - asset_id=asset_id, - signer=receiver.signer - ) - ) - - # Transfer asset - transfer_amount = 5 - result = algorand.send.asset_transfer( - AssetTransferParams( - sender=funded_account.address, - receiver=receiver.address, - asset_id=asset_id, - amount=transfer_amount - ) - ) - - # Verify transfer - receiver_balance = algorand.asset.get_account_information(receiver, asset_id) - assert receiver_balance.balance == transfer_amount -``` - -## Testing Application Calls - -Here’s how to test application method calls: - -```python -def test_app_method_call(algorand: AlgorandClient, funded_account: SigningAccount): - """Test calling ABI methods on an application""" - - # Deploy application first - app_spec = Path("artifacts/application.json").read_text() - factory = algorand.client.get_app_factory( - app_spec=app_spec, - default_sender=funded_account.address - ) - app_client, _ = factory.deploy() - - # Call application method - result = app_client.send.call( - AppClientMethodCallParams( - method="hello", - args=["world"] - ) - ) - - # Verify result - assert result.abi_return == "Hello, world" -``` - -## Testing Box Storage - -Here’s how to test application box storage: - -```python -def test_box_storage(algorand: AlgorandClient, funded_account: SigningAccount): - """Test application box storage""" - - # Deploy application - app_spec = Path("artifacts/application.json").read_text() - factory = algorand.client.get_app_factory( - app_spec=app_spec, - default_sender=funded_account.address - ) - app_client, _ = factory.deploy() - - # Fund app account for box storage MBR - app_client.fund_app_account( - FundAppAccountParams(amount=AlgoAmount.from_algos(1)) - ) - - # Store value in box - box_name = b"test_box" - box_value = "test_value" - app_client.send.call( - AppClientMethodCallParams( - method="set_box", - args=[box_name, box_value], - box_references=[box_name] - ) - ) - - # Verify box value - stored_value = app_client.get_box_value(box_name) - assert stored_value == box_value.encode() -``` diff --git a/docs/markdown/capabilities/transaction-composer.md b/docs/markdown/capabilities/transaction-composer.md deleted file mode 100644 index 3fb7f00c..00000000 --- a/docs/markdown/capabilities/transaction-composer.md +++ /dev/null @@ -1,487 +0,0 @@ -# Transaction composer - -The `TransactionComposer` class allows you to easily compose one or more compliant Algorand transactions and execute and/or simulate them. - -It’s the core of how the `AlgorandClient` class composes and sends transactions. - -```python -from algokit_utils import TransactionComposer, AppManager -from algokit_utils.transactions import ( - PaymentParams, - AppCallMethodCallParams, - AssetCreateParams, - AppCreateParams, - # ... other transaction parameter types -) -``` - -To get an instance of `TransactionComposer` you can either get it from an app client, from an `AlgorandClient`, or by instantiating via the constructor. - -```python -# From AlgorandClient -composer_from_algorand = algorand.new_group() - -# From AppClient -composer_from_app_client = app_client.algorand.new_group() - -# From constructor -composer_from_constructor = TransactionComposer( - algod=algod, - # Return the TransactionSigner for this address - get_signer=lambda address: signer -) - -# From constructor with optional params -composer_from_constructor = TransactionComposer( - algod=algod, - # Return the TransactionSigner for this address - get_signer=lambda address: signer, - # Custom function to get suggested params - get_suggested_params=lambda: algod.suggested_params(), - # Number of rounds the transaction should be valid for - default_validity_window=1000, - # Optional AppManager instance for TEAL compilation - app_manager=AppManager(algod) -) -``` - -## Constructing a transaction - -To construct a transaction you need to add it to the composer, passing in the relevant params object for that transaction. Params are Python dataclasses aavailable for import from `algokit_utils.transactions`. - -Parameter types include: - -- `PaymentParams` - For ALGO transfers -- `AssetCreateParams` - For creating ASAs -- `AssetConfigParams` - For reconfiguring ASAs -- `AssetTransferParams` - For ASA transfers -- `AssetOptInParams` - For opting in to ASAs -- `AssetOptOutParams` - For opting out of ASAs -- `AssetDestroyParams` - For destroying ASAs -- `AssetFreezeParams` - For freezing ASA balances -- `AppCreateParams` - For creating applications -- `AppCreateMethodCallParams` - For creating applications with ABI method calls -- `AppCallParams` - For calling applications -- `AppCallMethodCallParams` - For calling ABI methods on applications -- `AppUpdateParams` - For updating applications -- `AppUpdateMethodCallParams` - For updating applications with ABI method calls -- `AppDeleteParams` - For deleting applications -- `AppDeleteMethodCallParams` - For deleting applications with ABI method calls -- `OnlineKeyRegistrationParams` - For online key registration transactions -- `OfflineKeyRegistrationParams` - For offline key registration transactions - -The methods to construct a transaction are all named `add_{transaction_type}` and return an instance of the composer so they can be chained together fluently to construct a transaction group. - -For example: - -```python -from algokit_utils import AlgoAmount -from algokit_utils.transactions import AppCallMethodCallParams, PaymentParams - -result = ( - algorand.new_group() - .add_payment(PaymentParams( - sender="SENDER", - receiver="RECEIVER", - amount=AlgoAmount.from_micro_algos(100), - note=b"Payment note" - )) - .add_app_call_method_call(AppCallMethodCallParams( - sender="SENDER", - app_id=123, - method=abi_method, - args=[1, 2, 3], - boxes=[box_reference] # Optional box references - )) -) -``` - -## Simulating a transaction - -Transactions can be simulated using the simulate endpoint in algod, which enables evaluating the transaction on the network without it actually being committed to a block. -This is a powerful feature, which has a number of options which are detailed in the [simulate API docs](https://dev.algorand.co/reference/rest-apis/output/#simulatetransaction). - -The `simulate()` method accepts several optional parameters that are passed through to the algod simulate endpoint: - -- `allow_more_logs: bool | None` - Allow more logs than standard -- `allow_empty_signatures: bool | None` - Allow transactions without signatures -- `allow_unnamed_resources: bool | None` - Allow unnamed resources in app calls -- `extra_opcode_budget: int | None` - Additional opcode budget -- `exec_trace_config: SimulateTraceConfig | None` - Execution trace configuration -- `simulation_round: int | None` - Round to simulate at -- `skip_signatures: int | None` - Skip signature verification - -For example: - -```python -result = ( - algorand.new_group() - .add_payment(PaymentParams( - sender="SENDER", - receiver="RECEIVER", - amount=AlgoAmount.from_micro_algos(100) - )) - .add_app_call_method_call(AppCallMethodCallParams( - sender="SENDER", - app_id=123, - method=abi_method, - args=[1, 2, 3] - )) - .simulate() -) - -# Access simulation results -simulate_response = result.simulate_response -confirmations = result.confirmations -transactions = result.transactions -returns = result.returns # ABI returns if any -``` - -### Simulate without signing - -There are situations where you may not be able to (or want to) sign the transactions when executing simulate. -In these instances you should set `skip_signatures=True` which automatically builds empty transaction signers and sets both `fix-signers` and `allow-empty-signatures` to `True` when sending the algod API call. - -For example: - -```python -result = ( - algorand.new_group() - .add_payment(PaymentParams( - sender="SENDER", - receiver="RECEIVER", - amount=AlgoAmount.from_micro_algos(100) - )) - .add_app_call_method_call(AppCallMethodCallParams( - sender="SENDER", - app_id=123, - method=abi_method, - args=[1, 2, 3] - )) - .simulate( - skip_signatures=True, - allow_more_logs=True, # Optional: allow more logs - extra_opcode_budget=700 # Optional: increase opcode budget - ) -) -``` - -### Resource Population - -The `TransactionComposer` includes automatic resource population capabilities for application calls. When sending or simulating transactions, it can automatically detect and populate required references for: - -- Account references -- Application references -- Asset references -- Box references - -This happens automatically when either: - -1. The global `algokit_utils.config` instance is set to `populate_app_call_resources=True` (default is `False`) -2. The `populate_app_call_resources` parameter is explicitly passed as `True` when sending transactions - -```python -# Automatic resource population -result = ( - algorand.new_group() - .add_app_call_method_call(AppCallMethodCallParams( - sender="SENDER", - app_id=123, - method=abi_method, - args=[1, 2, 3] - # Resources will be automatically populated! - )) - .send(params=SendParams(populate_app_call_resources=True)) -) - -# Or disable automatic population -result = ( - algorand.new_group() - .add_app_call_method_call(AppCallMethodCallParams( - sender="SENDER", - app_id=123, - method=abi_method, - args=[1, 2, 3], - # Explicitly specify required resources - account_references=["ACCOUNT"], - app_references=[456], - asset_references=[789], - box_references=[box_reference] - )) - .send(params=SendParams(populate_app_call_resources=False)) -) -``` - -The resource population: - -- Respects the maximum limits (4 for accounts, 8 for foreign references) -- Handles cross-reference resources efficiently (e.g., asset holdings and local state) -- Automatically distributes resources across multiple transactions in a group when needed -- Raises descriptive errors if resource limits are exceeded - -This feature is particularly useful when: - -- Working with complex smart contracts that access various resources -- Building transaction groups where resources need to be coordinated -- Developing applications where resource requirements may change dynamically - -Note: Resource population uses simulation under the hood to detect required resources, so it may add a small overhead to transaction preparation time. - -### Covering App Call Inner Transaction Fees - -`cover_app_call_inner_transaction_fees` automatically calculate the required fee for a parent app call transaction that sends inner transactions. It leverages the simulate endpoint to discover the inner transactions sent and calculates a fee delta to resolve the optimal fee. This feature also takes care of accounting for any surplus transaction fee at the various levels, so as to effectively minimise the fees needed to successfully handle complex scenarios. This setting only applies when you have constucted at least one app call transaction. - -For example: - -```python -myMethod = algosdk.ABIMethod.fromSignature('my_method()void') -result = algorand - .new_group() - .add_app_call_method_call(AppCallMethodCallParams( - sender: 'SENDER', - app_id=123, - method=myMethod, - args=[1, 2, 3], - max_fee=AlgoAmount.from_micro_algo(5000), # NOTE: a maxFee value is required when enabling coverAppCallInnerTransactionFees - )) - .send(send_params={"cover_app_call_inner_transaction_fees": True}) -``` - -Assuming the app account is not covering any of the inner transaction fees, if `my_method` in the above example sends 2 inner transactions, then the fee calculated for the parent transaction will be 3000 µALGO when the transaction is sent to the network. - -The above example also has a `max_fee` of 5000 µALGO specified. An exception will be thrown if the transaction fee execeeds that value, which allows you to set fee limits. The `max_fee` field is required when enabling `cover_app_call_inner_transaction_fees`. - -Because `max_fee` is required and an `algosdk.Transaction` does not hold any max fee information, you cannot use the generic `add_transaction()` method on the composer with `cover_app_call_inner_transaction_fees` enabled. Instead use the below, which provides a better overall experience: - -```python -my_method = algosdk.abi.Method.from_signature('my_method()void') - -# Does not work -result = algorand - .new_group() - .add_transaction(localnet.algorand.create_transaction.app_call_method_call( - AppCallMethodCallParams( - sender='SENDER', - app_id=123, - method=my_method, - args=[1, 2, 3], - max_fee=AlgoAmount.from_micro_algos(5000), # This is only used to create the algosdk.Transaction object and isn't made available to the composer. - ) - ).transactions[0] - ) - .send(send_params={"cover_app_call_inner_transaction_fees": True}) - -# Works as expected -result = algorand - .new_group() - .add_app_call_method_call(AppCallMethodCallParams( - sender='SENDER', - app_id=123, - method=my_method, - args=[1, 2, 3], - max_fee=AlgoAmount.from_micro_algos(5000), - )) - .send(send_params={"cover_app_call_inner_transaction_fees": True}) -``` - -A more complex valid scenario which leverages an app client to send an ABI method call with ABI method call transactions argument is below: - -```python -app_factory = algorand.client.get_app_factory( - app_spec='APP_SPEC', - default_sender=sender.addr, -) - -app_client_1, _ = app_factory.send.bare.create() -app_client_2, _ = app_factory.send.bare.create() - -payment_arg = algorand.create_transaction.payment( - PaymentParams( - sender=sender.addr, - receiver=receiver.addr, - amount=AlgoAmount.from_micro_algos(1), - ) -) - -# Note the use of .params. here, this ensure that maxFee is still available to the composer -app_call_arg = app_client_2.params.call( - AppCallMethodCallParams( - method='my_other_method', - args=[], - max_fee=AlgoAmount.from_micro_algos(2000), - ) -) - -result = app_client_1.algorand - .new_group() - .add_app_call_method_call( - app_client_1.params.call( - AppClientMethodCallParams( - method='my_method', - args=[payment_arg, app_call_arg], - max_fee=AlgoAmount.from_micro_algos(5000), - ) - ), - ) - .send({"cover_app_call_inner_transaction_fees": True}) -``` - -This feature should efficiently calculate the minimum fee needed to execute an app call transaction with inners, however we always recommend testing your specific scenario behaves as expected before releasing. - -## Error Transformers - -Error transformers provide a powerful mechanism for enhancing error messages and debugging information when transactions fail. They allow you to register custom functions that can transform generic blockchain errors into more meaningful, application-specific error messages. - -### How Error Transformers Work - -Error transformers are functions that take an `Exception` as input and return either a transformed `Exception` or the original exception unchanged. They are called in sequence during transaction simulation or sending when errors occur, allowing for a chain of transformations. - -```python -from typing import Exception - -def my_error_transformer(error: Exception) -> Exception: - """Transform generic errors into more meaningful ones.""" - if "asset missing" in str(error).lower(): - return Exception("Asset not found: Please check the asset ID") - return error # Return unchanged if not applicable -``` - -### Registering Error Transformers - -Error transformers can be registered at two levels: - -#### 1. AlgorandClient Level (Global) - -Register error transformers globally to apply to all transaction groups created from this client: - -```python -from algokit_utils import AlgorandClient - -algorand = AlgorandClient.default_localnet() - -# Register a global error transformer -algorand.register_error_transformer(my_error_transformer) - -# All transaction groups from this client will use the transformer -result = algorand.new_group().add_payment(payment_params).send() - -# Unregister if needed -algorand.unregister_error_transformer(my_error_transformer) -``` - -#### 2. TransactionComposer Level (Per Group) - -Register error transformers for a specific transaction group: - -```python -# Register transformer for this specific group -composer = algorand.new_group() -composer.register_error_transformer(my_error_transformer) - -result = composer.add_payment(payment_params).send() -``` - -### Error Transformer Chain - -Multiple error transformers can be registered and they will be called in the order they were registered: - -```python -def transformer_1(error: Exception) -> Exception: - if "missing from" in str(error): - return Exception("ASSET MISSING???") - return error - -def transformer_2(error: Exception) -> Exception: - if str(error) == "ASSET MISSING???": - return Exception("ASSET MISSING: Check your asset configuration") - return error - -# Register multiple transformers -algorand.register_error_transformer(transformer_1) -algorand.register_error_transformer(transformer_2) - -# They will be applied in sequence: error -> transformer_1 -> transformer_2 -``` - -### App Client Integration - -The `AppClient` automatically registers error transformers to provide enhanced debugging for application-specific logic errors. These transformers: - -- Parse logic errors from the blockchain -- Apply source map information when available -- Filter errors to only handle those relevant to the specific application -- For new applications (app_id=0), compare program bytecode to ensure error handling is applied to the correct application - -```python -from algokit_utils import AppClient - -# Error transformer is automatically registered -app_client = AppClient( - app_spec=app_spec, - app_id=123, # Existing app - algorand=algorand -) - -# App-specific logic errors will be enhanced with source maps and debugging info -try: - result = app_client.send.call("my_method", args=[]) -except LogicError as e: - # Enhanced error with source information - print(f"Logic error at PC {e.pc}: {e.message}") - print(f"Source trace:\n{e.trace()}") -``` - -### Best Practices - -1. **Keep transformers focused**: Each transformer should handle a specific type of error or transformation. -2. **Return original on no match**: Always return the original error if your transformer doesn’t apply: - ```python - def my_transformer(error: Exception) -> Exception: - if not should_handle(error): - return error # Important: return unchanged - return transform_error(error) - ``` -3. **Chain appropriately**: Register transformers in logical order, from most specific to most general. -4. **Handle exceptions**: Ensure your transformer doesn’t raise exceptions: - ```python - def safe_transformer(error: Exception) -> Exception: - try: - return transform_error(error) - except Exception: - return error # Fallback to original - ``` -5. **Use type information**: Consider the error type when transforming: - ```python - def typed_transformer(error: Exception) -> Exception: - if isinstance(error, AlgodHTTPError): - return handle_algod_error(error) - elif isinstance(error, LogicError): - return enhance_logic_error(error) - return error - ``` - -### Error Types - -Common error types you might encounter and transform: - -- **`AlgodHTTPError`**: Network or node-related errors -- **`LogicError`**: Smart contract logic errors (automatically handled by AppClient) -- **Generic `Exception`**: General transaction or validation errors - -Error transformers work with both `send()` and `simulate()` operations, providing consistent error enhancement across all transaction execution paths. - -#### Read-only calls - -When invoking a readonly method, the transaction is simulated rather than being fully processed by the network. This allows users to call these methods without paying a fee. - -Even though no actual fee is paid, the simulation still evaluates the transaction as if a fee was being paid, therefore op budget and fee coverage checks are still performed. - -Because no fee is actually paid, calculating the minimum fee required to successfully execute the transaction is not required, and therefore we don’t need to send an additional simulate call to calculate the minimum fee, like we do with a non readonly method call. - -The behaviour of enabling `cover_app_call_inner_transaction_fees` for readonly method calls is very similar to non readonly method calls, however is subtly different as we use `max_fee` as the transaction fee when executing the readonly method call. - -### Covering App Call Op Budget - -The high level Algorand contract authoring languages all have support for ensuring appropriate app op budget is available via `ensure_budget` in Algorand Python, `ensureBudget` in Algorand TypeScript and `increaseOpcodeBudget` in TEALScript. This is great, as it allows contract authors to ensure appropriate budget is available by automatically sending op-up inner transactions to increase the budget available. These op-up inner transactions require the fees to be covered by an account, which is generally the responsibility of the application consumer. - -Application consumers may not be immediately aware of the number of op-up inner transactions sent, so it can be difficult for them to determine the exact fees required to successfully execute an application call. Fortunately the `cover_app_call_inner_transaction_fees` setting above can be leveraged to automatically cover the fees for any op-up inner transaction that an application sends. Additionally if a contract author decides to cover the fee for an op-up inner transaction, then the application consumer will not be charged a fee for that transaction. diff --git a/docs/markdown/capabilities/transaction.md b/docs/markdown/capabilities/transaction.md deleted file mode 100644 index c0f692e2..00000000 --- a/docs/markdown/capabilities/transaction.md +++ /dev/null @@ -1,135 +0,0 @@ -# Transaction management - -Transaction management is one of the core capabilities provided by AlgoKit Utils. It allows you to construct, simulate and send single or grouped transactions with consistent and highly configurable semantics, including configurable control of transaction notes, logging, fees, multiple sender account types, and sending behavior. - -## Transaction Results - -All AlgoKit Utils functions that send transactions return either a `SendSingleTransactionResult` or `SendAtomicTransactionComposerResults`, providing consistent mechanisms to interpret transaction outcomes. - -### SendSingleTransactionResult - -The base `SendSingleTransactionResult` class is used for single transactions: - -```python -@dataclass(frozen=True, kw_only=True) -class SendSingleTransactionResult: - transaction: TransactionWrapper # Last transaction - confirmation: AlgodResponseType # Last confirmation - group_id: str - tx_id: str | None = None # Transaction ID of the last transaction - tx_ids: list[str] # All transaction IDs in the group - transactions: list[TransactionWrapper] - confirmations: list[AlgodResponseType] - returns: list[ABIReturn] | None = None # ABI returns if applicable -``` - -Common variations include: - -- `SendSingleAssetCreateTransactionResult` - Adds `asset_id` -- `SendAppTransactionResult` - Adds `abi_return` -- `SendAppUpdateTransactionResult` - Adds compilation results -- `SendAppCreateTransactionResult` - Adds `app_id` and `app_address` - -### SendAtomicTransactionComposerResults - -When using the atomic transaction composer directly via `TransactionComposer.send()` or `TransactionComposer.simulate()`, you’ll receive a `SendAtomicTransactionComposerResults`: - -```python -@dataclass -class SendAtomicTransactionComposerResults: - group_id: str # The group ID if this was a transaction group - confirmations: list[AlgodResponseType] # The confirmation info for each transaction - tx_ids: list[str] # The transaction IDs that were sent - transactions: list[TransactionWrapper] # The transactions that were sent - returns: list[ABIReturn] # The ABI return values from any ABI method calls - simulate_response: dict[str, Any] | None = None # Simulation response if simulated -``` - -### Application-specific Result Types - -When working with applications via `AppClient` or `AppFactory`, you’ll get enhanced result types that provide direct access to parsed ABI values: - -- `SendAppFactoryTransactionResult` -- `SendAppUpdateFactoryTransactionResult` -- `SendAppCreateFactoryTransactionResult` - -These types extend the base transaction results to add an `abi_value` field that contains the parsed ABI return value according to the ARC-56 specification. The `Arc56ReturnValueType` can be: - -- A primitive ABI value (bool, int, str, bytes) -- An ABI struct (as a Python dict) -- None (for void returns) - -### Where You’ll Encounter Each Result Type - -Different interfaces return different result types: - -1. **Direct Transaction Composer** - - `TransactionComposer.send()` → `SendAtomicTransactionComposerResults` - - `TransactionComposer.simulate()` → `SendAtomicTransactionComposerResults` -2. **AlgorandClient Methods** - - `.send.payment()` → `SendSingleTransactionResult` - - `.send.asset_create()` → `SendSingleAssetCreateTransactionResult` - - `.send.app_call()` → `SendAppTransactionResult` (contains raw ABI return) - - `.send.app_create()` → `SendAppCreateTransactionResult` (with app ID/address) - - `.send.app_update()` → `SendAppUpdateTransactionResult` (with compilation info) -3. **AppClient Methods** - - `.call()` → `SendAppTransactionResult` - - `.create()` → `SendAppCreateTransactionResult` - - `.update()` → `SendAppUpdateTransactionResult` -4. **AppFactory Methods** - - `.create()` → `SendAppCreateFactoryTransactionResult` - - `.call()` → `SendAppFactoryTransactionResult` - - `.update()` → `SendAppUpdateFactoryTransactionResult` - -Example usage with AppFactory for easy access to ABI returns: - -```python -# Using AppFactory -result = app_factory.send.call(AppCallMethodCallParams( - method="my_method", - args=[1, 2, 3], - sender=sender -)) -# Access the parsed ABI return value directly -parsed_value = result.abi_value # Already decoded per ARC-56 spec - -# Compared to base AppClient where you need to parse manually -base_result = app_client.send.call(AppCallMethodCallParams( - method="my_method", - args=[1, 2, 3], - sender=sender -)) -# Need to manually handle ABI return parsing -if base_result.abi_return: - parsed_value = base_result.abi_return.value -``` - -Key differences between result types: - -1. **Base Transaction Results** (`SendSingleTransactionResult`) - - Focus on transaction confirmation details - - Include group support but optimized for single transactions - - No direct ABI value parsing -2. **Atomic Transaction Results** (`SendAtomicTransactionComposerResults`) - - Built for transaction groups - - Include simulation support - - Raw ABI returns via `.returns` - - No single transaction convenience fields -3. **Application Results** (`SendAppTransactionResult` family) - - Add application-specific fields (`app_id`, compilation results) - - Include raw ABI returns via `.abi_return` - - Base application transaction support -4. **Factory Results** (`SendAppFactoryTransactionResult` family) - - Highest level of abstraction - - Direct access to parsed ABI values via `.abi_value` - - Automatic ARC-56 compliant value parsing - - Combines app-specific fields with parsed ABI returns - -## Further reading - -To understand how to create, simulate and send transactions consult: - -- The [`TransactionComposer`](transaction-composer.md) documentation for composing transaction groups -- The [`AlgorandClient`](algorand-client.md) documentation for a high-level interface to send transactions - -The transaction composer documentation covers the details of constructing transactions and transaction groups, while the Algorand client documentation covers the high-level interface for sending transactions. diff --git a/docs/markdown/capabilities/transfer.md b/docs/markdown/capabilities/transfer.md deleted file mode 100644 index 7a0a3ffe..00000000 --- a/docs/markdown/capabilities/transfer.md +++ /dev/null @@ -1,151 +0,0 @@ -# Algo transfers (payments) - -Algo transfers, or [payments](https://dev.algorand.co/concepts/transactions/types#payment-transaction), is a higher-order use case capability provided by AlgoKit Utils that builds on top of the core capabilities, particularly [Algo amount handling](amount.md) and [Transaction management](transaction.md). It allows you to easily initiate Algo transfers between accounts, including dispenser management and idempotent account funding. - -To see some usage examples check out the automated tests in the repository. - -## `payment` - -The key function to facilitate Algo transfers is `algorand.send.payment(params)` (immediately send a single payment transaction), `algorand.create_transaction.payment(params)` (construct a payment transaction), or `algorand.new_group().add_payment(params)` (add payment to a group of transactions) per [`AlgorandClient`](algorand-client.md) [transaction semantics](algorand-client.md#creating-and-issuing-transactions). - -The base type for specifying a payment transaction is `PaymentParams`, which has the following parameters in addition to the [common transaction parameters](algorand-client.md#transaction-parameters): - -- `receiver: str` - The address of the account that will receive the Algo -- `amount: AlgoAmount` - The amount of Algo to send -- `close_remainder_to: Optional[str]` - If given, close the sender account and send the remaining balance to this address (**warning:** use this carefully as it can result in loss of funds if used incorrectly) - -```python -# Minimal example -result = algorand_client.send.payment( - PaymentParams( - sender="SENDERADDRESS", - receiver="RECEIVERADDRESS", - amount=AlgoAmount(4, "algo") - ) -) - -# Advanced example -result2 = algorand_client.send.payment( - PaymentParams( - sender="SENDERADDRESS", - receiver="RECEIVERADDRESS", - amount=AlgoAmount(4, "algo"), - close_remainder_to="CLOSEREMAINDERTOADDRESS", - lease="lease", - note=b"note", - # Use this with caution, it's generally better to use algorand_client.account.rekey_account - rekey_to="REKEYTOADDRESS", - # You wouldn't normally set this field - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount(1000, "microalgo"), - static_fee=AlgoAmount(1000, "microalgo"), - # Max fee doesn't make sense with extra_fee AND static_fee - # already specified, but here for completeness - max_fee=AlgoAmount(3000, "microalgo"), - # Signer only needed if you want to provide one, - # generally you'd register it with AlgorandClient - # against the sender and not need to pass it in - signer=transaction_signer, - ), - send_params=SendParams( - max_rounds_to_wait=5, - suppress_log=True, - ) -) -``` - -## `ensure_funded` - -The `ensure_funded` function automatically funds an account to maintain a minimum amount of [disposable Algo](https://dev.algorand.co/concepts/smart-contracts/costs-constraints#mbr). This is particularly useful for automation and deployment scripts that get run multiple times and consume Algo when run. - -There are 3 variants of this function: - -- `algorand_client.account.ensure_funded(account_to_fund, dispenser_account, min_spending_balance, options)` - Funds a given account using a dispenser account as a funding source such that the given account has a certain amount of Algo free to spend (accounting for Algo locked in minimum balance requirement). -- `algorand_client.account.ensure_funded_from_environment(account_to_fund, min_spending_balance, options)` - Funds a given account using a dispenser account retrieved from the environment, per the `dispenser_from_environment` method, as a funding source such that the given account has a certain amount of Algo free to spend (accounting for Algo locked in minimum balance requirement). - - **Note:** requires environment variables to be set. - - The dispenser account is retrieved from the account mnemonic stored in `DISPENSER_MNEMONIC` and optionally `DISPENSER_SENDER` - if it’s a rekeyed account, or against default LocalNet if no environment variables present. -- `algorand_client.account.ensure_funded_from_testnet_dispenser_api(account_to_fund, dispenser_client, min_spending_balance, options)` - Funds a given account using the [TestNet Dispenser API](https://github.com/algorandfoundation/algokit/blob/main/docs/testnet_api.md) as a funding source such that the account has a certain amount of Algo free to spend (accounting for Algo locked in minimum balance requirement). - -The general structure of these calls is similar, they all take: - -- `account_to_fund: str | Account` - Address or signing account of the account to fund -- The source (dispenser): - - In `ensure_funded`: `dispenser_account: str | Account` - the address or signing account of the account to use as a dispenser - - In `ensure_funded_from_environment`: Not specified, loaded automatically from the ephemeral environment - - In `ensure_funded_from_testnet_dispenser_api`: `dispenser_client: TestNetDispenserApiClient` - a client instance of the TestNet dispenser API -- `min_spending_balance: AlgoAmount` - The minimum balance of Algo that the account should have available to spend (i.e., on top of the minimum balance requirement) -- An `options` object, which has: - - [Common transaction parameters](algorand-client.md#transaction-parameters) (not for TestNet Dispenser API) - - [Execution parameters](algorand-client.md#sending-a-single-transaction) (not for TestNet Dispenser API) - - `min_funding_increment: Optional[AlgoAmount]` - When issuing a funding amount, the minimum amount to transfer; this avoids many small transfers if this function gets called often on an active account - -### Examples - -```python -# From account - -# Basic example -algorand_client.account.ensure_funded("ACCOUNTADDRESS", "DISPENSERADDRESS", AlgoAmount(1, "algo")) -# With configuration -algorand_client.account.ensure_funded( - "ACCOUNTADDRESS", - "DISPENSERADDRESS", - AlgoAmount(1, "algo"), - min_funding_increment=AlgoAmount(2, "algo"), - fee=AlgoAmount(1000, "microalgo"), - send_params=SendParams( - suppress_log=True, - ), -) - -# From environment - -# Basic example -algorand_client.account.ensure_funded_from_environment("ACCOUNTADDRESS", AlgoAmount(1, "algo")) -# With configuration -algorand_client.account.ensure_funded_from_environment( - "ACCOUNTADDRESS", - AlgoAmount(1, "algo"), - min_funding_increment=AlgoAmount(2, "algo"), - fee=AlgoAmount(1000, "microalgo"), - send_params=SendParams( - suppress_log=True, - ), -) - -# TestNet Dispenser API - -# Basic example -algorand_client.account.ensure_funded_from_testnet_dispenser_api( - "ACCOUNTADDRESS", - algorand_client.client.get_testnet_dispenser_from_environment(), - AlgoAmount(1, "algo") -) -# With configuration -algorand_client.account.ensure_funded_from_testnet_dispenser_api( - "ACCOUNTADDRESS", - algorand_client.client.get_testnet_dispenser_from_environment(), - AlgoAmount(1, "algo"), - min_funding_increment=AlgoAmount(2, "algo"), -) -``` - -All 3 variants return an `EnsureFundedResponse` (and the first two also return a [single transaction result](algorand-client.md#sending-a-single-transaction)) if a funding transaction was needed, or `None` if no transaction was required: - -- `amount_funded: AlgoAmount` - The number of Algo that was paid -- `transaction_id: str` - The ID of the transaction that funded the account - -If you are using the TestNet Dispenser API then the `transaction_id` is useful if you want to use the [refund functionality](dispenser-client.md#registering-a-refund). - -## Dispenser - -If you want to programmatically send funds to an account so it can transact then you will often need a “dispenser” account that has a store of Algo that can be sent and a private key available for that dispenser account. - -There’s a number of ways to get a dispensing account in AlgoKit Utils: - -- Get a dispenser via [account manager](account.md#dispenser) - either automatically from [LocalNet](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/localnet.md) or from the environment -- By programmatically creating one of the many account types via [account manager](account.md#accounts) -- By programmatically interacting with [KMD](account.md#kmd-account-management) if running against LocalNet -- By using the [AlgoKit TestNet Dispenser API client](dispenser-client.md) which can be used to fund accounts on TestNet via a dedicated API service diff --git a/docs/markdown/capabilities/typed-app-clients.md b/docs/markdown/capabilities/typed-app-clients.md deleted file mode 100644 index d886ae45..00000000 --- a/docs/markdown/capabilities/typed-app-clients.md +++ /dev/null @@ -1,184 +0,0 @@ -# Typed application clients - -Typed application clients are automatically generated, typed Python deployment and invocation clients for smart contracts that have a defined [ARC-56](https://github.com/algorandfoundation/ARCs/pull/258) or [ARC-32](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0032.md) application specification so that the development experience is easier with less upskill ramp-up and less deployment errors. These clients give you a type-safe, intellisense-driven experience for invoking the smart contract. - -Typed application clients are the recommended way of interacting with smart contracts. If you don’t have/want a typed client, but have an ARC-56/ARC-32 app spec then you can use the [non-typed application clients](app-client.md) and if you want to call a smart contract you don’t have an app spec file for you can use the underlying [app management](app.md) and [app deployment](app-deploy.md) functionality to manually construct transactions. - -## Generating an app spec - -You can generate an app spec file: - -- Using [Algorand Python](https://algorandfoundation.github.io/puya/#quick-start) -- Using [TEALScript](https://tealscript.netlify.app/tutorials/hello-world/0004-artifacts/) -- By hand by following the specification [ARC-56](https://github.com/algorandfoundation/ARCs/pull/258)/[ARC-32](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0032.md) -- Using [Beaker](https://algorand-devrel.github.io/beaker/html/usage.html) (PyTEAL) *(DEPRECATED)* - -## Generating a typed client - -To generate a typed client from an app spec file you can use [AlgoKit CLI](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/generate.md#1-typed-clients): - -```default -> algokit generate client application.json --output /absolute/path/to/client.py -``` - -Note: AlgoKit Utils >= 3.0.0 is compatible with the older 1.x.x generated typed clients, however if you want to utilise the new features or leverage ARC-56 support, you will need to generate using >= 2.x.x. See [AlgoKit CLI generator version pinning](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/generate.md#version-pinning) for more information on how to lock to a specific version. - -## Getting a typed client instance - -To get an instance of a typed client you can use an [`AlgorandClient`](algorand-client.md) instance or a typed app [`Factory`]() instance. - -The approach to obtaining a client instance depends on how many app clients you require for a given app spec and if the app has already been deployed: - -### App is deployed - -#### Resolve App by ID - -**Single Typed App Client Instance:** - -```python -# Typed: Using the AlgorandClient extension method -typed_client = algorand.client.get_typed_app_client_by_id( - MyContractClient, # Generated typed client class - app_id=1234, - # ... -) -# or Typed: Using the generated client class directly -typed_client = MyContractClient( - algorand, - app_id=1234, - # ... -) -``` - -**Multiple Typed App Client Instances:** - -```python -# Typed: Using a typed factory to get multiple client instances -typed_client1 = typed_factory.get_app_client_by_id( - app_id=1234, - # ... -) -typed_client2 = typed_factory.get_app_client_by_id( - app_id=4321, - # ... -) -``` - -#### Resolve App by Creator and Name - -**Single Typed App Client Instance:** - -```python -# Typed: Using the AlgorandClient extension method -typed_client = algorand.client.get_typed_app_client_by_creator_and_name( - MyContractClient, # Generated typed client class - creator_address="CREATORADDRESS", - app_name="contract-name", - # ... -) -# or Typed: Using the static method on the generated client class -typed_client = MyContractClient.from_creator_and_name( - algorand, - creator_address="CREATORADDRESS", - app_name="contract-name", - # ... -) -``` - -**Multiple Typed App Client Instances:** - -```python -# Typed: Using a typed factory to get multiple client instances by name -typed_client1 = typed_factory.get_app_client_by_creator_and_name( - creator_address="CREATORADDRESS", - app_name="contract-name", - # ... -) -typed_client2 = typed_factory.get_app_client_by_creator_and_name( - creator_address="CREATORADDRESS", - app_name="contract-name-2", - # ... -) -``` - -### App is not deployed - -#### Deploy a New App - -```python -# Typed: For typed clients, you call a specific creation method rather than generic 'create' -typed_client, response = typed_factory.send.create.{METHODNAME}( - # ... -) -``` - -#### Deploy or Resolve App Idempotently by Creator and Name - -```python -# Typed: Using the deploy method on a typed factory -typed_client, response = typed_factory.deploy( - on_update=OnUpdate.UpdateApp, - on_schema_break=OnSchemaBreak.ReplaceApp, - # The parameters for create/update/delete would be specific to your generated client - app_name="contract-name", - # ... -) -``` - -### Creating a typed factory instance - -If your scenario calls for an app factory, you can create one using the below: - -```python -# Typed: Using the AlgorandClient extension method -typed_factory = algorand.client.get_typed_app_factory(MyContractFactory) # Generated factory class -# or Typed: Using the factory class constructor directly -typed_factory = MyContractFactory(algorand) -``` - -## Client usage - -See the [official usage docs](https://github.com/algorandfoundation/algokit-client-generator-py/blob/main/docs/usage.md) for full details about typed clients. - -Below is a realistic example that deploys a contract, funds it if newly created, and calls a `"hello"` method: - -```python -# Typed: Complete example using a typed application client -import algokit_utils -from artifacts.hello_world.hello_world_client import ( - HelloArgs, # Generated args class - HelloWorldFactory, # Generated factory class -) - -# Get Algorand client from environment variables -algorand = algokit_utils.AlgorandClient.from_environment() -deployer = algorand.account.from_environment("DEPLOYER") - -# Create the typed app factory -typed_factory = algorand.client.get_typed_app_factory( - HelloWorldFactory, default_sender=deployer.address -) - -# Deploy idempotently - creates if it doesn't exist or updates if changed -typed_client, result = typed_factory.deploy( - on_update=algokit_utils.OnUpdate.AppendApp, - on_schema_break=algokit_utils.OnSchemaBreak.AppendApp, -) - -# Fund the app with 1 ALGO if it's newly created -if result.operation_performed in [ - algokit_utils.OperationPerformed.Create, - algokit_utils.OperationPerformed.Replace, -]: - algorand.send.payment( - algokit_utils.PaymentParams( - amount=algokit_utils.AlgoAmount(algo=1), - sender=deployer.address, - receiver=typed_client.app_address, - ) - ) - -# Call the hello method on the smart contract -name = "world" -response = typed_client.send.hello(args=HelloArgs(name=name)) # Using generated args class -``` diff --git a/docs/markdown/index.md b/docs/markdown/index.md deleted file mode 100644 index 3718d0d6..00000000 --- a/docs/markdown/index.md +++ /dev/null @@ -1,223 +0,0 @@ -# AlgoKit Python Utilities - -A set of core Algorand utilities written in Python and released via PyPi that make it easier to build solutions on Algorand. This project is part of [AlgoKit](https://github.com/algorandfoundation/algokit-cli). - -The goal of this library is to provide intuitive, productive utility functions that make it easier, quicker and safer to build applications on Algorand. Largely these functions wrap the underlying Algorand SDK, but provide a higher level interface with sensible defaults and capabilities for common tasks. - -#### NOTE -If you prefer TypeScript there’s an equivalent [TypeScript utility library](https://github.com/algorandfoundation/algokit-utils-ts). - -[Core principles](#core-principles) | [Installation](#installation) | [Usage](#usage) | [Config and logging](#config-logging) | [Capabilities](#capabilities) | [Reference docs](#reference-documentation) - -# Contents - -* [Account management](capabilities/account.md) - * [`AccountManager`](capabilities/account.md#accountmanager) - * [`TransactionSignerAccountProtocol`](capabilities/account.md#transactionsigneraccountprotocol) - * [Registering a signer](capabilities/account.md#registering-a-signer) - * [Default signer](capabilities/account.md#default-signer) - * [Get a signer](capabilities/account.md#get-a-signer) - * [Accounts](capabilities/account.md#accounts) - * [Rekey account](capabilities/account.md#rekey-account) - * [KMD account management](capabilities/account.md#kmd-account-management) -* [Algorand client](capabilities/algorand-client.md) - * [Accessing SDK clients](capabilities/algorand-client.md#accessing-sdk-clients) - * [Accessing manager class instances](capabilities/algorand-client.md#accessing-manager-class-instances) - * [Creating and issuing transactions](capabilities/algorand-client.md#creating-and-issuing-transactions) -* [Algo amount handling](capabilities/amount.md) - * [`AlgoAmount`](capabilities/amount.md#algoamount) -* [App client and App factory](capabilities/app-client.md) - * [`AppFactory`](capabilities/app-client.md#appfactory) - * [`AppClient`](capabilities/app-client.md#appclient) - * [Dynamically creating clients for a given app spec](capabilities/app-client.md#dynamically-creating-clients-for-a-given-app-spec) - * [Creating and deploying an app](capabilities/app-client.md#creating-and-deploying-an-app) - * [Updating and deleting an app](capabilities/app-client.md#updating-and-deleting-an-app) - * [Calling the app](capabilities/app-client.md#calling-the-app) - * [Funding the app account](capabilities/app-client.md#funding-the-app-account) - * [Reading state](capabilities/app-client.md#reading-state) - * [Handling logic errors and diagnosing errors](capabilities/app-client.md#handling-logic-errors-and-diagnosing-errors) - * [Default arguments](capabilities/app-client.md#default-arguments) -* [App deployment](capabilities/app-deploy.md) - * [Smart contract development lifecycle](capabilities/app-deploy.md#smart-contract-development-lifecycle) - * [`AppDeployer`](capabilities/app-deploy.md#appdeployer) - * [Deployment metadata](capabilities/app-deploy.md#deployment-metadata) - * [Lookup deployed apps by name](capabilities/app-deploy.md#lookup-deployed-apps-by-name) - * [Performing a deployment](capabilities/app-deploy.md#performing-a-deployment) -* [App management](capabilities/app.md) - * [`AppManager`](capabilities/app.md#appmanager) - * [Calling apps](capabilities/app.md#calling-apps) - * [Accessing state](capabilities/app.md#accessing-state) - * [Getting app information](capabilities/app.md#getting-app-information) - * [Box references](capabilities/app.md#box-references) - * [Common app parameters](capabilities/app.md#common-app-parameters) -* [Assets](capabilities/asset.md) - * [`AssetManager`](capabilities/asset.md#assetmanager) - * [Asset Information](capabilities/asset.md#asset-information) - * [Bulk Operations](capabilities/asset.md#bulk-operations) - * [Get Asset Information](capabilities/asset.md#get-asset-information) -* [Client management](capabilities/client.md) - * [`ClientManager`](capabilities/client.md#clientmanager) - * [Network configuration](capabilities/client.md#network-configuration) - * [Clients](capabilities/client.md#clients) - * [Automatic retry](capabilities/client.md#automatic-retry) - * [Network information](capabilities/client.md#network-information) -* [Debugger](capabilities/debugging.md) - * [Configuration](capabilities/debugging.md#configuration) - * [`AlgoKitLogger`](capabilities/debugging.md#algokitlogger) - * [Debugging Utilities](capabilities/debugging.md#debugging-utilities) -* [TestNet Dispenser Client](capabilities/dispenser-client.md) - * [Creating a Dispenser Client](capabilities/dispenser-client.md#creating-a-dispenser-client) - * [Funding an Account](capabilities/dispenser-client.md#funding-an-account) - * [Registering a Refund](capabilities/dispenser-client.md#registering-a-refund) - * [Getting Current Limit](capabilities/dispenser-client.md#getting-current-limit) - * [Error Handling](capabilities/dispenser-client.md#error-handling) -* [Testing](capabilities/testing.md) - * [Basic Test Setup](capabilities/testing.md#basic-test-setup) - * [Creating Test Assets](capabilities/testing.md#creating-test-assets) - * [Testing Application Deployments](capabilities/testing.md#testing-application-deployments) - * [Testing Asset Transfers](capabilities/testing.md#testing-asset-transfers) - * [Testing Application Calls](capabilities/testing.md#testing-application-calls) - * [Testing Box Storage](capabilities/testing.md#testing-box-storage) -* [Transaction composer](capabilities/transaction-composer.md) - * [Constructing a transaction](capabilities/transaction-composer.md#constructing-a-transaction) - * [Simulating a transaction](capabilities/transaction-composer.md#simulating-a-transaction) - * [Error Transformers](capabilities/transaction-composer.md#error-transformers) -* [Transaction management](capabilities/transaction.md) - * [Transaction Results](capabilities/transaction.md#transaction-results) - * [Further reading](capabilities/transaction.md#further-reading) -* [Algo transfers (payments)](capabilities/transfer.md) - * [`payment`](capabilities/transfer.md#payment) - * [`ensure_funded`](capabilities/transfer.md#ensure-funded) - * [Dispenser](capabilities/transfer.md#dispenser) -* [Typed application clients](capabilities/typed-app-clients.md) - * [Generating an app spec](capabilities/typed-app-clients.md#generating-an-app-spec) - * [Generating a typed client](capabilities/typed-app-clients.md#generating-a-typed-client) - * [Getting a typed client instance](capabilities/typed-app-clients.md#getting-a-typed-client-instance) - * [Client usage](capabilities/typed-app-clients.md#client-usage) -* [Migration Guide - v3](v3-migration-guide.md) - * [Migration Steps](v3-migration-guide.md#migration-steps) - * [Breaking Changes](v3-migration-guide.md#breaking-changes) - * [Best Practices](v3-migration-guide.md#best-practices) - * [Troubleshooting](v3-migration-guide.md#troubleshooting) -* [API Reference](autoapi/index.md) - * [algokit_utils](autoapi/algokit_utils/index.md) - - - -# Core principles - -This library follows the [Guiding Principles of AlgoKit](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/algokit.md#guiding-principles) and is designed with the following principles: - -- **Modularity** - This library is a thin wrapper of modular building blocks over the Algorand SDK; the primitives from the underlying Algorand SDK are exposed and used wherever possible so you can opt-in to which parts of this library you want to use without having to use an all or nothing approach. -- **Type-safety** - This library provides strong type hints with effort put into creating types that provide good type safety and intellisense when used with tools like MyPy. -- **Productivity** - This library is built to make solution developers highly productive; it has a number of mechanisms to make common code easier and terser to write. - - - -# Installation - -This library can be installed from PyPi using pip or poetry: - -```bash -pip install algokit-utils -# or -poetry add algokit-utils -``` - - - -# Usage - -The main entrypoint to the bulk of the functionality in AlgoKit Utils is the `AlgorandClient` class. You can get started by using one of the static initialization methods to create an Algorand client: - -```python -# Point to the network configured through environment variables or -# if no environment variables it will point to the default LocalNet configuration -algorand = AlgorandClient.from_environment() -# Point to default LocalNet configuration -algorand = AlgorandClient.default_localnet() -# Point to TestNet using AlgoNode free tier -algorand = AlgorandClient.testnet() -# Point to MainNet using AlgoNode free tier -algorand = AlgorandClient.mainnet() -# Point to a pre-created algod client -algorand = AlgorandClient.from_clients(algod=...) -# Point to a pre-created algod and indexer client -algorand = AlgorandClient.from_clients(algod=..., indexer=..., kmd=...) -# Point to custom configuration for algod -algod_config = AlgoClientNetworkConfig(server=..., token=..., port=...) -algorand = AlgorandClient.from_config(algod_config=algod_config) -# Point to custom configuration for algod and indexer and kmd -algod_config = AlgoClientNetworkConfig(server=..., token=..., port=...) -indexer_config = AlgoClientNetworkConfig(server=..., token=..., port=...) -kmd_config = AlgoClientNetworkConfig(server=..., token=..., port=...) -algorand = AlgorandClient.from_config(algod_config=algod_config, indexer_config=indexer_config, kmd_config=kmd_config) -``` - -# Testing - -AlgoKit Utils provides a dedicated documentation page on various useful snippets that can be reused for testing with tools like [Pytest](https://docs.pytest.org/en/latest/): - -- [Testing](capabilities/testing.md) - -# Types - -The library leverages Python’s native type hints and is fully compatible with [MyPy](https://mypy-lang.org/) for static type checking. - -All public abstractions and methods are organized in logical modules matching their domain functionality. You can import types either directly from the root module or from their source submodules. Refer to [API documentation](autoapi/index.md) for more details. - - - -# Config and logging - -To configure the AlgoKit Utils library you can make use of the [`Config`](autoapi/algokit_utils/config/index.md) object, which has a configure method that lets you configure some or all of the configuration options. - -## Config singleton - -The AlgoKit Utils configuration singleton can be updated using `config.configure()`. Refer to the [Config API documentation](autoapi/algokit_utils/config/index.md) for more details. - -## Logging - -AlgoKit has an in-built logging abstraction through the [`algokit_utils.config.AlgoKitLogger`](autoapi/algokit_utils/config/index.md#algokit_utils.config.AlgoKitLogger) class that provides standardized logging capabilities. The logger is accessible through the `config.logger` property and provides various logging levels. - -Each method supports optional suppression of output using the `suppress_log` parameter. - -## Debug mode - -To turn on debug mode you can use the following: - -```python -from algokit_utils.config import config -config.configure(debug=True) -``` - -To retrieve the current debug state you can use `debug` property. - -This will turn on things like automatic tracing, more verbose logging and [advanced debugging](capabilities/debugging.md). It’s likely this option will result in extra HTTP calls to algod and it’s worth being careful when it’s turned on. - - - -# Capabilities - -The library helps you interact with and develop against the Algorand blockchain with a series of end-to-end capabilities as described below: - -- [**AlgorandClient**](capabilities/algorand-client.md) - The key entrypoint to the AlgoKit Utils functionality -- **Core capabilities** - - [**Client management**](capabilities/client.md) - Creation of (auto-retry) algod, indexer and kmd clients against various networks resolved from environment or specified configuration, and creation of other API clients (e.g. TestNet Dispenser API and app clients) - - [**Account management**](capabilities/account.md) - Creation, use, and management of accounts including mnemonic, rekeyed, multisig, transaction signer, idempotent KMD accounts and environment variable injected - - [**Algo amount handling**](capabilities/amount.md) - Reliable, explicit, and terse specification of microAlgo and Algo amounts and safe conversion between them - - [**Transaction management**](capabilities/transaction.md) - Ability to construct, simulate and send transactions with consistent and highly configurable semantics, including configurable control of transaction notes, logging, fees, validity, signing, and sending behaviour -- **Higher-order use cases** - - [**Asset management**](capabilities/asset.md) - Creation, transfer, destroying, opting in and out and managing Algorand Standard Assets - - [**Typed application clients**](capabilities/typed-app-clients.md) - Type-safe application clients that are [generated](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/generate.md#1-typed-clients) from ARC-56 or ARC-32 application spec files and allow you to intuitively and productively interact with a deployed app, which is the recommended way of interacting with apps and builds on top of the following capabilities: - - [**ARC-56 / ARC-32 App client and App factory**](capabilities/app-client.md) - Builds on top of the App management and App deployment capabilities (below) to provide a high productivity application client that works with ARC-56 and ARC-32 application spec defined smart contracts - - [**App management**](capabilities/app.md) - Creation, updating, deleting, calling (ABI and otherwise) smart contract apps and the metadata associated with them (including state and boxes) - - [**App deployment**](capabilities/app-deploy.md) - Idempotent (safely retryable) deployment of an app, including deploy-time immutability and permanence control and TEAL template substitution - - [**Algo transfers (payments)**](capabilities/transfer.md) - Ability to easily initiate Algo transfers between accounts, including dispenser management and idempotent account funding - - [**Automated testing**](capabilities/testing.md) - Reusable snippets to leverage AlgoKit Utils abstractions in a manner that are useful for when writing tests in tools like [Pytest](https://docs.pytest.org/en/latest/). - - - -# Reference documentation - -For detailed API documentation, see the [`algokit_utils`](autoapi/algokit_utils/index.md#module-algokit_utils) diff --git a/docs/markdown/v3-migration-guide.md b/docs/markdown/v3-migration-guide.md deleted file mode 100644 index 9cb15bf6..00000000 --- a/docs/markdown/v3-migration-guide.md +++ /dev/null @@ -1,275 +0,0 @@ -# Migration Guide - v3 - -Version 3 of `algokit-utils-ts` moved from a stateless function-based interface to a stateful class-based interfaces. This change allows for: - -- Easier and simpler consumption experience guided by IDE autocompletion -- Less redundant parameter passing (e.g., `algod` client) -- Better performance through caching of commonly retrieved values like transaction parameters -- More consistent and intuitive API design -- Stronger type safety and better error messages -- Improved ARC-56 compatibility -- Feature parity with `algokit-utils-ts` >= `v7` interfaces - -The entry point to most functionality in AlgoKit Utils is now available via a single entry-point, the `AlgorandClient` class. - -The v2 interfaces and abstractions will be removed in future major version bumps, however in order to ensure gradual migration, *all v2 abstractions are available* with respective deprecation warnings. The new way to use AlgoKit Utils is via the `AlgorandClient` class, which is easier, simpler, and more convenient to use and has powerful new features. - -> BREAKING CHANGE: the `beta` module is now removed, any imports from `algokit_utils.beta` will now raise an error with a link to a new expected import path. This is due to the fact that the interfaces introduced in `beta` are now refined and available in the main module. - -## Migration Steps - -In general, your codebase might fall into one of the following migration scenarios: - -- Using `algokit-utils-py` v2.x only without use of abstractions from `beta` module -- Using `algokit-utils-py` v2.x only and with use of abstractions from `beta` module -- Using `algokit-utils-py` v2.x with `algokit-client-generator-py` v1.x -- Using `algokit-client-generator-py` v1.x only (implies implicit dependency on `algokit-utils-py` v2.x) - -Given that `algokit-utils-py` v3.x is backwards compatible with `algokit-client-generator-py` v1.x, the following general guidelines are applicable to all scenarios (note that the order of operations is important to ensure straight-forward migration): - -1. Upgrade to `algokit-utils-py` v3.x - - 1.1 (If used) Update imports from `algokit_utils.beta` to `algokit_utils` - - 1.2 Follow hints in deprecation warnings to update your codebase to rely on latest v3 interfaces -2. Upgrade to `algokit-client-generator-py` v2.x and regenerate typed clients - - 2.1 Follow `algokit-client-generator-py` [v2.x migration guide](https://github.com/algorandfoundation/algokit-client-generator-py/blob/main/docs/v2-migration-guide.md) - -The remaining set of guidelines are outlining migrations for specific abstractions that had direct equivalents in `algokit-utils-py` v2.x. - -### Prerequisites - -It is important to reiterate that if you have previously relied on `beta` versions of `algokit-utils-py` v2.x, you will need to update your imports to rely on the new interfaces. Errors thrown during import from `beta` will provide a description of the new expected import path. - -> As with `v2.x` all public abstractions in `algokit_utils` are available for direct imports `from algokit_utils import ...`, however underlying modules have been refined to be structured loosely around common AVM domains such as `applications`, `transactions`, `accounts`, `assets`, etc. See [API reference](https://algokit-utils-py.readthedocs.io/en/latest/api_reference/index.html) for latest and detailed overview. - -### Step 1 - Replace SDK Clients with AlgorandClient - -First, replace your SDK client initialization with `AlgorandClient`. Look for `get_algod_client` calls and replace with an appropriate `AlgorandClient` initialization: - -```python -"""Before""" -import algokit_utils -algod = algokit_utils.get_algod_client() -indexer = algokit_utils.get_indexer_client() - -"""After""" -from algokit_utils import AlgorandClient -algorand = AlgorandClient.from_environment() # or .testnet(), .mainnet(), etc. -``` - -During migration, you can still access SDK clients if needed: - -```python -algod = algorand.client.algod -indexer = algorand.client.indexer -kmd = algorand.client.kmd -``` - -### Step 2 - Update Account Management - -Account management has moved to `algorand.account`: - -#### Before: - -```python -account = algokit_utils.get_account_from_mnemonic( - mnemonic=os.getenv("MY_ACCOUNT_MNEMONIC"), -) -dispenser = algokit_utils.get_dispenser_account(algod) -``` - -#### After: - -```python -account = algorand.account.from_mnemonic(os.getenv("MY_ACCOUNT_MNEMONIC")) -dispenser = algorand.account.dispenser_from_environment() -``` - -Key changes: - -- `get_account` → `account.from_environment` -- `get_account_from_mnemonic` → `account.from_mnemonic` -- `get_dispenser_account` → `account.dispenser_from_environment` -- `get_localnet_default_account` → `account.localnet_dispenser` - -### Step 3 - Update Transaction Management - -Transaction creation and sending is now more structured: - -#### Before: - -```python -# Single transaction -result = algokit_utils.transfer_algos( - from_account=account, - to_addr="RECEIVER", - amount=algokit_utils.algos(1), - algod_client=algod, -) - -# Transaction groups -atc = AtomicTransactionComposer() -# ... add transactions ... -result = algokit_utils.execute_atc_with_logic_error(atc, algod) -``` - -#### After: - -```python -# Single transaction -result = algorand.send.payment( - sender=account.address, - receiver="RECEIVER", - amount=AlgoAmount.from_algo(1), -) - -# Transaction groups -composer = algorand.new_group() -# ... add transactions ... -result = composer.send() -``` - -Key changes: - -- `transfer_algos` → `algorand.send.payment` -- `transfer_asset` → `algorand.send.asset_transfer` -- `execute_atc_with_logic_error` → `composer.send()` -- Transaction parameters are now more consistently named (e.g., `sender` instead of `from_account`) -- Improved amount handling with dedicated `AlgoAmount` class (e.g., `AlgoAmount.from_algo(1)`) - -### Step 4 - Update `ApplicationSpecification` usage - -`ApplicationSpecification` abstraction is largely identical to v2, however it’s been renamed to `Arc32Contract` to better reflect the fact that it’s a contract specification for a specific ARC and addition of `Arc56Contract` supporting the latest recommended conventions. Hence the main actionable change is to update your import to `from algokit_utils import Arc32Contract` and rename `ApplicationSpecification` to `Arc32Contract`. - -You can instantiate an `Arc56Contract` instance from an `Arc32Contract` instance using the `Arc56Contract.from_arc32` method. For instance: - -```python -testing_app_arc32_app_spec = Arc32Contract.from_json(app_spec_json) -arc56_app_spec = Arc56Contract.from_arc32(testing_app_arc32_app_spec) -``` - -> Despite auto conversion of ARC-32 to ARC-56, we recommend recompiling your contract to a fully compliant ARC-56 specification given that auto conversion would skip populating information that can’t be parsed from raw ARC-32. - -### Step 5 - Replace `ApplicationClient` usage - -The existing `ApplicationClient` (untyped app client) class is still present until at least v4, but it’s worthwhile migrating to the new [`AppClient` and `AppFactory` classes](capabilities/app-client.md). These new clients are [ARC-56](https://github.com/algorandfoundation/ARCs/pull/258) compatible, but also support [ARC-32](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0032.md) app specs and will continue to support this indefinitely until such time the community deems they are deprecated. - -All of the functionality in `ApplicationClient` is available within the new classes, but their interface is slightly different to make it easier to use and more consistent with the new `AlgorandClient` functionality. The key existing methods that have changed all have `@deprecation` notices to help guide you on this, but broadly the changes are: - -- The app resolution semantics, now have static methods that determine different ways of constructing a client and the constructor itself is very simple (requiring `app_id`) -- If you want to call `create` or `deploy` then you need an `AppFactory` to do that, and then it will in turn give you an `AppClient` instance that is connected to the app you just created / deployed. This significantly simplifies the app client because now the app client has a clear operating purpose: allow for calls and state management for an *instance* of an app, whereas the app factory handles all of the calls when you don’t have an instance yet (or may or may not have an instance in the case of `deploy`). -- This means that you can simply access `client.app_id` and `client.app_address` on `AppClient` since these values are known statically and won’t change (previously associated calls to `app_address`, `app_id` properties potentially required extra API calls as the values weren’t always available). -- Adding `fund_app_account` which serves as a convenience method to top up the balance of address associated with application. -- All of the methods that return or execute a transaction (`update`, `call`, `opt_in`, etc.) are now exposed in an interface similar to the one in [`AlgorandClient`](capabilities/algorand-client.md#creating-and-issuing-transactions), namely (where `{call_type}` is one of: `update` / `delete` / `opt_in` / `close_out` / `clear_state` / `call`): - - `appClient.create_transaction.{callType}` to get a transaction for an ABI method call - - `appClient.send.{call_type}` to sign and send a transaction for an ABI method call - - `appClient.params.{call_type}` to get a [params object](capabilities/algorand-client.md#transaction-parameters) for an ABI method call - - `appClient.create_transaction.bare.{call_type}` to get a transaction for a bare app call - - `appClient.send.bare.{call_type}` to sign and send a transaction for a bare app call - - `appClient.params.bare.{call_type}` to get a [params object](capabilities/algorand-client.md#transaction-parameters) for a bare app call -- The semantics to resolve the application is now available via [simpler entrypoints within `algorand.client`](capabilities/app-client.md#appclient) -- When making an ABI method call, the method arguments property is are now passed via explicit `args` field in a parameters dataclass applicable to the method call. -- The foreign reference arrays have been renamed to align with typed parameters on `ts` and related core `algosdk`: - - `boxes` -> `box_references` - - `apps` -> `app_references` - - `assets` -> `asset_references` - - `accounts` -> `account_references` -- The return value for methods that send a transaction will have any ABI return value directly in the `abi_return` property rather than the low level algosdk `ABIResult` type while also automatically decoding values based on provided ARC56 spec. - -### Step 6 - Replace typed app client usage - -Version 2 of the Python typed app client generator introduces breaking changes to the generated client that support the new `AppFactory` and `AppClient` functionality along with adding ARC-56 support. The generated client has better typing support for things like state commensurate with the new capabilities within ARC-56. - -It’s worth noting that because we have maintained backwards compatibility with the pre v2 `algokit-utils-py` stateless functions, older typed clients generated using version 1 of the Python typed client generator will work against v3 of utils, however you won’t have access to the new features or ARC-56 support. - -If you want to convert from an older typed client to a new one you will need to make certain changes. Refer to [client generator v2 migration guide](https://github.com/algorandfoundation/algokit-client-generator-py/blob/main/docs/v2-migration.md). - -### Step 7 - Update `AppClient` State Management - -State management is now more structured and type-safe: - -```python -"""Before""" -global_state = app_client.get_global_state() -local_state = app_client.get_local_state(account_address) -box_value = app_client.get_box_value("box_name") - -"""After""" -# Global state -global_state = app_client.state.global_state.get_all() -value = app_client.state.global_state.get_value("key_name") -map_value = app_client.state.global_state.get_map_value("map_name", "key") - -# Local state -local_state = app_client.state.local_state(account_address).get_all() -value = app_client.state.local_state(account_address).get_value("key_name") -map_value = app_client.state.local_state(account_address).get_map_value("map_name", "key") - -# Box storage -box_value = app_client.state.box.get_value("box_name") -boxes = app_client.state.box.get_all() -map_value = app_client.state.box.get_map_value("map_name", "key") -``` - -### Step 8 - Update Asset Management - -Asset management is now more consistent: - -```python -"""Before""" -result = algokit_utils.opt_in(algod, account, [asset_id]) - -"""After""" -result = algorand.send.asset_opt_in( - params=AssetOptInParams( - sender=account.address, - asset_id=asset_id, - ) -) -``` - -## Breaking Changes - -1. **Client Management** - - Removal of standalone client creation functions - - All clients now accessed through `AlgorandClient` -2. **Account Management** - - Account creation functions moved to `AccountManager` accessible via `algorand.account` property - - Unified `TransactionSignerAccountProtocol` with compliant and typed `SigningAccount`, `TransactionSignerAccount`, `LogicSigAccount`, `MultiSigAccount` classes encapsulating low level `algosdk` abstractions. - - Improved typing for account operations, such as obtaining account information from `algod`, returning a typed information object. -3. **Transaction Management** - - Consistent and intuitive transaction creation and sending interface accessible via `algorand.{send|params|create_transaction}` properties - - New transaction composition interface accessible via `algorand.new_group` - - Removing necessity to interact with low level and untyped `algosdk` abstractions for assembling, signing and sending transaction(s). -4. **Application Client** - - Split into `AppClient`, `AppDeployer` and `AppFactory` - - `deploy` method in `AppFactory`/`AppDeployer` no longer auto increments the contract version by default. It is the user’s responsibility to explicitly manage versioning of their smart contracts (if desired). - - New intuitive structured interface for creating or sending `AppCall`|`AppMethodCall` transactions - - ARC-56 support along with automatic conversion of specs from ARC-32 to ARC-56 -5. **State Management** - - New hierarchical state access available via `app_client.state.{global_state|local_state|box}` properties - - Improved typing for state values - - Support for ARC-56 state schemas -6. **Asset Management** - - Dedicated `AssetManager` class for asset management accessible via `algorand.asset` property - - Improved typing for asset operations, such as obtaining asset information from `algod`, returning a typed information object. - - Consistent interface for asset opt-in, transfer, freeze, etc. - -## Best Practices - -1. Use the new `AlgorandClient` as the main entry point -2. Leverage IDE autocompletion to discover available functionality, consult with [API reference](https://algokit-utils-py.readthedocs.io/en/latest/api_reference/index.html) when unsure -3. Use the transaction parameter builders for type-safe transaction creation (`algorand.params.{}`) -4. Use the state accessor patterns for cleaner state management {`algorand.state.{}`} -5. Use high level `TransactionComposer` interface over low level `algosdk` abstractions (where possible) -6. Use source maps and debug mode to quickly troubleshoot on-chain errors -7. Use idempotent deployment patterns with versioning - -## Troubleshooting - -### A v2 interface/method/class does not display a deprecation warning correctly or at all - -Submit an issue to [algokit-utils-py](https://github.com/algorandfoundation/algokit-utils-py/issues) with a description of the problem and the code that is causing it. - -### Useful scenario of converting v2 to v3 not covered in generic migration guide - -If you have a scenario that you think is useful and not covered in the generic migration guide, please submit an issue to [algokit-utils-py](https://github.com/algorandfoundation/algokit-utils-py/issues) with a scenario. diff --git a/docs/package.json b/docs/package.json new file mode 100644 index 00000000..76c3f3ab --- /dev/null +++ b/docs/package.json @@ -0,0 +1,28 @@ +{ + "name": "docs", + "type": "module", + "version": "0.0.1", + "packageManager": "pnpm@10.30.3", + "scripts": { + "predev": "tsx scripts/generate-examples-mdx.ts", + "dev": "astro dev", + "start": "astro dev", + "prebuild": "tsx scripts/generate-examples-mdx.ts", + "build": "astro build", + "preview": "astro preview", + "astro": "astro" + }, + "dependencies": { + "@astrojs/starlight": "^0.37.6", + "astro": "^5.6.1", + "remark-github-alerts": "^0.1.1", + "sharp": "^0.34.2" + }, + "devDependencies": { + "@types/node": "^22.19.15", + "tsx": "^4.21.0" + }, + "engines": { + "node": ">=20" + } +} diff --git a/docs/pnpm-lock.yaml b/docs/pnpm-lock.yaml new file mode 100644 index 00000000..20208503 --- /dev/null +++ b/docs/pnpm-lock.yaml @@ -0,0 +1,4441 @@ +lockfileVersion: '9.0' + +settings: + autoInstallPeers: true + excludeLinksFromLockfile: false + +importers: + + .: + dependencies: + '@astrojs/starlight': + specifier: ^0.37.6 + version: 0.37.7(astro@5.18.0(@types/node@22.19.15)(rollup@4.59.0)(tsx@4.21.0)(typescript@5.9.3)) + astro: + specifier: ^5.6.1 + version: 5.18.0(@types/node@22.19.15)(rollup@4.59.0)(tsx@4.21.0)(typescript@5.9.3) + remark-github-alerts: + specifier: ^0.1.1 + version: 0.1.1(@types/mdast@4.0.4)(unified@11.0.5) + sharp: + specifier: ^0.34.2 + version: 0.34.5 + devDependencies: + '@types/node': + specifier: ^22.19.15 + version: 22.19.15 + tsx: + specifier: ^4.21.0 + version: 4.21.0 + +packages: + + '@astrojs/compiler@2.13.1': + resolution: {integrity: sha512-f3FN83d2G/v32ipNClRKgYv30onQlMZX1vCeZMjPsMMPl1mDpmbl0+N5BYo4S/ofzqJyS5hvwacEo0CCVDn/Qg==} + + '@astrojs/internal-helpers@0.7.5': + resolution: {integrity: sha512-vreGnYSSKhAjFJCWAwe/CNhONvoc5lokxtRoZims+0wa3KbHBdPHSSthJsKxPd8d/aic6lWKpRTYGY/hsgK6EA==} + + '@astrojs/markdown-remark@6.3.10': + resolution: {integrity: sha512-kk4HeYR6AcnzC4QV8iSlOfh+N8TZ3MEStxPyenyCtemqn8IpEATBFMTJcfrNW32dgpt6MY3oCkMM/Tv3/I4G3A==} + + '@astrojs/mdx@4.3.13': + resolution: {integrity: sha512-IHDHVKz0JfKBy3//52JSiyWv089b7GVSChIXLrlUOoTLWowG3wr2/8hkaEgEyd/vysvNQvGk+QhysXpJW5ve6Q==} + engines: {node: 18.20.8 || ^20.3.0 || >=22.0.0} + peerDependencies: + astro: ^5.0.0 + + '@astrojs/prism@3.3.0': + resolution: {integrity: sha512-q8VwfU/fDZNoDOf+r7jUnMC2//H2l0TuQ6FkGJL8vD8nw/q5KiL3DS1KKBI3QhI9UQhpJ5dc7AtqfbXWuOgLCQ==} + engines: {node: 18.20.8 || ^20.3.0 || >=22.0.0} + + '@astrojs/sitemap@3.7.0': + resolution: {integrity: sha512-+qxjUrz6Jcgh+D5VE1gKUJTA3pSthuPHe6Ao5JCxok794Lewx8hBFaWHtOnN0ntb2lfOf7gvOi9TefUswQ/ZVA==} + + '@astrojs/starlight@0.37.7': + resolution: {integrity: sha512-KyBnou8aKIlPJUSNx6a1SN7XyH22oj/VAvTGC+Edld4Bnei1A//pmCRTBvSrSeoGrdUjK0ErFUfaEhhO1bPfDg==} + peerDependencies: + astro: ^5.5.0 + + '@astrojs/telemetry@3.3.0': + resolution: {integrity: sha512-UFBgfeldP06qu6khs/yY+q1cDAaArM2/7AEIqQ9Cuvf7B1hNLq0xDrZkct+QoIGyjq56y8IaE2I3CTvG99mlhQ==} + engines: {node: 18.20.8 || ^20.3.0 || >=22.0.0} + + '@babel/helper-string-parser@7.27.1': + resolution: {integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==} + engines: {node: '>=6.9.0'} + + '@babel/helper-validator-identifier@7.28.5': + resolution: {integrity: sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==} + engines: {node: '>=6.9.0'} + + '@babel/parser@7.29.0': + resolution: {integrity: sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==} + engines: {node: '>=6.0.0'} + hasBin: true + + '@babel/runtime@7.28.6': + resolution: {integrity: sha512-05WQkdpL9COIMz4LjTxGpPNCdlpyimKppYNoJ5Di5EUObifl8t4tuLuUBBZEpoLYOmfvIWrsp9fCl0HoPRVTdA==} + engines: {node: '>=6.9.0'} + + '@babel/types@7.29.0': + resolution: {integrity: sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==} + engines: {node: '>=6.9.0'} + + '@capsizecss/unpack@4.0.0': + resolution: {integrity: sha512-VERIM64vtTP1C4mxQ5thVT9fK0apjPFobqybMtA1UdUujWka24ERHbRHFGmpbbhp73MhV+KSsHQH9C6uOTdEQA==} + engines: {node: '>=18'} + + '@ctrl/tinycolor@4.2.0': + resolution: {integrity: sha512-kzyuwOAQnXJNLS9PSyrk0CWk35nWJW/zl/6KvnTBMFK65gm7U1/Z5BqjxeapjZCIhQcM/DsrEmcbRwDyXyXK4A==} + engines: {node: '>=14'} + + '@emnapi/runtime@1.8.1': + resolution: {integrity: sha512-mehfKSMWjjNol8659Z8KxEMrdSJDDot5SXMq00dM8BN4o+CLNXQ0xH2V7EchNHV4RmbZLmmPdEaXZc5H2FXmDg==} + + '@esbuild/aix-ppc64@0.25.12': + resolution: {integrity: sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==} + engines: {node: '>=18'} + cpu: [ppc64] + os: [aix] + + '@esbuild/aix-ppc64@0.27.3': + resolution: {integrity: sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg==} + engines: {node: '>=18'} + cpu: [ppc64] + os: [aix] + + '@esbuild/android-arm64@0.25.12': + resolution: {integrity: sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [android] + + '@esbuild/android-arm64@0.27.3': + resolution: {integrity: sha512-YdghPYUmj/FX2SYKJ0OZxf+iaKgMsKHVPF1MAq/P8WirnSpCStzKJFjOjzsW0QQ7oIAiccHdcqjbHmJxRb/dmg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [android] + + '@esbuild/android-arm@0.25.12': + resolution: {integrity: sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==} + engines: {node: '>=18'} + cpu: [arm] + os: [android] + + '@esbuild/android-arm@0.27.3': + resolution: {integrity: sha512-i5D1hPY7GIQmXlXhs2w8AWHhenb00+GxjxRncS2ZM7YNVGNfaMxgzSGuO8o8SJzRc/oZwU2bcScvVERk03QhzA==} + engines: {node: '>=18'} + cpu: [arm] + os: [android] + + '@esbuild/android-x64@0.25.12': + resolution: {integrity: sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==} + engines: {node: '>=18'} + cpu: [x64] + os: [android] + + '@esbuild/android-x64@0.27.3': + resolution: {integrity: sha512-IN/0BNTkHtk8lkOM8JWAYFg4ORxBkZQf9zXiEOfERX/CzxW3Vg1ewAhU7QSWQpVIzTW+b8Xy+lGzdYXV6UZObQ==} + engines: {node: '>=18'} + cpu: [x64] + os: [android] + + '@esbuild/darwin-arm64@0.25.12': + resolution: {integrity: sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [darwin] + + '@esbuild/darwin-arm64@0.27.3': + resolution: {integrity: sha512-Re491k7ByTVRy0t3EKWajdLIr0gz2kKKfzafkth4Q8A5n1xTHrkqZgLLjFEHVD+AXdUGgQMq+Godfq45mGpCKg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [darwin] + + '@esbuild/darwin-x64@0.25.12': + resolution: {integrity: sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==} + engines: {node: '>=18'} + cpu: [x64] + os: [darwin] + + '@esbuild/darwin-x64@0.27.3': + resolution: {integrity: sha512-vHk/hA7/1AckjGzRqi6wbo+jaShzRowYip6rt6q7VYEDX4LEy1pZfDpdxCBnGtl+A5zq8iXDcyuxwtv3hNtHFg==} + engines: {node: '>=18'} + cpu: [x64] + os: [darwin] + + '@esbuild/freebsd-arm64@0.25.12': + resolution: {integrity: sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [freebsd] + + '@esbuild/freebsd-arm64@0.27.3': + resolution: {integrity: sha512-ipTYM2fjt3kQAYOvo6vcxJx3nBYAzPjgTCk7QEgZG8AUO3ydUhvelmhrbOheMnGOlaSFUoHXB6un+A7q4ygY9w==} + engines: {node: '>=18'} + cpu: [arm64] + os: [freebsd] + + '@esbuild/freebsd-x64@0.25.12': + resolution: {integrity: sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==} + engines: {node: '>=18'} + cpu: [x64] + os: [freebsd] + + '@esbuild/freebsd-x64@0.27.3': + resolution: {integrity: sha512-dDk0X87T7mI6U3K9VjWtHOXqwAMJBNN2r7bejDsc+j03SEjtD9HrOl8gVFByeM0aJksoUuUVU9TBaZa2rgj0oA==} + engines: {node: '>=18'} + cpu: [x64] + os: [freebsd] + + '@esbuild/linux-arm64@0.25.12': + resolution: {integrity: sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==} + engines: {node: '>=18'} + cpu: [arm64] + os: [linux] + + '@esbuild/linux-arm64@0.27.3': + resolution: {integrity: sha512-sZOuFz/xWnZ4KH3YfFrKCf1WyPZHakVzTiqji3WDc0BCl2kBwiJLCXpzLzUBLgmp4veFZdvN5ChW4Eq/8Fc2Fg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [linux] + + '@esbuild/linux-arm@0.25.12': + resolution: {integrity: sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==} + engines: {node: '>=18'} + cpu: [arm] + os: [linux] + + '@esbuild/linux-arm@0.27.3': + resolution: {integrity: sha512-s6nPv2QkSupJwLYyfS+gwdirm0ukyTFNl3KTgZEAiJDd+iHZcbTPPcWCcRYH+WlNbwChgH2QkE9NSlNrMT8Gfw==} + engines: {node: '>=18'} + cpu: [arm] + os: [linux] + + '@esbuild/linux-ia32@0.25.12': + resolution: {integrity: sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==} + engines: {node: '>=18'} + cpu: [ia32] + os: [linux] + + '@esbuild/linux-ia32@0.27.3': + resolution: {integrity: sha512-yGlQYjdxtLdh0a3jHjuwOrxQjOZYD/C9PfdbgJJF3TIZWnm/tMd/RcNiLngiu4iwcBAOezdnSLAwQDPqTmtTYg==} + engines: {node: '>=18'} + cpu: [ia32] + os: [linux] + + '@esbuild/linux-loong64@0.25.12': + resolution: {integrity: sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==} + engines: {node: '>=18'} + cpu: [loong64] + os: [linux] + + '@esbuild/linux-loong64@0.27.3': + resolution: {integrity: sha512-WO60Sn8ly3gtzhyjATDgieJNet/KqsDlX5nRC5Y3oTFcS1l0KWba+SEa9Ja1GfDqSF1z6hif/SkpQJbL63cgOA==} + engines: {node: '>=18'} + cpu: [loong64] + os: [linux] + + '@esbuild/linux-mips64el@0.25.12': + resolution: {integrity: sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==} + engines: {node: '>=18'} + cpu: [mips64el] + os: [linux] + + '@esbuild/linux-mips64el@0.27.3': + resolution: {integrity: sha512-APsymYA6sGcZ4pD6k+UxbDjOFSvPWyZhjaiPyl/f79xKxwTnrn5QUnXR5prvetuaSMsb4jgeHewIDCIWljrSxw==} + engines: {node: '>=18'} + cpu: [mips64el] + os: [linux] + + '@esbuild/linux-ppc64@0.25.12': + resolution: {integrity: sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==} + engines: {node: '>=18'} + cpu: [ppc64] + os: [linux] + + '@esbuild/linux-ppc64@0.27.3': + resolution: {integrity: sha512-eizBnTeBefojtDb9nSh4vvVQ3V9Qf9Df01PfawPcRzJH4gFSgrObw+LveUyDoKU3kxi5+9RJTCWlj4FjYXVPEA==} + engines: {node: '>=18'} + cpu: [ppc64] + os: [linux] + + '@esbuild/linux-riscv64@0.25.12': + resolution: {integrity: sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==} + engines: {node: '>=18'} + cpu: [riscv64] + os: [linux] + + '@esbuild/linux-riscv64@0.27.3': + resolution: {integrity: sha512-3Emwh0r5wmfm3ssTWRQSyVhbOHvqegUDRd0WhmXKX2mkHJe1SFCMJhagUleMq+Uci34wLSipf8Lagt4LlpRFWQ==} + engines: {node: '>=18'} + cpu: [riscv64] + os: [linux] + + '@esbuild/linux-s390x@0.25.12': + resolution: {integrity: sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==} + engines: {node: '>=18'} + cpu: [s390x] + os: [linux] + + '@esbuild/linux-s390x@0.27.3': + resolution: {integrity: sha512-pBHUx9LzXWBc7MFIEEL0yD/ZVtNgLytvx60gES28GcWMqil8ElCYR4kvbV2BDqsHOvVDRrOxGySBM9Fcv744hw==} + engines: {node: '>=18'} + cpu: [s390x] + os: [linux] + + '@esbuild/linux-x64@0.25.12': + resolution: {integrity: sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==} + engines: {node: '>=18'} + cpu: [x64] + os: [linux] + + '@esbuild/linux-x64@0.27.3': + resolution: {integrity: sha512-Czi8yzXUWIQYAtL/2y6vogER8pvcsOsk5cpwL4Gk5nJqH5UZiVByIY8Eorm5R13gq+DQKYg0+JyQoytLQas4dA==} + engines: {node: '>=18'} + cpu: [x64] + os: [linux] + + '@esbuild/netbsd-arm64@0.25.12': + resolution: {integrity: sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [netbsd] + + '@esbuild/netbsd-arm64@0.27.3': + resolution: {integrity: sha512-sDpk0RgmTCR/5HguIZa9n9u+HVKf40fbEUt+iTzSnCaGvY9kFP0YKBWZtJaraonFnqef5SlJ8/TiPAxzyS+UoA==} + engines: {node: '>=18'} + cpu: [arm64] + os: [netbsd] + + '@esbuild/netbsd-x64@0.25.12': + resolution: {integrity: sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==} + engines: {node: '>=18'} + cpu: [x64] + os: [netbsd] + + '@esbuild/netbsd-x64@0.27.3': + resolution: {integrity: sha512-P14lFKJl/DdaE00LItAukUdZO5iqNH7+PjoBm+fLQjtxfcfFE20Xf5CrLsmZdq5LFFZzb5JMZ9grUwvtVYzjiA==} + engines: {node: '>=18'} + cpu: [x64] + os: [netbsd] + + '@esbuild/openbsd-arm64@0.25.12': + resolution: {integrity: sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==} + engines: {node: '>=18'} + cpu: [arm64] + os: [openbsd] + + '@esbuild/openbsd-arm64@0.27.3': + resolution: {integrity: sha512-AIcMP77AvirGbRl/UZFTq5hjXK+2wC7qFRGoHSDrZ5v5b8DK/GYpXW3CPRL53NkvDqb9D+alBiC/dV0Fb7eJcw==} + engines: {node: '>=18'} + cpu: [arm64] + os: [openbsd] + + '@esbuild/openbsd-x64@0.25.12': + resolution: {integrity: sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==} + engines: {node: '>=18'} + cpu: [x64] + os: [openbsd] + + '@esbuild/openbsd-x64@0.27.3': + resolution: {integrity: sha512-DnW2sRrBzA+YnE70LKqnM3P+z8vehfJWHXECbwBmH/CU51z6FiqTQTHFenPlHmo3a8UgpLyH3PT+87OViOh1AQ==} + engines: {node: '>=18'} + cpu: [x64] + os: [openbsd] + + '@esbuild/openharmony-arm64@0.25.12': + resolution: {integrity: sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [openharmony] + + '@esbuild/openharmony-arm64@0.27.3': + resolution: {integrity: sha512-NinAEgr/etERPTsZJ7aEZQvvg/A6IsZG/LgZy+81wON2huV7SrK3e63dU0XhyZP4RKGyTm7aOgmQk0bGp0fy2g==} + engines: {node: '>=18'} + cpu: [arm64] + os: [openharmony] + + '@esbuild/sunos-x64@0.25.12': + resolution: {integrity: sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==} + engines: {node: '>=18'} + cpu: [x64] + os: [sunos] + + '@esbuild/sunos-x64@0.27.3': + resolution: {integrity: sha512-PanZ+nEz+eWoBJ8/f8HKxTTD172SKwdXebZ0ndd953gt1HRBbhMsaNqjTyYLGLPdoWHy4zLU7bDVJztF5f3BHA==} + engines: {node: '>=18'} + cpu: [x64] + os: [sunos] + + '@esbuild/win32-arm64@0.25.12': + resolution: {integrity: sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [win32] + + '@esbuild/win32-arm64@0.27.3': + resolution: {integrity: sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA==} + engines: {node: '>=18'} + cpu: [arm64] + os: [win32] + + '@esbuild/win32-ia32@0.25.12': + resolution: {integrity: sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==} + engines: {node: '>=18'} + cpu: [ia32] + os: [win32] + + '@esbuild/win32-ia32@0.27.3': + resolution: {integrity: sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q==} + engines: {node: '>=18'} + cpu: [ia32] + os: [win32] + + '@esbuild/win32-x64@0.25.12': + resolution: {integrity: sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==} + engines: {node: '>=18'} + cpu: [x64] + os: [win32] + + '@esbuild/win32-x64@0.27.3': + resolution: {integrity: sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==} + engines: {node: '>=18'} + cpu: [x64] + os: [win32] + + '@expressive-code/core@0.41.7': + resolution: {integrity: sha512-ck92uZYZ9Wba2zxkiZLsZGi9N54pMSAVdrI9uW3Oo9AtLglD5RmrdTwbYPCT2S/jC36JGB2i+pnQtBm/Ib2+dg==} + + '@expressive-code/plugin-frames@0.41.7': + resolution: {integrity: sha512-diKtxjQw/979cTglRFaMCY/sR6hWF0kSMg8jsKLXaZBSfGS0I/Hoe7Qds3vVEgeoW+GHHQzMcwvgx/MOIXhrTA==} + + '@expressive-code/plugin-shiki@0.41.7': + resolution: {integrity: sha512-DL605bLrUOgqTdZ0Ot5MlTaWzppRkzzqzeGEu7ODnHF39IkEBbFdsC7pbl3LbUQ1DFtnfx6rD54k/cdofbW6KQ==} + + '@expressive-code/plugin-text-markers@0.41.7': + resolution: {integrity: sha512-Ewpwuc5t6eFdZmWlFyeuy3e1PTQC0jFvw2Q+2bpcWXbOZhPLsT7+h8lsSIJxb5mS7wZko7cKyQ2RLYDyK6Fpmw==} + + '@img/colour@1.1.0': + resolution: {integrity: sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ==} + engines: {node: '>=18'} + + '@img/sharp-darwin-arm64@0.34.5': + resolution: {integrity: sha512-imtQ3WMJXbMY4fxb/Ndp6HBTNVtWCUI0WdobyheGf5+ad6xX8VIDO8u2xE4qc/fr08CKG/7dDseFtn6M6g/r3w==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [arm64] + os: [darwin] + + '@img/sharp-darwin-x64@0.34.5': + resolution: {integrity: sha512-YNEFAF/4KQ/PeW0N+r+aVVsoIY0/qxxikF2SWdp+NRkmMB7y9LBZAVqQ4yhGCm/H3H270OSykqmQMKLBhBJDEw==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [x64] + os: [darwin] + + '@img/sharp-libvips-darwin-arm64@1.2.4': + resolution: {integrity: sha512-zqjjo7RatFfFoP0MkQ51jfuFZBnVE2pRiaydKJ1G/rHZvnsrHAOcQALIi9sA5co5xenQdTugCvtb1cuf78Vf4g==} + cpu: [arm64] + os: [darwin] + + '@img/sharp-libvips-darwin-x64@1.2.4': + resolution: {integrity: sha512-1IOd5xfVhlGwX+zXv2N93k0yMONvUlANylbJw1eTah8K/Jtpi15KC+WSiaX/nBmbm2HxRM1gZ0nSdjSsrZbGKg==} + cpu: [x64] + os: [darwin] + + '@img/sharp-libvips-linux-arm64@1.2.4': + resolution: {integrity: sha512-excjX8DfsIcJ10x1Kzr4RcWe1edC9PquDRRPx3YVCvQv+U5p7Yin2s32ftzikXojb1PIFc/9Mt28/y+iRklkrw==} + cpu: [arm64] + os: [linux] + libc: [glibc] + + '@img/sharp-libvips-linux-arm@1.2.4': + resolution: {integrity: sha512-bFI7xcKFELdiNCVov8e44Ia4u2byA+l3XtsAj+Q8tfCwO6BQ8iDojYdvoPMqsKDkuoOo+X6HZA0s0q11ANMQ8A==} + cpu: [arm] + os: [linux] + libc: [glibc] + + '@img/sharp-libvips-linux-ppc64@1.2.4': + resolution: {integrity: sha512-FMuvGijLDYG6lW+b/UvyilUWu5Ayu+3r2d1S8notiGCIyYU/76eig1UfMmkZ7vwgOrzKzlQbFSuQfgm7GYUPpA==} + cpu: [ppc64] + os: [linux] + libc: [glibc] + + '@img/sharp-libvips-linux-riscv64@1.2.4': + resolution: {integrity: sha512-oVDbcR4zUC0ce82teubSm+x6ETixtKZBh/qbREIOcI3cULzDyb18Sr/Wcyx7NRQeQzOiHTNbZFF1UwPS2scyGA==} + cpu: [riscv64] + os: [linux] + libc: [glibc] + + '@img/sharp-libvips-linux-s390x@1.2.4': + resolution: {integrity: sha512-qmp9VrzgPgMoGZyPvrQHqk02uyjA0/QrTO26Tqk6l4ZV0MPWIW6LTkqOIov+J1yEu7MbFQaDpwdwJKhbJvuRxQ==} + cpu: [s390x] + os: [linux] + libc: [glibc] + + '@img/sharp-libvips-linux-x64@1.2.4': + resolution: {integrity: sha512-tJxiiLsmHc9Ax1bz3oaOYBURTXGIRDODBqhveVHonrHJ9/+k89qbLl0bcJns+e4t4rvaNBxaEZsFtSfAdquPrw==} + cpu: [x64] + os: [linux] + libc: [glibc] + + '@img/sharp-libvips-linuxmusl-arm64@1.2.4': + resolution: {integrity: sha512-FVQHuwx1IIuNow9QAbYUzJ+En8KcVm9Lk5+uGUQJHaZmMECZmOlix9HnH7n1TRkXMS0pGxIJokIVB9SuqZGGXw==} + cpu: [arm64] + os: [linux] + libc: [musl] + + '@img/sharp-libvips-linuxmusl-x64@1.2.4': + resolution: {integrity: sha512-+LpyBk7L44ZIXwz/VYfglaX/okxezESc6UxDSoyo2Ks6Jxc4Y7sGjpgU9s4PMgqgjj1gZCylTieNamqA1MF7Dg==} + cpu: [x64] + os: [linux] + libc: [musl] + + '@img/sharp-linux-arm64@0.34.5': + resolution: {integrity: sha512-bKQzaJRY/bkPOXyKx5EVup7qkaojECG6NLYswgktOZjaXecSAeCWiZwwiFf3/Y+O1HrauiE3FVsGxFg8c24rZg==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [arm64] + os: [linux] + libc: [glibc] + + '@img/sharp-linux-arm@0.34.5': + resolution: {integrity: sha512-9dLqsvwtg1uuXBGZKsxem9595+ujv0sJ6Vi8wcTANSFpwV/GONat5eCkzQo/1O6zRIkh0m/8+5BjrRr7jDUSZw==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [arm] + os: [linux] + libc: [glibc] + + '@img/sharp-linux-ppc64@0.34.5': + resolution: {integrity: sha512-7zznwNaqW6YtsfrGGDA6BRkISKAAE1Jo0QdpNYXNMHu2+0dTrPflTLNkpc8l7MUP5M16ZJcUvysVWWrMefZquA==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [ppc64] + os: [linux] + libc: [glibc] + + '@img/sharp-linux-riscv64@0.34.5': + resolution: {integrity: sha512-51gJuLPTKa7piYPaVs8GmByo7/U7/7TZOq+cnXJIHZKavIRHAP77e3N2HEl3dgiqdD/w0yUfiJnII77PuDDFdw==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [riscv64] + os: [linux] + libc: [glibc] + + '@img/sharp-linux-s390x@0.34.5': + resolution: {integrity: sha512-nQtCk0PdKfho3eC5MrbQoigJ2gd1CgddUMkabUj+rBevs8tZ2cULOx46E7oyX+04WGfABgIwmMC0VqieTiR4jg==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [s390x] + os: [linux] + libc: [glibc] + + '@img/sharp-linux-x64@0.34.5': + resolution: {integrity: sha512-MEzd8HPKxVxVenwAa+JRPwEC7QFjoPWuS5NZnBt6B3pu7EG2Ge0id1oLHZpPJdn3OQK+BQDiw9zStiHBTJQQQQ==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [x64] + os: [linux] + libc: [glibc] + + '@img/sharp-linuxmusl-arm64@0.34.5': + resolution: {integrity: sha512-fprJR6GtRsMt6Kyfq44IsChVZeGN97gTD331weR1ex1c1rypDEABN6Tm2xa1wE6lYb5DdEnk03NZPqA7Id21yg==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [arm64] + os: [linux] + libc: [musl] + + '@img/sharp-linuxmusl-x64@0.34.5': + resolution: {integrity: sha512-Jg8wNT1MUzIvhBFxViqrEhWDGzqymo3sV7z7ZsaWbZNDLXRJZoRGrjulp60YYtV4wfY8VIKcWidjojlLcWrd8Q==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [x64] + os: [linux] + libc: [musl] + + '@img/sharp-wasm32@0.34.5': + resolution: {integrity: sha512-OdWTEiVkY2PHwqkbBI8frFxQQFekHaSSkUIJkwzclWZe64O1X4UlUjqqqLaPbUpMOQk6FBu/HtlGXNblIs0huw==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [wasm32] + + '@img/sharp-win32-arm64@0.34.5': + resolution: {integrity: sha512-WQ3AgWCWYSb2yt+IG8mnC6Jdk9Whs7O0gxphblsLvdhSpSTtmu69ZG1Gkb6NuvxsNACwiPV6cNSZNzt0KPsw7g==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [arm64] + os: [win32] + + '@img/sharp-win32-ia32@0.34.5': + resolution: {integrity: sha512-FV9m/7NmeCmSHDD5j4+4pNI8Cp3aW+JvLoXcTUo0IqyjSfAZJ8dIUmijx1qaJsIiU+Hosw6xM5KijAWRJCSgNg==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [ia32] + os: [win32] + + '@img/sharp-win32-x64@0.34.5': + resolution: {integrity: sha512-+29YMsqY2/9eFEiW93eqWnuLcWcufowXewwSNIT6UwZdUUCrM3oFjMWH/Z6/TMmb4hlFenmfAVbpWeup2jryCw==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [x64] + os: [win32] + + '@jridgewell/sourcemap-codec@1.5.5': + resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==} + + '@mdx-js/mdx@3.1.1': + resolution: {integrity: sha512-f6ZO2ifpwAQIpzGWaBQT2TXxPv6z3RBzQKpVftEWN78Vl/YweF1uwussDx8ECAXVtr3Rs89fKyG9YlzUs9DyGQ==} + + '@oslojs/encoding@1.1.0': + resolution: {integrity: sha512-70wQhgYmndg4GCPxPPxPGevRKqTIJ2Nh4OkiMWmDAVYsTQ+Ta7Sq+rPevXyXGdzr30/qZBnyOalCszoMxlyldQ==} + + '@pagefind/darwin-arm64@1.4.0': + resolution: {integrity: sha512-2vMqkbv3lbx1Awea90gTaBsvpzgRs7MuSgKDxW0m9oV1GPZCZbZBJg/qL83GIUEN2BFlY46dtUZi54pwH+/pTQ==} + cpu: [arm64] + os: [darwin] + + '@pagefind/darwin-x64@1.4.0': + resolution: {integrity: sha512-e7JPIS6L9/cJfow+/IAqknsGqEPjJnVXGjpGm25bnq+NPdoD3c/7fAwr1OXkG4Ocjx6ZGSCijXEV4ryMcH2E3A==} + cpu: [x64] + os: [darwin] + + '@pagefind/default-ui@1.4.0': + resolution: {integrity: sha512-wie82VWn3cnGEdIjh4YwNESyS1G6vRHwL6cNjy9CFgNnWW/PGRjsLq300xjVH5sfPFK3iK36UxvIBymtQIEiSQ==} + + '@pagefind/freebsd-x64@1.4.0': + resolution: {integrity: sha512-WcJVypXSZ+9HpiqZjFXMUobfFfZZ6NzIYtkhQ9eOhZrQpeY5uQFqNWLCk7w9RkMUwBv1HAMDW3YJQl/8OqsV0Q==} + cpu: [x64] + os: [freebsd] + + '@pagefind/linux-arm64@1.4.0': + resolution: {integrity: sha512-PIt8dkqt4W06KGmQjONw7EZbhDF+uXI7i0XtRLN1vjCUxM9vGPdtJc2mUyVPevjomrGz5M86M8bqTr6cgDp1Uw==} + cpu: [arm64] + os: [linux] + + '@pagefind/linux-x64@1.4.0': + resolution: {integrity: sha512-z4oddcWwQ0UHrTHR8psLnVlz6USGJ/eOlDPTDYZ4cI8TK8PgwRUPQZp9D2iJPNIPcS6Qx/E4TebjuGJOyK8Mmg==} + cpu: [x64] + os: [linux] + + '@pagefind/windows-x64@1.4.0': + resolution: {integrity: sha512-NkT+YAdgS2FPCn8mIA9bQhiBs+xmniMGq1LFPDhcFn0+2yIUEiIG06t7bsZlhdjknEQRTSdT7YitP6fC5qwP0g==} + cpu: [x64] + os: [win32] + + '@rollup/pluginutils@5.3.0': + resolution: {integrity: sha512-5EdhGZtnu3V88ces7s53hhfK5KSASnJZv8Lulpc04cWO3REESroJXg73DFsOmgbU2BhwV0E20bu2IDZb3VKW4Q==} + engines: {node: '>=14.0.0'} + peerDependencies: + rollup: ^1.20.0||^2.0.0||^3.0.0||^4.0.0 + peerDependenciesMeta: + rollup: + optional: true + + '@rollup/rollup-android-arm-eabi@4.59.0': + resolution: {integrity: sha512-upnNBkA6ZH2VKGcBj9Fyl9IGNPULcjXRlg0LLeaioQWueH30p6IXtJEbKAgvyv+mJaMxSm1l6xwDXYjpEMiLMg==} + cpu: [arm] + os: [android] + + '@rollup/rollup-android-arm64@4.59.0': + resolution: {integrity: sha512-hZ+Zxj3SySm4A/DylsDKZAeVg0mvi++0PYVceVyX7hemkw7OreKdCvW2oQ3T1FMZvCaQXqOTHb8qmBShoqk69Q==} + cpu: [arm64] + os: [android] + + '@rollup/rollup-darwin-arm64@4.59.0': + resolution: {integrity: sha512-W2Psnbh1J8ZJw0xKAd8zdNgF9HRLkdWwwdWqubSVk0pUuQkoHnv7rx4GiF9rT4t5DIZGAsConRE3AxCdJ4m8rg==} + cpu: [arm64] + os: [darwin] + + '@rollup/rollup-darwin-x64@4.59.0': + resolution: {integrity: sha512-ZW2KkwlS4lwTv7ZVsYDiARfFCnSGhzYPdiOU4IM2fDbL+QGlyAbjgSFuqNRbSthybLbIJ915UtZBtmuLrQAT/w==} + cpu: [x64] + os: [darwin] + + '@rollup/rollup-freebsd-arm64@4.59.0': + resolution: {integrity: sha512-EsKaJ5ytAu9jI3lonzn3BgG8iRBjV4LxZexygcQbpiU0wU0ATxhNVEpXKfUa0pS05gTcSDMKpn3Sx+QB9RlTTA==} + cpu: [arm64] + os: [freebsd] + + '@rollup/rollup-freebsd-x64@4.59.0': + resolution: {integrity: sha512-d3DuZi2KzTMjImrxoHIAODUZYoUUMsuUiY4SRRcJy6NJoZ6iIqWnJu9IScV9jXysyGMVuW+KNzZvBLOcpdl3Vg==} + cpu: [x64] + os: [freebsd] + + '@rollup/rollup-linux-arm-gnueabihf@4.59.0': + resolution: {integrity: sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw==} + cpu: [arm] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-arm-musleabihf@4.59.0': + resolution: {integrity: sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA==} + cpu: [arm] + os: [linux] + libc: [musl] + + '@rollup/rollup-linux-arm64-gnu@4.59.0': + resolution: {integrity: sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA==} + cpu: [arm64] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-arm64-musl@4.59.0': + resolution: {integrity: sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA==} + cpu: [arm64] + os: [linux] + libc: [musl] + + '@rollup/rollup-linux-loong64-gnu@4.59.0': + resolution: {integrity: sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg==} + cpu: [loong64] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-loong64-musl@4.59.0': + resolution: {integrity: sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q==} + cpu: [loong64] + os: [linux] + libc: [musl] + + '@rollup/rollup-linux-ppc64-gnu@4.59.0': + resolution: {integrity: sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA==} + cpu: [ppc64] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-ppc64-musl@4.59.0': + resolution: {integrity: sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA==} + cpu: [ppc64] + os: [linux] + libc: [musl] + + '@rollup/rollup-linux-riscv64-gnu@4.59.0': + resolution: {integrity: sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg==} + cpu: [riscv64] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-riscv64-musl@4.59.0': + resolution: {integrity: sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg==} + cpu: [riscv64] + os: [linux] + libc: [musl] + + '@rollup/rollup-linux-s390x-gnu@4.59.0': + resolution: {integrity: sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w==} + cpu: [s390x] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-x64-gnu@4.59.0': + resolution: {integrity: sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg==} + cpu: [x64] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-x64-musl@4.59.0': + resolution: {integrity: sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg==} + cpu: [x64] + os: [linux] + libc: [musl] + + '@rollup/rollup-openbsd-x64@4.59.0': + resolution: {integrity: sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ==} + cpu: [x64] + os: [openbsd] + + '@rollup/rollup-openharmony-arm64@4.59.0': + resolution: {integrity: sha512-tt9KBJqaqp5i5HUZzoafHZX8b5Q2Fe7UjYERADll83O4fGqJ49O1FsL6LpdzVFQcpwvnyd0i+K/VSwu/o/nWlA==} + cpu: [arm64] + os: [openharmony] + + '@rollup/rollup-win32-arm64-msvc@4.59.0': + resolution: {integrity: sha512-V5B6mG7OrGTwnxaNUzZTDTjDS7F75PO1ae6MJYdiMu60sq0CqN5CVeVsbhPxalupvTX8gXVSU9gq+Rx1/hvu6A==} + cpu: [arm64] + os: [win32] + + '@rollup/rollup-win32-ia32-msvc@4.59.0': + resolution: {integrity: sha512-UKFMHPuM9R0iBegwzKF4y0C4J9u8C6MEJgFuXTBerMk7EJ92GFVFYBfOZaSGLu6COf7FxpQNqhNS4c4icUPqxA==} + cpu: [ia32] + os: [win32] + + '@rollup/rollup-win32-x64-gnu@4.59.0': + resolution: {integrity: sha512-laBkYlSS1n2L8fSo1thDNGrCTQMmxjYY5G0WFWjFFYZkKPjsMBsgJfGf4TLxXrF6RyhI60L8TMOjBMvXiTcxeA==} + cpu: [x64] + os: [win32] + + '@rollup/rollup-win32-x64-msvc@4.59.0': + resolution: {integrity: sha512-2HRCml6OztYXyJXAvdDXPKcawukWY2GpR5/nxKp4iBgiO3wcoEGkAaqctIbZcNB6KlUQBIqt8VYkNSj2397EfA==} + cpu: [x64] + os: [win32] + + '@shikijs/core@3.23.0': + resolution: {integrity: sha512-NSWQz0riNb67xthdm5br6lAkvpDJRTgB36fxlo37ZzM2yq0PQFFzbd8psqC2XMPgCzo1fW6cVi18+ArJ44wqgA==} + + '@shikijs/engine-javascript@3.23.0': + resolution: {integrity: sha512-aHt9eiGFobmWR5uqJUViySI1bHMqrAgamWE1TYSUoftkAeCCAiGawPMwM+VCadylQtF4V3VNOZ5LmfItH5f3yA==} + + '@shikijs/engine-oniguruma@3.23.0': + resolution: {integrity: sha512-1nWINwKXxKKLqPibT5f4pAFLej9oZzQTsby8942OTlsJzOBZ0MWKiwzMsd+jhzu8YPCHAswGnnN1YtQfirL35g==} + + '@shikijs/langs@3.23.0': + resolution: {integrity: sha512-2Ep4W3Re5aB1/62RSYQInK9mM3HsLeB91cHqznAJMuylqjzNVAVCMnNWRHFtcNHXsoNRayP9z1qj4Sq3nMqYXg==} + + '@shikijs/themes@3.23.0': + resolution: {integrity: sha512-5qySYa1ZgAT18HR/ypENL9cUSGOeI2x+4IvYJu4JgVJdizn6kG4ia5Q1jDEOi7gTbN4RbuYtmHh0W3eccOrjMA==} + + '@shikijs/types@3.23.0': + resolution: {integrity: sha512-3JZ5HXOZfYjsYSk0yPwBrkupyYSLpAE26Qc0HLghhZNGTZg/SKxXIIgoxOpmmeQP0RRSDJTk1/vPfw9tbw+jSQ==} + + '@shikijs/vscode-textmate@10.0.2': + resolution: {integrity: sha512-83yeghZ2xxin3Nj8z1NMd/NCuca+gsYXswywDy5bHvwlWL8tpTQmzGeUuHd9FC3E/SBEMvzJRwWEOz5gGes9Qg==} + + '@types/debug@4.1.12': + resolution: {integrity: sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==} + + '@types/estree-jsx@1.0.5': + resolution: {integrity: sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==} + + '@types/estree@1.0.8': + resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==} + + '@types/hast@3.0.4': + resolution: {integrity: sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==} + + '@types/js-yaml@4.0.9': + resolution: {integrity: sha512-k4MGaQl5TGo/iipqb2UDG2UwjXziSWkh0uysQelTlJpX1qGlpUZYm8PnO4DxG1qBomtJUdYJ6qR6xdIah10JLg==} + + '@types/mdast@4.0.4': + resolution: {integrity: sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==} + + '@types/mdx@2.0.13': + resolution: {integrity: sha512-+OWZQfAYyio6YkJb3HLxDrvnx6SWWDbC0zVPfBRzUk0/nqoDyf6dNxQi3eArPe8rJ473nobTMQ/8Zk+LxJ+Yuw==} + + '@types/ms@2.1.0': + resolution: {integrity: sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==} + + '@types/nlcst@2.0.3': + resolution: {integrity: sha512-vSYNSDe6Ix3q+6Z7ri9lyWqgGhJTmzRjZRqyq15N0Z/1/UnVsno9G/N40NBijoYx2seFDIl0+B2mgAb9mezUCA==} + + '@types/node@17.0.45': + resolution: {integrity: sha512-w+tIMs3rq2afQdsPJlODhoUEKzFP1ayaoyl1CcnwtIlsVe7K7bA1NGm4s3PraqTLlXnbIN84zuBlxBWo1u9BLw==} + + '@types/node@22.19.15': + resolution: {integrity: sha512-F0R/h2+dsy5wJAUe3tAU6oqa2qbWY5TpNfL/RGmo1y38hiyO1w3x2jPtt76wmuaJI4DQnOBu21cNXQ2STIUUWg==} + + '@types/sax@1.2.7': + resolution: {integrity: sha512-rO73L89PJxeYM3s3pPPjiPgVVcymqU490g0YO5n5By0k2Erzj6tay/4lr1CHAAU4JyOWd1rpQ8bCf6cZfHU96A==} + + '@types/unist@2.0.11': + resolution: {integrity: sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==} + + '@types/unist@3.0.3': + resolution: {integrity: sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==} + + '@ungap/structured-clone@1.3.0': + resolution: {integrity: sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==} + + acorn-jsx@5.3.2: + resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==} + peerDependencies: + acorn: ^6.0.0 || ^7.0.0 || ^8.0.0 + + acorn@8.16.0: + resolution: {integrity: sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==} + engines: {node: '>=0.4.0'} + hasBin: true + + ansi-align@3.0.1: + resolution: {integrity: sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==} + + ansi-regex@5.0.1: + resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==} + engines: {node: '>=8'} + + ansi-regex@6.2.2: + resolution: {integrity: sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==} + engines: {node: '>=12'} + + ansi-styles@6.2.3: + resolution: {integrity: sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==} + engines: {node: '>=12'} + + anymatch@3.1.3: + resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==} + engines: {node: '>= 8'} + + arg@5.0.2: + resolution: {integrity: sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==} + + argparse@2.0.1: + resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==} + + aria-query@5.3.2: + resolution: {integrity: sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw==} + engines: {node: '>= 0.4'} + + array-iterate@2.0.1: + resolution: {integrity: sha512-I1jXZMjAgCMmxT4qxXfPXa6SthSoE8h6gkSI9BGGNv8mP8G/v0blc+qFnZu6K42vTOiuME596QaLO0TP3Lk0xg==} + + astring@1.9.0: + resolution: {integrity: sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg==} + hasBin: true + + astro-expressive-code@0.41.7: + resolution: {integrity: sha512-hUpogGc6DdAd+I7pPXsctyYPRBJDK7Q7d06s4cyP0Vz3OcbziP3FNzN0jZci1BpCvLn9675DvS7B9ctKKX64JQ==} + peerDependencies: + astro: ^4.0.0-beta || ^5.0.0-beta || ^3.3.0 || ^6.0.0-beta + + astro@5.18.0: + resolution: {integrity: sha512-CHiohwJIS4L0G6/IzE1Fx3dgWqXBCXus/od0eGUfxrZJD2um2pE7ehclMmgL/fXqbU7NfE1Ze2pq34h2QaA6iQ==} + engines: {node: 18.20.8 || ^20.3.0 || >=22.0.0, npm: '>=9.6.5', pnpm: '>=7.1.0'} + hasBin: true + + axobject-query@4.1.0: + resolution: {integrity: sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==} + engines: {node: '>= 0.4'} + + bail@2.0.2: + resolution: {integrity: sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==} + + base-64@1.0.0: + resolution: {integrity: sha512-kwDPIFCGx0NZHog36dj+tHiwP4QMzsZ3AgMViUBKI0+V5n4U0ufTCUMhnQ04diaRI8EX/QcPfql7zlhZ7j4zgg==} + + bcp-47-match@2.0.3: + resolution: {integrity: sha512-JtTezzbAibu8G0R9op9zb3vcWZd9JF6M0xOYGPn0fNCd7wOpRB1mU2mH9T8gaBGbAAyIIVgB2G7xG0GP98zMAQ==} + + bcp-47@2.1.0: + resolution: {integrity: sha512-9IIS3UPrvIa1Ej+lVDdDwO7zLehjqsaByECw0bu2RRGP73jALm6FYbzI5gWbgHLvNdkvfXB5YrSbocZdOS0c0w==} + + boolbase@1.0.0: + resolution: {integrity: sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==} + + boxen@8.0.1: + resolution: {integrity: sha512-F3PH5k5juxom4xktynS7MoFY+NUWH5LC4CnH11YB8NPew+HLpmBLCybSAEyb2F+4pRXhuhWqFesoQd6DAyc2hw==} + engines: {node: '>=18'} + + camelcase@8.0.0: + resolution: {integrity: sha512-8WB3Jcas3swSvjIeA2yvCJ+Miyz5l1ZmB6HFb9R1317dt9LCQoswg/BGrmAmkWVEszSrrg4RwmO46qIm2OEnSA==} + engines: {node: '>=16'} + + ccount@2.0.1: + resolution: {integrity: sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==} + + chalk@5.6.2: + resolution: {integrity: sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==} + engines: {node: ^12.17.0 || ^14.13 || >=16.0.0} + + character-entities-html4@2.1.0: + resolution: {integrity: sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==} + + character-entities-legacy@3.0.0: + resolution: {integrity: sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==} + + character-entities@2.0.2: + resolution: {integrity: sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==} + + character-reference-invalid@2.0.1: + resolution: {integrity: sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw==} + + chokidar@5.0.0: + resolution: {integrity: sha512-TQMmc3w+5AxjpL8iIiwebF73dRDF4fBIieAqGn9RGCWaEVwQ6Fb2cGe31Yns0RRIzii5goJ1Y7xbMwo1TxMplw==} + engines: {node: '>= 20.19.0'} + + ci-info@4.4.0: + resolution: {integrity: sha512-77PSwercCZU2Fc4sX94eF8k8Pxte6JAwL4/ICZLFjJLqegs7kCuAsqqj/70NQF6TvDpgFjkubQB2FW2ZZddvQg==} + engines: {node: '>=8'} + + cli-boxes@3.0.0: + resolution: {integrity: sha512-/lzGpEWL/8PfI0BmBOPRwp0c/wFNX1RdUML3jK/RcSBA9T8mZDdQpqYBKtCFTOfQbwPqWEOpjqW+Fnayc0969g==} + engines: {node: '>=10'} + + clsx@2.1.1: + resolution: {integrity: sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==} + engines: {node: '>=6'} + + collapse-white-space@2.1.0: + resolution: {integrity: sha512-loKTxY1zCOuG4j9f6EPnuyyYkf58RnhhWTvRoZEokgB+WbdXehfjFviyOVYkqzEWz1Q5kRiZdBYS5SwxbQYwzw==} + + comma-separated-tokens@2.0.3: + resolution: {integrity: sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==} + + commander@11.1.0: + resolution: {integrity: sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ==} + engines: {node: '>=16'} + + common-ancestor-path@1.0.1: + resolution: {integrity: sha512-L3sHRo1pXXEqX8VU28kfgUY+YGsk09hPqZiZmLacNib6XNTCM8ubYeT7ryXQw8asB1sKgcU5lkB7ONug08aB8w==} + + cookie-es@1.2.2: + resolution: {integrity: sha512-+W7VmiVINB+ywl1HGXJXmrqkOhpKrIiVZV6tQuV54ZyQC7MMuBt81Vc336GMLoHBq5hV/F9eXgt5Mnx0Rha5Fg==} + + cookie@1.1.1: + resolution: {integrity: sha512-ei8Aos7ja0weRpFzJnEA9UHJ/7XQmqglbRwnf2ATjcB9Wq874VKH9kfjjirM6UhU2/E5fFYadylyhFldcqSidQ==} + engines: {node: '>=18'} + + crossws@0.3.5: + resolution: {integrity: sha512-ojKiDvcmByhwa8YYqbQI/hg7MEU0NC03+pSdEq4ZUnZR9xXpwk7E43SMNGkn+JxJGPFtNvQ48+vV2p+P1ml5PA==} + + css-select@5.2.2: + resolution: {integrity: sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==} + + css-selector-parser@3.3.0: + resolution: {integrity: sha512-Y2asgMGFqJKF4fq4xHDSlFYIkeVfRsm69lQC1q9kbEsH5XtnINTMrweLkjYMeaUgiXBy/uvKeO/a1JHTNnmB2g==} + + css-tree@2.2.1: + resolution: {integrity: sha512-OA0mILzGc1kCOCSJerOeqDxDQ4HOh+G8NbOJFOTgOCzpw7fCBubk0fEyxp8AgOL/jvLgYA/uV0cMbe43ElF1JA==} + engines: {node: ^10 || ^12.20.0 || ^14.13.0 || >=15.0.0, npm: '>=7.0.0'} + + css-tree@3.2.1: + resolution: {integrity: sha512-X7sjQzceUhu1u7Y/ylrRZFU2FS6LRiFVp6rKLPg23y3x3c3DOKAwuXGDp+PAGjh6CSnCjYeAul8pcT8bAl+lSA==} + engines: {node: ^10 || ^12.20.0 || ^14.13.0 || >=15.0.0} + + css-what@6.2.2: + resolution: {integrity: sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==} + engines: {node: '>= 6'} + + cssesc@3.0.0: + resolution: {integrity: sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==} + engines: {node: '>=4'} + hasBin: true + + csso@5.0.5: + resolution: {integrity: sha512-0LrrStPOdJj+SPCCrGhzryycLjwcgUSHBtxNA8aIDxf0GLsRh1cKYhB00Gd1lDOS4yGH69+SNn13+TWbVHETFQ==} + engines: {node: ^10 || ^12.20.0 || ^14.13.0 || >=15.0.0, npm: '>=7.0.0'} + + debug@4.4.3: + resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==} + engines: {node: '>=6.0'} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true + + decode-named-character-reference@1.3.0: + resolution: {integrity: sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q==} + + defu@6.1.4: + resolution: {integrity: sha512-mEQCMmwJu317oSz8CwdIOdwf3xMif1ttiM8LTufzc3g6kR+9Pe236twL8j3IYT1F7GfRgGcW6MWxzZjLIkuHIg==} + + dequal@2.0.3: + resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==} + engines: {node: '>=6'} + + destr@2.0.5: + resolution: {integrity: sha512-ugFTXCtDZunbzasqBxrK93Ik/DRYsO6S/fedkWEMKqt04xZ4csmnmwGDBAb07QWNaGMAmnTIemsYZCksjATwsA==} + + detect-libc@2.1.2: + resolution: {integrity: sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==} + engines: {node: '>=8'} + + deterministic-object-hash@2.0.2: + resolution: {integrity: sha512-KxektNH63SrbfUyDiwXqRb1rLwKt33AmMv+5Nhsw1kqZ13SJBRTgZHtGbE+hH3a1mVW1cz+4pqSWVPAtLVXTzQ==} + engines: {node: '>=18'} + + devalue@5.6.3: + resolution: {integrity: sha512-nc7XjUU/2Lb+SvEFVGcWLiKkzfw8+qHI7zn8WYXKkLMgfGSHbgCEaR6bJpev8Cm6Rmrb19Gfd/tZvGqx9is3wg==} + + devlop@1.1.0: + resolution: {integrity: sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==} + + diff@8.0.3: + resolution: {integrity: sha512-qejHi7bcSD4hQAZE0tNAawRK1ZtafHDmMTMkrrIGgSLl7hTnQHmKCeB45xAcbfTqK2zowkM3j3bHt/4b/ARbYQ==} + engines: {node: '>=0.3.1'} + + direction@2.0.1: + resolution: {integrity: sha512-9S6m9Sukh1cZNknO1CWAr2QAWsbKLafQiyM5gZ7VgXHeuaoUwffKN4q6NC4A/Mf9iiPlOXQEKW/Mv/mh9/3YFA==} + hasBin: true + + dlv@1.1.3: + resolution: {integrity: sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==} + + dom-serializer@2.0.0: + resolution: {integrity: sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==} + + domelementtype@2.3.0: + resolution: {integrity: sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==} + + domhandler@5.0.3: + resolution: {integrity: sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==} + engines: {node: '>= 4'} + + domutils@3.2.2: + resolution: {integrity: sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==} + + dset@3.1.4: + resolution: {integrity: sha512-2QF/g9/zTaPDc3BjNcVTGoBbXBgYfMTTceLaYcFJ/W9kggFUkhxD/hMEeuLKbugyef9SqAx8cpgwlIP/jinUTA==} + engines: {node: '>=4'} + + emoji-regex@10.6.0: + resolution: {integrity: sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A==} + + emoji-regex@8.0.0: + resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==} + + entities@4.5.0: + resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==} + engines: {node: '>=0.12'} + + entities@6.0.1: + resolution: {integrity: sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==} + engines: {node: '>=0.12'} + + es-module-lexer@1.7.0: + resolution: {integrity: sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==} + + esast-util-from-estree@2.0.0: + resolution: {integrity: sha512-4CyanoAudUSBAn5K13H4JhsMH6L9ZP7XbLVe/dKybkxMO7eDyLsT8UHl9TRNrU2Gr9nz+FovfSIjuXWJ81uVwQ==} + + esast-util-from-js@2.0.1: + resolution: {integrity: sha512-8Ja+rNJ0Lt56Pcf3TAmpBZjmx8ZcK5Ts4cAzIOjsjevg9oSXJnl6SUQ2EevU8tv3h6ZLWmoKL5H4fgWvdvfETw==} + + esbuild@0.25.12: + resolution: {integrity: sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==} + engines: {node: '>=18'} + hasBin: true + + esbuild@0.27.3: + resolution: {integrity: sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg==} + engines: {node: '>=18'} + hasBin: true + + escape-string-regexp@5.0.0: + resolution: {integrity: sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==} + engines: {node: '>=12'} + + estree-util-attach-comments@3.0.0: + resolution: {integrity: sha512-cKUwm/HUcTDsYh/9FgnuFqpfquUbwIqwKM26BVCGDPVgvaCl/nDCCjUfiLlx6lsEZ3Z4RFxNbOQ60pkaEwFxGw==} + + estree-util-build-jsx@3.0.1: + resolution: {integrity: sha512-8U5eiL6BTrPxp/CHbs2yMgP8ftMhR5ww1eIKoWRMlqvltHF8fZn5LRDvTKuxD3DUn+shRbLGqXemcP51oFCsGQ==} + + estree-util-is-identifier-name@3.0.0: + resolution: {integrity: sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg==} + + estree-util-scope@1.0.0: + resolution: {integrity: sha512-2CAASclonf+JFWBNJPndcOpA8EMJwa0Q8LUFJEKqXLW6+qBvbFZuF5gItbQOs/umBUkjviCSDCbBwU2cXbmrhQ==} + + estree-util-to-js@2.0.0: + resolution: {integrity: sha512-WDF+xj5rRWmD5tj6bIqRi6CkLIXbbNQUcxQHzGysQzvHmdYG2G7p/Tf0J0gpxGgkeMZNTIjT/AoSvC9Xehcgdg==} + + estree-util-visit@2.0.0: + resolution: {integrity: sha512-m5KgiH85xAhhW8Wta0vShLcUvOsh3LLPI2YVwcbio1l7E09NTLL1EyMZFM1OyWowoH0skScNbhOPl4kcBgzTww==} + + estree-walker@2.0.2: + resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==} + + estree-walker@3.0.3: + resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==} + + eventemitter3@5.0.4: + resolution: {integrity: sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==} + + expressive-code@0.41.7: + resolution: {integrity: sha512-2wZjC8OQ3TaVEMcBtYY4Va3lo6J+Ai9jf3d4dbhURMJcU4Pbqe6EcHe424MIZI0VHUA1bR6xdpoHYi3yxokWqA==} + + extend@3.0.2: + resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==} + + fdir@6.5.0: + resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==} + engines: {node: '>=12.0.0'} + peerDependencies: + picomatch: ^3 || ^4 + peerDependenciesMeta: + picomatch: + optional: true + + flattie@1.1.1: + resolution: {integrity: sha512-9UbaD6XdAL97+k/n+N7JwX46K/M6Zc6KcFYskrYL8wbBV/Uyk0CTAMY0VT+qiK5PM7AIc9aTWYtq65U7T+aCNQ==} + engines: {node: '>=8'} + + fontace@0.4.1: + resolution: {integrity: sha512-lDMvbAzSnHmbYMTEld5qdtvNH2/pWpICOqpean9IgC7vUbUJc3k+k5Dokp85CegamqQpFbXf0rAVkbzpyTA8aw==} + + fontkitten@1.0.3: + resolution: {integrity: sha512-Wp1zXWPVUPBmfoa3Cqc9ctaKuzKAV6uLstRqlR56kSjplf5uAce+qeyYym7F+PHbGTk+tCEdkCW6RD7DX/gBZw==} + engines: {node: '>=20'} + + fsevents@2.3.3: + resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==} + engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} + os: [darwin] + + get-east-asian-width@1.5.0: + resolution: {integrity: sha512-CQ+bEO+Tva/qlmw24dCejulK5pMzVnUOFOijVogd3KQs07HnRIgp8TGipvCCRT06xeYEbpbgwaCxglFyiuIcmA==} + engines: {node: '>=18'} + + get-tsconfig@4.13.6: + resolution: {integrity: sha512-shZT/QMiSHc/YBLxxOkMtgSid5HFoauqCE3/exfsEcwg1WkeqjG+V40yBbBrsD+jW2HDXcs28xOfcbm2jI8Ddw==} + + github-slugger@2.0.0: + resolution: {integrity: sha512-IaOQ9puYtjrkq7Y0Ygl9KDZnrf/aiUJYUpVf89y8kyaxbRG7Y1SrX/jaumrv81vc61+kiMempujsM3Yw7w5qcw==} + + h3@1.15.5: + resolution: {integrity: sha512-xEyq3rSl+dhGX2Lm0+eFQIAzlDN6Fs0EcC4f7BNUmzaRX/PTzeuM+Tr2lHB8FoXggsQIeXLj8EDVgs5ywxyxmg==} + + hast-util-embedded@3.0.0: + resolution: {integrity: sha512-naH8sld4Pe2ep03qqULEtvYr7EjrLK2QHY8KJR6RJkTUjPGObe1vnx585uzem2hGra+s1q08DZZpfgDVYRbaXA==} + + hast-util-format@1.1.0: + resolution: {integrity: sha512-yY1UDz6bC9rDvCWHpx12aIBGRG7krurX0p0Fm6pT547LwDIZZiNr8a+IHDogorAdreULSEzP82Nlv5SZkHZcjA==} + + hast-util-from-html@2.0.3: + resolution: {integrity: sha512-CUSRHXyKjzHov8yKsQjGOElXy/3EKpyX56ELnkHH34vDVw1N1XSQ1ZcAvTyAPtGqLTuKP/uxM+aLkSPqF/EtMw==} + + hast-util-from-parse5@8.0.3: + resolution: {integrity: sha512-3kxEVkEKt0zvcZ3hCRYI8rqrgwtlIOFMWkbclACvjlDw8Li9S2hk/d51OI0nr/gIpdMHNepwgOKqZ/sy0Clpyg==} + + hast-util-has-property@3.0.0: + resolution: {integrity: sha512-MNilsvEKLFpV604hwfhVStK0usFY/QmM5zX16bo7EjnAEGofr5YyI37kzopBlZJkHD4t887i+q/C8/tr5Q94cA==} + + hast-util-is-body-ok-link@3.0.1: + resolution: {integrity: sha512-0qpnzOBLztXHbHQenVB8uNuxTnm/QBFUOmdOSsEn7GnBtyY07+ENTWVFBAnXd/zEgd9/SUG3lRY7hSIBWRgGpQ==} + + hast-util-is-element@3.0.0: + resolution: {integrity: sha512-Val9mnv2IWpLbNPqc/pUem+a7Ipj2aHacCwgNfTiK0vJKl0LF+4Ba4+v1oPHFpf3bLYmreq0/l3Gud9S5OH42g==} + + hast-util-minify-whitespace@1.0.1: + resolution: {integrity: sha512-L96fPOVpnclQE0xzdWb/D12VT5FabA7SnZOUMtL1DbXmYiHJMXZvFkIZfiMmTCNJHUeO2K9UYNXoVyfz+QHuOw==} + + hast-util-parse-selector@4.0.0: + resolution: {integrity: sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A==} + + hast-util-phrasing@3.0.1: + resolution: {integrity: sha512-6h60VfI3uBQUxHqTyMymMZnEbNl1XmEGtOxxKYL7stY2o601COo62AWAYBQR9lZbYXYSBoxag8UpPRXK+9fqSQ==} + + hast-util-raw@9.1.0: + resolution: {integrity: sha512-Y8/SBAHkZGoNkpzqqfCldijcuUKh7/su31kEBp67cFY09Wy0mTRgtsLYsiIxMJxlu0f6AA5SUTbDR8K0rxnbUw==} + + hast-util-select@6.0.4: + resolution: {integrity: sha512-RqGS1ZgI0MwxLaKLDxjprynNzINEkRHY2i8ln4DDjgv9ZhcYVIHN9rlpiYsqtFwrgpYU361SyWDQcGNIBVu3lw==} + + hast-util-to-estree@3.1.3: + resolution: {integrity: sha512-48+B/rJWAp0jamNbAAf9M7Uf//UVqAoMmgXhBdxTDJLGKY+LRnZ99qcG+Qjl5HfMpYNzS5v4EAwVEF34LeAj7w==} + + hast-util-to-html@9.0.5: + resolution: {integrity: sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw==} + + hast-util-to-jsx-runtime@2.3.6: + resolution: {integrity: sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg==} + + hast-util-to-parse5@8.0.1: + resolution: {integrity: sha512-MlWT6Pjt4CG9lFCjiz4BH7l9wmrMkfkJYCxFwKQic8+RTZgWPuWxwAfjJElsXkex7DJjfSJsQIt931ilUgmwdA==} + + hast-util-to-string@3.0.1: + resolution: {integrity: sha512-XelQVTDWvqcl3axRfI0xSeoVKzyIFPwsAGSLIsKdJKQMXDYJS4WYrBNF/8J7RdhIcFI2BOHgAifggsvsxp/3+A==} + + hast-util-to-text@4.0.2: + resolution: {integrity: sha512-KK6y/BN8lbaq654j7JgBydev7wuNMcID54lkRav1P0CaE1e47P72AWWPiGKXTJU271ooYzcvTAn/Zt0REnvc7A==} + + hast-util-whitespace@3.0.0: + resolution: {integrity: sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==} + + hastscript@9.0.1: + resolution: {integrity: sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w==} + + html-escaper@3.0.3: + resolution: {integrity: sha512-RuMffC89BOWQoY0WKGpIhn5gX3iI54O6nRA0yC124NYVtzjmFWBIiFd8M0x+ZdX0P9R4lADg1mgP8C7PxGOWuQ==} + + html-void-elements@3.0.0: + resolution: {integrity: sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==} + + html-whitespace-sensitive-tag-names@3.0.1: + resolution: {integrity: sha512-q+310vW8zmymYHALr1da4HyXUQ0zgiIwIicEfotYPWGN0OJVEN/58IJ3A4GBYcEq3LGAZqKb+ugvP0GNB9CEAA==} + + http-cache-semantics@4.2.0: + resolution: {integrity: sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==} + + i18next@23.16.8: + resolution: {integrity: sha512-06r/TitrM88Mg5FdUXAKL96dJMzgqLE5dv3ryBAra4KCwD9mJ4ndOTS95ZuymIGoE+2hzfdaMak2X11/es7ZWg==} + + import-meta-resolve@4.2.0: + resolution: {integrity: sha512-Iqv2fzaTQN28s/FwZAoFq0ZSs/7hMAHJVX+w8PZl3cY19Pxk6jFFalxQoIfW2826i/fDLXv8IiEZRIT0lDuWcg==} + + inline-style-parser@0.2.7: + resolution: {integrity: sha512-Nb2ctOyNR8DqQoR0OwRG95uNWIC0C1lCgf5Naz5H6Ji72KZ8OcFZLz2P5sNgwlyoJ8Yif11oMuYs5pBQa86csA==} + + iron-webcrypto@1.2.1: + resolution: {integrity: sha512-feOM6FaSr6rEABp/eDfVseKyTMDt+KGpeB35SkVn9Tyn0CqvVsY3EwI0v5i8nMHyJnzCIQf7nsy3p41TPkJZhg==} + + is-alphabetical@2.0.1: + resolution: {integrity: sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ==} + + is-alphanumerical@2.0.1: + resolution: {integrity: sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw==} + + is-decimal@2.0.1: + resolution: {integrity: sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A==} + + is-docker@3.0.0: + resolution: {integrity: sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + hasBin: true + + is-fullwidth-code-point@3.0.0: + resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==} + engines: {node: '>=8'} + + is-hexadecimal@2.0.1: + resolution: {integrity: sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg==} + + is-inside-container@1.0.0: + resolution: {integrity: sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA==} + engines: {node: '>=14.16'} + hasBin: true + + is-plain-obj@4.1.0: + resolution: {integrity: sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==} + engines: {node: '>=12'} + + is-wsl@3.1.1: + resolution: {integrity: sha512-e6rvdUCiQCAuumZslxRJWR/Doq4VpPR82kqclvcS0efgt430SlGIk05vdCN58+VrzgtIcfNODjozVielycD4Sw==} + engines: {node: '>=16'} + + js-yaml@4.1.1: + resolution: {integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==} + hasBin: true + + kleur@3.0.3: + resolution: {integrity: sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==} + engines: {node: '>=6'} + + klona@2.0.6: + resolution: {integrity: sha512-dhG34DXATL5hSxJbIexCft8FChFXtmskoZYnoPWjXQuebWYCNkVeV3KkGegCK9CP1oswI/vQibS2GY7Em/sJJA==} + engines: {node: '>= 8'} + + longest-streak@3.1.0: + resolution: {integrity: sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==} + + lru-cache@11.2.6: + resolution: {integrity: sha512-ESL2CrkS/2wTPfuend7Zhkzo2u0daGJ/A2VucJOgQ/C48S/zB8MMeMHSGKYpXhIjbPxfuezITkaBH1wqv00DDQ==} + engines: {node: 20 || >=22} + + magic-string@0.30.21: + resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==} + + magicast@0.5.2: + resolution: {integrity: sha512-E3ZJh4J3S9KfwdjZhe2afj6R9lGIN5Pher1pF39UGrXRqq/VDaGVIGN13BjHd2u8B61hArAGOnso7nBOouW3TQ==} + + markdown-extensions@2.0.0: + resolution: {integrity: sha512-o5vL7aDWatOTX8LzaS1WMoaoxIiLRQJuIKKe2wAw6IeULDHaqbiqiggmx+pKvZDb1Sj+pE46Sn1T7lCqfFtg1Q==} + engines: {node: '>=16'} + + markdown-table@3.0.4: + resolution: {integrity: sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw==} + + mdast-util-definitions@6.0.0: + resolution: {integrity: sha512-scTllyX6pnYNZH/AIp/0ePz6s4cZtARxImwoPJ7kS42n+MnVsI4XbnG6d4ibehRIldYMWM2LD7ImQblVhUejVQ==} + + mdast-util-directive@3.1.0: + resolution: {integrity: sha512-I3fNFt+DHmpWCYAT7quoM6lHf9wuqtI+oCOfvILnoicNIqjh5E3dEJWiXuYME2gNe8vl1iMQwyUHa7bgFmak6Q==} + + mdast-util-find-and-replace@3.0.2: + resolution: {integrity: sha512-Tmd1Vg/m3Xz43afeNxDIhWRtFZgM2VLyaf4vSTYwudTyeuTneoL3qtWMA5jeLyz/O1vDJmmV4QuScFCA2tBPwg==} + + mdast-util-from-markdown@2.0.3: + resolution: {integrity: sha512-W4mAWTvSlKvf8L6J+VN9yLSqQ9AOAAvHuoDAmPkz4dHf553m5gVj2ejadHJhoJmcmxEnOv6Pa8XJhpxE93kb8Q==} + + mdast-util-gfm-autolink-literal@2.0.1: + resolution: {integrity: sha512-5HVP2MKaP6L+G6YaxPNjuL0BPrq9orG3TsrZ9YXbA3vDw/ACI4MEsnoDpn6ZNm7GnZgtAcONJyPhOP8tNJQavQ==} + + mdast-util-gfm-footnote@2.1.0: + resolution: {integrity: sha512-sqpDWlsHn7Ac9GNZQMeUzPQSMzR6Wv0WKRNvQRg0KqHh02fpTz69Qc1QSseNX29bhz1ROIyNyxExfawVKTm1GQ==} + + mdast-util-gfm-strikethrough@2.0.0: + resolution: {integrity: sha512-mKKb915TF+OC5ptj5bJ7WFRPdYtuHv0yTRxK2tJvi+BDqbkiG7h7u/9SI89nRAYcmap2xHQL9D+QG/6wSrTtXg==} + + mdast-util-gfm-table@2.0.0: + resolution: {integrity: sha512-78UEvebzz/rJIxLvE7ZtDd/vIQ0RHv+3Mh5DR96p7cS7HsBhYIICDBCu8csTNWNO6tBWfqXPWekRuj2FNOGOZg==} + + mdast-util-gfm-task-list-item@2.0.0: + resolution: {integrity: sha512-IrtvNvjxC1o06taBAVJznEnkiHxLFTzgonUdy8hzFVeDun0uTjxxrRGVaNFqkU1wJR3RBPEfsxmU6jDWPofrTQ==} + + mdast-util-gfm@3.1.0: + resolution: {integrity: sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ==} + + mdast-util-mdx-expression@2.0.1: + resolution: {integrity: sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ==} + + mdast-util-mdx-jsx@3.2.0: + resolution: {integrity: sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q==} + + mdast-util-mdx@3.0.0: + resolution: {integrity: sha512-JfbYLAW7XnYTTbUsmpu0kdBUVe+yKVJZBItEjwyYJiDJuZ9w4eeaqks4HQO+R7objWgS2ymV60GYpI14Ug554w==} + + mdast-util-mdxjs-esm@2.0.1: + resolution: {integrity: sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg==} + + mdast-util-phrasing@4.1.0: + resolution: {integrity: sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==} + + mdast-util-to-hast@13.2.1: + resolution: {integrity: sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==} + + mdast-util-to-markdown@2.1.2: + resolution: {integrity: sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA==} + + mdast-util-to-string@4.0.0: + resolution: {integrity: sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg==} + + mdn-data@2.0.28: + resolution: {integrity: sha512-aylIc7Z9y4yzHYAJNuESG3hfhC+0Ibp/MAMiaOZgNv4pmEdFyfZhhhny4MNiAfWdBQ1RQ2mfDWmM1x8SvGyp8g==} + + mdn-data@2.27.1: + resolution: {integrity: sha512-9Yubnt3e8A0OKwxYSXyhLymGW4sCufcLG6VdiDdUGVkPhpqLxlvP5vl1983gQjJl3tqbrM731mjaZaP68AgosQ==} + + micromark-core-commonmark@2.0.3: + resolution: {integrity: sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg==} + + micromark-extension-directive@3.0.2: + resolution: {integrity: sha512-wjcXHgk+PPdmvR58Le9d7zQYWy+vKEU9Se44p2CrCDPiLr2FMyiT4Fyb5UFKFC66wGB3kPlgD7q3TnoqPS7SZA==} + + micromark-extension-gfm-autolink-literal@2.1.0: + resolution: {integrity: sha512-oOg7knzhicgQ3t4QCjCWgTmfNhvQbDDnJeVu9v81r7NltNCVmhPy1fJRX27pISafdjL+SVc4d3l48Gb6pbRypw==} + + micromark-extension-gfm-footnote@2.1.0: + resolution: {integrity: sha512-/yPhxI1ntnDNsiHtzLKYnE3vf9JZ6cAisqVDauhp4CEHxlb4uoOTxOCJ+9s51bIB8U1N1FJ1RXOKTIlD5B/gqw==} + + micromark-extension-gfm-strikethrough@2.1.0: + resolution: {integrity: sha512-ADVjpOOkjz1hhkZLlBiYA9cR2Anf8F4HqZUO6e5eDcPQd0Txw5fxLzzxnEkSkfnD0wziSGiv7sYhk/ktvbf1uw==} + + micromark-extension-gfm-table@2.1.1: + resolution: {integrity: sha512-t2OU/dXXioARrC6yWfJ4hqB7rct14e8f7m0cbI5hUmDyyIlwv5vEtooptH8INkbLzOatzKuVbQmAYcbWoyz6Dg==} + + micromark-extension-gfm-tagfilter@2.0.0: + resolution: {integrity: sha512-xHlTOmuCSotIA8TW1mDIM6X2O1SiX5P9IuDtqGonFhEK0qgRI4yeC6vMxEV2dgyr2TiD+2PQ10o+cOhdVAcwfg==} + + micromark-extension-gfm-task-list-item@2.1.0: + resolution: {integrity: sha512-qIBZhqxqI6fjLDYFTBIa4eivDMnP+OZqsNwmQ3xNLE4Cxwc+zfQEfbs6tzAo2Hjq+bh6q5F+Z8/cksrLFYWQQw==} + + micromark-extension-gfm@3.0.0: + resolution: {integrity: sha512-vsKArQsicm7t0z2GugkCKtZehqUm31oeGBV/KVSorWSy8ZlNAv7ytjFhvaryUiCUJYqs+NoE6AFhpQvBTM6Q4w==} + + micromark-extension-mdx-expression@3.0.1: + resolution: {integrity: sha512-dD/ADLJ1AeMvSAKBwO22zG22N4ybhe7kFIZ3LsDI0GlsNr2A3KYxb0LdC1u5rj4Nw+CHKY0RVdnHX8vj8ejm4Q==} + + micromark-extension-mdx-jsx@3.0.2: + resolution: {integrity: sha512-e5+q1DjMh62LZAJOnDraSSbDMvGJ8x3cbjygy2qFEi7HCeUT4BDKCvMozPozcD6WmOt6sVvYDNBKhFSz3kjOVQ==} + + micromark-extension-mdx-md@2.0.0: + resolution: {integrity: sha512-EpAiszsB3blw4Rpba7xTOUptcFeBFi+6PY8VnJ2hhimH+vCQDirWgsMpz7w1XcZE7LVrSAUGb9VJpG9ghlYvYQ==} + + micromark-extension-mdxjs-esm@3.0.0: + resolution: {integrity: sha512-DJFl4ZqkErRpq/dAPyeWp15tGrcrrJho1hKK5uBS70BCtfrIFg81sqcTVu3Ta+KD1Tk5vAtBNElWxtAa+m8K9A==} + + micromark-extension-mdxjs@3.0.0: + resolution: {integrity: sha512-A873fJfhnJ2siZyUrJ31l34Uqwy4xIFmvPY1oj+Ean5PHcPBYzEsvqvWGaWcfEIr11O5Dlw3p2y0tZWpKHDejQ==} + + micromark-factory-destination@2.0.1: + resolution: {integrity: sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA==} + + micromark-factory-label@2.0.1: + resolution: {integrity: sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg==} + + micromark-factory-mdx-expression@2.0.3: + resolution: {integrity: sha512-kQnEtA3vzucU2BkrIa8/VaSAsP+EJ3CKOvhMuJgOEGg9KDC6OAY6nSnNDVRiVNRqj7Y4SlSzcStaH/5jge8JdQ==} + + micromark-factory-space@2.0.1: + resolution: {integrity: sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==} + + micromark-factory-title@2.0.1: + resolution: {integrity: sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw==} + + micromark-factory-whitespace@2.0.1: + resolution: {integrity: sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ==} + + micromark-util-character@2.1.1: + resolution: {integrity: sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==} + + micromark-util-chunked@2.0.1: + resolution: {integrity: sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA==} + + micromark-util-classify-character@2.0.1: + resolution: {integrity: sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q==} + + micromark-util-combine-extensions@2.0.1: + resolution: {integrity: sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg==} + + micromark-util-decode-numeric-character-reference@2.0.2: + resolution: {integrity: sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw==} + + micromark-util-decode-string@2.0.1: + resolution: {integrity: sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ==} + + micromark-util-encode@2.0.1: + resolution: {integrity: sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==} + + micromark-util-events-to-acorn@2.0.3: + resolution: {integrity: sha512-jmsiEIiZ1n7X1Rr5k8wVExBQCg5jy4UXVADItHmNk1zkwEVhBuIUKRu3fqv+hs4nxLISi2DQGlqIOGiFxgbfHg==} + + micromark-util-html-tag-name@2.0.1: + resolution: {integrity: sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA==} + + micromark-util-normalize-identifier@2.0.1: + resolution: {integrity: sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q==} + + micromark-util-resolve-all@2.0.1: + resolution: {integrity: sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg==} + + micromark-util-sanitize-uri@2.0.1: + resolution: {integrity: sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==} + + micromark-util-subtokenize@2.1.0: + resolution: {integrity: sha512-XQLu552iSctvnEcgXw6+Sx75GflAPNED1qx7eBJ+wydBb2KCbRZe+NwvIEEMM83uml1+2WSXpBAcp9IUCgCYWA==} + + micromark-util-symbol@2.0.1: + resolution: {integrity: sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==} + + micromark-util-types@2.0.2: + resolution: {integrity: sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==} + + micromark@4.0.2: + resolution: {integrity: sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA==} + + mrmime@2.0.1: + resolution: {integrity: sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==} + engines: {node: '>=10'} + + ms@2.1.3: + resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==} + + nanoid@3.3.11: + resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==} + engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1} + hasBin: true + + neotraverse@0.6.18: + resolution: {integrity: sha512-Z4SmBUweYa09+o6pG+eASabEpP6QkQ70yHj351pQoEXIs8uHbaU2DWVmzBANKgflPa47A50PtB2+NgRpQvr7vA==} + engines: {node: '>= 10'} + + nlcst-to-string@4.0.0: + resolution: {integrity: sha512-YKLBCcUYKAg0FNlOBT6aI91qFmSiFKiluk655WzPF+DDMA02qIyy8uiRqI8QXtcFpEvll12LpL5MXqEmAZ+dcA==} + + node-fetch-native@1.6.7: + resolution: {integrity: sha512-g9yhqoedzIUm0nTnTqAQvueMPVOuIY16bqgAJJC8XOOubYFNwz6IER9qs0Gq2Xd0+CecCKFjtdDTMA4u4xG06Q==} + + node-mock-http@1.0.4: + resolution: {integrity: sha512-8DY+kFsDkNXy1sJglUfuODx1/opAGJGyrTuFqEoN90oRc2Vk0ZbD4K2qmKXBBEhZQzdKHIVfEJpDU8Ak2NJEvQ==} + + normalize-path@3.0.0: + resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==} + engines: {node: '>=0.10.0'} + + nth-check@2.1.1: + resolution: {integrity: sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==} + + ofetch@1.5.1: + resolution: {integrity: sha512-2W4oUZlVaqAPAil6FUg/difl6YhqhUR7x2eZY4bQCko22UXg3hptq9KLQdqFClV+Wu85UX7hNtdGTngi/1BxcA==} + + ohash@2.0.11: + resolution: {integrity: sha512-RdR9FQrFwNBNXAr4GixM8YaRZRJ5PUWbKYbE5eOsrwAjJW0q2REGcf79oYPsLyskQCZG1PLN+S/K1V00joZAoQ==} + + oniguruma-parser@0.12.1: + resolution: {integrity: sha512-8Unqkvk1RYc6yq2WBYRj4hdnsAxVze8i7iPfQr8e4uSP3tRv0rpZcbGUDvxfQQcdwHt/e9PrMvGCsa8OqG9X3w==} + + oniguruma-to-es@4.3.4: + resolution: {integrity: sha512-3VhUGN3w2eYxnTzHn+ikMI+fp/96KoRSVK9/kMTcFqj1NRDh2IhQCKvYxDnWePKRXY/AqH+Fuiyb7VHSzBjHfA==} + + p-limit@6.2.0: + resolution: {integrity: sha512-kuUqqHNUqoIWp/c467RI4X6mmyuojY5jGutNU0wVTmEOOfcuwLqyMVoAi9MKi2Ak+5i9+nhmrK4ufZE8069kHA==} + engines: {node: '>=18'} + + p-queue@8.1.1: + resolution: {integrity: sha512-aNZ+VfjobsWryoiPnEApGGmf5WmNsCo9xu8dfaYamG5qaLP7ClhLN6NgsFe6SwJ2UbLEBK5dv9x8Mn5+RVhMWQ==} + engines: {node: '>=18'} + + p-timeout@6.1.4: + resolution: {integrity: sha512-MyIV3ZA/PmyBN/ud8vV9XzwTrNtR4jFrObymZYnZqMmW0zA8Z17vnT0rBgFE/TlohB+YCHqXMgZzb3Csp49vqg==} + engines: {node: '>=14.16'} + + package-manager-detector@1.6.0: + resolution: {integrity: sha512-61A5ThoTiDG/C8s8UMZwSorAGwMJ0ERVGj2OjoW5pAalsNOg15+iQiPzrLJ4jhZ1HJzmC2PIHT2oEiH3R5fzNA==} + + pagefind@1.4.0: + resolution: {integrity: sha512-z2kY1mQlL4J8q5EIsQkLzQjilovKzfNVhX8De6oyE6uHpfFtyBaqUpcl/XzJC/4fjD8vBDyh1zolimIcVrCn9g==} + hasBin: true + + parse-entities@4.0.2: + resolution: {integrity: sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw==} + + parse-latin@7.0.0: + resolution: {integrity: sha512-mhHgobPPua5kZ98EF4HWiH167JWBfl4pvAIXXdbaVohtK7a6YBOy56kvhCqduqyo/f3yrHFWmqmiMg/BkBkYYQ==} + + parse5@7.3.0: + resolution: {integrity: sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==} + + piccolore@0.1.3: + resolution: {integrity: sha512-o8bTeDWjE086iwKrROaDf31K0qC/BENdm15/uH9usSC/uZjJOKb2YGiVHfLY4GhwsERiPI1jmwI2XrA7ACOxVw==} + + picocolors@1.1.1: + resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==} + + picomatch@2.3.1: + resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==} + engines: {node: '>=8.6'} + + picomatch@4.0.3: + resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==} + engines: {node: '>=12'} + + postcss-nested@6.2.0: + resolution: {integrity: sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ==} + engines: {node: '>=12.0'} + peerDependencies: + postcss: ^8.2.14 + + postcss-selector-parser@6.1.2: + resolution: {integrity: sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==} + engines: {node: '>=4'} + + postcss@8.5.8: + resolution: {integrity: sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg==} + engines: {node: ^10 || ^12 || >=14} + + prismjs@1.30.0: + resolution: {integrity: sha512-DEvV2ZF2r2/63V+tK8hQvrR2ZGn10srHbXviTlcv7Kpzw8jWiNTqbVgjO3IY8RxrrOUF8VPMQQFysYYYv0YZxw==} + engines: {node: '>=6'} + + prompts@2.4.2: + resolution: {integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==} + engines: {node: '>= 6'} + + property-information@7.1.0: + resolution: {integrity: sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==} + + radix3@1.1.2: + resolution: {integrity: sha512-b484I/7b8rDEdSDKckSSBA8knMpcdsXudlE/LNL639wFoHKwLbEkQFZHWEYwDC0wa0FKUcCY+GAF73Z7wxNVFA==} + + readdirp@5.0.0: + resolution: {integrity: sha512-9u/XQ1pvrQtYyMpZe7DXKv2p5CNvyVwzUB6uhLAnQwHMSgKMBR62lc7AHljaeteeHXn11XTAaLLUVZYVZyuRBQ==} + engines: {node: '>= 20.19.0'} + + recma-build-jsx@1.0.0: + resolution: {integrity: sha512-8GtdyqaBcDfva+GUKDr3nev3VpKAhup1+RvkMvUxURHpW7QyIvk9F5wz7Vzo06CEMSilw6uArgRqhpiUcWp8ew==} + + recma-jsx@1.0.1: + resolution: {integrity: sha512-huSIy7VU2Z5OLv6oFLosQGGDqPqdO1iq6bWNAdhzMxSJP7RAso4fCZ1cKu8j9YHCZf3TPrq4dw3okhrylgcd7w==} + peerDependencies: + acorn: ^6.0.0 || ^7.0.0 || ^8.0.0 + + recma-parse@1.0.0: + resolution: {integrity: sha512-OYLsIGBB5Y5wjnSnQW6t3Xg7q3fQ7FWbw/vcXtORTnyaSFscOtABg+7Pnz6YZ6c27fG1/aN8CjfwoUEUIdwqWQ==} + + recma-stringify@1.0.0: + resolution: {integrity: sha512-cjwII1MdIIVloKvC9ErQ+OgAtwHBmcZ0Bg4ciz78FtbT8In39aAYbaA7zvxQ61xVMSPE8WxhLwLbhif4Js2C+g==} + + regex-recursion@6.0.2: + resolution: {integrity: sha512-0YCaSCq2VRIebiaUviZNs0cBz1kg5kVS2UKUfNIx8YVs1cN3AV7NTctO5FOKBA+UT2BPJIWZauYHPqJODG50cg==} + + regex-utilities@2.3.0: + resolution: {integrity: sha512-8VhliFJAWRaUiVvREIiW2NXXTmHs4vMNnSzuJVhscgmGav3g9VDxLrQndI3dZZVVdp0ZO/5v0xmX516/7M9cng==} + + regex@6.1.0: + resolution: {integrity: sha512-6VwtthbV4o/7+OaAF9I5L5V3llLEsoPyq9P1JVXkedTP33c7MfCG0/5NOPcSJn0TzXcG9YUrR0gQSWioew3LDg==} + + rehype-expressive-code@0.41.7: + resolution: {integrity: sha512-25f8ZMSF1d9CMscX7Cft0TSQIqdwjce2gDOvQ+d/w0FovsMwrSt3ODP4P3Z7wO1jsIJ4eYyaDRnIR/27bd/EMQ==} + + rehype-format@5.0.1: + resolution: {integrity: sha512-zvmVru9uB0josBVpr946OR8ui7nJEdzZobwLOOqHb/OOD88W0Vk2SqLwoVOj0fM6IPCCO6TaV9CvQvJMWwukFQ==} + + rehype-parse@9.0.1: + resolution: {integrity: sha512-ksCzCD0Fgfh7trPDxr2rSylbwq9iYDkSn8TCDmEJ49ljEUBxDVCzCHv7QNzZOfODanX4+bWQ4WZqLCRWYLfhag==} + + rehype-raw@7.0.0: + resolution: {integrity: sha512-/aE8hCfKlQeA8LmyeyQvQF3eBiLRGNlfBJEvWH7ivp9sBqs7TNqBL5X3v157rM4IFETqDnIOO+z5M/biZbo9Ww==} + + rehype-recma@1.0.0: + resolution: {integrity: sha512-lqA4rGUf1JmacCNWWZx0Wv1dHqMwxzsDWYMTowuplHF3xH0N/MmrZ/G3BDZnzAkRmxDadujCjaKM2hqYdCBOGw==} + + rehype-stringify@10.0.1: + resolution: {integrity: sha512-k9ecfXHmIPuFVI61B9DeLPN0qFHfawM6RsuX48hoqlaKSF61RskNjSm1lI8PhBEM0MRdLxVVm4WmTqJQccH9mA==} + + rehype@13.0.2: + resolution: {integrity: sha512-j31mdaRFrwFRUIlxGeuPXXKWQxet52RBQRvCmzl5eCefn/KGbomK5GMHNMsOJf55fgo3qw5tST5neDuarDYR2A==} + + remark-directive@3.0.1: + resolution: {integrity: sha512-gwglrEQEZcZYgVyG1tQuA+h58EZfq5CSULw7J90AFuCTyib1thgHPoqQ+h9iFvU6R+vnZ5oNFQR5QKgGpk741A==} + + remark-gfm@4.0.1: + resolution: {integrity: sha512-1quofZ2RQ9EWdeN34S79+KExV1764+wCUGop5CPL1WGdD0ocPpu91lzPGbwWMECpEpd42kJGQwzRfyov9j4yNg==} + + remark-github-alerts@0.1.1: + resolution: {integrity: sha512-A0NLfeAuu76ymiGIoEoBcHmqlPcdLFq+FoCGiWlzu8vkyhscyDv+pAkMA9paGr+OHpzpFflZKnsqOCvMESG/Uw==} + peerDependencies: + '@types/mdast': ^4.0.0 + unified: ^11.0.0 + + remark-mdx@3.1.1: + resolution: {integrity: sha512-Pjj2IYlUY3+D8x00UJsIOg5BEvfMyeI+2uLPn9VO9Wg4MEtN/VTIq2NEJQfde9PnX15KgtHyl9S0BcTnWrIuWg==} + + remark-parse@11.0.0: + resolution: {integrity: sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA==} + + remark-rehype@11.1.2: + resolution: {integrity: sha512-Dh7l57ianaEoIpzbp0PC9UKAdCSVklD8E5Rpw7ETfbTl3FqcOOgq5q2LVDhgGCkaBv7p24JXikPdvhhmHvKMsw==} + + remark-smartypants@3.0.2: + resolution: {integrity: sha512-ILTWeOriIluwEvPjv67v7Blgrcx+LZOkAUVtKI3putuhlZm84FnqDORNXPPm+HY3NdZOMhyDwZ1E+eZB/Df5dA==} + engines: {node: '>=16.0.0'} + + remark-stringify@11.0.0: + resolution: {integrity: sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw==} + + resolve-pkg-maps@1.0.0: + resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==} + + retext-latin@4.0.0: + resolution: {integrity: sha512-hv9woG7Fy0M9IlRQloq/N6atV82NxLGveq+3H2WOi79dtIYWN8OaxogDm77f8YnVXJL2VD3bbqowu5E3EMhBYA==} + + retext-smartypants@6.2.0: + resolution: {integrity: sha512-kk0jOU7+zGv//kfjXEBjdIryL1Acl4i9XNkHxtM7Tm5lFiCog576fjNC9hjoR7LTKQ0DsPWy09JummSsH1uqfQ==} + + retext-stringify@4.0.0: + resolution: {integrity: sha512-rtfN/0o8kL1e+78+uxPTqu1Klt0yPzKuQ2BfWwwfgIUSayyzxpM1PJzkKt4V8803uB9qSy32MvI7Xep9khTpiA==} + + retext@9.0.0: + resolution: {integrity: sha512-sbMDcpHCNjvlheSgMfEcVrZko3cDzdbe1x/e7G66dFp0Ff7Mldvi2uv6JkJQzdRcvLYE8CA8Oe8siQx8ZOgTcA==} + + rollup@4.59.0: + resolution: {integrity: sha512-2oMpl67a3zCH9H79LeMcbDhXW/UmWG/y2zuqnF2jQq5uq9TbM9TVyXvA4+t+ne2IIkBdrLpAaRQAvo7YI/Yyeg==} + engines: {node: '>=18.0.0', npm: '>=8.0.0'} + hasBin: true + + sax@1.5.0: + resolution: {integrity: sha512-21IYA3Q5cQf089Z6tgaUTr7lDAyzoTPx5HRtbhsME8Udispad8dC/+sziTNugOEx54ilvatQ9YCzl4KQLPcRHA==} + engines: {node: '>=11.0.0'} + + semver@7.7.4: + resolution: {integrity: sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==} + engines: {node: '>=10'} + hasBin: true + + sharp@0.34.5: + resolution: {integrity: sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + + shiki@3.23.0: + resolution: {integrity: sha512-55Dj73uq9ZXL5zyeRPzHQsK7Nbyt6Y10k5s7OjuFZGMhpp4r/rsLBH0o/0fstIzX1Lep9VxefWljK/SKCzygIA==} + + sisteransi@1.0.5: + resolution: {integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==} + + sitemap@8.0.3: + resolution: {integrity: sha512-9Ew1tR2WYw8RGE2XLy7GjkusvYXy8Rg6y8TYuBuQMfIEdGcWoJpY2Wr5DzsEiL/TKCw56+YKTCCUHglorEYK+A==} + engines: {node: '>=14.0.0', npm: '>=6.0.0'} + hasBin: true + + smol-toml@1.6.0: + resolution: {integrity: sha512-4zemZi0HvTnYwLfrpk/CF9LOd9Lt87kAt50GnqhMpyF9U3poDAP2+iukq2bZsO/ufegbYehBkqINbsWxj4l4cw==} + engines: {node: '>= 18'} + + source-map-js@1.2.1: + resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==} + engines: {node: '>=0.10.0'} + + source-map@0.7.6: + resolution: {integrity: sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==} + engines: {node: '>= 12'} + + space-separated-tokens@2.0.2: + resolution: {integrity: sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==} + + stream-replace-string@2.0.0: + resolution: {integrity: sha512-TlnjJ1C0QrmxRNrON00JvaFFlNh5TTG00APw23j74ET7gkQpTASi6/L2fuiav8pzK715HXtUeClpBTw2NPSn6w==} + + string-width@4.2.3: + resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==} + engines: {node: '>=8'} + + string-width@7.2.0: + resolution: {integrity: sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==} + engines: {node: '>=18'} + + stringify-entities@4.0.4: + resolution: {integrity: sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==} + + strip-ansi@6.0.1: + resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==} + engines: {node: '>=8'} + + strip-ansi@7.2.0: + resolution: {integrity: sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==} + engines: {node: '>=12'} + + style-to-js@1.1.21: + resolution: {integrity: sha512-RjQetxJrrUJLQPHbLku6U/ocGtzyjbJMP9lCNK7Ag0CNh690nSH8woqWH9u16nMjYBAok+i7JO1NP2pOy8IsPQ==} + + style-to-object@1.0.14: + resolution: {integrity: sha512-LIN7rULI0jBscWQYaSswptyderlarFkjQ+t79nzty8tcIAceVomEVlLzH5VP4Cmsv6MtKhs7qaAiwlcp+Mgaxw==} + + svgo@4.0.1: + resolution: {integrity: sha512-XDpWUOPC6FEibaLzjfe0ucaV0YrOjYotGJO1WpF0Zd+n6ZGEQUsSugaoLq9QkEZtAfQIxT42UChcssDVPP3+/w==} + engines: {node: '>=16'} + hasBin: true + + tiny-inflate@1.0.3: + resolution: {integrity: sha512-pkY1fj1cKHb2seWDy0B16HeWyczlJA9/WW3u3c4z/NiWDsO3DOU5D7nhTLE9CF0yXv/QZFY7sEJmj24dK+Rrqw==} + + tinyexec@1.0.2: + resolution: {integrity: sha512-W/KYk+NFhkmsYpuHq5JykngiOCnxeVL8v8dFnqxSD8qEEdRfXk1SDM6JzNqcERbcGYj9tMrDQBYV9cjgnunFIg==} + engines: {node: '>=18'} + + tinyglobby@0.2.15: + resolution: {integrity: sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==} + engines: {node: '>=12.0.0'} + + trim-lines@3.0.1: + resolution: {integrity: sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==} + + trough@2.2.0: + resolution: {integrity: sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==} + + tsconfck@3.1.6: + resolution: {integrity: sha512-ks6Vjr/jEw0P1gmOVwutM3B7fWxoWBL2KRDb1JfqGVawBmO5UsvmWOQFGHBPl5yxYz4eERr19E6L7NMv+Fej4w==} + engines: {node: ^18 || >=20} + hasBin: true + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + tslib@2.8.1: + resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==} + + tsx@4.21.0: + resolution: {integrity: sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==} + engines: {node: '>=18.0.0'} + hasBin: true + + type-fest@4.41.0: + resolution: {integrity: sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==} + engines: {node: '>=16'} + + typescript@5.9.3: + resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==} + engines: {node: '>=14.17'} + hasBin: true + + ufo@1.6.3: + resolution: {integrity: sha512-yDJTmhydvl5lJzBmy/hyOAA0d+aqCBuwl818haVdYCRrWV84o7YyeVm4QlVHStqNrrJSTb6jKuFAVqAFsr+K3Q==} + + ultrahtml@1.6.0: + resolution: {integrity: sha512-R9fBn90VTJrqqLDwyMph+HGne8eqY1iPfYhPzZrvKpIfwkWZbcYlfpsb8B9dTvBfpy1/hqAD7Wi8EKfP9e8zdw==} + + uncrypto@0.1.3: + resolution: {integrity: sha512-Ql87qFHB3s/De2ClA9e0gsnS6zXG27SkTiSJwjCc9MebbfapQfuPzumMIUMi38ezPZVNFcHI9sUIepeQfw8J8Q==} + + undici-types@6.21.0: + resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==} + + unified@11.0.5: + resolution: {integrity: sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==} + + unifont@0.7.4: + resolution: {integrity: sha512-oHeis4/xl42HUIeHuNZRGEvxj5AaIKR+bHPNegRq5LV1gdc3jundpONbjglKpihmJf+dswygdMJn3eftGIMemg==} + + unist-util-find-after@5.0.0: + resolution: {integrity: sha512-amQa0Ep2m6hE2g72AugUItjbuM8X8cGQnFoHk0pGfrFeT9GZhzN5SW8nRsiGKK7Aif4CrACPENkA6P/Lw6fHGQ==} + + unist-util-is@6.0.1: + resolution: {integrity: sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==} + + unist-util-modify-children@4.0.0: + resolution: {integrity: sha512-+tdN5fGNddvsQdIzUF3Xx82CU9sMM+fA0dLgR9vOmT0oPT2jH+P1nd5lSqfCfXAw+93NhcXNY2qqvTUtE4cQkw==} + + unist-util-position-from-estree@2.0.0: + resolution: {integrity: sha512-KaFVRjoqLyF6YXCbVLNad/eS4+OfPQQn2yOd7zF/h5T/CSL2v8NpN6a5TPvtbXthAGw5nG+PuTtq+DdIZr+cRQ==} + + unist-util-position@5.0.0: + resolution: {integrity: sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==} + + unist-util-remove-position@5.0.0: + resolution: {integrity: sha512-Hp5Kh3wLxv0PHj9m2yZhhLt58KzPtEYKQQ4yxfYFEO7EvHwzyDYnduhHnY1mDxoqr7VUwVuHXk9RXKIiYS1N8Q==} + + unist-util-stringify-position@4.0.0: + resolution: {integrity: sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==} + + unist-util-visit-children@3.0.0: + resolution: {integrity: sha512-RgmdTfSBOg04sdPcpTSD1jzoNBjt9a80/ZCzp5cI9n1qPzLZWF9YdvWGN2zmTumP1HWhXKdUWexjy/Wy/lJ7tA==} + + unist-util-visit-parents@6.0.2: + resolution: {integrity: sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ==} + + unist-util-visit@5.1.0: + resolution: {integrity: sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg==} + + unstorage@1.17.4: + resolution: {integrity: sha512-fHK0yNg38tBiJKp/Vgsq4j0JEsCmgqH58HAn707S7zGkArbZsVr/CwINoi+nh3h98BRCwKvx1K3Xg9u3VV83sw==} + peerDependencies: + '@azure/app-configuration': ^1.8.0 + '@azure/cosmos': ^4.2.0 + '@azure/data-tables': ^13.3.0 + '@azure/identity': ^4.6.0 + '@azure/keyvault-secrets': ^4.9.0 + '@azure/storage-blob': ^12.26.0 + '@capacitor/preferences': ^6 || ^7 || ^8 + '@deno/kv': '>=0.9.0' + '@netlify/blobs': ^6.5.0 || ^7.0.0 || ^8.1.0 || ^9.0.0 || ^10.0.0 + '@planetscale/database': ^1.19.0 + '@upstash/redis': ^1.34.3 + '@vercel/blob': '>=0.27.1' + '@vercel/functions': ^2.2.12 || ^3.0.0 + '@vercel/kv': ^1 || ^2 || ^3 + aws4fetch: ^1.0.20 + db0: '>=0.2.1' + idb-keyval: ^6.2.1 + ioredis: ^5.4.2 + uploadthing: ^7.4.4 + peerDependenciesMeta: + '@azure/app-configuration': + optional: true + '@azure/cosmos': + optional: true + '@azure/data-tables': + optional: true + '@azure/identity': + optional: true + '@azure/keyvault-secrets': + optional: true + '@azure/storage-blob': + optional: true + '@capacitor/preferences': + optional: true + '@deno/kv': + optional: true + '@netlify/blobs': + optional: true + '@planetscale/database': + optional: true + '@upstash/redis': + optional: true + '@vercel/blob': + optional: true + '@vercel/functions': + optional: true + '@vercel/kv': + optional: true + aws4fetch: + optional: true + db0: + optional: true + idb-keyval: + optional: true + ioredis: + optional: true + uploadthing: + optional: true + + util-deprecate@1.0.2: + resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==} + + vfile-location@5.0.3: + resolution: {integrity: sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg==} + + vfile-message@4.0.3: + resolution: {integrity: sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==} + + vfile@6.0.3: + resolution: {integrity: sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==} + + vite@6.4.1: + resolution: {integrity: sha512-+Oxm7q9hDoLMyJOYfUYBuHQo+dkAloi33apOPP56pzj+vsdJDzr+j1NISE5pyaAuKL4A3UD34qd0lx5+kfKp2g==} + engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0} + hasBin: true + peerDependencies: + '@types/node': ^18.0.0 || ^20.0.0 || >=22.0.0 + jiti: '>=1.21.0' + less: '*' + lightningcss: ^1.21.0 + sass: '*' + sass-embedded: '*' + stylus: '*' + sugarss: '*' + terser: ^5.16.0 + tsx: ^4.8.1 + yaml: ^2.4.2 + peerDependenciesMeta: + '@types/node': + optional: true + jiti: + optional: true + less: + optional: true + lightningcss: + optional: true + sass: + optional: true + sass-embedded: + optional: true + stylus: + optional: true + sugarss: + optional: true + terser: + optional: true + tsx: + optional: true + yaml: + optional: true + + vitefu@1.1.2: + resolution: {integrity: sha512-zpKATdUbzbsycPFBN71nS2uzBUQiVnFoOrr2rvqv34S1lcAgMKKkjWleLGeiJlZ8lwCXvtWaRn7R3ZC16SYRuw==} + peerDependencies: + vite: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-beta.0 + peerDependenciesMeta: + vite: + optional: true + + web-namespaces@2.0.1: + resolution: {integrity: sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==} + + which-pm-runs@1.1.0: + resolution: {integrity: sha512-n1brCuqClxfFfq/Rb0ICg9giSZqCS+pLtccdag6C2HyufBrh3fBOiy9nb6ggRMvWOVH5GrdJskj5iGTZNxd7SA==} + engines: {node: '>=4'} + + widest-line@5.0.0: + resolution: {integrity: sha512-c9bZp7b5YtRj2wOe6dlj32MK+Bx/M/d+9VB2SHM1OtsUHR0aV0tdP6DWh/iMt0kWi1t5g1Iudu6hQRNd1A4PVA==} + engines: {node: '>=18'} + + wrap-ansi@9.0.2: + resolution: {integrity: sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww==} + engines: {node: '>=18'} + + xxhash-wasm@1.1.0: + resolution: {integrity: sha512-147y/6YNh+tlp6nd/2pWq38i9h6mz/EuQ6njIrmW8D1BS5nCqs0P6DG+m6zTGnNz5I+uhZ0SHxBs9BsPrwcKDA==} + + yargs-parser@21.1.1: + resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==} + engines: {node: '>=12'} + + yocto-queue@1.2.2: + resolution: {integrity: sha512-4LCcse/U2MHZ63HAJVE+v71o7yOdIe4cZ70Wpf8D/IyjDKYQLV5GD46B+hSTjJsvV5PztjvHoU580EftxjDZFQ==} + engines: {node: '>=12.20'} + + yocto-spinner@0.2.3: + resolution: {integrity: sha512-sqBChb33loEnkoXte1bLg45bEBsOP9N1kzQh5JZNKj/0rik4zAPTNSAVPj3uQAdc6slYJ0Ksc403G2XgxsJQFQ==} + engines: {node: '>=18.19'} + + yoctocolors@2.1.2: + resolution: {integrity: sha512-CzhO+pFNo8ajLM2d2IW/R93ipy99LWjtwblvC1RsoSUMZgyLbYFr221TnSNT7GjGdYui6P459mw9JH/g/zW2ug==} + engines: {node: '>=18'} + + zod-to-json-schema@3.25.1: + resolution: {integrity: sha512-pM/SU9d3YAggzi6MtR4h7ruuQlqKtad8e9S0fmxcMi+ueAK5Korys/aWcV9LIIHTVbj01NdzxcnXSN+O74ZIVA==} + peerDependencies: + zod: ^3.25 || ^4 + + zod-to-ts@1.2.0: + resolution: {integrity: sha512-x30XE43V+InwGpvTySRNz9kB7qFU8DlyEy7BsSTCHPH1R0QasMmHWZDCzYm6bVXtj/9NNJAZF3jW8rzFvH5OFA==} + peerDependencies: + typescript: ^4.9.4 || ^5.0.2 + zod: ^3 + + zod@3.25.76: + resolution: {integrity: sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==} + + zwitch@2.0.4: + resolution: {integrity: sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==} + +snapshots: + + '@astrojs/compiler@2.13.1': {} + + '@astrojs/internal-helpers@0.7.5': {} + + '@astrojs/markdown-remark@6.3.10': + dependencies: + '@astrojs/internal-helpers': 0.7.5 + '@astrojs/prism': 3.3.0 + github-slugger: 2.0.0 + hast-util-from-html: 2.0.3 + hast-util-to-text: 4.0.2 + import-meta-resolve: 4.2.0 + js-yaml: 4.1.1 + mdast-util-definitions: 6.0.0 + rehype-raw: 7.0.0 + rehype-stringify: 10.0.1 + remark-gfm: 4.0.1 + remark-parse: 11.0.0 + remark-rehype: 11.1.2 + remark-smartypants: 3.0.2 + shiki: 3.23.0 + smol-toml: 1.6.0 + unified: 11.0.5 + unist-util-remove-position: 5.0.0 + unist-util-visit: 5.1.0 + unist-util-visit-parents: 6.0.2 + vfile: 6.0.3 + transitivePeerDependencies: + - supports-color + + '@astrojs/mdx@4.3.13(astro@5.18.0(@types/node@22.19.15)(rollup@4.59.0)(tsx@4.21.0)(typescript@5.9.3))': + dependencies: + '@astrojs/markdown-remark': 6.3.10 + '@mdx-js/mdx': 3.1.1 + acorn: 8.16.0 + astro: 5.18.0(@types/node@22.19.15)(rollup@4.59.0)(tsx@4.21.0)(typescript@5.9.3) + es-module-lexer: 1.7.0 + estree-util-visit: 2.0.0 + hast-util-to-html: 9.0.5 + piccolore: 0.1.3 + rehype-raw: 7.0.0 + remark-gfm: 4.0.1 + remark-smartypants: 3.0.2 + source-map: 0.7.6 + unist-util-visit: 5.1.0 + vfile: 6.0.3 + transitivePeerDependencies: + - supports-color + + '@astrojs/prism@3.3.0': + dependencies: + prismjs: 1.30.0 + + '@astrojs/sitemap@3.7.0': + dependencies: + sitemap: 8.0.3 + stream-replace-string: 2.0.0 + zod: 3.25.76 + + '@astrojs/starlight@0.37.7(astro@5.18.0(@types/node@22.19.15)(rollup@4.59.0)(tsx@4.21.0)(typescript@5.9.3))': + dependencies: + '@astrojs/markdown-remark': 6.3.10 + '@astrojs/mdx': 4.3.13(astro@5.18.0(@types/node@22.19.15)(rollup@4.59.0)(tsx@4.21.0)(typescript@5.9.3)) + '@astrojs/sitemap': 3.7.0 + '@pagefind/default-ui': 1.4.0 + '@types/hast': 3.0.4 + '@types/js-yaml': 4.0.9 + '@types/mdast': 4.0.4 + astro: 5.18.0(@types/node@22.19.15)(rollup@4.59.0)(tsx@4.21.0)(typescript@5.9.3) + astro-expressive-code: 0.41.7(astro@5.18.0(@types/node@22.19.15)(rollup@4.59.0)(tsx@4.21.0)(typescript@5.9.3)) + bcp-47: 2.1.0 + hast-util-from-html: 2.0.3 + hast-util-select: 6.0.4 + hast-util-to-string: 3.0.1 + hastscript: 9.0.1 + i18next: 23.16.8 + js-yaml: 4.1.1 + klona: 2.0.6 + magic-string: 0.30.21 + mdast-util-directive: 3.1.0 + mdast-util-to-markdown: 2.1.2 + mdast-util-to-string: 4.0.0 + pagefind: 1.4.0 + rehype: 13.0.2 + rehype-format: 5.0.1 + remark-directive: 3.0.1 + ultrahtml: 1.6.0 + unified: 11.0.5 + unist-util-visit: 5.1.0 + vfile: 6.0.3 + transitivePeerDependencies: + - supports-color + + '@astrojs/telemetry@3.3.0': + dependencies: + ci-info: 4.4.0 + debug: 4.4.3 + dlv: 1.1.3 + dset: 3.1.4 + is-docker: 3.0.0 + is-wsl: 3.1.1 + which-pm-runs: 1.1.0 + transitivePeerDependencies: + - supports-color + + '@babel/helper-string-parser@7.27.1': {} + + '@babel/helper-validator-identifier@7.28.5': {} + + '@babel/parser@7.29.0': + dependencies: + '@babel/types': 7.29.0 + + '@babel/runtime@7.28.6': {} + + '@babel/types@7.29.0': + dependencies: + '@babel/helper-string-parser': 7.27.1 + '@babel/helper-validator-identifier': 7.28.5 + + '@capsizecss/unpack@4.0.0': + dependencies: + fontkitten: 1.0.3 + + '@ctrl/tinycolor@4.2.0': {} + + '@emnapi/runtime@1.8.1': + dependencies: + tslib: 2.8.1 + optional: true + + '@esbuild/aix-ppc64@0.25.12': + optional: true + + '@esbuild/aix-ppc64@0.27.3': + optional: true + + '@esbuild/android-arm64@0.25.12': + optional: true + + '@esbuild/android-arm64@0.27.3': + optional: true + + '@esbuild/android-arm@0.25.12': + optional: true + + '@esbuild/android-arm@0.27.3': + optional: true + + '@esbuild/android-x64@0.25.12': + optional: true + + '@esbuild/android-x64@0.27.3': + optional: true + + '@esbuild/darwin-arm64@0.25.12': + optional: true + + '@esbuild/darwin-arm64@0.27.3': + optional: true + + '@esbuild/darwin-x64@0.25.12': + optional: true + + '@esbuild/darwin-x64@0.27.3': + optional: true + + '@esbuild/freebsd-arm64@0.25.12': + optional: true + + '@esbuild/freebsd-arm64@0.27.3': + optional: true + + '@esbuild/freebsd-x64@0.25.12': + optional: true + + '@esbuild/freebsd-x64@0.27.3': + optional: true + + '@esbuild/linux-arm64@0.25.12': + optional: true + + '@esbuild/linux-arm64@0.27.3': + optional: true + + '@esbuild/linux-arm@0.25.12': + optional: true + + '@esbuild/linux-arm@0.27.3': + optional: true + + '@esbuild/linux-ia32@0.25.12': + optional: true + + '@esbuild/linux-ia32@0.27.3': + optional: true + + '@esbuild/linux-loong64@0.25.12': + optional: true + + '@esbuild/linux-loong64@0.27.3': + optional: true + + '@esbuild/linux-mips64el@0.25.12': + optional: true + + '@esbuild/linux-mips64el@0.27.3': + optional: true + + '@esbuild/linux-ppc64@0.25.12': + optional: true + + '@esbuild/linux-ppc64@0.27.3': + optional: true + + '@esbuild/linux-riscv64@0.25.12': + optional: true + + '@esbuild/linux-riscv64@0.27.3': + optional: true + + '@esbuild/linux-s390x@0.25.12': + optional: true + + '@esbuild/linux-s390x@0.27.3': + optional: true + + '@esbuild/linux-x64@0.25.12': + optional: true + + '@esbuild/linux-x64@0.27.3': + optional: true + + '@esbuild/netbsd-arm64@0.25.12': + optional: true + + '@esbuild/netbsd-arm64@0.27.3': + optional: true + + '@esbuild/netbsd-x64@0.25.12': + optional: true + + '@esbuild/netbsd-x64@0.27.3': + optional: true + + '@esbuild/openbsd-arm64@0.25.12': + optional: true + + '@esbuild/openbsd-arm64@0.27.3': + optional: true + + '@esbuild/openbsd-x64@0.25.12': + optional: true + + '@esbuild/openbsd-x64@0.27.3': + optional: true + + '@esbuild/openharmony-arm64@0.25.12': + optional: true + + '@esbuild/openharmony-arm64@0.27.3': + optional: true + + '@esbuild/sunos-x64@0.25.12': + optional: true + + '@esbuild/sunos-x64@0.27.3': + optional: true + + '@esbuild/win32-arm64@0.25.12': + optional: true + + '@esbuild/win32-arm64@0.27.3': + optional: true + + '@esbuild/win32-ia32@0.25.12': + optional: true + + '@esbuild/win32-ia32@0.27.3': + optional: true + + '@esbuild/win32-x64@0.25.12': + optional: true + + '@esbuild/win32-x64@0.27.3': + optional: true + + '@expressive-code/core@0.41.7': + dependencies: + '@ctrl/tinycolor': 4.2.0 + hast-util-select: 6.0.4 + hast-util-to-html: 9.0.5 + hast-util-to-text: 4.0.2 + hastscript: 9.0.1 + postcss: 8.5.8 + postcss-nested: 6.2.0(postcss@8.5.8) + unist-util-visit: 5.1.0 + unist-util-visit-parents: 6.0.2 + + '@expressive-code/plugin-frames@0.41.7': + dependencies: + '@expressive-code/core': 0.41.7 + + '@expressive-code/plugin-shiki@0.41.7': + dependencies: + '@expressive-code/core': 0.41.7 + shiki: 3.23.0 + + '@expressive-code/plugin-text-markers@0.41.7': + dependencies: + '@expressive-code/core': 0.41.7 + + '@img/colour@1.1.0': {} + + '@img/sharp-darwin-arm64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-darwin-arm64': 1.2.4 + optional: true + + '@img/sharp-darwin-x64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-darwin-x64': 1.2.4 + optional: true + + '@img/sharp-libvips-darwin-arm64@1.2.4': + optional: true + + '@img/sharp-libvips-darwin-x64@1.2.4': + optional: true + + '@img/sharp-libvips-linux-arm64@1.2.4': + optional: true + + '@img/sharp-libvips-linux-arm@1.2.4': + optional: true + + '@img/sharp-libvips-linux-ppc64@1.2.4': + optional: true + + '@img/sharp-libvips-linux-riscv64@1.2.4': + optional: true + + '@img/sharp-libvips-linux-s390x@1.2.4': + optional: true + + '@img/sharp-libvips-linux-x64@1.2.4': + optional: true + + '@img/sharp-libvips-linuxmusl-arm64@1.2.4': + optional: true + + '@img/sharp-libvips-linuxmusl-x64@1.2.4': + optional: true + + '@img/sharp-linux-arm64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linux-arm64': 1.2.4 + optional: true + + '@img/sharp-linux-arm@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linux-arm': 1.2.4 + optional: true + + '@img/sharp-linux-ppc64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linux-ppc64': 1.2.4 + optional: true + + '@img/sharp-linux-riscv64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linux-riscv64': 1.2.4 + optional: true + + '@img/sharp-linux-s390x@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linux-s390x': 1.2.4 + optional: true + + '@img/sharp-linux-x64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linux-x64': 1.2.4 + optional: true + + '@img/sharp-linuxmusl-arm64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linuxmusl-arm64': 1.2.4 + optional: true + + '@img/sharp-linuxmusl-x64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linuxmusl-x64': 1.2.4 + optional: true + + '@img/sharp-wasm32@0.34.5': + dependencies: + '@emnapi/runtime': 1.8.1 + optional: true + + '@img/sharp-win32-arm64@0.34.5': + optional: true + + '@img/sharp-win32-ia32@0.34.5': + optional: true + + '@img/sharp-win32-x64@0.34.5': + optional: true + + '@jridgewell/sourcemap-codec@1.5.5': {} + + '@mdx-js/mdx@3.1.1': + dependencies: + '@types/estree': 1.0.8 + '@types/estree-jsx': 1.0.5 + '@types/hast': 3.0.4 + '@types/mdx': 2.0.13 + acorn: 8.16.0 + collapse-white-space: 2.1.0 + devlop: 1.1.0 + estree-util-is-identifier-name: 3.0.0 + estree-util-scope: 1.0.0 + estree-walker: 3.0.3 + hast-util-to-jsx-runtime: 2.3.6 + markdown-extensions: 2.0.0 + recma-build-jsx: 1.0.0 + recma-jsx: 1.0.1(acorn@8.16.0) + recma-stringify: 1.0.0 + rehype-recma: 1.0.0 + remark-mdx: 3.1.1 + remark-parse: 11.0.0 + remark-rehype: 11.1.2 + source-map: 0.7.6 + unified: 11.0.5 + unist-util-position-from-estree: 2.0.0 + unist-util-stringify-position: 4.0.0 + unist-util-visit: 5.1.0 + vfile: 6.0.3 + transitivePeerDependencies: + - supports-color + + '@oslojs/encoding@1.1.0': {} + + '@pagefind/darwin-arm64@1.4.0': + optional: true + + '@pagefind/darwin-x64@1.4.0': + optional: true + + '@pagefind/default-ui@1.4.0': {} + + '@pagefind/freebsd-x64@1.4.0': + optional: true + + '@pagefind/linux-arm64@1.4.0': + optional: true + + '@pagefind/linux-x64@1.4.0': + optional: true + + '@pagefind/windows-x64@1.4.0': + optional: true + + '@rollup/pluginutils@5.3.0(rollup@4.59.0)': + dependencies: + '@types/estree': 1.0.8 + estree-walker: 2.0.2 + picomatch: 4.0.3 + optionalDependencies: + rollup: 4.59.0 + + '@rollup/rollup-android-arm-eabi@4.59.0': + optional: true + + '@rollup/rollup-android-arm64@4.59.0': + optional: true + + '@rollup/rollup-darwin-arm64@4.59.0': + optional: true + + '@rollup/rollup-darwin-x64@4.59.0': + optional: true + + '@rollup/rollup-freebsd-arm64@4.59.0': + optional: true + + '@rollup/rollup-freebsd-x64@4.59.0': + optional: true + + '@rollup/rollup-linux-arm-gnueabihf@4.59.0': + optional: true + + '@rollup/rollup-linux-arm-musleabihf@4.59.0': + optional: true + + '@rollup/rollup-linux-arm64-gnu@4.59.0': + optional: true + + '@rollup/rollup-linux-arm64-musl@4.59.0': + optional: true + + '@rollup/rollup-linux-loong64-gnu@4.59.0': + optional: true + + '@rollup/rollup-linux-loong64-musl@4.59.0': + optional: true + + '@rollup/rollup-linux-ppc64-gnu@4.59.0': + optional: true + + '@rollup/rollup-linux-ppc64-musl@4.59.0': + optional: true + + '@rollup/rollup-linux-riscv64-gnu@4.59.0': + optional: true + + '@rollup/rollup-linux-riscv64-musl@4.59.0': + optional: true + + '@rollup/rollup-linux-s390x-gnu@4.59.0': + optional: true + + '@rollup/rollup-linux-x64-gnu@4.59.0': + optional: true + + '@rollup/rollup-linux-x64-musl@4.59.0': + optional: true + + '@rollup/rollup-openbsd-x64@4.59.0': + optional: true + + '@rollup/rollup-openharmony-arm64@4.59.0': + optional: true + + '@rollup/rollup-win32-arm64-msvc@4.59.0': + optional: true + + '@rollup/rollup-win32-ia32-msvc@4.59.0': + optional: true + + '@rollup/rollup-win32-x64-gnu@4.59.0': + optional: true + + '@rollup/rollup-win32-x64-msvc@4.59.0': + optional: true + + '@shikijs/core@3.23.0': + dependencies: + '@shikijs/types': 3.23.0 + '@shikijs/vscode-textmate': 10.0.2 + '@types/hast': 3.0.4 + hast-util-to-html: 9.0.5 + + '@shikijs/engine-javascript@3.23.0': + dependencies: + '@shikijs/types': 3.23.0 + '@shikijs/vscode-textmate': 10.0.2 + oniguruma-to-es: 4.3.4 + + '@shikijs/engine-oniguruma@3.23.0': + dependencies: + '@shikijs/types': 3.23.0 + '@shikijs/vscode-textmate': 10.0.2 + + '@shikijs/langs@3.23.0': + dependencies: + '@shikijs/types': 3.23.0 + + '@shikijs/themes@3.23.0': + dependencies: + '@shikijs/types': 3.23.0 + + '@shikijs/types@3.23.0': + dependencies: + '@shikijs/vscode-textmate': 10.0.2 + '@types/hast': 3.0.4 + + '@shikijs/vscode-textmate@10.0.2': {} + + '@types/debug@4.1.12': + dependencies: + '@types/ms': 2.1.0 + + '@types/estree-jsx@1.0.5': + dependencies: + '@types/estree': 1.0.8 + + '@types/estree@1.0.8': {} + + '@types/hast@3.0.4': + dependencies: + '@types/unist': 3.0.3 + + '@types/js-yaml@4.0.9': {} + + '@types/mdast@4.0.4': + dependencies: + '@types/unist': 3.0.3 + + '@types/mdx@2.0.13': {} + + '@types/ms@2.1.0': {} + + '@types/nlcst@2.0.3': + dependencies: + '@types/unist': 3.0.3 + + '@types/node@17.0.45': {} + + '@types/node@22.19.15': + dependencies: + undici-types: 6.21.0 + + '@types/sax@1.2.7': + dependencies: + '@types/node': 22.19.15 + + '@types/unist@2.0.11': {} + + '@types/unist@3.0.3': {} + + '@ungap/structured-clone@1.3.0': {} + + acorn-jsx@5.3.2(acorn@8.16.0): + dependencies: + acorn: 8.16.0 + + acorn@8.16.0: {} + + ansi-align@3.0.1: + dependencies: + string-width: 4.2.3 + + ansi-regex@5.0.1: {} + + ansi-regex@6.2.2: {} + + ansi-styles@6.2.3: {} + + anymatch@3.1.3: + dependencies: + normalize-path: 3.0.0 + picomatch: 2.3.1 + + arg@5.0.2: {} + + argparse@2.0.1: {} + + aria-query@5.3.2: {} + + array-iterate@2.0.1: {} + + astring@1.9.0: {} + + astro-expressive-code@0.41.7(astro@5.18.0(@types/node@22.19.15)(rollup@4.59.0)(tsx@4.21.0)(typescript@5.9.3)): + dependencies: + astro: 5.18.0(@types/node@22.19.15)(rollup@4.59.0)(tsx@4.21.0)(typescript@5.9.3) + rehype-expressive-code: 0.41.7 + + astro@5.18.0(@types/node@22.19.15)(rollup@4.59.0)(tsx@4.21.0)(typescript@5.9.3): + dependencies: + '@astrojs/compiler': 2.13.1 + '@astrojs/internal-helpers': 0.7.5 + '@astrojs/markdown-remark': 6.3.10 + '@astrojs/telemetry': 3.3.0 + '@capsizecss/unpack': 4.0.0 + '@oslojs/encoding': 1.1.0 + '@rollup/pluginutils': 5.3.0(rollup@4.59.0) + acorn: 8.16.0 + aria-query: 5.3.2 + axobject-query: 4.1.0 + boxen: 8.0.1 + ci-info: 4.4.0 + clsx: 2.1.1 + common-ancestor-path: 1.0.1 + cookie: 1.1.1 + cssesc: 3.0.0 + debug: 4.4.3 + deterministic-object-hash: 2.0.2 + devalue: 5.6.3 + diff: 8.0.3 + dlv: 1.1.3 + dset: 3.1.4 + es-module-lexer: 1.7.0 + esbuild: 0.27.3 + estree-walker: 3.0.3 + flattie: 1.1.1 + fontace: 0.4.1 + github-slugger: 2.0.0 + html-escaper: 3.0.3 + http-cache-semantics: 4.2.0 + import-meta-resolve: 4.2.0 + js-yaml: 4.1.1 + magic-string: 0.30.21 + magicast: 0.5.2 + mrmime: 2.0.1 + neotraverse: 0.6.18 + p-limit: 6.2.0 + p-queue: 8.1.1 + package-manager-detector: 1.6.0 + piccolore: 0.1.3 + picomatch: 4.0.3 + prompts: 2.4.2 + rehype: 13.0.2 + semver: 7.7.4 + shiki: 3.23.0 + smol-toml: 1.6.0 + svgo: 4.0.1 + tinyexec: 1.0.2 + tinyglobby: 0.2.15 + tsconfck: 3.1.6(typescript@5.9.3) + ultrahtml: 1.6.0 + unifont: 0.7.4 + unist-util-visit: 5.1.0 + unstorage: 1.17.4 + vfile: 6.0.3 + vite: 6.4.1(@types/node@22.19.15)(tsx@4.21.0) + vitefu: 1.1.2(vite@6.4.1(@types/node@22.19.15)(tsx@4.21.0)) + xxhash-wasm: 1.1.0 + yargs-parser: 21.1.1 + yocto-spinner: 0.2.3 + zod: 3.25.76 + zod-to-json-schema: 3.25.1(zod@3.25.76) + zod-to-ts: 1.2.0(typescript@5.9.3)(zod@3.25.76) + optionalDependencies: + sharp: 0.34.5 + transitivePeerDependencies: + - '@azure/app-configuration' + - '@azure/cosmos' + - '@azure/data-tables' + - '@azure/identity' + - '@azure/keyvault-secrets' + - '@azure/storage-blob' + - '@capacitor/preferences' + - '@deno/kv' + - '@netlify/blobs' + - '@planetscale/database' + - '@types/node' + - '@upstash/redis' + - '@vercel/blob' + - '@vercel/functions' + - '@vercel/kv' + - aws4fetch + - db0 + - idb-keyval + - ioredis + - jiti + - less + - lightningcss + - rollup + - sass + - sass-embedded + - stylus + - sugarss + - supports-color + - terser + - tsx + - typescript + - uploadthing + - yaml + + axobject-query@4.1.0: {} + + bail@2.0.2: {} + + base-64@1.0.0: {} + + bcp-47-match@2.0.3: {} + + bcp-47@2.1.0: + dependencies: + is-alphabetical: 2.0.1 + is-alphanumerical: 2.0.1 + is-decimal: 2.0.1 + + boolbase@1.0.0: {} + + boxen@8.0.1: + dependencies: + ansi-align: 3.0.1 + camelcase: 8.0.0 + chalk: 5.6.2 + cli-boxes: 3.0.0 + string-width: 7.2.0 + type-fest: 4.41.0 + widest-line: 5.0.0 + wrap-ansi: 9.0.2 + + camelcase@8.0.0: {} + + ccount@2.0.1: {} + + chalk@5.6.2: {} + + character-entities-html4@2.1.0: {} + + character-entities-legacy@3.0.0: {} + + character-entities@2.0.2: {} + + character-reference-invalid@2.0.1: {} + + chokidar@5.0.0: + dependencies: + readdirp: 5.0.0 + + ci-info@4.4.0: {} + + cli-boxes@3.0.0: {} + + clsx@2.1.1: {} + + collapse-white-space@2.1.0: {} + + comma-separated-tokens@2.0.3: {} + + commander@11.1.0: {} + + common-ancestor-path@1.0.1: {} + + cookie-es@1.2.2: {} + + cookie@1.1.1: {} + + crossws@0.3.5: + dependencies: + uncrypto: 0.1.3 + + css-select@5.2.2: + dependencies: + boolbase: 1.0.0 + css-what: 6.2.2 + domhandler: 5.0.3 + domutils: 3.2.2 + nth-check: 2.1.1 + + css-selector-parser@3.3.0: {} + + css-tree@2.2.1: + dependencies: + mdn-data: 2.0.28 + source-map-js: 1.2.1 + + css-tree@3.2.1: + dependencies: + mdn-data: 2.27.1 + source-map-js: 1.2.1 + + css-what@6.2.2: {} + + cssesc@3.0.0: {} + + csso@5.0.5: + dependencies: + css-tree: 2.2.1 + + debug@4.4.3: + dependencies: + ms: 2.1.3 + + decode-named-character-reference@1.3.0: + dependencies: + character-entities: 2.0.2 + + defu@6.1.4: {} + + dequal@2.0.3: {} + + destr@2.0.5: {} + + detect-libc@2.1.2: {} + + deterministic-object-hash@2.0.2: + dependencies: + base-64: 1.0.0 + + devalue@5.6.3: {} + + devlop@1.1.0: + dependencies: + dequal: 2.0.3 + + diff@8.0.3: {} + + direction@2.0.1: {} + + dlv@1.1.3: {} + + dom-serializer@2.0.0: + dependencies: + domelementtype: 2.3.0 + domhandler: 5.0.3 + entities: 4.5.0 + + domelementtype@2.3.0: {} + + domhandler@5.0.3: + dependencies: + domelementtype: 2.3.0 + + domutils@3.2.2: + dependencies: + dom-serializer: 2.0.0 + domelementtype: 2.3.0 + domhandler: 5.0.3 + + dset@3.1.4: {} + + emoji-regex@10.6.0: {} + + emoji-regex@8.0.0: {} + + entities@4.5.0: {} + + entities@6.0.1: {} + + es-module-lexer@1.7.0: {} + + esast-util-from-estree@2.0.0: + dependencies: + '@types/estree-jsx': 1.0.5 + devlop: 1.1.0 + estree-util-visit: 2.0.0 + unist-util-position-from-estree: 2.0.0 + + esast-util-from-js@2.0.1: + dependencies: + '@types/estree-jsx': 1.0.5 + acorn: 8.16.0 + esast-util-from-estree: 2.0.0 + vfile-message: 4.0.3 + + esbuild@0.25.12: + optionalDependencies: + '@esbuild/aix-ppc64': 0.25.12 + '@esbuild/android-arm': 0.25.12 + '@esbuild/android-arm64': 0.25.12 + '@esbuild/android-x64': 0.25.12 + '@esbuild/darwin-arm64': 0.25.12 + '@esbuild/darwin-x64': 0.25.12 + '@esbuild/freebsd-arm64': 0.25.12 + '@esbuild/freebsd-x64': 0.25.12 + '@esbuild/linux-arm': 0.25.12 + '@esbuild/linux-arm64': 0.25.12 + '@esbuild/linux-ia32': 0.25.12 + '@esbuild/linux-loong64': 0.25.12 + '@esbuild/linux-mips64el': 0.25.12 + '@esbuild/linux-ppc64': 0.25.12 + '@esbuild/linux-riscv64': 0.25.12 + '@esbuild/linux-s390x': 0.25.12 + '@esbuild/linux-x64': 0.25.12 + '@esbuild/netbsd-arm64': 0.25.12 + '@esbuild/netbsd-x64': 0.25.12 + '@esbuild/openbsd-arm64': 0.25.12 + '@esbuild/openbsd-x64': 0.25.12 + '@esbuild/openharmony-arm64': 0.25.12 + '@esbuild/sunos-x64': 0.25.12 + '@esbuild/win32-arm64': 0.25.12 + '@esbuild/win32-ia32': 0.25.12 + '@esbuild/win32-x64': 0.25.12 + + esbuild@0.27.3: + optionalDependencies: + '@esbuild/aix-ppc64': 0.27.3 + '@esbuild/android-arm': 0.27.3 + '@esbuild/android-arm64': 0.27.3 + '@esbuild/android-x64': 0.27.3 + '@esbuild/darwin-arm64': 0.27.3 + '@esbuild/darwin-x64': 0.27.3 + '@esbuild/freebsd-arm64': 0.27.3 + '@esbuild/freebsd-x64': 0.27.3 + '@esbuild/linux-arm': 0.27.3 + '@esbuild/linux-arm64': 0.27.3 + '@esbuild/linux-ia32': 0.27.3 + '@esbuild/linux-loong64': 0.27.3 + '@esbuild/linux-mips64el': 0.27.3 + '@esbuild/linux-ppc64': 0.27.3 + '@esbuild/linux-riscv64': 0.27.3 + '@esbuild/linux-s390x': 0.27.3 + '@esbuild/linux-x64': 0.27.3 + '@esbuild/netbsd-arm64': 0.27.3 + '@esbuild/netbsd-x64': 0.27.3 + '@esbuild/openbsd-arm64': 0.27.3 + '@esbuild/openbsd-x64': 0.27.3 + '@esbuild/openharmony-arm64': 0.27.3 + '@esbuild/sunos-x64': 0.27.3 + '@esbuild/win32-arm64': 0.27.3 + '@esbuild/win32-ia32': 0.27.3 + '@esbuild/win32-x64': 0.27.3 + + escape-string-regexp@5.0.0: {} + + estree-util-attach-comments@3.0.0: + dependencies: + '@types/estree': 1.0.8 + + estree-util-build-jsx@3.0.1: + dependencies: + '@types/estree-jsx': 1.0.5 + devlop: 1.1.0 + estree-util-is-identifier-name: 3.0.0 + estree-walker: 3.0.3 + + estree-util-is-identifier-name@3.0.0: {} + + estree-util-scope@1.0.0: + dependencies: + '@types/estree': 1.0.8 + devlop: 1.1.0 + + estree-util-to-js@2.0.0: + dependencies: + '@types/estree-jsx': 1.0.5 + astring: 1.9.0 + source-map: 0.7.6 + + estree-util-visit@2.0.0: + dependencies: + '@types/estree-jsx': 1.0.5 + '@types/unist': 3.0.3 + + estree-walker@2.0.2: {} + + estree-walker@3.0.3: + dependencies: + '@types/estree': 1.0.8 + + eventemitter3@5.0.4: {} + + expressive-code@0.41.7: + dependencies: + '@expressive-code/core': 0.41.7 + '@expressive-code/plugin-frames': 0.41.7 + '@expressive-code/plugin-shiki': 0.41.7 + '@expressive-code/plugin-text-markers': 0.41.7 + + extend@3.0.2: {} + + fdir@6.5.0(picomatch@4.0.3): + optionalDependencies: + picomatch: 4.0.3 + + flattie@1.1.1: {} + + fontace@0.4.1: + dependencies: + fontkitten: 1.0.3 + + fontkitten@1.0.3: + dependencies: + tiny-inflate: 1.0.3 + + fsevents@2.3.3: + optional: true + + get-east-asian-width@1.5.0: {} + + get-tsconfig@4.13.6: + dependencies: + resolve-pkg-maps: 1.0.0 + + github-slugger@2.0.0: {} + + h3@1.15.5: + dependencies: + cookie-es: 1.2.2 + crossws: 0.3.5 + defu: 6.1.4 + destr: 2.0.5 + iron-webcrypto: 1.2.1 + node-mock-http: 1.0.4 + radix3: 1.1.2 + ufo: 1.6.3 + uncrypto: 0.1.3 + + hast-util-embedded@3.0.0: + dependencies: + '@types/hast': 3.0.4 + hast-util-is-element: 3.0.0 + + hast-util-format@1.1.0: + dependencies: + '@types/hast': 3.0.4 + hast-util-embedded: 3.0.0 + hast-util-minify-whitespace: 1.0.1 + hast-util-phrasing: 3.0.1 + hast-util-whitespace: 3.0.0 + html-whitespace-sensitive-tag-names: 3.0.1 + unist-util-visit-parents: 6.0.2 + + hast-util-from-html@2.0.3: + dependencies: + '@types/hast': 3.0.4 + devlop: 1.1.0 + hast-util-from-parse5: 8.0.3 + parse5: 7.3.0 + vfile: 6.0.3 + vfile-message: 4.0.3 + + hast-util-from-parse5@8.0.3: + dependencies: + '@types/hast': 3.0.4 + '@types/unist': 3.0.3 + devlop: 1.1.0 + hastscript: 9.0.1 + property-information: 7.1.0 + vfile: 6.0.3 + vfile-location: 5.0.3 + web-namespaces: 2.0.1 + + hast-util-has-property@3.0.0: + dependencies: + '@types/hast': 3.0.4 + + hast-util-is-body-ok-link@3.0.1: + dependencies: + '@types/hast': 3.0.4 + + hast-util-is-element@3.0.0: + dependencies: + '@types/hast': 3.0.4 + + hast-util-minify-whitespace@1.0.1: + dependencies: + '@types/hast': 3.0.4 + hast-util-embedded: 3.0.0 + hast-util-is-element: 3.0.0 + hast-util-whitespace: 3.0.0 + unist-util-is: 6.0.1 + + hast-util-parse-selector@4.0.0: + dependencies: + '@types/hast': 3.0.4 + + hast-util-phrasing@3.0.1: + dependencies: + '@types/hast': 3.0.4 + hast-util-embedded: 3.0.0 + hast-util-has-property: 3.0.0 + hast-util-is-body-ok-link: 3.0.1 + hast-util-is-element: 3.0.0 + + hast-util-raw@9.1.0: + dependencies: + '@types/hast': 3.0.4 + '@types/unist': 3.0.3 + '@ungap/structured-clone': 1.3.0 + hast-util-from-parse5: 8.0.3 + hast-util-to-parse5: 8.0.1 + html-void-elements: 3.0.0 + mdast-util-to-hast: 13.2.1 + parse5: 7.3.0 + unist-util-position: 5.0.0 + unist-util-visit: 5.1.0 + vfile: 6.0.3 + web-namespaces: 2.0.1 + zwitch: 2.0.4 + + hast-util-select@6.0.4: + dependencies: + '@types/hast': 3.0.4 + '@types/unist': 3.0.3 + bcp-47-match: 2.0.3 + comma-separated-tokens: 2.0.3 + css-selector-parser: 3.3.0 + devlop: 1.1.0 + direction: 2.0.1 + hast-util-has-property: 3.0.0 + hast-util-to-string: 3.0.1 + hast-util-whitespace: 3.0.0 + nth-check: 2.1.1 + property-information: 7.1.0 + space-separated-tokens: 2.0.2 + unist-util-visit: 5.1.0 + zwitch: 2.0.4 + + hast-util-to-estree@3.1.3: + dependencies: + '@types/estree': 1.0.8 + '@types/estree-jsx': 1.0.5 + '@types/hast': 3.0.4 + comma-separated-tokens: 2.0.3 + devlop: 1.1.0 + estree-util-attach-comments: 3.0.0 + estree-util-is-identifier-name: 3.0.0 + hast-util-whitespace: 3.0.0 + mdast-util-mdx-expression: 2.0.1 + mdast-util-mdx-jsx: 3.2.0 + mdast-util-mdxjs-esm: 2.0.1 + property-information: 7.1.0 + space-separated-tokens: 2.0.2 + style-to-js: 1.1.21 + unist-util-position: 5.0.0 + zwitch: 2.0.4 + transitivePeerDependencies: + - supports-color + + hast-util-to-html@9.0.5: + dependencies: + '@types/hast': 3.0.4 + '@types/unist': 3.0.3 + ccount: 2.0.1 + comma-separated-tokens: 2.0.3 + hast-util-whitespace: 3.0.0 + html-void-elements: 3.0.0 + mdast-util-to-hast: 13.2.1 + property-information: 7.1.0 + space-separated-tokens: 2.0.2 + stringify-entities: 4.0.4 + zwitch: 2.0.4 + + hast-util-to-jsx-runtime@2.3.6: + dependencies: + '@types/estree': 1.0.8 + '@types/hast': 3.0.4 + '@types/unist': 3.0.3 + comma-separated-tokens: 2.0.3 + devlop: 1.1.0 + estree-util-is-identifier-name: 3.0.0 + hast-util-whitespace: 3.0.0 + mdast-util-mdx-expression: 2.0.1 + mdast-util-mdx-jsx: 3.2.0 + mdast-util-mdxjs-esm: 2.0.1 + property-information: 7.1.0 + space-separated-tokens: 2.0.2 + style-to-js: 1.1.21 + unist-util-position: 5.0.0 + vfile-message: 4.0.3 + transitivePeerDependencies: + - supports-color + + hast-util-to-parse5@8.0.1: + dependencies: + '@types/hast': 3.0.4 + comma-separated-tokens: 2.0.3 + devlop: 1.1.0 + property-information: 7.1.0 + space-separated-tokens: 2.0.2 + web-namespaces: 2.0.1 + zwitch: 2.0.4 + + hast-util-to-string@3.0.1: + dependencies: + '@types/hast': 3.0.4 + + hast-util-to-text@4.0.2: + dependencies: + '@types/hast': 3.0.4 + '@types/unist': 3.0.3 + hast-util-is-element: 3.0.0 + unist-util-find-after: 5.0.0 + + hast-util-whitespace@3.0.0: + dependencies: + '@types/hast': 3.0.4 + + hastscript@9.0.1: + dependencies: + '@types/hast': 3.0.4 + comma-separated-tokens: 2.0.3 + hast-util-parse-selector: 4.0.0 + property-information: 7.1.0 + space-separated-tokens: 2.0.2 + + html-escaper@3.0.3: {} + + html-void-elements@3.0.0: {} + + html-whitespace-sensitive-tag-names@3.0.1: {} + + http-cache-semantics@4.2.0: {} + + i18next@23.16.8: + dependencies: + '@babel/runtime': 7.28.6 + + import-meta-resolve@4.2.0: {} + + inline-style-parser@0.2.7: {} + + iron-webcrypto@1.2.1: {} + + is-alphabetical@2.0.1: {} + + is-alphanumerical@2.0.1: + dependencies: + is-alphabetical: 2.0.1 + is-decimal: 2.0.1 + + is-decimal@2.0.1: {} + + is-docker@3.0.0: {} + + is-fullwidth-code-point@3.0.0: {} + + is-hexadecimal@2.0.1: {} + + is-inside-container@1.0.0: + dependencies: + is-docker: 3.0.0 + + is-plain-obj@4.1.0: {} + + is-wsl@3.1.1: + dependencies: + is-inside-container: 1.0.0 + + js-yaml@4.1.1: + dependencies: + argparse: 2.0.1 + + kleur@3.0.3: {} + + klona@2.0.6: {} + + longest-streak@3.1.0: {} + + lru-cache@11.2.6: {} + + magic-string@0.30.21: + dependencies: + '@jridgewell/sourcemap-codec': 1.5.5 + + magicast@0.5.2: + dependencies: + '@babel/parser': 7.29.0 + '@babel/types': 7.29.0 + source-map-js: 1.2.1 + + markdown-extensions@2.0.0: {} + + markdown-table@3.0.4: {} + + mdast-util-definitions@6.0.0: + dependencies: + '@types/mdast': 4.0.4 + '@types/unist': 3.0.3 + unist-util-visit: 5.1.0 + + mdast-util-directive@3.1.0: + dependencies: + '@types/mdast': 4.0.4 + '@types/unist': 3.0.3 + ccount: 2.0.1 + devlop: 1.1.0 + mdast-util-from-markdown: 2.0.3 + mdast-util-to-markdown: 2.1.2 + parse-entities: 4.0.2 + stringify-entities: 4.0.4 + unist-util-visit-parents: 6.0.2 + transitivePeerDependencies: + - supports-color + + mdast-util-find-and-replace@3.0.2: + dependencies: + '@types/mdast': 4.0.4 + escape-string-regexp: 5.0.0 + unist-util-is: 6.0.1 + unist-util-visit-parents: 6.0.2 + + mdast-util-from-markdown@2.0.3: + dependencies: + '@types/mdast': 4.0.4 + '@types/unist': 3.0.3 + decode-named-character-reference: 1.3.0 + devlop: 1.1.0 + mdast-util-to-string: 4.0.0 + micromark: 4.0.2 + micromark-util-decode-numeric-character-reference: 2.0.2 + micromark-util-decode-string: 2.0.1 + micromark-util-normalize-identifier: 2.0.1 + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + unist-util-stringify-position: 4.0.0 + transitivePeerDependencies: + - supports-color + + mdast-util-gfm-autolink-literal@2.0.1: + dependencies: + '@types/mdast': 4.0.4 + ccount: 2.0.1 + devlop: 1.1.0 + mdast-util-find-and-replace: 3.0.2 + micromark-util-character: 2.1.1 + + mdast-util-gfm-footnote@2.1.0: + dependencies: + '@types/mdast': 4.0.4 + devlop: 1.1.0 + mdast-util-from-markdown: 2.0.3 + mdast-util-to-markdown: 2.1.2 + micromark-util-normalize-identifier: 2.0.1 + transitivePeerDependencies: + - supports-color + + mdast-util-gfm-strikethrough@2.0.0: + dependencies: + '@types/mdast': 4.0.4 + mdast-util-from-markdown: 2.0.3 + mdast-util-to-markdown: 2.1.2 + transitivePeerDependencies: + - supports-color + + mdast-util-gfm-table@2.0.0: + dependencies: + '@types/mdast': 4.0.4 + devlop: 1.1.0 + markdown-table: 3.0.4 + mdast-util-from-markdown: 2.0.3 + mdast-util-to-markdown: 2.1.2 + transitivePeerDependencies: + - supports-color + + mdast-util-gfm-task-list-item@2.0.0: + dependencies: + '@types/mdast': 4.0.4 + devlop: 1.1.0 + mdast-util-from-markdown: 2.0.3 + mdast-util-to-markdown: 2.1.2 + transitivePeerDependencies: + - supports-color + + mdast-util-gfm@3.1.0: + dependencies: + mdast-util-from-markdown: 2.0.3 + mdast-util-gfm-autolink-literal: 2.0.1 + mdast-util-gfm-footnote: 2.1.0 + mdast-util-gfm-strikethrough: 2.0.0 + mdast-util-gfm-table: 2.0.0 + mdast-util-gfm-task-list-item: 2.0.0 + mdast-util-to-markdown: 2.1.2 + transitivePeerDependencies: + - supports-color + + mdast-util-mdx-expression@2.0.1: + dependencies: + '@types/estree-jsx': 1.0.5 + '@types/hast': 3.0.4 + '@types/mdast': 4.0.4 + devlop: 1.1.0 + mdast-util-from-markdown: 2.0.3 + mdast-util-to-markdown: 2.1.2 + transitivePeerDependencies: + - supports-color + + mdast-util-mdx-jsx@3.2.0: + dependencies: + '@types/estree-jsx': 1.0.5 + '@types/hast': 3.0.4 + '@types/mdast': 4.0.4 + '@types/unist': 3.0.3 + ccount: 2.0.1 + devlop: 1.1.0 + mdast-util-from-markdown: 2.0.3 + mdast-util-to-markdown: 2.1.2 + parse-entities: 4.0.2 + stringify-entities: 4.0.4 + unist-util-stringify-position: 4.0.0 + vfile-message: 4.0.3 + transitivePeerDependencies: + - supports-color + + mdast-util-mdx@3.0.0: + dependencies: + mdast-util-from-markdown: 2.0.3 + mdast-util-mdx-expression: 2.0.1 + mdast-util-mdx-jsx: 3.2.0 + mdast-util-mdxjs-esm: 2.0.1 + mdast-util-to-markdown: 2.1.2 + transitivePeerDependencies: + - supports-color + + mdast-util-mdxjs-esm@2.0.1: + dependencies: + '@types/estree-jsx': 1.0.5 + '@types/hast': 3.0.4 + '@types/mdast': 4.0.4 + devlop: 1.1.0 + mdast-util-from-markdown: 2.0.3 + mdast-util-to-markdown: 2.1.2 + transitivePeerDependencies: + - supports-color + + mdast-util-phrasing@4.1.0: + dependencies: + '@types/mdast': 4.0.4 + unist-util-is: 6.0.1 + + mdast-util-to-hast@13.2.1: + dependencies: + '@types/hast': 3.0.4 + '@types/mdast': 4.0.4 + '@ungap/structured-clone': 1.3.0 + devlop: 1.1.0 + micromark-util-sanitize-uri: 2.0.1 + trim-lines: 3.0.1 + unist-util-position: 5.0.0 + unist-util-visit: 5.1.0 + vfile: 6.0.3 + + mdast-util-to-markdown@2.1.2: + dependencies: + '@types/mdast': 4.0.4 + '@types/unist': 3.0.3 + longest-streak: 3.1.0 + mdast-util-phrasing: 4.1.0 + mdast-util-to-string: 4.0.0 + micromark-util-classify-character: 2.0.1 + micromark-util-decode-string: 2.0.1 + unist-util-visit: 5.1.0 + zwitch: 2.0.4 + + mdast-util-to-string@4.0.0: + dependencies: + '@types/mdast': 4.0.4 + + mdn-data@2.0.28: {} + + mdn-data@2.27.1: {} + + micromark-core-commonmark@2.0.3: + dependencies: + decode-named-character-reference: 1.3.0 + devlop: 1.1.0 + micromark-factory-destination: 2.0.1 + micromark-factory-label: 2.0.1 + micromark-factory-space: 2.0.1 + micromark-factory-title: 2.0.1 + micromark-factory-whitespace: 2.0.1 + micromark-util-character: 2.1.1 + micromark-util-chunked: 2.0.1 + micromark-util-classify-character: 2.0.1 + micromark-util-html-tag-name: 2.0.1 + micromark-util-normalize-identifier: 2.0.1 + micromark-util-resolve-all: 2.0.1 + micromark-util-subtokenize: 2.1.0 + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + + micromark-extension-directive@3.0.2: + dependencies: + devlop: 1.1.0 + micromark-factory-space: 2.0.1 + micromark-factory-whitespace: 2.0.1 + micromark-util-character: 2.1.1 + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + parse-entities: 4.0.2 + + micromark-extension-gfm-autolink-literal@2.1.0: + dependencies: + micromark-util-character: 2.1.1 + micromark-util-sanitize-uri: 2.0.1 + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + + micromark-extension-gfm-footnote@2.1.0: + dependencies: + devlop: 1.1.0 + micromark-core-commonmark: 2.0.3 + micromark-factory-space: 2.0.1 + micromark-util-character: 2.1.1 + micromark-util-normalize-identifier: 2.0.1 + micromark-util-sanitize-uri: 2.0.1 + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + + micromark-extension-gfm-strikethrough@2.1.0: + dependencies: + devlop: 1.1.0 + micromark-util-chunked: 2.0.1 + micromark-util-classify-character: 2.0.1 + micromark-util-resolve-all: 2.0.1 + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + + micromark-extension-gfm-table@2.1.1: + dependencies: + devlop: 1.1.0 + micromark-factory-space: 2.0.1 + micromark-util-character: 2.1.1 + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + + micromark-extension-gfm-tagfilter@2.0.0: + dependencies: + micromark-util-types: 2.0.2 + + micromark-extension-gfm-task-list-item@2.1.0: + dependencies: + devlop: 1.1.0 + micromark-factory-space: 2.0.1 + micromark-util-character: 2.1.1 + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + + micromark-extension-gfm@3.0.0: + dependencies: + micromark-extension-gfm-autolink-literal: 2.1.0 + micromark-extension-gfm-footnote: 2.1.0 + micromark-extension-gfm-strikethrough: 2.1.0 + micromark-extension-gfm-table: 2.1.1 + micromark-extension-gfm-tagfilter: 2.0.0 + micromark-extension-gfm-task-list-item: 2.1.0 + micromark-util-combine-extensions: 2.0.1 + micromark-util-types: 2.0.2 + + micromark-extension-mdx-expression@3.0.1: + dependencies: + '@types/estree': 1.0.8 + devlop: 1.1.0 + micromark-factory-mdx-expression: 2.0.3 + micromark-factory-space: 2.0.1 + micromark-util-character: 2.1.1 + micromark-util-events-to-acorn: 2.0.3 + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + + micromark-extension-mdx-jsx@3.0.2: + dependencies: + '@types/estree': 1.0.8 + devlop: 1.1.0 + estree-util-is-identifier-name: 3.0.0 + micromark-factory-mdx-expression: 2.0.3 + micromark-factory-space: 2.0.1 + micromark-util-character: 2.1.1 + micromark-util-events-to-acorn: 2.0.3 + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + vfile-message: 4.0.3 + + micromark-extension-mdx-md@2.0.0: + dependencies: + micromark-util-types: 2.0.2 + + micromark-extension-mdxjs-esm@3.0.0: + dependencies: + '@types/estree': 1.0.8 + devlop: 1.1.0 + micromark-core-commonmark: 2.0.3 + micromark-util-character: 2.1.1 + micromark-util-events-to-acorn: 2.0.3 + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + unist-util-position-from-estree: 2.0.0 + vfile-message: 4.0.3 + + micromark-extension-mdxjs@3.0.0: + dependencies: + acorn: 8.16.0 + acorn-jsx: 5.3.2(acorn@8.16.0) + micromark-extension-mdx-expression: 3.0.1 + micromark-extension-mdx-jsx: 3.0.2 + micromark-extension-mdx-md: 2.0.0 + micromark-extension-mdxjs-esm: 3.0.0 + micromark-util-combine-extensions: 2.0.1 + micromark-util-types: 2.0.2 + + micromark-factory-destination@2.0.1: + dependencies: + micromark-util-character: 2.1.1 + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + + micromark-factory-label@2.0.1: + dependencies: + devlop: 1.1.0 + micromark-util-character: 2.1.1 + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + + micromark-factory-mdx-expression@2.0.3: + dependencies: + '@types/estree': 1.0.8 + devlop: 1.1.0 + micromark-factory-space: 2.0.1 + micromark-util-character: 2.1.1 + micromark-util-events-to-acorn: 2.0.3 + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + unist-util-position-from-estree: 2.0.0 + vfile-message: 4.0.3 + + micromark-factory-space@2.0.1: + dependencies: + micromark-util-character: 2.1.1 + micromark-util-types: 2.0.2 + + micromark-factory-title@2.0.1: + dependencies: + micromark-factory-space: 2.0.1 + micromark-util-character: 2.1.1 + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + + micromark-factory-whitespace@2.0.1: + dependencies: + micromark-factory-space: 2.0.1 + micromark-util-character: 2.1.1 + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + + micromark-util-character@2.1.1: + dependencies: + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + + micromark-util-chunked@2.0.1: + dependencies: + micromark-util-symbol: 2.0.1 + + micromark-util-classify-character@2.0.1: + dependencies: + micromark-util-character: 2.1.1 + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + + micromark-util-combine-extensions@2.0.1: + dependencies: + micromark-util-chunked: 2.0.1 + micromark-util-types: 2.0.2 + + micromark-util-decode-numeric-character-reference@2.0.2: + dependencies: + micromark-util-symbol: 2.0.1 + + micromark-util-decode-string@2.0.1: + dependencies: + decode-named-character-reference: 1.3.0 + micromark-util-character: 2.1.1 + micromark-util-decode-numeric-character-reference: 2.0.2 + micromark-util-symbol: 2.0.1 + + micromark-util-encode@2.0.1: {} + + micromark-util-events-to-acorn@2.0.3: + dependencies: + '@types/estree': 1.0.8 + '@types/unist': 3.0.3 + devlop: 1.1.0 + estree-util-visit: 2.0.0 + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + vfile-message: 4.0.3 + + micromark-util-html-tag-name@2.0.1: {} + + micromark-util-normalize-identifier@2.0.1: + dependencies: + micromark-util-symbol: 2.0.1 + + micromark-util-resolve-all@2.0.1: + dependencies: + micromark-util-types: 2.0.2 + + micromark-util-sanitize-uri@2.0.1: + dependencies: + micromark-util-character: 2.1.1 + micromark-util-encode: 2.0.1 + micromark-util-symbol: 2.0.1 + + micromark-util-subtokenize@2.1.0: + dependencies: + devlop: 1.1.0 + micromark-util-chunked: 2.0.1 + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + + micromark-util-symbol@2.0.1: {} + + micromark-util-types@2.0.2: {} + + micromark@4.0.2: + dependencies: + '@types/debug': 4.1.12 + debug: 4.4.3 + decode-named-character-reference: 1.3.0 + devlop: 1.1.0 + micromark-core-commonmark: 2.0.3 + micromark-factory-space: 2.0.1 + micromark-util-character: 2.1.1 + micromark-util-chunked: 2.0.1 + micromark-util-combine-extensions: 2.0.1 + micromark-util-decode-numeric-character-reference: 2.0.2 + micromark-util-encode: 2.0.1 + micromark-util-normalize-identifier: 2.0.1 + micromark-util-resolve-all: 2.0.1 + micromark-util-sanitize-uri: 2.0.1 + micromark-util-subtokenize: 2.1.0 + micromark-util-symbol: 2.0.1 + micromark-util-types: 2.0.2 + transitivePeerDependencies: + - supports-color + + mrmime@2.0.1: {} + + ms@2.1.3: {} + + nanoid@3.3.11: {} + + neotraverse@0.6.18: {} + + nlcst-to-string@4.0.0: + dependencies: + '@types/nlcst': 2.0.3 + + node-fetch-native@1.6.7: {} + + node-mock-http@1.0.4: {} + + normalize-path@3.0.0: {} + + nth-check@2.1.1: + dependencies: + boolbase: 1.0.0 + + ofetch@1.5.1: + dependencies: + destr: 2.0.5 + node-fetch-native: 1.6.7 + ufo: 1.6.3 + + ohash@2.0.11: {} + + oniguruma-parser@0.12.1: {} + + oniguruma-to-es@4.3.4: + dependencies: + oniguruma-parser: 0.12.1 + regex: 6.1.0 + regex-recursion: 6.0.2 + + p-limit@6.2.0: + dependencies: + yocto-queue: 1.2.2 + + p-queue@8.1.1: + dependencies: + eventemitter3: 5.0.4 + p-timeout: 6.1.4 + + p-timeout@6.1.4: {} + + package-manager-detector@1.6.0: {} + + pagefind@1.4.0: + optionalDependencies: + '@pagefind/darwin-arm64': 1.4.0 + '@pagefind/darwin-x64': 1.4.0 + '@pagefind/freebsd-x64': 1.4.0 + '@pagefind/linux-arm64': 1.4.0 + '@pagefind/linux-x64': 1.4.0 + '@pagefind/windows-x64': 1.4.0 + + parse-entities@4.0.2: + dependencies: + '@types/unist': 2.0.11 + character-entities-legacy: 3.0.0 + character-reference-invalid: 2.0.1 + decode-named-character-reference: 1.3.0 + is-alphanumerical: 2.0.1 + is-decimal: 2.0.1 + is-hexadecimal: 2.0.1 + + parse-latin@7.0.0: + dependencies: + '@types/nlcst': 2.0.3 + '@types/unist': 3.0.3 + nlcst-to-string: 4.0.0 + unist-util-modify-children: 4.0.0 + unist-util-visit-children: 3.0.0 + vfile: 6.0.3 + + parse5@7.3.0: + dependencies: + entities: 6.0.1 + + piccolore@0.1.3: {} + + picocolors@1.1.1: {} + + picomatch@2.3.1: {} + + picomatch@4.0.3: {} + + postcss-nested@6.2.0(postcss@8.5.8): + dependencies: + postcss: 8.5.8 + postcss-selector-parser: 6.1.2 + + postcss-selector-parser@6.1.2: + dependencies: + cssesc: 3.0.0 + util-deprecate: 1.0.2 + + postcss@8.5.8: + dependencies: + nanoid: 3.3.11 + picocolors: 1.1.1 + source-map-js: 1.2.1 + + prismjs@1.30.0: {} + + prompts@2.4.2: + dependencies: + kleur: 3.0.3 + sisteransi: 1.0.5 + + property-information@7.1.0: {} + + radix3@1.1.2: {} + + readdirp@5.0.0: {} + + recma-build-jsx@1.0.0: + dependencies: + '@types/estree': 1.0.8 + estree-util-build-jsx: 3.0.1 + vfile: 6.0.3 + + recma-jsx@1.0.1(acorn@8.16.0): + dependencies: + acorn: 8.16.0 + acorn-jsx: 5.3.2(acorn@8.16.0) + estree-util-to-js: 2.0.0 + recma-parse: 1.0.0 + recma-stringify: 1.0.0 + unified: 11.0.5 + + recma-parse@1.0.0: + dependencies: + '@types/estree': 1.0.8 + esast-util-from-js: 2.0.1 + unified: 11.0.5 + vfile: 6.0.3 + + recma-stringify@1.0.0: + dependencies: + '@types/estree': 1.0.8 + estree-util-to-js: 2.0.0 + unified: 11.0.5 + vfile: 6.0.3 + + regex-recursion@6.0.2: + dependencies: + regex-utilities: 2.3.0 + + regex-utilities@2.3.0: {} + + regex@6.1.0: + dependencies: + regex-utilities: 2.3.0 + + rehype-expressive-code@0.41.7: + dependencies: + expressive-code: 0.41.7 + + rehype-format@5.0.1: + dependencies: + '@types/hast': 3.0.4 + hast-util-format: 1.1.0 + + rehype-parse@9.0.1: + dependencies: + '@types/hast': 3.0.4 + hast-util-from-html: 2.0.3 + unified: 11.0.5 + + rehype-raw@7.0.0: + dependencies: + '@types/hast': 3.0.4 + hast-util-raw: 9.1.0 + vfile: 6.0.3 + + rehype-recma@1.0.0: + dependencies: + '@types/estree': 1.0.8 + '@types/hast': 3.0.4 + hast-util-to-estree: 3.1.3 + transitivePeerDependencies: + - supports-color + + rehype-stringify@10.0.1: + dependencies: + '@types/hast': 3.0.4 + hast-util-to-html: 9.0.5 + unified: 11.0.5 + + rehype@13.0.2: + dependencies: + '@types/hast': 3.0.4 + rehype-parse: 9.0.1 + rehype-stringify: 10.0.1 + unified: 11.0.5 + + remark-directive@3.0.1: + dependencies: + '@types/mdast': 4.0.4 + mdast-util-directive: 3.1.0 + micromark-extension-directive: 3.0.2 + unified: 11.0.5 + transitivePeerDependencies: + - supports-color + + remark-gfm@4.0.1: + dependencies: + '@types/mdast': 4.0.4 + mdast-util-gfm: 3.1.0 + micromark-extension-gfm: 3.0.0 + remark-parse: 11.0.0 + remark-stringify: 11.0.0 + unified: 11.0.5 + transitivePeerDependencies: + - supports-color + + remark-github-alerts@0.1.1(@types/mdast@4.0.4)(unified@11.0.5): + dependencies: + '@types/mdast': 4.0.4 + unified: 11.0.5 + unist-util-visit: 5.1.0 + + remark-mdx@3.1.1: + dependencies: + mdast-util-mdx: 3.0.0 + micromark-extension-mdxjs: 3.0.0 + transitivePeerDependencies: + - supports-color + + remark-parse@11.0.0: + dependencies: + '@types/mdast': 4.0.4 + mdast-util-from-markdown: 2.0.3 + micromark-util-types: 2.0.2 + unified: 11.0.5 + transitivePeerDependencies: + - supports-color + + remark-rehype@11.1.2: + dependencies: + '@types/hast': 3.0.4 + '@types/mdast': 4.0.4 + mdast-util-to-hast: 13.2.1 + unified: 11.0.5 + vfile: 6.0.3 + + remark-smartypants@3.0.2: + dependencies: + retext: 9.0.0 + retext-smartypants: 6.2.0 + unified: 11.0.5 + unist-util-visit: 5.1.0 + + remark-stringify@11.0.0: + dependencies: + '@types/mdast': 4.0.4 + mdast-util-to-markdown: 2.1.2 + unified: 11.0.5 + + resolve-pkg-maps@1.0.0: {} + + retext-latin@4.0.0: + dependencies: + '@types/nlcst': 2.0.3 + parse-latin: 7.0.0 + unified: 11.0.5 + + retext-smartypants@6.2.0: + dependencies: + '@types/nlcst': 2.0.3 + nlcst-to-string: 4.0.0 + unist-util-visit: 5.1.0 + + retext-stringify@4.0.0: + dependencies: + '@types/nlcst': 2.0.3 + nlcst-to-string: 4.0.0 + unified: 11.0.5 + + retext@9.0.0: + dependencies: + '@types/nlcst': 2.0.3 + retext-latin: 4.0.0 + retext-stringify: 4.0.0 + unified: 11.0.5 + + rollup@4.59.0: + dependencies: + '@types/estree': 1.0.8 + optionalDependencies: + '@rollup/rollup-android-arm-eabi': 4.59.0 + '@rollup/rollup-android-arm64': 4.59.0 + '@rollup/rollup-darwin-arm64': 4.59.0 + '@rollup/rollup-darwin-x64': 4.59.0 + '@rollup/rollup-freebsd-arm64': 4.59.0 + '@rollup/rollup-freebsd-x64': 4.59.0 + '@rollup/rollup-linux-arm-gnueabihf': 4.59.0 + '@rollup/rollup-linux-arm-musleabihf': 4.59.0 + '@rollup/rollup-linux-arm64-gnu': 4.59.0 + '@rollup/rollup-linux-arm64-musl': 4.59.0 + '@rollup/rollup-linux-loong64-gnu': 4.59.0 + '@rollup/rollup-linux-loong64-musl': 4.59.0 + '@rollup/rollup-linux-ppc64-gnu': 4.59.0 + '@rollup/rollup-linux-ppc64-musl': 4.59.0 + '@rollup/rollup-linux-riscv64-gnu': 4.59.0 + '@rollup/rollup-linux-riscv64-musl': 4.59.0 + '@rollup/rollup-linux-s390x-gnu': 4.59.0 + '@rollup/rollup-linux-x64-gnu': 4.59.0 + '@rollup/rollup-linux-x64-musl': 4.59.0 + '@rollup/rollup-openbsd-x64': 4.59.0 + '@rollup/rollup-openharmony-arm64': 4.59.0 + '@rollup/rollup-win32-arm64-msvc': 4.59.0 + '@rollup/rollup-win32-ia32-msvc': 4.59.0 + '@rollup/rollup-win32-x64-gnu': 4.59.0 + '@rollup/rollup-win32-x64-msvc': 4.59.0 + fsevents: 2.3.3 + + sax@1.5.0: {} + + semver@7.7.4: {} + + sharp@0.34.5: + dependencies: + '@img/colour': 1.1.0 + detect-libc: 2.1.2 + semver: 7.7.4 + optionalDependencies: + '@img/sharp-darwin-arm64': 0.34.5 + '@img/sharp-darwin-x64': 0.34.5 + '@img/sharp-libvips-darwin-arm64': 1.2.4 + '@img/sharp-libvips-darwin-x64': 1.2.4 + '@img/sharp-libvips-linux-arm': 1.2.4 + '@img/sharp-libvips-linux-arm64': 1.2.4 + '@img/sharp-libvips-linux-ppc64': 1.2.4 + '@img/sharp-libvips-linux-riscv64': 1.2.4 + '@img/sharp-libvips-linux-s390x': 1.2.4 + '@img/sharp-libvips-linux-x64': 1.2.4 + '@img/sharp-libvips-linuxmusl-arm64': 1.2.4 + '@img/sharp-libvips-linuxmusl-x64': 1.2.4 + '@img/sharp-linux-arm': 0.34.5 + '@img/sharp-linux-arm64': 0.34.5 + '@img/sharp-linux-ppc64': 0.34.5 + '@img/sharp-linux-riscv64': 0.34.5 + '@img/sharp-linux-s390x': 0.34.5 + '@img/sharp-linux-x64': 0.34.5 + '@img/sharp-linuxmusl-arm64': 0.34.5 + '@img/sharp-linuxmusl-x64': 0.34.5 + '@img/sharp-wasm32': 0.34.5 + '@img/sharp-win32-arm64': 0.34.5 + '@img/sharp-win32-ia32': 0.34.5 + '@img/sharp-win32-x64': 0.34.5 + + shiki@3.23.0: + dependencies: + '@shikijs/core': 3.23.0 + '@shikijs/engine-javascript': 3.23.0 + '@shikijs/engine-oniguruma': 3.23.0 + '@shikijs/langs': 3.23.0 + '@shikijs/themes': 3.23.0 + '@shikijs/types': 3.23.0 + '@shikijs/vscode-textmate': 10.0.2 + '@types/hast': 3.0.4 + + sisteransi@1.0.5: {} + + sitemap@8.0.3: + dependencies: + '@types/node': 17.0.45 + '@types/sax': 1.2.7 + arg: 5.0.2 + sax: 1.5.0 + + smol-toml@1.6.0: {} + + source-map-js@1.2.1: {} + + source-map@0.7.6: {} + + space-separated-tokens@2.0.2: {} + + stream-replace-string@2.0.0: {} + + string-width@4.2.3: + dependencies: + emoji-regex: 8.0.0 + is-fullwidth-code-point: 3.0.0 + strip-ansi: 6.0.1 + + string-width@7.2.0: + dependencies: + emoji-regex: 10.6.0 + get-east-asian-width: 1.5.0 + strip-ansi: 7.2.0 + + stringify-entities@4.0.4: + dependencies: + character-entities-html4: 2.1.0 + character-entities-legacy: 3.0.0 + + strip-ansi@6.0.1: + dependencies: + ansi-regex: 5.0.1 + + strip-ansi@7.2.0: + dependencies: + ansi-regex: 6.2.2 + + style-to-js@1.1.21: + dependencies: + style-to-object: 1.0.14 + + style-to-object@1.0.14: + dependencies: + inline-style-parser: 0.2.7 + + svgo@4.0.1: + dependencies: + commander: 11.1.0 + css-select: 5.2.2 + css-tree: 3.2.1 + css-what: 6.2.2 + csso: 5.0.5 + picocolors: 1.1.1 + sax: 1.5.0 + + tiny-inflate@1.0.3: {} + + tinyexec@1.0.2: {} + + tinyglobby@0.2.15: + dependencies: + fdir: 6.5.0(picomatch@4.0.3) + picomatch: 4.0.3 + + trim-lines@3.0.1: {} + + trough@2.2.0: {} + + tsconfck@3.1.6(typescript@5.9.3): + optionalDependencies: + typescript: 5.9.3 + + tslib@2.8.1: + optional: true + + tsx@4.21.0: + dependencies: + esbuild: 0.27.3 + get-tsconfig: 4.13.6 + optionalDependencies: + fsevents: 2.3.3 + + type-fest@4.41.0: {} + + typescript@5.9.3: {} + + ufo@1.6.3: {} + + ultrahtml@1.6.0: {} + + uncrypto@0.1.3: {} + + undici-types@6.21.0: {} + + unified@11.0.5: + dependencies: + '@types/unist': 3.0.3 + bail: 2.0.2 + devlop: 1.1.0 + extend: 3.0.2 + is-plain-obj: 4.1.0 + trough: 2.2.0 + vfile: 6.0.3 + + unifont@0.7.4: + dependencies: + css-tree: 3.2.1 + ofetch: 1.5.1 + ohash: 2.0.11 + + unist-util-find-after@5.0.0: + dependencies: + '@types/unist': 3.0.3 + unist-util-is: 6.0.1 + + unist-util-is@6.0.1: + dependencies: + '@types/unist': 3.0.3 + + unist-util-modify-children@4.0.0: + dependencies: + '@types/unist': 3.0.3 + array-iterate: 2.0.1 + + unist-util-position-from-estree@2.0.0: + dependencies: + '@types/unist': 3.0.3 + + unist-util-position@5.0.0: + dependencies: + '@types/unist': 3.0.3 + + unist-util-remove-position@5.0.0: + dependencies: + '@types/unist': 3.0.3 + unist-util-visit: 5.1.0 + + unist-util-stringify-position@4.0.0: + dependencies: + '@types/unist': 3.0.3 + + unist-util-visit-children@3.0.0: + dependencies: + '@types/unist': 3.0.3 + + unist-util-visit-parents@6.0.2: + dependencies: + '@types/unist': 3.0.3 + unist-util-is: 6.0.1 + + unist-util-visit@5.1.0: + dependencies: + '@types/unist': 3.0.3 + unist-util-is: 6.0.1 + unist-util-visit-parents: 6.0.2 + + unstorage@1.17.4: + dependencies: + anymatch: 3.1.3 + chokidar: 5.0.0 + destr: 2.0.5 + h3: 1.15.5 + lru-cache: 11.2.6 + node-fetch-native: 1.6.7 + ofetch: 1.5.1 + ufo: 1.6.3 + + util-deprecate@1.0.2: {} + + vfile-location@5.0.3: + dependencies: + '@types/unist': 3.0.3 + vfile: 6.0.3 + + vfile-message@4.0.3: + dependencies: + '@types/unist': 3.0.3 + unist-util-stringify-position: 4.0.0 + + vfile@6.0.3: + dependencies: + '@types/unist': 3.0.3 + vfile-message: 4.0.3 + + vite@6.4.1(@types/node@22.19.15)(tsx@4.21.0): + dependencies: + esbuild: 0.25.12 + fdir: 6.5.0(picomatch@4.0.3) + picomatch: 4.0.3 + postcss: 8.5.8 + rollup: 4.59.0 + tinyglobby: 0.2.15 + optionalDependencies: + '@types/node': 22.19.15 + fsevents: 2.3.3 + tsx: 4.21.0 + + vitefu@1.1.2(vite@6.4.1(@types/node@22.19.15)(tsx@4.21.0)): + optionalDependencies: + vite: 6.4.1(@types/node@22.19.15)(tsx@4.21.0) + + web-namespaces@2.0.1: {} + + which-pm-runs@1.1.0: {} + + widest-line@5.0.0: + dependencies: + string-width: 7.2.0 + + wrap-ansi@9.0.2: + dependencies: + ansi-styles: 6.2.3 + string-width: 7.2.0 + strip-ansi: 7.2.0 + + xxhash-wasm@1.1.0: {} + + yargs-parser@21.1.1: {} + + yocto-queue@1.2.2: {} + + yocto-spinner@0.2.3: + dependencies: + yoctocolors: 2.1.2 + + yoctocolors@2.1.2: {} + + zod-to-json-schema@3.25.1(zod@3.25.76): + dependencies: + zod: 3.25.76 + + zod-to-ts@1.2.0(typescript@5.9.3)(zod@3.25.76): + dependencies: + typescript: 5.9.3 + zod: 3.25.76 + + zod@3.25.76: {} + + zwitch@2.0.4: {} diff --git a/docs/prd/accountmanager-fromsecret-wrapped-interfaces.md b/docs/prd/accountmanager-fromsecret-wrapped-interfaces.md new file mode 100644 index 00000000..50d354ab --- /dev/null +++ b/docs/prd/accountmanager-fromsecret-wrapped-interfaces.md @@ -0,0 +1,209 @@ +# PRD: AccountManager.fromSecret with Simplified Wrapped Interfaces + +## Problem Statement + +The Python algokit-utils library currently has a fragmented interface for creating accounts from secrets: + +1. **`from_mnemonic`** only supports legacy 25-word Algorand mnemonics, requiring the mnemonic to be passed as a plain string +2. **Wrapped secret interfaces** require mandatory `wrap_*` methods, which is cumbersome for implementations where wrapping is handled automatically (e.g., hardware wallets, certain keyring services) +3. **No unified `fromSecret` method** exists that can accept multiple secret types (seeds, HD extended keys, HD mnemonics, legacy mnemonics) through a single ergonomic interface +4. Users working with **HD wallets** must manually convert mnemonics to seeds and then derive keys, rather than having a direct path from wrapped mnemonics to accounts + +This creates friction for developers who want to: +- Use secure key storage with wrapped secrets that don't need explicit re-wrapping +- Work with HD wallets using BIP39 mnemonics +- Have a single consistent interface for all secret types + +## Solution + +Implement a unified `from_secret` method on `AccountManager` that accepts any wrapped secret type (Ed25519 seed, HD extended private key, HD mnemonic, or legacy mnemonic). Simplify the wrapped secret interfaces by making the `wrap` method optional. Deprecate `from_mnemonic` in favor of `from_secret`. + +This mirrors the TypeScript PR #575 and brings the Python library into parity with the TypeScript implementation's ergonomics. + +## User Stories + +1. As a developer using a hardware wallet, I want to pass a wrapped secret without implementing a no-op wrap method, so that my code is cleaner and more focused on the actual security requirements. + +2. As a developer using HD wallets with BIP39 mnemonics, I want to create an account directly from a wrapped HD mnemonic, so that I don't have to manually convert the mnemonic to a seed and derive the account. + +3. As a developer migrating from the TypeScript algokit-utils, I want the same `fromSecret` interface in Python, so that I can maintain consistency across my codebase. + +4. As a developer using secure key storage, I want to use wrapped secrets for all account types (seeds, HD keys, and mnemonics), so that my private key material is never exposed in plaintext. + +5. As a developer working with legacy Algorand accounts, I want to continue using 25-word mnemonics through the new `from_secret` interface, so that I can migrate to the new API without losing existing functionality. + +6. As a developer reviewing code, I want to see a single `from_secret` method used consistently across the codebase, so that I can more easily understand and audit secret handling. + +7. As a security-conscious developer, I want the `wrap` method to be optional in wrapped secret protocols, so that implementations where secrets are automatically secured don't require boilerplate code. + +8. As a developer working with the AlgorandClient, I want to call `algorand.account.from_secret()` with any wrapped secret type, so that I can create and register accounts in a single, consistent call. + +9. As a maintainer of the library, I want to deprecate `from_mnemonic` with a clear migration path, so that users gradually move to the more secure and flexible `from_secret` method. + +10. As a developer writing tests, I want to mock wrapped secrets without implementing wrap methods, so that my test code is simpler and more maintainable. + +## Implementation Decisions + +### Module Structure + +The implementation spans two primary modules: + +1. **`algokit_crypto`** - Contains the wrapped secret protocols and signing key derivation functions +2. **`algokit_utils.accounts`** - Contains the `AccountManager` class with the new `from_secret` method + +### Wrapped Secret Protocol Changes + +**Current State:** +- `WrappedEd25519Seed` requires `wrap_ed25519_seed()` method +- `WrappedHdExtendedPrivateKey` requires `wrap_hd_extended_private_key()` method + +**New State:** +- `WrappedEd25519Seed` with `unwrap_ed25519_seed()` and optional `wrap()` method +- `WrappedHdExtendedPrivateKey` with `unwrap_hd_extended_private_key()` and optional `wrap()` method +- `WrappedHdMnemonic` (new) with `unwrap_hd_mnemonic()` and optional `wrap()` method +- `WrappedLegacyMnemonic` (new) with `unwrap_legacy_mnemonic()` and optional `wrap()` method + +**Type Union:** +```python +WrappedEd25519Secret = ( + WrappedEd25519Seed + | WrappedHdExtendedPrivateKey + | WrappedHdMnemonic + | WrappedLegacyMnemonic +) +``` + +### HD Wallet Helper Functions + +Three new helper functions will be added to support HD mnemonic handling: + +1. `hd_seed_from_mnemonic(mnemonic: str) -> bytearray` - Converts BIP39 mnemonic to 64-byte seed using xhd-wallet-api's `seed_from_mnemonic` +2. `hd_root_key_from_seed(seed: bytearray) -> bytearray` - Converts seed to 96-byte extended private key root +3. `hd_root_key_from_mnemonic(mnemonic: str) -> bytearray` - Combines the above two functions + +### Signing Key Derivation Updates + +The `ed25519_signing_key_from_wrapped_secret` function will be updated to handle all four wrapped secret types: + +- **WrappedEd25519Seed**: Use PyNaCl to derive public key and create signer +- **WrappedHdExtendedPrivateKey**: Use xhd-wallet-api to derive public key and create raw signer +- **WrappedHdMnemonic**: Convert to seed → root key → derive account 0, index 0 → create signer +- **WrappedLegacyMnemonic**: Convert to 32-byte seed using algo25 → use PyNaCl for signing + +### AccountManager.from_secret Method + +```python +def from_secret( + self, + *, + secret: WrappedEd25519Secret, + sender: str | None = None +) -> AddressWithSigners: + """Create and register an account from a wrapped secret. + + Supports Ed25519 seeds, HD extended private keys, HD mnemonics (BIP39), + and legacy Algorand mnemonics (25-word). + + Args: + secret: A wrapped secret implementing one of the WrappedEd25519Secret protocols + sender: Optional sender address for rekeyed accounts + + Returns: + AddressWithSigners: The created account with signer registered + """ +``` + +### Deprecation Strategy + +`from_mnemonic` will be marked as deprecated using Python's `warnings` module with `DeprecationWarning`. The deprecation message will direct users to use `from_secret` with `WrappedLegacyMnemonic` instead. + +### Error Handling + +All wrapped secret operations will maintain the existing error handling patterns: +- Invalid secret lengths raise `ValueError` +- Failures during unwrap/sign/wrap operations raise `ExceptionGroup` when both operations fail +- Secret zeroing happens in `finally` blocks to ensure memory cleanup + +## Testing Decisions + +### Test Philosophy + +Tests should focus on external behavior (public API contracts) rather than implementation details. Specifically: + +- Test that `from_secret` correctly creates accounts for each secret type +- Test that optional `wrap` methods are truly optional (can be omitted) +- Test deprecation warnings are raised for `from_mnemonic` +- Test error handling paths (invalid secrets, wrap failures) +- Test integration with `AlgorandClient` via `set_signer_from_account` + +### Test Modules + +1. **`tests/crypto/test_wrapped_secrets.py`** - Unit tests for wrapped secret protocols and signing key derivation +2. **`tests/accounts/test_account_manager.py`** - Integration tests for `from_secret` method + +### Prior Art + +Similar tests exist for: +- `ed25519_signing_key_from_wrapped_secret` in `tests/modules/crypto/test_signing.py` +- `from_mnemonic` in `tests/accounts/test_account_manager.py` +- Keyring examples in `examples/signing/` + +## Out of Scope + +The following are explicitly out of scope for this PRD: + +1. **Moving algo25 under crypto** - The TypeScript PR moved algo25 under the crypto package to avoid circular dependencies. This is not needed in Python as algo25 is already a separate package. + +2. **Adding passphrase support for HD mnemonics** - The HD mnemonic functions will use empty passphrases by default. Support for custom passphrases can be added in a future iteration. + +3. **Custom derivation paths for HD mnemonics** - HD mnemonics will always derive account 0, index 0. Users needing custom paths can use `WrappedHdExtendedPrivateKey` directly. + +4. **Async wrapped secrets** - The Python implementation uses synchronous protocols. Async support is not needed at this time. + +5. **Documentation updates** - While the implementation will include docstrings, updating the external documentation site is out of scope. + +## Further Notes + +### Breaking Changes + +This is a **breaking change** (hence `feat!:` in the commit type): + +1. The `wrap` method becoming optional changes the Protocol definition, which could affect existing implementations that relied on the method being required (though runtime behavior remains compatible) + +2. `from_mnemonic` is deprecated, though it will continue to work until the next major version + +### TypeScript Parity + +This implementation aims to match the TypeScript PR #575 behavior: +- Same wrapped secret type names +- Same method signatures (adapted to Python conventions) +- Same optional `wrap` function pattern +- Same `fromSecret` method signature + +### Security Considerations + +- All secrets are zeroed in memory after use via `finally` blocks +- The optional `wrap` method design reduces friction for secure implementations while still supporting explicit wrapping when needed +- Mnemonic-to-seed conversion happens in memory and the seed is not retained after account creation + +### Migration Path for Users + +Users currently using `from_mnemonic` can migrate as follows: + +**Before:** +```python +account = account_manager.from_mnemonic(mnemonic="word1 word2 ...") +``` + +**After:** +```python +class WrappedMnemonic: + def __init__(self, mnemonic: str): + self._mnemonic = mnemonic + def unwrap_legacy_mnemonic(self) -> str: + return self._mnemonic + +account = account_manager.from_secret(secret=WrappedMnemonic("word1 word2 ...")) +``` + +Or for simpler cases, a convenience wrapper can be provided in the future. diff --git a/docs/public/favicon.svg b/docs/public/favicon.svg new file mode 100644 index 00000000..9e3b41ff --- /dev/null +++ b/docs/public/favicon.svg @@ -0,0 +1,20 @@ + + + + + + + + + + + + diff --git a/docs/markdown/images/lifecycle.jpg b/docs/public/images/lifecycle.jpg similarity index 100% rename from docs/markdown/images/lifecycle.jpg rename to docs/public/images/lifecycle.jpg diff --git a/docs/scripts/generate-examples-mdx.ts b/docs/scripts/generate-examples-mdx.ts new file mode 100644 index 00000000..f95d3fab --- /dev/null +++ b/docs/scripts/generate-examples-mdx.ts @@ -0,0 +1,284 @@ +/** + * Generates static .mdx files from example .py files for devportal inclusion. + * + * Reuses parsing and category definitions from the examples-loader. + * Output goes to src/content/docs/examples/ so it gets packaged in the tarball. + * + * Run: npx tsx docs/scripts/generate-examples-mdx.ts + */ + +import fs from 'node:fs' +import path from 'node:path' +import { CATEGORIES, parseDocstring, extractOrder, createSlug } from '../src/loaders/examples-loader.ts' + +const REPO_ROOT = path.resolve(import.meta.dirname, '..', '..') +const EXAMPLES_DIR = path.join(REPO_ROOT, 'examples') +const OUTPUT_DIR = path.join(REPO_ROOT, 'docs', 'src', 'content', 'docs', 'examples') +const GITHUB_BASE = 'https://github.com/algorandfoundation/algokit-utils-py/blob/main/examples' + +// Clean output directory +if (fs.existsSync(OUTPUT_DIR)) { + fs.rmSync(OUTPUT_DIR, { recursive: true }) +} + +// Collect all examples across categories for cross-referencing +type ExampleInfo = { title: string; slug: string; description: string; categoryDir: string; categorySlug: string; categoryLabel: string } +const allExamplesByCategory: Record = {} +let totalCount = 0 + +for (const [categoryDir, meta] of Object.entries(CATEGORIES)) { + const categoryPath = path.join(EXAMPLES_DIR, categoryDir) + if (!fs.existsSync(categoryPath)) { + console.warn(` Skipping missing category: ${categoryDir}`) + continue + } + + const outputCategoryDir = path.join(OUTPUT_DIR, meta.slug) + fs.mkdirSync(outputCategoryDir, { recursive: true }) + + const files = fs.readdirSync(categoryPath).filter((f) => f.endsWith('.py') && !f.startsWith('_')) + const categoryExamples: ExampleInfo[] = [] + + for (const filename of files) { + const content = fs.readFileSync(path.join(categoryPath, filename), 'utf-8') + const { title, description, prerequisites } = parseDocstring(content) + const order = extractOrder(filename) + const slug = createSlug(filename) + const githubUrl = `${GITHUB_BASE}/${categoryDir}/${filename}` + const runCommand = `uv run python ${categoryDir}/${filename}` + + const prereqText = prerequisites || 'LocalNet running (`algokit localnet start`)' + + // Build "Other examples in this category" links (filled in second pass) + categoryExamples.push({ title, slug, description, categoryDir, categorySlug: meta.slug, categoryLabel: meta.label }) + + const mdx = `--- +title: "${title}" +description: "${description.split('\n')[0].replace(/"/g, '\\"')}" +sidebar: + order: ${order} +--- + +[← Back to ${meta.label}](../) + +## Description + +${description.replace(//g, '>').replace(/\{/g, '{').replace(/\}/g, '}')} + +## Prerequisites + +${prereqText} + +## Run This Example + +From the repository's \`examples\` directory: + +\`\`\`bash +cd examples +${runCommand} +\`\`\` + +## Code + +[View source on GitHub](${githubUrl}) + +\`\`\`python title="${filename}" +${content} +\`\`\` + +--- + +### Other examples in ${meta.label} + +PLACEHOLDER_OTHER_EXAMPLES_${meta.slug} +` + + fs.writeFileSync(path.join(outputCategoryDir, `${slug}.mdx`), mdx) + totalCount++ + } + + allExamplesByCategory[meta.slug] = categoryExamples +} + +// Second pass: replace placeholder with actual sibling links +for (const [categorySlug, examples] of Object.entries(allExamplesByCategory)) { + const outputCategoryDir = path.join(OUTPUT_DIR, categorySlug) + + for (const example of examples) { + const filePath = path.join(outputCategoryDir, `${example.slug}.mdx`) + let content = fs.readFileSync(filePath, 'utf-8') + + const siblingLinks = examples + .map((ex) => (ex.slug === example.slug ? `- **${ex.title}**` : `- [${ex.title}](../${ex.slug}/)`)) + .join('\n') + + content = content.replace(`PLACEHOLDER_OTHER_EXAMPLES_${categorySlug}`, siblingLinks) + fs.writeFileSync(filePath, content) + } + + // Category index page — HTML table with full descriptions including bullets + const escapeForMdx = (text: string) => + text.replace(/&/g, '&').replace(//g, '>').replace(/\{/g, '{').replace(/\}/g, '}') + + const tableRows = examples + .map((ex) => { + const lines = ex.description.split('\n') + let descHtml = '' + let bulletBuffer: string[] = [] + const flushBullets = () => { + if (bulletBuffer.length > 0) { + descHtml += '
    ' + bulletBuffer.map((b) => `
  • ${escapeForMdx(b)}
  • `).join('') + '
' + bulletBuffer = [] + } + } + for (const line of lines) { + const trimmed = line.trim() + if (!trimmed) continue + if (/^[-•]\s/.test(trimmed)) { + bulletBuffer.push(trimmed.replace(/^[-•]\s*/, '')) + } else { + flushBullets() + descHtml += `

${escapeForMdx(trimmed)}

` + } + } + flushBullets() + + return `${escapeForMdx(ex.title)}${descHtml}` + }) + .join('\n') + + fs.writeFileSync( + path.join(outputCategoryDir, 'index.mdx'), + `--- +title: "${allExamplesByCategory[categorySlug][0].categoryLabel}" +description: "${CATEGORIES[examples[0].categoryDir].description.replace(/"/g, '\\"')}" +sidebar: + label: "${allExamplesByCategory[categorySlug][0].categoryLabel}" + order: 0 +--- + +[← Back to Examples Overview](../) + +${CATEGORIES[examples[0].categoryDir].description} + +## Examples (${examples.length}) + + + + +${tableRows} + +
ExampleDescription
+ +## Quick Start + +Run any example from the repository's \`examples\` directory: + +\`\`\`bash +cd examples +uv run python ${examples[0].categoryDir}/${examples[0].slug.replace(/-/g, '_')}.py +\`\`\` +`, + ) +} + +// Top-level examples index — custom card grid +const categoryCards = Object.entries(CATEGORIES) + .map(([dirName, meta]) => { + const count = allExamplesByCategory[meta.slug]?.length ?? 0 + return ` +

${meta.label}

+

${meta.description}

+ ${count} examples +
` + }) + .join('\n') + +fs.mkdirSync(OUTPUT_DIR, { recursive: true }) +fs.writeFileSync( + path.join(OUTPUT_DIR, 'index.mdx'), + `--- +title: Code Examples +description: "${totalCount} runnable Python examples demonstrating AlgoKit Utils features" +sidebar: + order: 0 +--- + +Browse **${totalCount}** runnable Python examples organized by feature area. Each example is self-contained and demonstrates specific functionality of the AlgoKit Utils library. + +## Quick Start + +\`\`\`bash +# Clone the repository +git clone https://github.com/algorandfoundation/algokit-utils-py.git +cd algokit-utils-py + +# Install dependencies +uv sync + +# Run any example +cd examples +uv run python algorand_client/01_client_instantiation.py +\`\`\` + +## Prerequisites + +- Python >= 3.10 +- [uv](https://docs.astral.sh/uv/) installed +- [AlgoKit CLI](https://github.com/algorandfoundation/algokit-cli) installed +- LocalNet running for network examples (\`algokit localnet start\`) + +*Some examples marked "No LocalNet required" work with pure utility functions.* + +## Categories + +
+${categoryCards} +
+ + +`, +) + +console.log(`Generated ${totalCount} example MDX files + index pages in docs/src/content/docs/examples/`) diff --git a/docs/sidebar.config.json b/docs/sidebar.config.json new file mode 100644 index 00000000..353acc6b --- /dev/null +++ b/docs/sidebar.config.json @@ -0,0 +1,129 @@ +[ + { "label": "Home", "link": "/" }, + { + "label": "Getting Started", + "items": [{ "slug": "tutorials/quick-start" }] + }, + { + "label": "Core Concepts", + "items": [ + { "slug": "concepts/core/algorand-client" }, + { "slug": "concepts/core/account" }, + { "slug": "concepts/core/transaction" }, + { "slug": "concepts/core/amount" }, + { "slug": "concepts/core/client" }, + { "slug": "concepts/core/secret-management" } + ] + }, + { + "label": "Building Applications", + "items": [ + { "slug": "concepts/building/app-client" }, + { "slug": "concepts/building/app-deploy" }, + { "slug": "concepts/building/app" }, + { "slug": "concepts/building/typed-app-clients" }, + { "slug": "concepts/building/asset" }, + { "slug": "concepts/building/transfer" }, + { "slug": "concepts/building/testing" } + ] + }, + { + "label": "Advanced Topics", + "collapsed": true, + "items": [ + { "slug": "concepts/advanced/transaction-composer" }, + { "slug": "concepts/advanced/modular-imports" }, + { "slug": "concepts/advanced/debugging" }, + { "slug": "concepts/advanced/indexer" }, + { "slug": "concepts/advanced/dispenser-client" } + ] + }, + { + "label": "Migration Guides", + "collapsed": true, + "autogenerate": { "directory": "migration" } + }, + { + "label": "Examples", + "collapsed": true, + "items": [ + { "label": "Overview", "slug": "examples" }, + { "label": "ABI Encoding", "slug": "examples/abi" }, + { "label": "Mnemonic Utilities", "slug": "examples/algo25" }, + { "label": "Algod Client", "slug": "examples/algod-client" }, + { "label": "Algorand Client", "slug": "examples/algorand-client" }, + { "label": "Common Utilities", "slug": "examples/common" }, + { "label": "Indexer Client", "slug": "examples/indexer-client" }, + { "label": "KMD Client", "slug": "examples/kmd-client" }, + { "label": "Signing", "slug": "examples/signing" }, + { "label": "Transactions", "slug": "examples/transact" } + ] + }, + { + "label": "API Reference", + "collapsed": true, + "items": [ + { "slug": "api/algokit_utils", "label": "Algokit Utils Index" }, + { + "label": "accounts", + "collapsed": true, + "autogenerate": { "directory": "api/algokit_utils/accounts" } + }, + { + "label": "algo25", + "collapsed": true, + "autogenerate": { "directory": "api/algokit_utils/algo25" } + }, + { + "label": "algorand", + "collapsed": true, + "autogenerate": { "directory": "api/algokit_utils/algorand" } + }, + { + "label": "applications", + "collapsed": true, + "autogenerate": { "directory": "api/algokit_utils/applications" } + }, + { + "label": "assets", + "collapsed": true, + "autogenerate": { "directory": "api/algokit_utils/assets" } + }, + { + "label": "clients", + "collapsed": true, + "autogenerate": { "directory": "api/algokit_utils/clients" } + }, + { + "label": "config", + "collapsed": true, + "autogenerate": { "directory": "api/algokit_utils/config" } + }, + { + "label": "errors", + "collapsed": true, + "autogenerate": { "directory": "api/algokit_utils/errors" } + }, + { + "label": "models", + "collapsed": true, + "autogenerate": { "directory": "api/algokit_utils/models" } + }, + { + "label": "protocols", + "collapsed": true, + "autogenerate": { "directory": "api/algokit_utils/protocols" } + }, + { + "label": "transact", + "collapsed": true, + "autogenerate": { "directory": "api/algokit_utils/transact" } + }, + { + "label": "transactions", + "collapsed": true, + "autogenerate": { "directory": "api/algokit_utils/transactions" } + } + ] + } +] diff --git a/docs/source/capabilities/account.md b/docs/source/capabilities/account.md deleted file mode 100644 index fe0f7340..00000000 --- a/docs/source/capabilities/account.md +++ /dev/null @@ -1,215 +0,0 @@ -# Account management - -Account management is one of the core capabilities provided by AlgoKit Utils. It allows you to create mnemonic, rekeyed, multisig, transaction signer, idempotent KMD and environment variable injected accounts that can be used to sign transactions as well as representing a sender address at the same time. This significantly simplifies management of transaction signing. - -## `AccountManager` - -The {py:obj}`AccountManager ` is a class that is used to get, create, and fund accounts and perform account-related actions such as funding. The `AccountManager` also keeps track of signers for each address so when using the [`TransactionComposer`](./transaction-composer.md) to send transactions, a signer function does not need to manually be specified for each transaction - instead it can be inferred from the sender address automatically! - -To get an instance of `AccountManager`, you can use either [`AlgorandClient`](./algorand-client.md) via `algorand.account` or instantiate it directly: - -```python -from algokit_utils import AccountManager - -account_manager = AccountManager(client_manager) -``` - -## `TransactionSignerAccountProtocol` - -The core internal type that holds information about a signer/sender pair for a transaction is {py:obj}`TransactionSignerAccountProtocol `, which represents an `algosdk.transaction.TransactionSigner` (`signer`) along with a sender address (`address`) as the encoded string address. - -The following conform to `TransactionSignerAccountProtocol`: - -- {py:obj}`TransactionSignerAccount ` - a basic transaction signer account that holds an address and a signer conforming to `TransactionSignerAccountProtocol` -- {py:obj}`SigningAccount ` - an abstraction that used to be available under `Account` in previous versions of AlgoKit Utils. Renamed for consistency with equivalent `ts` version. Holds private key and conforms to `TransactionSignerAccountProtocol` -- {py:obj}`LogicSigAccount ` - a wrapper class around `algosdk` logicsig abstractions conforming to `TransactionSignerAccountProtocol` -- {py:obj}`MultisigAccount ` - a wrapper class around `algosdk` multisig abstractions conforming to `TransactionSignerAccountProtocol` - -## Registering a signer - -The `AccountManager` keeps track of which signer is associated with a given sender address. This is used by [`AlgorandClient`](./algorand-client.md) to automatically sign transactions by that sender. Any of the [methods](#accounts) within `AccountManager` that return an account will automatically register the signer with the sender. - -There are two methods that can be used for this, `set_signer_from_account`, which takes any number of [account based objects](#underlying-account-classes) that combine signer and sender (`TransactionSignerAccount` | `SigningAccount` | `LogicSigAccount` | `MultisigAccount`), or `set_signer` which takes the sender address and the `TransactionSigner`: - -```python -algorand.account - .set_signer_from_account(TransactionSignerAccount(your_address, your_signer)) - .set_signer_from_account(SigningAccount.new_account()) - .set_signer_from_account( - LogicSigAccount(algosdk.transaction.LogicSigAccount(program, args)) - ) - .set_signer_from_account( - MultisigAccount( - MultisigMetadata( - version = 1, - threshold = 1, - addresses = ["ADDRESS1...", "ADDRESS2..."] - ), - [account1, account2] - ) - ) - .set_signer("SENDERADDRESS", transaction_signer) -``` - -## Default signer - -If you want to have a default signer that is used to sign transactions without a registered signer (rather than throwing an exception) then you can {py:meth}`set_default_signer `: - -```python -algorand.account.set_default_signer(my_default_signer) -``` - -## Get a signer - -[`AlgorandClient`](./algorand-client.md) will automatically retrieve a signer when signing a transaction, but if you need to get a `TransactionSigner` externally to do something more custom then you can {py:meth}`get_signer ` for a given sender address: - -```python -signer = algorand.account.get_signer("SENDER_ADDRESS") -``` - -If there is no signer registered for that sender address it will either return the default signer ([if registered](#default-signer)) or throw an exception. - -## Accounts - -In order to get/register accounts for signing operations you can use the following methods on [`AccountManager`](#accountmanager) (expressed here as `algorand.account` to denote the syntax via an [`AlgorandClient`](./algorand-client.md)): - -- {py:meth}`from_environment ` - Registers and returns an account with private key loaded by convention based on the given name identifier - either by idempotently creating the account in KMD or from environment variable via `process.env['{NAME}_MNEMONIC']` and (optionally) `process.env['{NAME}_SENDER']` (if account is rekeyed) - - This allows you to have powerful code that will automatically create and fund an account by name locally and when deployed against TestNet/MainNet will automatically resolve from environment variables, without having to have different code - - Note: `fund_with` allows you to control how many Algo are seeded into an account created in KMD -- {py:meth}`from_mnemonic ` - Registers and returns an account with secret key loaded by taking the mnemonic secret -- {py:meth}`multisig ` - Registers and returns a multisig account with one or more signing keys loaded -- {py:meth}`rekeyed ` - Registers and returns an account representing the given rekeyed sender/signer combination -- {py:meth}`random ` - Returns a new, cryptographically randomly generated account with private key loaded -- {py:meth}`from_kmd ` - Returns an account with private key loaded from the given KMD wallet (identified by name) -- {py:meth}`logicsig ` - Returns an account that represents a logic signature - -### Underlying account classes - -While `TransactionSignerAccount` is the main class used to represent an account that can sign, there are underlying account classes that can underpin the signer within the transaction signer account. - -- {py:obj}`TransactionSignerAccount ` - A default class conforming to `TransactionSignerAccountProtocol` that holds an address and a signer -- {py:obj}`SigningAccount ` - An abstraction around `algosdk.Account` that supports rekeyed accounts -- {py:obj}`LogicSigAccount ` - An abstraction around `algosdk.LogicSigAccount` and `algosdk.LogicSig` that supports logic sig signing. Exposes access to the underlying algosdk `algosdk.transaction.LogicSigAccount` object instance via `lsig` property. -- {py:obj}`MultisigAccount ` - An abstraction around `algosdk.MultisigMetadata`, `algosdk.makeMultiSigAccountTransactionSigner`, `algosdk.multisigAddress`, `algosdk.signMultisigTransaction` and `algosdk.appendSignMultisigTransaction` that supports multisig accounts with one or more signers present. Exposes access to the underlying algosdk `algosdk.transaction.Multisig` object instance via `multisig` property. - -### Dispenser - -- {py:meth}`dispenser_from_environment ` - Returns an account (with private key loaded) that can act as a dispenser from environment variables, or against default LocalNet if no environment variables present -- {py:meth}`localnet_dispenser ` - Returns an account with private key loaded that can act as a dispenser for the default LocalNet dispenser account - -## Rekey account - -One of the unique features of Algorand is the ability to change the private key that can authorise transactions for an account. This is called [rekeying](https://dev.algorand.co/concepts/accounts/rekeying). - -> [!WARNING] -> Rekeying should be done with caution as a rekey transaction can result in permanent loss of control of an account. - -You can issue a transaction to rekey an account by using the {py:meth}`rekey_account ` function: - -- `account: string | TransactionSignerAccount` - The account address or signing account of the account that will be rekeyed -- `rekeyTo: string | TransactionSignerAccount` - The account address or signing account of the account that will be used to authorise transactions for the rekeyed account going forward. If a signing account is provided that will now be tracked as the signer for `account` in the `AccountManager` instance. -- An `options` object, which has: - - [Common transaction parameters](./algorand-client.md#transaction-parameters) - - [Execution parameters](./algorand-client.md#sending-a-single-transaction) - -You can also pass in `rekeyTo` as a [common transaction parameter](./algorand-client.md#transaction-parameters) to any transaction. - -### Examples - -```python -# Basic example (with string addresses) - -algorand.account.rekey_account({ - account: "ACCOUNTADDRESS", - rekey_to: "NEWADDRESS", -}) - -# Basic example (with signer accounts) - -algorand.account.rekey_account({ - account: account1, - rekey_to: new_signer_account, -}) - -# Advanced example - -algorand.account.rekey_account({ - account: "ACCOUNTADDRESS", - rekey_to: "NEWADDRESS", - lease: "lease", - note: "note", - first_valid_round: 1000, - validity_window: 10, - extra_fee: AlgoAmount.from_micro_algos(1000), - static_fee: AlgoAmount.from_micro_algos(1000), - # Max fee doesn't make sense with extra_fee AND static_fee - # already specified, but here for completeness - max_fee: AlgoAmount.from_micro_algos(3000), - max_rounds_to_wait_for_confirmation: 5, - suppress_log: True, -}) - - -# Using a rekeyed account - -Note: if a signing account is passed into `algorand.account.rekey_account` then you don't need to call `rekeyed_account` to register the new signer - -rekeyed_account = algorand.account.rekey_account(account, new_account) -# rekeyed_account can be used to sign transactions on behalf of account... -``` - -## KMD account management - -When running LocalNet, you have an instance of the [Key Management Daemon](https://github.com/algorand/go-algorand/blob/master/daemon/kmd/README.md), which is useful for: - -- Accessing the private key of the default accounts that are pre-seeded with Algo so that other accounts can be funded and it's possible to use LocalNet -- Idempotently creating new accounts against a name that will stay intact while the LocalNet instance is running without you needing to store private keys anywhere (i.e. completely automated) - -The KMD SDK is fairly low level so to make use of it there is a fair bit of boilerplate code that's needed. This code has been abstracted away into the `KmdAccountManager` class. - -To get an instance of the `KmdAccountManager` class you can access it from [`AlgorandClient`](./algorand-client.md) via `algorand.account.kmd` or instantiate it directly (passing in a [`ClientManager`](./client.md)): - -```python -from algokit_utils import KmdAccountManager - -kmd_account_manager = KmdAccountManager(client_manager) -``` - -The methods that are available are: - -- {py:meth}`get_wallet_account ` - Returns an Algorand signing account with private key loaded from the given KMD wallet (identified by name). -- {py:meth}`get_or_create_wallet_account ` - Gets an account with private key loaded from a KMD wallet of the given name, or alternatively creates one with funds in it via a KMD wallet of the given name. -- {py:meth}`get_localnet_dispenser_account ` - Returns an Algorand account with private key loaded for the default LocalNet dispenser account (that can be used to fund other accounts) - -```python -# Get a wallet account that seeded the LocalNet network -default_dispenser_account = kmd_account_manager.get_wallet_account( - "unencrypted-default-wallet", - lambda a: a["status"] != "Offline" and a["amount"] > 1_000_000_000 -) -# Same as above, but dedicated method call for convenience -localnet_dispenser_account = kmd_account_manager.get_localnet_dispenser_account() -# Idempotently get (if exists) or create (if it doesn't exist yet) an account by name using KMD -# if creating it then fund it with 2 ALGO from the default dispenser account -new_account = kmd_account_manager.get_or_create_wallet_account( - "account1", - AlgoAmount.from_algos(2) -) -# This will return the same account as above since the name matches -existing_account = kmd_account_manager.get_or_create_wallet_account( - "account1" -) -``` - -Some of this functionality is directly exposed from [`AccountManager`](#accountmanager), which has the added benefit of registering the account as a signer so they can be automatically used to sign transactions when using via [`AlgorandClient`](./algorand-client.md): - -```python -# Get and register LocalNet dispenser -localnet_dispenser = algorand.account.localnet_dispenser() -# Get and register a dispenser by environment variable, or if not set then LocalNet dispenser via KMD -dispenser = algorand.account.dispenser_from_environment() -# Get an account from KMD idempotently by name. In this case we'll get the default dispenser account -dispenser_via_kmd = algorand.account.from_kmd('unencrypted-default-wallet', lambda a: a.status != 'Offline' and a.amount > 1_000_000_000) -# Get / create and register account from KMD idempotently by name -fresh_account_via_kmd = algorand.account.kmd.get_or_create_wallet_account('account1', AlgoAmount.from_algos(2)) -``` diff --git a/docs/source/capabilities/algorand-client.md b/docs/source/capabilities/algorand-client.md deleted file mode 100644 index 087c5352..00000000 --- a/docs/source/capabilities/algorand-client.md +++ /dev/null @@ -1,212 +0,0 @@ -# Algorand client - -`AlgorandClient` is a client class that brokers easy access to Algorand functionality. It's the [default entrypoint](../index.md#usage) into AlgoKit Utils functionality. - -The main entrypoint to the bulk of the functionality in AlgoKit Utils is the `AlgorandClient` class, most of the time you can get started by typing `AlgorandClient.` and choosing one of the static initialisation methods to create an {py:class}`algokit_utils.algorand.AlgorandClient`, e.g.: - -```python -# Point to the network configured through environment variables or -# if no environment variables it will point to the default LocalNet -# configuration -algorand = AlgorandClient.from_environment() -# Point to default LocalNet configuration -algorand = AlgorandClient.default_localnet() -# Point to TestNet using AlgoNode free tier -algorand = AlgorandClient.testnet() -# Point to MainNet using AlgoNode free tier -algorand = AlgorandClient.mainnet() -# Point to a pre-created algod client -algorand = AlgorandClient.from_clients(algod=algod) -# Point to pre-created algod, indexer and kmd clients -algorand = AlgorandClient.from_clients(algod=algod, indexer=indexer, kmd=kmd) -# Point to custom configuration for algod -algorand = AlgorandClient.from_config(algod_config=algod_config) -# Point to custom configuration for algod, indexer and kmd -algorand = AlgorandClient.from_config( - algod_config=algod_config, - indexer_config=indexer_config, - kmd_config=kmd_config -) -``` - -## Accessing SDK clients - -Once you have an `AlgorandClient` instance, you can access the SDK clients for the various Algorand APIs via the `algorand.client` property. - -```py -algorand = AlgorandClient.default_localnet() - -algod_client = algorand.client.algod -indexer_client = algorand.client.indexer -kmd_client = algorand.client.kmd -``` - -## Accessing manager class instances - -The `AlgorandClient` has a number of manager class instances that help you quickly use intellisense to get access to advanced functionality. - -- [`AccountManager`](./account.md) via `algorand.account`, there are also some chainable convenience methods which wrap specific methods in `AccountManager`: - - `algorand.setDefaultSigner(signer)` - - - `algorand.setSignerFromAccount(account)` - - - `algorand.setSigner(sender, signer)` -- [`AssetManager`](./asset.md) via `algorand.asset` -- [`ClientManager`](./client.md) via `algorand.client` - -## Creating and issuing transactions - -`AlgorandClient` exposes a series of methods that allow you to create, execute, and compose groups of transactions (all via the [`TransactionComposer`](./transaction-composer.md)). - -### Creating transactions - -You can compose a transaction via `algorand.create_transaction.`, which gives you an instance of the {py:class}`algokit_utils.transactions.AlgorandClientTransactionCreator` class. Intellisense will guide you on the different options. - -The signature for the calls to send a single transaction usually look like: - -```python -algorand.create_transaction.{method}(params=TxnParams(...), send_params=SendParams(...)) -> Transaction: -``` - -- `TxnParams` is a union type that can be any of the Algorand transaction types, exact dataclasses can be imported from `algokit_utils` and consist of: - - `AppCallParams`, - - `AppCreateParams`, - - `AppDeleteParams`, - - `AppUpdateParams`, - - `AssetConfigParams`, - - `AssetCreateParams`, - - `AssetDestroyParams`, - - `AssetFreezeParams`, - - `AssetOptInParams`, - - `AssetOptOutParams`, - - `AssetTransferParams`, - - `OfflineKeyRegistrationParams`, - - `OnlineKeyRegistrationParams`, - - `PaymentParams`, -- `SendParams` is a typed dictionary exposing setting to apply during send operation: - - `max_rounds_to_wait_for_confirmation: int | None` - The number of rounds to wait for confirmation. By default until the latest lastValid has past. - - `suppress_log: bool | None` - Whether to suppress log messages from transaction send, default: do not suppress. - - `populate_app_call_resources: bool | None` - Whether to use simulate to automatically populate app call resources in the txn objects. Defaults to `Config.populateAppCallResources`. - - `cover_app_call_inner_transaction_fees: bool | None` - Whether to use simulate to automatically calculate required app call inner transaction fees and cover them in the parent app call transaction fee - -The return type for the ABI method call methods are slightly different: - -```python -algorand.createTransaction.app{call_type}_method_call(params=MethodCallParams(...), send_params=SendParams(...)) -> BuiltTransactions -``` - -MethodCallParams is a union type that can be any of the Algorand method call types, exact dataclasses can be imported from `algokit_utils` and consist of: - -- `AppCreateMethodCallParams`, -- `AppCallMethodCallParams`, -- `AppDeleteMethodCallParams`, -- `AppUpdateMethodCallParams`, - -Where `BuiltTransactions` looks like this: - -```python -@dataclass(frozen=True) -class BuiltTransactions: - transactions: list[algosdk.transaction.Transaction] - method_calls: dict[int, Method] - signers: dict[int, TransactionSigner] -``` - -This signifies the fact that an ABI method call can actually result in multiple transactions (which in turn may have different signers), that you need ABI metadata to be able to extract the return value from the transaction result. - -### Sending a single transaction - -You can compose a single transaction via `algorand.send...`, which gives you an instance of the {py:class}`algokit_utils.transactions.AlgorandClientTransactionSender` class. Intellisense will guide you on the different options. - -Further documentation is present in the related capabilities: - -- [App management](./app.md) -- [Asset management](./asset.md) -- [Algo transfers](./transfer.md) - -The signature for the calls to send a single transaction usually look like: - -`algorand.send.{method}(params=TxnParams, send_params=SendParams) -> SingleSendTransactionResult` - -- To get intellisense on the params, use your IDE's intellisense keyboard shortcut (e.g. ctrl+space). -- `TxnParams` is a union type that can be any of the Algorand transaction types, exact dataclasses can be imported from `algokit_utils`. -- {py:class}`algokit_utils.transactions.SendParams` a typed dictionary exposing setting to apply during send operation. -- {py:class}`algokit_utils.transactions.SendSingleTransactionResult` is all of the information that is relevant when [sending a single transaction to the network](./transaction.md#transaction-results) - -Generally, the functions to immediately send a single transaction will emit log messages before and/or after sending the transaction. You can opt-out of this by sending `suppressLog: true`. - -### Composing a group of transactions - -You can compose a group of transactions for execution by using the `new_group()` method on `AlgorandClient` and then use the various `.add_{Type}()` methods on [`TransactionComposer`](./transaction-composer.md) to add a series of transactions. - -```python -result = (algorand - .new_group() - .add_payment( - PaymentParams( - sender="SENDERADDRESS", - receiver="RECEIVERADDRESS", - amount=1_000_000 # 1 Algo in microAlgos - ) - ) - .add_asset_opt_in( - AssetOptInParams( - sender="SENDERADDRESS", - asset_id=12345 - ) - ) - .send()) -``` - -`new_group()` returns a new [`TransactionComposer`](./transaction-composer.md) instance, which can also return the group of transactions, simulate them and other things. - -### Transaction parameters - -To create a transaction you instantiate a relevant Transaction parameters dataclass from `algokit_utils.transactions import *` or `from algokit_utils import PaymentParams, AssetOptInParams, etc`. - -All transaction parameters share the following common base parameters: - -- `sender: str` - The address of the account sending the transaction. -- `signer: algosdk.TransactionSigner | TransactionSignerAccount | None` - The function used to sign transaction(s); if not specified then an attempt will be made to find a registered signer for the given `sender` or use a default signer (if configured). -- `rekey_to: string | None` - Change the signing key of the sender to the given address. **Warning:** Please be careful with this parameter and be sure to read the [official rekey guidance](https://dev.algorand.co/concepts/accounts/rekeying). -- `note: bytes | str | None` - Note to attach to the transaction. Max of 1000 bytes. -- `lease: bytes | str | None` - Prevent multiple transactions with the same lease being included within the validity window. A [lease](https://dev.algorand.co/concepts/transactions/leases) enforces a mutually exclusive transaction (useful to prevent double-posting and other scenarios). -- Fee management - - `static_fee: AlgoAmount | None` - The static transaction fee. In most cases you want to use `extra_fee` unless setting the fee to 0 to be covered by another transaction. - - `extra_fee: AlgoAmount | None` - The fee to pay IN ADDITION to the suggested fee. Useful for covering inner transaction fees. - - `max_fee: AlgoAmount | None` - Throw an error if the fee for the transaction is more than this amount; prevents overspending on fees during high congestion periods. -- Round validity management - - `validity_window: int | None` - How many rounds the transaction should be valid for, if not specified then the registered default validity window will be used. - - `first_valid_round: int | None` - Set the first round this transaction is valid. If left undefined, the value from algod will be used. We recommend you only set this when you intentionally want this to be some time in the future. - - `last_valid_round: int | None` - The last round this transaction is valid. It is recommended to use `validity_window` instead. - -Then on top of that the base type gets extended for the specific type of transaction you are issuing. These are all defined as part of [`TransactionComposer`](./transaction-composer.md) and we recommend reading these docs, especially when leveraging either `populate_app_call_resources` or `cover_app_call_inner_transaction_fees`. - -### Transaction configuration - -AlgorandClient caches network provided transaction values for you automatically to reduce network traffic. It has a set of default configurations that control this behaviour, but you have the ability to override and change the configuration of this behaviour: - -- `algorand.set_default_validity_window(validity_window)` - Set the default validity window (number of rounds from the current known round that the transaction will be valid to be accepted for), having a smallish value for this is usually ideal to avoid transactions that are valid for a long future period and may be submitted even after you think it failed to submit if waiting for a particular number of rounds for the transaction to be successfully submitted. The validity window defaults to `10`, except localnet environments where it's set to `1000`. -- `algorand.set_suggested_params(suggested_params, until?)` - Set the suggested network parameters to use (optionally until the given time) -- `algorand.set_suggested_params_timeout(timeout)` - Set the timeout that is used to cache the suggested network parameters (by default 3 seconds) -- `algorand.get_suggested_params()` - Get the current suggested network parameters object, either the cached value, or if the cache has expired a fresh value - -### Error handling - -AlgorandClient provides error transformer functionality to enhance error messages and debugging information when transactions fail. Error transformers allow you to register custom functions that can transform generic blockchain errors into more meaningful, application-specific error messages. - -#### Registering Error Transformers - -```python -def my_error_transformer(error: Exception) -> Exception: - """Transform generic errors into more meaningful ones.""" - if "asset missing" in str(error).lower(): - return Exception("Asset not found: Please check the asset ID") - return error # Return unchanged if not applicable - -# Register globally for all transaction groups -algorand.register_error_transformer(my_error_transformer) - -# Unregister when no longer needed -algorand.unregister_error_transformer(my_error_transformer) -``` - -Error transformers registered at the `AlgorandClient` level will be applied to all transaction groups created from that client instance. For more detailed documentation on error transformers, including examples and best practices, see the [Transaction Composer Error Transformers](./transaction-composer.md#error-transformers) section. diff --git a/docs/source/capabilities/amount.md b/docs/source/capabilities/amount.md deleted file mode 100644 index 9030f612..00000000 --- a/docs/source/capabilities/amount.md +++ /dev/null @@ -1,55 +0,0 @@ -# Algo amount handling - -Algo amount handling is one of the core capabilities provided by AlgoKit Utils. It allows you to reliably and tersely specify amounts of microAlgo and Algo and safely convert between them. - -Any AlgoKit Utils function that needs an Algo amount will take an `AlgoAmount` object, which ensures that there is never any confusion about what value is being passed around. Whenever an AlgoKit Utils function calls into an underlying algosdk function, or if you need to take an `AlgoAmount` and pass it into an underlying algosdk function (per the {ref}`modularity principle `) you can safely and explicitly convert to microAlgo or Algo. - -To see some usage examples check out the automated tests. Alternatively, you can see the reference documentation for `AlgoAmount`. - -## `AlgoAmount` - -The `AlgoAmount` class provides a safe wrapper around an underlying amount of microAlgo where any value entering or existing the `AlgoAmount` class must be explicitly stated to be in microAlgo or Algo. This makes it much safer to handle Algo amounts rather than passing them around as raw numbers where it's easy to make a (potentially costly!) mistake and not perform a conversion when one is needed (or perform one when it shouldn't be!). - -To import the AlgoAmount class you can access it via: - -```python -from algokit_utils import AlgoAmount -``` - -### Creating an `AlgoAmount` - -There are a few ways to create an `AlgoAmount`: - -- Algo - - Constructor: `AlgoAmount(algo=10)` - - Static helper: `AlgoAmount.from_algo(10)` -- microAlgo - - Constructor: `AlgoAmount(micro_algo=10_000)` - - Static helper: `AlgoAmount.from_micro_algo(10_000)` - -### Extracting a value from `AlgoAmount` - -The `AlgoAmount` class has properties to return Algo and microAlgo: - -- `amount.algo` - Returns the value in Algo as a python `Decimal` object -- `amount.micro_algo` - Returns the value in microAlgo as an integer - -`AlgoAmount` will coerce to an integer automatically (in microAlgo) when using `int(amount)`, which allows you to use `AlgoAmount` objects in comparison operations such as `<` and `>=` etc. - -You can also call `str(amount)` or use an `AlgoAmount` directly in string interpolation to convert it to a nice user-facing formatted amount expressed in microAlgo. - -### Additional Features - -The `AlgoAmount` class supports arithmetic operations: - -- Addition: `amount1 + amount2` -- Subtraction: `amount1 - amount2` -- Comparison operations: `<`, `<=`, `>`, `>=`, `==`, `!=` - -Example: - -```python -amount1 = AlgoAmount(algo=1) -amount2 = AlgoAmount(micro_algo=500_000) -total = amount1 + amount2 # Results in 1.5 Algo -``` diff --git a/docs/source/capabilities/app-client.md b/docs/source/capabilities/app-client.md deleted file mode 100644 index 3e4dac6d..00000000 --- a/docs/source/capabilities/app-client.md +++ /dev/null @@ -1,356 +0,0 @@ -# App client and App factory - -> [!NOTE] -> This page covers the untyped app client, but we recommend using typed clients (coming soon), which will give you a better developer experience with strong typing specific to the app itself. - -App client and App factory are higher-order use case capabilities provided by AlgoKit Utils that builds on top of the core capabilities, particularly [App deployment](./app-deploy.md) and [App management](./app.md). They allow you to access high productivity application clients that work with [ARC-56](https://github.com/algorandfoundation/ARCs/pull/258) and [ARC-32](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0032.md) application spec defined smart contracts, which you can use to create, update, delete, deploy and call a smart contract and access state data for it. - -> [!NOTE] -> If you are confused about when to use the factory vs client the mental model is: use the client if you know the app ID, use the factory if you don't know the app ID (deferred knowledge or the instance doesn't exist yet on the blockchain) or you have multiple app IDs - -## `AppFactory` - -The `AppFactory` is a class that, for a given app spec, allows you to create and deploy one or more app instances and to create one or more app clients to interact with those (or other) app instances. - -To get an instance of `AppFactory` you can use `AlgorandClient` via `algorand.get_app_factory`: - -```python -# Minimal example -factory = algorand.get_app_factory( - app_spec="{/* ARC-56 or ARC-32 compatible JSON */}", -) - -# Advanced example -factory = algorand.get_app_factory( - app_spec=parsed_arc32_or_arc56_app_spec, - default_sender="SENDERADDRESS", - app_name="OverriddenAppName", - version="2.0.0", - compilation_params={ - "updatable": True, - "deletable": False, - "deploy_time_params": { "ONE": 1, "TWO": "value" }, - } -) -``` - -## `AppClient` - -The `AppClient` is a class that, for a given app spec, allows you to manage calls and state for a specific deployed instance of an app (with a known app ID). - -To get an instance of `AppClient` you can use either `AlgorandClient` or instantiate it directly: - -```python -# Minimal examples -app_client = AppClient.from_creator_and_name( - app_spec="{/* ARC-56 or ARC-32 compatible JSON */}", - creator_address="CREATORADDRESS", - algorand=algorand, -) - -app_client = AppClient( - AppClientParams( - app_spec="{/* ARC-56 or ARC-32 compatible JSON */}", - app_id=12345, - algorand=algorand, - ) -) - -app_client = AppClient.from_network( - app_spec="{/* ARC-56 or ARC-32 compatible JSON */}", - algorand=algorand, -) - -# Advanced example -app_client = AppClient( - AppClientParams( - app_spec=parsed_app_spec, - app_id=12345, - algorand=algorand, - app_name="OverriddenAppName", - default_sender="SENDERADDRESS", - approval_source_map=approval_teal_source_map, - clear_source_map=clear_teal_source_map, - ) -) -``` - -You can access `app_id`, `app_address`, `app_name` and `app_spec` as properties on the `AppClient`. - -## Dynamically creating clients for a given app spec - -The `AppFactory` allows you to conveniently create multiple `AppClient` instances on-the-fly with information pre-populated. - -This is possible via two methods on the app factory: - -- `factory.get_app_client_by_id(app_id, ...)` - Returns a new `AppClient` for an app instance of the given ID. Automatically populates app_name, default_sender and source maps from the factory if not specified. -- `factory.get_app_client_by_creator_and_name(creator_address, app_name, ...)` - Returns a new `AppClient`, resolving the app by creator address and name using AlgoKit app deployment semantics. Automatically populates app_name, default_sender and source maps from the factory if not specified. - -```python -app_client1 = factory.get_app_client_by_id(app_id=12345) -app_client2 = factory.get_app_client_by_id(app_id=12346) -app_client3 = factory.get_app_client_by_id( - app_id=12345, - default_sender="SENDER2ADDRESS" -) - -app_client4 = factory.get_app_client_by_creator_and_name( - creator_address="CREATORADDRESS" -) -app_client5 = factory.get_app_client_by_creator_and_name( - creator_address="CREATORADDRESS", - app_name="NonDefaultAppName" -) -app_client6 = factory.get_app_client_by_creator_and_name( - creator_address="CREATORADDRESS", - app_name="NonDefaultAppName", - ignore_cache=True, # Perform fresh indexer lookups - default_sender="SENDER2ADDRESS" -) -``` - -## Creating and deploying an app - -Once you have an app factory you can perform the following actions: - -- `factory.send.bare.create(...)` - Signs and sends a transaction to create an app and returns the result of that call and an `AppClient` instance for the created app -- `factory.deploy(...)` - Uses the creator address and app name pattern to find if the app has already been deployed or not and either creates, updates or replaces that app based on the deployment rules (i.e. it's an idempotent deployment) and returns the result of the deployment and an `AppClient` instance for the created/updated/existing app. - -> See {py:func}`API docs ` for details on parameter signatures. - -### Create - -The create method is a wrapper over the `app_create` (bare calls) and `app_create_method_call` (ABI method calls) methods, with the following differences: - -- You don't need to specify the `approval_program`, `clear_state_program`, or `schema` because these are all specified or calculated from the app spec -- `sender` is optional and if not specified then the `default_sender` from the `AppFactory` constructor is used -- `deploy_time_params`, `updatable` and `deletable` can be passed in to control deploy-time parameter replacements and deploy-time immutability and permanence control. Note these are consolidated under the `compilation_params` `TypedDict`, see {py:func}`API docs ` for details. - -```python -# Use no-argument bare-call -result, app_client = factory.send.bare.create() - -# Specify parameters for bare-call and override other parameters -result, app_client = factory.send.bare.create( - params=AppClientBareCallParams( - args=[bytes([1, 2, 3, 4])], - static_fee=AlgoAmount.from_microalgos(3000), - on_complete=OnComplete.OptIn, - ), - compilation_params={ - "deploy_time_params": { - "ONE": 1, - "TWO": "two", - }, - "updatable": True, - "deletable": False, - } -) - -# Specify parameters for ABI method call -result, app_client = factory.send.create( - AppClientMethodCallParams( - method="create_application", - args=[1, "something"] - ) -) -``` - -## Updating and deleting an app - -Deploy method aside, the ability to make update and delete calls happens after there is an instance of an app created via `AppClient`. The semantics of this are no different than other calls, with the caveat that the update call is a bit different since the code will be compiled when constructing the update params and the update calls thus optionally takes compilation parameters (`compilation_params`) for deploy-time parameter replacements and deploy-time immutability and permanence control. - -## Calling the app - -You can construct a params object, transaction(s) and sign and send a transaction to call the app that a given `AppClient` instance is pointing to. - -This is done via the following properties: - -- `app_client.params.{method}(params)` - Params for an ABI method call -- `app_client.params.bare.{method}(params)` - Params for a bare call -- `app_client.create_transaction.{method}(params)` - Transaction(s) for an ABI method call -- `app_client.create_transaction.bare.{method}(params)` - Transaction for a bare call -- `app_client.send.{method}(params)` - Sign and send an ABI method call -- `app_client.send.bare.{method}(params)` - Sign and send a bare call - -Where `{method}` is one of: - -- `update` - An update call -- `opt_in` - An opt-in call -- `delete` - A delete application call -- `clear_state` - A clear state call (note: calls the clear program and only applies to bare calls) -- `close_out` - A close-out call -- `call` - A no-op call (or other call if `on_complete` is specified to anything other than update) - -```python -call1 = app_client.send.update( - AppClientMethodCallParams( - method="update_abi", - args=["string_io"], - ), - compilation_params={"deploy_time_params": deploy_time_params} -) - -call2 = app_client.send.delete( - AppClientMethodCallParams( - method="delete_abi", - args=["string_io"] - ) -) - -call3 = app_client.send.opt_in( - AppClientMethodCallParams(method="opt_in") -) - -call4 = app_client.send.bare.clear_state() - -transaction = app_client.create_transaction.bare.close_out( - AppClientBareCallParams( - args=[bytes([1, 2, 3])] - ) -) - -params = app_client.params.opt_in( - AppClientMethodCallParams(method="optin") -) -``` - -## Funding the app account - -Often there is a need to fund an app account to cover minimum balance requirements for boxes and other scenarios. There is an app client method that will do this for you via `fund_app_account(params)`. - -The input parameters are: - -- A `FundAppAccountParams` object, which has the same properties as a payment transaction except `receiver` is not required and `sender` is optional (if not specified then it will be set to the app client's default sender if configured). - -Note: If you are passing the funding payment in as an ABI argument so it can be validated by the ABI method then you'll want to get the funding call as a transaction, e.g.: - -```python -result = app_client.send.call( - AppClientMethodCallParams( - method="bootstrap", - args=[ - app_client.create_transaction.fund_app_account( - FundAppAccountParams( - amount=AlgoAmount.from_microalgos(200_000) - ) - ) - ], - box_references=["Box1"] - ) -) -``` - -You can also get the funding call as a params object via `app_client.params.fund_app_account(params)`. - -## Reading state - -`AppClient` has a number of mechanisms to read state (global, local and box storage) from the app instance. - -### App spec methods - -The ARC-56 app spec can specify detailed information about the encoding format of state values and as such allows for a more advanced ability to automatically read state values and decode them as their high-level language types rather than the limited `int` / `bytes` / `str` ability that the generic methods give you. - -You can access this functionality via: - -- `app_client.state.global_state.{method}()` - Global state -- `app_client.state.local_state(address).{method}()` - Local state -- `app_client.state.box.{method}()` - Box storage - -Where `{method}` is one of: - -- `get_all()` - Returns all single-key state values in a dict keyed by the key name and the value a decoded ABI value. -- `get_value(name)` - Returns a single state value for the current app with the value a decoded ABI value. -- `get_map_value(map_name, key)` - Returns a single value from the given map for the current app with the value a decoded ABI value. Key can either be bytes with the binary value of the key value on-chain (without the map prefix) or the high level (decoded) value that will be encoded to bytes for the app spec specified `key_type` -- `get_map(map_name)` - Returns all map values for the given map in a key=>value dict. It's recommended that this is only done when you have a unique `prefix` for the map otherwise there's a high risk that incorrect values will be included in the map. - -```python -values = app_client.state.global_state.get_all() -value = app_client.state.local_state("ADDRESS").get_value("value1") -map_value = app_client.state.box.get_map_value("map1", "mapKey") -map_dict = app_client.state.global_state.get_map("myMap") -``` - -### Generic methods - -There are various methods defined that let you read state from the smart contract app: - -- `get_global_state()` - Gets the current global state using {py:func}`algorand.app.get_global_state `. -- `get_local_state(address: str)` - Gets the current local state for the given account address using {py:func}`algorand.app.get_local_state `. -- `get_box_names()` - Gets the current box names using {py:func}`algorand.app.get_box_names `. -- `get_box_value(name)` - Gets the current value of the given box using {py:func}`algorand.app.get_box_value `. -- `get_box_value_from_abi_type(name)` - Gets the current value of the given box from an ABI type using {py:func}`algorand.app.get_box_value_from_abi_type `. -- `get_box_values(filter)` - Gets the current values of the boxes using {py:func}`algorand.app.get_box_values `. -- `get_box_values_from_abi_type(type, filter)` - Gets the current values of the boxes from an ABI type using {py:func}`algorand.app.get_box_values_from_abi_type `. - -```python -global_state = app_client.get_global_state() -local_state = app_client.get_local_state("ACCOUNTADDRESS") - -box_name: BoxReference = BoxReference(app_id=app_client.app_id, name="my-box") -box_name2: BoxReference = BoxReference(app_id=app_client.app_id, name="my-box2") - -box_names = app_client.get_box_names() -box_value = app_client.get_box_value(box_name) -box_values = app_client.get_box_values([box_name, box_name2]) -box_abi_value = app_client.get_box_value_from_abi_type( - box_name, - algosdk.ABIStringType -) -box_abi_values = app_client.get_box_values_from_abi_type( - [box_name, box_name2], - algosdk.ABIStringType -) -``` - -## Handling logic errors and diagnosing errors - -Often when calling a smart contract during development you will get logic errors that cause an exception to throw. This may be because of a failing assertion, a lack of fees, exhaustion of opcode budget, or any number of other reasons. - -When this occurs, you will generally get an error that looks something like: `TransactionPool.Remember: transaction {TRANSACTION_ID}: logic eval error: {ERROR_MESSAGE}. Details: pc={PROGRAM_COUNTER_VALUE}, opcodes={LIST_OF_OP_CODES}`. - -The information in that error message can be parsed and when combined with the [source map from compilation](./app-deploy.md#compilation-and-template-substitution) you can expose debugging information that makes it much easier to understand what's happening. The ARC-56 app spec, if provided, can also specify human-readable error messages against certain program counter values and further augment the error message. - -The app client and app factory automatically provide this functionality for all smart contract calls through an automatically registered error transformer. This error transformer: - -- Parses logic errors from blockchain responses -- Applies source map information when available to provide line numbers and context -- Filters errors to only handle those relevant to the specific application -- For new applications (app_id=0), compares program bytecode to ensure error handling is applied to the correct application instance - -They also expose a function that can be used for any custom calls you manually construct and need to add into your own try/catch `expose_logic_error(e: Error, is_clear: bool = False)`. - -For more information about error transformers and how to create custom ones, see the [Transaction Composer Error Transformers](./transaction-composer.md#error-transformers) documentation. - -When an error is thrown then the resulting error that is re-thrown will be a {py:obj}`LogicError `, which has the following fields: - -- `logic_error: Exception` - The original logic error exception -- `logic_error_str: str` - The string representation of the logic error -- `program: str` - The TEAL program source code -- `source_map: AlgoSourceMap | None` - The source map if available -- `transaction_id: str` - The transaction ID that triggered the error -- `message: str` - Combined error message with debugging information -- `pc: int` - The program counter value where error occurred -- `traces: list[SimulationTrace] | None` - Simulation traces if debug enabled -- `line_no: int | None` - The line number in the TEAL source code -- `lines: list[str]` - The TEAL program split into individual lines - -Note: This information will only show if the app client / app factory has a source map. This will occur if: - -- You have called `create`, `update` or `deploy` -- You have called `import_source_maps(source_maps)` and provided the source maps (which you can get by calling `export_source_maps()` after variously calling `create`, `update`, or `deploy` and it returns a serialisable value) -- You had source maps present in an app factory and then used it to [create an app client](#dynamically-creating-clients-for-a-given-app-spec) (they are automatically passed through) - -If you want to go a step further and automatically issue a [simulated transaction](https://algorand.github.io/js-algorand-sdk/classes/modelsv2.SimulateTransactionResult.html) and get trace information when there is an error when an ABI method is called you can turn on debug mode: - -```python -config.configure(debug=True) -``` - -If you do that then the exception will have the `traces` property within the underlying exception will have key information from the simulation within it and this will get populated into the `led.traces` property of the thrown error. - -When this debug flag is set, it will also emit debugging symbols to allow break-point debugging of the calls if the [project root is also configured](./debugging.md). - -## Default arguments - -If an ABI method call specifies default argument values for any of its arguments you can pass in `None` for the value of that argument for the default value to be automatically populated. diff --git a/docs/source/capabilities/app.md b/docs/source/capabilities/app.md deleted file mode 100644 index 55d30b17..00000000 --- a/docs/source/capabilities/app.md +++ /dev/null @@ -1,163 +0,0 @@ -# App management - -App management is a higher-order use case capability provided by AlgoKit Utils that builds on top of the core capabilities. It allows you to create, update, delete, call (ABI and otherwise) smart contract apps and the metadata associated with them (including state and boxes). - -## `AppManager` - -The `AppManager` is a class that is used to manage app information. To get an instance of `AppManager` you can use either [`AlgorandClient`](./algorand-client.md) via `algorand.app` or instantiate it directly (passing in an algod client instance): - -```python -from algokit_utils import AppManager - -app_manager = AppManager(algod_client) -``` - -## Calling apps - -### App Clients - -The recommended way of interacting with apps is via [App clients](./app-client.md) and [App factory](./app-client.md#appfactory). The methods shown on this page are the underlying mechanisms that app clients use and are for advanced use cases when you want more control. - -### Compilation - -The `AppManager` class allows you to compile TEAL code with caching semantics that allows you to avoid duplicate compilation and keep track of source maps from compiled code. - -```python -# Basic compilation -teal_code = "return 1" -compilation_result = app_manager.compile_teal(teal_code) - -# Get cached compilation result -cached_result = app_manager.get_compilation_result(teal_code) - -# Compile with template substitution -template_code = "int TMPL_VALUE" -template_params = {"VALUE": 1} -compilation_result = app_manager.compile_teal_template( - template_code, - template_params=template_params -) - -# Compile with deployment control (updatable/deletable) -control_template = f"""#pragma version 8 -int {UPDATABLE_TEMPLATE_NAME} -int {DELETABLE_TEMPLATE_NAME}""" -deployment_metadata = {"updatable": True, "deletable": True} -compilation_result = app_manager.compile_teal_template( - control_template, - deployment_metadata=deployment_metadata -) -``` - -The compilation result contains: - -- `teal` - Original TEAL code -- `compiled` - Base64 encoded compiled bytecode -- `compiled_hash` - Hash of compiled bytecode -- `compiled_base64_to_bytes` - Raw bytes of compiled bytecode -- `source_map` - Source map for debugging - -## Accessing state - -### Global state - -To access global state you can use: - -```python -# Get global state for app -global_state = app_manager.get_global_state(app_id) - -# Parse raw state from algod -decoded_state = AppManager.decode_app_state(raw_state) - -# Access state values -key_raw = decoded_state["value1"].key_raw # Raw bytes -key_base64 = decoded_state["value1"].key_base64 # Base64 encoded -value = decoded_state["value1"].value # Parsed value (str or int) -value_raw = decoded_state["value1"].value_raw # Raw bytes if bytes value -value_base64 = decoded_state["value1"].value_base64 # Base64 if bytes value -``` - -### Local state - -To access local state you can use: - -```python -local_state = app_manager.get_local_state(app_id, "ACCOUNT_ADDRESS") -``` - -### Boxes - -To access box storage: - -```python -# Get box names -box_names = app_manager.get_box_names(app_id) - -# Get box values -box_value = app_manager.get_box_value(app_id, box_name) -box_values = app_manager.get_box_values(app_id, [box_name1, box_name2]) - -# Get decoded ABI values -abi_value = app_manager.get_box_value_from_abi_type( - app_id, box_name, algosdk.abi.StringType() -) -abi_values = app_manager.get_box_values_from_abi_type( - app_id, [box_name1, box_name2], algosdk.abi.StringType() -) - -# Get box reference for transaction -box_ref = AppManager.get_box_reference(box_id) -``` - -## Getting app information - -To get app information: - -```python -# Get app info by ID -app_info = app_manager.get_by_id(app_id) - -# Get ABI return value from transaction -abi_return = AppManager.get_abi_return(confirmation, abi_method) -``` - -## Box references - -Box references can be specified in several ways: - -```python -# String name (encoded to bytes) -box_ref = "my_box" - -# Raw bytes -box_ref = b"my_box" - -# Account signer (uses address as name) -box_ref = account_signer - -# Box reference with app ID -box_ref = BoxReference(app_id=123, name=b"my_box") -``` - -## Common app parameters - -When interacting with apps (creating, updating, deleting, calling), there are common parameters that can be passed: - -- `app_id` - ID of the application -- `sender` - Address of transaction sender -- `signer` - Transaction signer (optional) -- `args` - Arguments to pass to the smart contract -- `account_references` - Account addresses to reference -- `app_references` - App IDs to reference -- `asset_references` - Asset IDs to reference -- `box_references` - Box references to load -- `on_complete` - On complete action -- Other common transaction parameters like `note`, `lease`, etc. - -For ABI method calls, additional parameters: - -- `method` - The ABI method to call -- `args` - ABI typed arguments to pass - -See [App client](./app-client.md) for more details on constructing app calls. diff --git a/docs/source/capabilities/asset.md b/docs/source/capabilities/asset.md deleted file mode 100644 index 731af016..00000000 --- a/docs/source/capabilities/asset.md +++ /dev/null @@ -1,134 +0,0 @@ -# Assets - -The Algorand Standard Asset (ASA) management functions include creating, opting in and transferring assets, which are fundamental to asset interaction in a blockchain environment. - -## `AssetManager` - -The `AssetManager` class provides functionality for managing Algorand Standard Assets (ASAs). It can be accessed through the `AlgorandClient` via `algorand.asset` or instantiated directly: - -```python -from algokit_utils import AssetManager, TransactionComposer -from algosdk.v2client import algod - -asset_manager = AssetManager( - algod_client=algod_client, - new_group=lambda: TransactionComposer() -) -``` - -## Asset Information - -The `AssetManager` provides two key data classes for asset information: - -### `AssetInformation` - -Contains details about an Algorand Standard Asset (ASA): - -```python -@dataclass -class AssetInformation: - asset_id: int # The ID of the asset - creator: str # Address of the creator account - total: int # Total units created - decimals: int # Number of decimal places - default_frozen: bool | None = None # Whether asset is frozen by default - manager: str | None = None # Optional manager address - reserve: str | None = None # Optional reserve address - freeze: str | None = None # Optional freeze address - clawback: str | None = None # Optional clawback address - unit_name: str | None = None # Optional unit name (e.g. ticker) - asset_name: str | None = None # Optional asset name - url: str | None = None # Optional URL for more info - metadata_hash: bytes | None = None # Optional 32-byte metadata hash -``` - -### `AccountAssetInformation` - -Contains information about an account's holding of a particular asset: - -```python -@dataclass -class AccountAssetInformation: - asset_id: int # The ID of the asset - balance: int # Amount held by the account - frozen: bool # Whether frozen for this account - round: int # Round this info was retrieved at -``` - -## Bulk Operations - -The `AssetManager` provides methods for bulk opt-in/opt-out operations: - -### Bulk Opt-In - -```python -# Basic example -result = asset_manager.bulk_opt_in( - account="ACCOUNT_ADDRESS", - asset_ids=[12345, 67890] -) - -# Advanced example with optional parameters -result = asset_manager.bulk_opt_in( - account="ACCOUNT_ADDRESS", - asset_ids=[12345, 67890], - signer=transaction_signer, - note=b"opt-in note", - lease=b"lease", - static_fee=AlgoAmount(1000), - extra_fee=AlgoAmount(500), - max_fee=AlgoAmount(2000), - validity_window=10, - send_params=SendParams(...) -) -``` - -### Bulk Opt-Out - -```python -# Basic example -result = asset_manager.bulk_opt_out( - account="ACCOUNT_ADDRESS", - asset_ids=[12345, 67890] -) - -# Advanced example with optional parameters -result = asset_manager.bulk_opt_out( - account="ACCOUNT_ADDRESS", - asset_ids=[12345, 67890], - ensure_zero_balance=True, - signer=transaction_signer, - note=b"opt-out note", - lease=b"lease", - static_fee=AlgoAmount(1000), - extra_fee=AlgoAmount(500), - max_fee=AlgoAmount(2000), - validity_window=10, - send_params=SendParams(...) -) -``` - -The bulk operations return a list of `BulkAssetOptInOutResult` objects containing: - -- `asset_id`: The ID of the asset opted into/out of -- `transaction_id`: The transaction ID of the opt-in/out - -## Get Asset Information - -### Getting Asset Parameters - -You can get the current parameters of an asset from algod using `get_by_id()`: - -```python -asset_info = asset_manager.get_by_id(12345) -``` - -### Getting Account Holdings - -You can get an account's current holdings of an asset using `get_account_information()`: - -```python -address = "XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA" -asset_id = 12345 -account_info = asset_manager.get_account_information(address, asset_id) -``` diff --git a/docs/source/capabilities/client.md b/docs/source/capabilities/client.md deleted file mode 100644 index d1f98af8..00000000 --- a/docs/source/capabilities/client.md +++ /dev/null @@ -1,111 +0,0 @@ -# Client management - -Client management is one of the core capabilities provided by AlgoKit Utils. It allows you to create (auto-retry) [algod](https://dev.algorand.co/reference/rest-apis/algod), [indexer](https://dev.algorand.co/reference/rest-apis/indexer) and [kmd](https://dev.algorand.co/reference/rest-apis/kmd) clients against various networks resolved from environment or specified configuration. - -Any AlgoKit Utils function that needs one of these clients will take the underlying algosdk classes (`algosdk.v2client.algod.AlgodClient`, `algosdk.v2client.indexer.IndexerClient`, `algosdk.kmd.KMDClient`) so inline with the [Modularity](../index.md#core-principles) principle you can use existing logic to get instances of these clients without needing to use the Client management capability if you prefer. - -To see some usage examples check out the [automated tests](https://github.com/algorandfoundation/algokit-utils-py/blob/main/tests/test_network_clients.py). - -## `ClientManager` - -The `ClientManager` is a class that is used to manage client instances. - -To get an instance of `ClientManager` you can instantiate it directly: - -```python -from algokit_utils import ClientManager, AlgoSdkClients, AlgoClientConfigs -from algosdk.v2client.algod import AlgodClient - -# Using AlgoSdkClients -algod_client = AlgodClient(...) -algorand_client = ... # Get AlgorandClient instance from somewhere -clients = AlgoSdkClients(algod=algod_client, indexer=indexer_client, kmd=kmd_client) -client_manager = ClientManager(clients, algorand_client) - -# Using AlgoClientConfigs -algod_config = AlgoClientNetworkConfig(server="https://...", token="") -configs = AlgoClientConfigs(algod_config=algod_config) -client_manager = ClientManager(configs, algorand_client) -``` - -## Network configuration - -The network configuration is specified using the `AlgoClientConfig` type. This same type is used to specify the config for `algod`, `indexer`, and `kmd` [SDK clients](https://github.com/algorand/py-algorand-sdk). - -There are a number of ways to produce one of these configuration objects: - -- Manually specifying a dataclass, e.g. - - ```python - from algokit_utils import AlgoClientNetworkConfig - - config = AlgoClientNetworkConfig( - server="https://myalgodnode.com", - token="SECRET_TOKEN" # optional - ) - ``` - -- `ClientManager.get_config_from_environment_or_localnet()` - Loads the Algod client config, the Indexer client config and the Kmd config from well-known environment variables or if not found then default LocalNet; this is useful to have code that can work across multiple blockchain environments (including LocalNet), without having to change -- `ClientManager.get_algod_config_from_environment()` - Loads an Algod client config from well-known environment variables -- `ClientManager.get_indexer_config_from_environment()` - Loads an Indexer client config from well-known environment variables; useful to have code that can work across multiple blockchain environments (including LocalNet), without having to change -- `ClientManager.get_algonode_config(network)` - Loads an Algod or indexer config against [AlgoNode free tier](https://nodely.io/docs/free/start) to either MainNet or TestNet -- `ClientManager.get_default_localnet_config()` - Loads an Algod, Indexer or Kmd config against [LocalNet](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/localnet.md) using the default configuration - -## Clients - -### Creating an SDK client instance - -Once you have the configuration for a client, to get a new client you can use the following functions: - -- `ClientManager.get_algod_client(config)` - Returns an Algod client for the given configuration; the client automatically retries on transient HTTP errors -- `ClientManager.get_indexer_client(config)` - Returns an Indexer client for given configuration -- `ClientManager.get_kmd_client(config)` - Returns a Kmd client for the given configuration - -You can also shortcut needing to write the likes of `ClientManager.get_algod_client(ClientManager.get_algod_config_from_environment())` with environment shortcut methods: - -- `ClientManager.get_algod_client_from_environment()` - Returns an Algod client by loading the config from environment variables -- `ClientManager.get_indexer_client_from_environment()` - Returns an indexer client by loading the config from environment variables -- `ClientManager.get_kmd_client_from_environment()` - Returns a kmd client by loading the config from environment variables - -### Accessing SDK clients via ClientManager instance - -Once you have a `ClientManager` instance, you can access the SDK clients: - -```python -client_manager = ClientManager(algod=algod_client, indexer=indexer_client, kmd=kmd_client) - -algod_client = client_manager.algod -indexer_client = client_manager.indexer -kmd_client = client_manager.kmd -``` - -If the method to create the `ClientManager` doesn't configure indexer or kmd (both of which are optional), then accessing those clients will trigger an error. - -### Creating a TestNet dispenser API client instance - -You can also create a [TestNet dispenser API client instance](./dispenser-client.md) from `ClientManager` too. - -## Automatic retry - -When receiving an Algod or Indexer client from AlgoKit Utils, it will be a special wrapper client that handles retrying transient failures. - -## Network information - -You can get information about the current network you are connected to: - -```python -# Get network information -network = client_manager.network() -print(f"Is mainnet: {network.is_mainnet}") -print(f"Is testnet: {network.is_testnet}") -print(f"Is localnet: {network.is_localnet}") -print(f"Genesis ID: {network.genesis_id}") -print(f"Genesis hash: {network.genesis_hash}") - -# Convenience methods -is_mainnet = client_manager.is_mainnet() -is_testnet = client_manager.is_testnet() -is_localnet = client_manager.is_localnet() -``` - -The first time `network()` is called it will make a HTTP call to algod to get the network parameters, but from then on it will be cached within that `ClientManager` instance for subsequent calls. diff --git a/docs/source/capabilities/debugging.md b/docs/source/capabilities/debugging.md deleted file mode 100644 index 996cee6b..00000000 --- a/docs/source/capabilities/debugging.md +++ /dev/null @@ -1,93 +0,0 @@ -# Debugger - -The AlgoKit Python Utilities package provides a set of debugging tools that can be used to simulate and trace transactions on the Algorand blockchain. These tools and methods are optimized for developers who are building applications on Algorand and need to test and debug their smart contracts via [AlgoKit AVM Debugger extension](https://marketplace.visualstudio.com/items?itemName=algorandfoundation.algokit-avm-vscode-debugger). - -## Configuration - -The `config.py` file contains the `UpdatableConfig` class which manages and updates configuration settings for the AlgoKit project. - -- `debug`: Indicates whether debug mode is enabled. -- `project_root`: The path to the project root directory. Can be ignored if you are using `algokit_utils` inside an `algokit` compliant project (containing `.algokit.toml` file). For non algokit compliant projects, simply provide the path to the folder where you want to store sourcemaps and traces to be used with [`AlgoKit AVM Debugger`](https://github.com/algorandfoundation/algokit-avm-vscode-debugger). Alternatively you can also set the value via the `ALGOKIT_PROJECT_ROOT` environment variable. -- `trace_all`: Indicates whether to trace all operations. Defaults to false, this means that when debug mode is enabled, any (or all) application client calls performed via `algokit_utils` will store responses from `simulate` endpoint. These files are called traces, and can be used with `AlgoKit AVM Debugger` to debug TEAL source codes, transactions in the atomic group and etc. -- `trace_buffer_size_mb`: The size of the trace buffer in megabytes. By default uses 256 megabytes. When output folder containing debug trace files exceedes the size, oldest files are removed to optimize for storage consumption. -- `max_search_depth`: The maximum depth to search for a an `algokit` config file. By default it will traverse at most 10 folders searching for `.algokit.toml` file which will be used to assume algokit compliant project root path. -- `populate_app_call_resources`: Indicates whether to populate app call resources. Defaults to false, which means that when debug mode is enabled, any (or all) application client calls performed via `algokit_utils` will not populate app call resources. -- `logger`: A custom logger to use. Defaults to {py:class}`algokit_utils.config.AlgoKitLogger` instance. - -The `configure` method can be used to set these attributes. - -To enable debug mode in your project you can configure it as follows: - -```python -from algokit_utils.config import config - -config.configure( - debug=True, - project_root=Path("./my-project"), - trace_all=True, - trace_buffer_size_mb=512, - max_search_depth=15, - populate_app_call_resources=True, -) -``` - -## `AlgoKitLogger` - -The `AlgoKitLogger` is a custom logger that is used to log messages in the AlgoKit project. -It is a subclass of the `logging.Logger` class and extends it to provide additional functionality. - -### Suppressing log messages per log call - -To supress log messages for individual log calls you can pass `'suppress_log':True` to the log call's `extra` argument. - -### Suppressing log messages globally - -To supress log messages globally you can configure the config object to use a custom logger that does not log anything. - -```python -config.configure(logger=AlgoKitLogger.get_null_logger()) -``` - -## Debugging Utilities - -When debug mode is enabled, AlgoKit Utils will automatically: - -- Generate transaction traces compatible with the AVM Debugger -- Manage trace file storage with automatic cleanup -- Provide source map generation for TEAL contracts - -The following methods are provided for manual debugging operations: - -- `persist_sourcemaps`: Persists sourcemaps for given TEAL contracts as AVM Debugger-compliant artifacts. Parameters: - - - `sources`: List of TEAL sources to generate sourcemaps for - - `project_root`: Project root directory for storage - - `client`: AlgodClient instance - - `with_sources`: Whether to include TEAL source files (default: True) - -- `simulate_and_persist_response`: Simulates transactions and persists debug traces. Parameters: - - `atc`: AtomicTransactionComposer containing transactions - - `project_root`: Project root directory for storage - - `algod_client`: AlgodClient instance - - `buffer_size_mb`: Maximum trace storage in MB (default: 256) - - `allow_empty_signatures`: Allow unsigned transactions (default: True) - - `allow_unnamed_resources`: Allow unnamed resources (default: True) - - `extra_opcode_budget`: Additional opcode budget - - `exec_trace_config`: Custom trace configuration - - `simulation_round`: Specific round to simulate - -### Trace filename format - -The trace files are named in a specific format to provide useful information about the transactions they contain. The format is as follows: - -``` -${timestamp}_lr${last_round}_${transaction_types}.trace.avm.json -``` - -Where: - -- `timestamp`: The time when the trace file was created, in ISO 8601 format, with colons and periods removed. -- `last_round`: The last round when the simulation was performed. -- `transaction_types`: A string representing the types and counts of transactions in the atomic group. Each transaction type is represented as `${count}${type}`, and different transaction types are separated by underscores. - -For example, a trace file might be named `20220301T123456Z_lr1000_2pay_1axfer.trace.avm.json`, indicating that the trace file was created at `2022-03-01T12:34:56Z`, the last round was `1000`, and the atomic group contained 2 payment transactions and 1 asset transfer transaction. diff --git a/docs/source/capabilities/testing.md b/docs/source/capabilities/testing.md deleted file mode 100644 index bdc6ff7a..00000000 --- a/docs/source/capabilities/testing.md +++ /dev/null @@ -1,204 +0,0 @@ -# Testing - -The following is a collection of useful snippets that can help you get started with testing your Algorand applications using AlgoKit utils. For the sake of simplicity, we'll use [pytest](https://docs.pytest.org/en/latest/) in the examples below. - -## Basic Test Setup - -Here's a basic test setup using pytest fixtures that provides common testing utilities: - -```python -import pytest -from algokit_utils import Account, SigningAccount -from algokit_utils.algorand import AlgorandClient -from algokit_utils.models.amount import AlgoAmount - -@pytest.fixture -def algorand() -> AlgorandClient: - """Get an AlgorandClient instance configured for LocalNet""" - return AlgorandClient.default_localnet() - -@pytest.fixture -def funded_account(algorand: AlgorandClient) -> SigningAccount: - """Create and fund a test account with ALGOs""" - new_account = algorand.account.random() - dispenser = algorand.account.localnet_dispenser() - algorand.account.ensure_funded( - new_account, - dispenser, - min_spending_balance=AlgoAmount.from_algos(100), - min_funding_increment=AlgoAmount.from_algos(1) - ) - algorand.set_signer(sender=new_account.address, signer=new_account.signer) - return new_account -``` - -Refer to [pytest fixture scopes](https://docs.pytest.org/en/latest/how-to/fixtures.html#fixture-scopes) for more information on how to control lifecycle of fixtures. - -## Creating Test Assets - -Here's a helper function to create test ASAs (Algorand Standard Assets): - -```python -def generate_test_asset(algorand: AlgorandClient, sender: Account, total: int | None = None) -> int: - """Create a test asset and return its ID""" - if total is None: - total = random.randint(20, 120) - - create_result = algorand.send.asset_create( - AssetCreateParams( - sender=sender.address, - total=total, - decimals=0, - default_frozen=False, - unit_name="TST", - asset_name=f"Test Asset {random.randint(1,100)}", - url="https://example.com", - manager=sender.address, - reserve=sender.address, - freeze=sender.address, - clawback=sender.address, - ) - ) - - return int(create_result.confirmation["asset-index"]) -``` - -## Testing Application Deployments - -Here's how one can test smart contract application deployments: - -```python -def test_app_deployment(algorand: AlgorandClient, funded_account: SigningAccount): - """Test deploying a smart contract application""" - - # Load the application spec - app_spec = Path("artifacts/application.json").read_text() - - # Create app factory - factory = algorand.client.get_app_factory( - app_spec=app_spec, - default_sender=funded_account.address - ) - - # Deploy the app - app_client, deploy_response = factory.deploy( - compilation_params={ - "deletable": True, - "updatable": True, - "deploy_time_params": {"VERSION": 1}, - }, - ) - - # Verify deployment - assert deploy_response.app.app_id > 0 - assert deploy_response.app.app_address -``` - -## Testing Asset Transfers - -Here's how one can test ASA transfers between accounts: - -```python -def test_asset_transfer(algorand: AlgorandClient, funded_account: SigningAccount): - """Test ASA transfers between accounts""" - - # Create receiver account - receiver = algorand.account.random() - algorand.account.ensure_funded( - account_to_fund=receiver, - dispenser_account=funded_account, - min_spending_balance=AlgoAmount.from_algos(1) - ) - - # Create test asset - asset_id = generate_test_asset(algorand, funded_account, 100) - - # Opt receiver into asset - algorand.send.asset_opt_in( - AssetOptInParams( - sender=receiver.address, - asset_id=asset_id, - signer=receiver.signer - ) - ) - - # Transfer asset - transfer_amount = 5 - result = algorand.send.asset_transfer( - AssetTransferParams( - sender=funded_account.address, - receiver=receiver.address, - asset_id=asset_id, - amount=transfer_amount - ) - ) - - # Verify transfer - receiver_balance = algorand.asset.get_account_information(receiver, asset_id) - assert receiver_balance.balance == transfer_amount -``` - -## Testing Application Calls - -Here's how to test application method calls: - -```python -def test_app_method_call(algorand: AlgorandClient, funded_account: SigningAccount): - """Test calling ABI methods on an application""" - - # Deploy application first - app_spec = Path("artifacts/application.json").read_text() - factory = algorand.client.get_app_factory( - app_spec=app_spec, - default_sender=funded_account.address - ) - app_client, _ = factory.deploy() - - # Call application method - result = app_client.send.call( - AppClientMethodCallParams( - method="hello", - args=["world"] - ) - ) - - # Verify result - assert result.abi_return == "Hello, world" -``` - -## Testing Box Storage - -Here's how to test application box storage: - -```python -def test_box_storage(algorand: AlgorandClient, funded_account: SigningAccount): - """Test application box storage""" - - # Deploy application - app_spec = Path("artifacts/application.json").read_text() - factory = algorand.client.get_app_factory( - app_spec=app_spec, - default_sender=funded_account.address - ) - app_client, _ = factory.deploy() - - # Fund app account for box storage MBR - app_client.fund_app_account( - FundAppAccountParams(amount=AlgoAmount.from_algos(1)) - ) - - # Store value in box - box_name = b"test_box" - box_value = "test_value" - app_client.send.call( - AppClientMethodCallParams( - method="set_box", - args=[box_name, box_value], - box_references=[box_name] - ) - ) - - # Verify box value - stored_value = app_client.get_box_value(box_name) - assert stored_value == box_value.encode() -``` diff --git a/docs/source/capabilities/transaction-composer.md b/docs/source/capabilities/transaction-composer.md deleted file mode 100644 index 97f6db28..00000000 --- a/docs/source/capabilities/transaction-composer.md +++ /dev/null @@ -1,491 +0,0 @@ -# Transaction composer - -The `TransactionComposer` class allows you to easily compose one or more compliant Algorand transactions and execute and/or simulate them. - -It's the core of how the `AlgorandClient` class composes and sends transactions. - -```python -from algokit_utils import TransactionComposer, AppManager -from algokit_utils.transactions import ( - PaymentParams, - AppCallMethodCallParams, - AssetCreateParams, - AppCreateParams, - # ... other transaction parameter types -) -``` - -To get an instance of `TransactionComposer` you can either get it from an app client, from an `AlgorandClient`, or by instantiating via the constructor. - -```python -# From AlgorandClient -composer_from_algorand = algorand.new_group() - -# From AppClient -composer_from_app_client = app_client.algorand.new_group() - -# From constructor -composer_from_constructor = TransactionComposer( - algod=algod, - # Return the TransactionSigner for this address - get_signer=lambda address: signer -) - -# From constructor with optional params -composer_from_constructor = TransactionComposer( - algod=algod, - # Return the TransactionSigner for this address - get_signer=lambda address: signer, - # Custom function to get suggested params - get_suggested_params=lambda: algod.suggested_params(), - # Number of rounds the transaction should be valid for - default_validity_window=1000, - # Optional AppManager instance for TEAL compilation - app_manager=AppManager(algod) -) -``` - -## Constructing a transaction - -To construct a transaction you need to add it to the composer, passing in the relevant params object for that transaction. Params are Python dataclasses aavailable for import from `algokit_utils.transactions`. - -Parameter types include: - -- `PaymentParams` - For ALGO transfers -- `AssetCreateParams` - For creating ASAs -- `AssetConfigParams` - For reconfiguring ASAs -- `AssetTransferParams` - For ASA transfers -- `AssetOptInParams` - For opting in to ASAs -- `AssetOptOutParams` - For opting out of ASAs -- `AssetDestroyParams` - For destroying ASAs -- `AssetFreezeParams` - For freezing ASA balances -- `AppCreateParams` - For creating applications -- `AppCreateMethodCallParams` - For creating applications with ABI method calls -- `AppCallParams` - For calling applications -- `AppCallMethodCallParams` - For calling ABI methods on applications -- `AppUpdateParams` - For updating applications -- `AppUpdateMethodCallParams` - For updating applications with ABI method calls -- `AppDeleteParams` - For deleting applications -- `AppDeleteMethodCallParams` - For deleting applications with ABI method calls -- `OnlineKeyRegistrationParams` - For online key registration transactions -- `OfflineKeyRegistrationParams` - For offline key registration transactions - -The methods to construct a transaction are all named `add_{transaction_type}` and return an instance of the composer so they can be chained together fluently to construct a transaction group. - -For example: - -```python -from algokit_utils import AlgoAmount -from algokit_utils.transactions import AppCallMethodCallParams, PaymentParams - -result = ( - algorand.new_group() - .add_payment(PaymentParams( - sender="SENDER", - receiver="RECEIVER", - amount=AlgoAmount.from_micro_algos(100), - note=b"Payment note" - )) - .add_app_call_method_call(AppCallMethodCallParams( - sender="SENDER", - app_id=123, - method=abi_method, - args=[1, 2, 3], - boxes=[box_reference] # Optional box references - )) -) -``` - -## Simulating a transaction - -Transactions can be simulated using the simulate endpoint in algod, which enables evaluating the transaction on the network without it actually being committed to a block. -This is a powerful feature, which has a number of options which are detailed in the [simulate API docs](https://dev.algorand.co/reference/rest-apis/output/#simulatetransaction). - -The `simulate()` method accepts several optional parameters that are passed through to the algod simulate endpoint: - -- `allow_more_logs: bool | None` - Allow more logs than standard -- `allow_empty_signatures: bool | None` - Allow transactions without signatures -- `allow_unnamed_resources: bool | None` - Allow unnamed resources in app calls -- `extra_opcode_budget: int | None` - Additional opcode budget -- `exec_trace_config: SimulateTraceConfig | None` - Execution trace configuration -- `simulation_round: int | None` - Round to simulate at -- `skip_signatures: int | None` - Skip signature verification - -For example: - -```python -result = ( - algorand.new_group() - .add_payment(PaymentParams( - sender="SENDER", - receiver="RECEIVER", - amount=AlgoAmount.from_micro_algos(100) - )) - .add_app_call_method_call(AppCallMethodCallParams( - sender="SENDER", - app_id=123, - method=abi_method, - args=[1, 2, 3] - )) - .simulate() -) - -# Access simulation results -simulate_response = result.simulate_response -confirmations = result.confirmations -transactions = result.transactions -returns = result.returns # ABI returns if any -``` - -### Simulate without signing - -There are situations where you may not be able to (or want to) sign the transactions when executing simulate. -In these instances you should set `skip_signatures=True` which automatically builds empty transaction signers and sets both `fix-signers` and `allow-empty-signatures` to `True` when sending the algod API call. - -For example: - -```python -result = ( - algorand.new_group() - .add_payment(PaymentParams( - sender="SENDER", - receiver="RECEIVER", - amount=AlgoAmount.from_micro_algos(100) - )) - .add_app_call_method_call(AppCallMethodCallParams( - sender="SENDER", - app_id=123, - method=abi_method, - args=[1, 2, 3] - )) - .simulate( - skip_signatures=True, - allow_more_logs=True, # Optional: allow more logs - extra_opcode_budget=700 # Optional: increase opcode budget - ) -) -``` - -### Resource Population - -The `TransactionComposer` includes automatic resource population capabilities for application calls. When sending or simulating transactions, it can automatically detect and populate required references for: - -- Account references -- Application references -- Asset references -- Box references - -This happens automatically when either: - -1. The global `algokit_utils.config` instance is set to `populate_app_call_resources=True` (default is `False`) -2. The `populate_app_call_resources` parameter is explicitly passed as `True` when sending transactions - -```python -# Automatic resource population -result = ( - algorand.new_group() - .add_app_call_method_call(AppCallMethodCallParams( - sender="SENDER", - app_id=123, - method=abi_method, - args=[1, 2, 3] - # Resources will be automatically populated! - )) - .send(params=SendParams(populate_app_call_resources=True)) -) - -# Or disable automatic population -result = ( - algorand.new_group() - .add_app_call_method_call(AppCallMethodCallParams( - sender="SENDER", - app_id=123, - method=abi_method, - args=[1, 2, 3], - # Explicitly specify required resources - account_references=["ACCOUNT"], - app_references=[456], - asset_references=[789], - box_references=[box_reference] - )) - .send(params=SendParams(populate_app_call_resources=False)) -) -``` - -The resource population: - -- Respects the maximum limits (4 for accounts, 8 for foreign references) -- Handles cross-reference resources efficiently (e.g., asset holdings and local state) -- Automatically distributes resources across multiple transactions in a group when needed -- Raises descriptive errors if resource limits are exceeded - -This feature is particularly useful when: - -- Working with complex smart contracts that access various resources -- Building transaction groups where resources need to be coordinated -- Developing applications where resource requirements may change dynamically - -Note: Resource population uses simulation under the hood to detect required resources, so it may add a small overhead to transaction preparation time. - -### Covering App Call Inner Transaction Fees - -`cover_app_call_inner_transaction_fees` automatically calculate the required fee for a parent app call transaction that sends inner transactions. It leverages the simulate endpoint to discover the inner transactions sent and calculates a fee delta to resolve the optimal fee. This feature also takes care of accounting for any surplus transaction fee at the various levels, so as to effectively minimise the fees needed to successfully handle complex scenarios. This setting only applies when you have constucted at least one app call transaction. - -For example: - -```python -myMethod = algosdk.ABIMethod.fromSignature('my_method()void') -result = algorand - .new_group() - .add_app_call_method_call(AppCallMethodCallParams( - sender: 'SENDER', - app_id=123, - method=myMethod, - args=[1, 2, 3], - max_fee=AlgoAmount.from_micro_algo(5000), # NOTE: a maxFee value is required when enabling coverAppCallInnerTransactionFees - )) - .send(send_params={"cover_app_call_inner_transaction_fees": True}) -``` - -Assuming the app account is not covering any of the inner transaction fees, if `my_method` in the above example sends 2 inner transactions, then the fee calculated for the parent transaction will be 3000 µALGO when the transaction is sent to the network. - -The above example also has a `max_fee` of 5000 µALGO specified. An exception will be thrown if the transaction fee execeeds that value, which allows you to set fee limits. The `max_fee` field is required when enabling `cover_app_call_inner_transaction_fees`. - -Because `max_fee` is required and an `algosdk.Transaction` does not hold any max fee information, you cannot use the generic `add_transaction()` method on the composer with `cover_app_call_inner_transaction_fees` enabled. Instead use the below, which provides a better overall experience: - -```python -my_method = algosdk.abi.Method.from_signature('my_method()void') - -# Does not work -result = algorand - .new_group() - .add_transaction(localnet.algorand.create_transaction.app_call_method_call( - AppCallMethodCallParams( - sender='SENDER', - app_id=123, - method=my_method, - args=[1, 2, 3], - max_fee=AlgoAmount.from_micro_algos(5000), # This is only used to create the algosdk.Transaction object and isn't made available to the composer. - ) - ).transactions[0] - ) - .send(send_params={"cover_app_call_inner_transaction_fees": True}) - -# Works as expected -result = algorand - .new_group() - .add_app_call_method_call(AppCallMethodCallParams( - sender='SENDER', - app_id=123, - method=my_method, - args=[1, 2, 3], - max_fee=AlgoAmount.from_micro_algos(5000), - )) - .send(send_params={"cover_app_call_inner_transaction_fees": True}) -``` - -A more complex valid scenario which leverages an app client to send an ABI method call with ABI method call transactions argument is below: - -```python -app_factory = algorand.client.get_app_factory( - app_spec='APP_SPEC', - default_sender=sender.addr, -) - -app_client_1, _ = app_factory.send.bare.create() -app_client_2, _ = app_factory.send.bare.create() - -payment_arg = algorand.create_transaction.payment( - PaymentParams( - sender=sender.addr, - receiver=receiver.addr, - amount=AlgoAmount.from_micro_algos(1), - ) -) - -# Note the use of .params. here, this ensure that maxFee is still available to the composer -app_call_arg = app_client_2.params.call( - AppCallMethodCallParams( - method='my_other_method', - args=[], - max_fee=AlgoAmount.from_micro_algos(2000), - ) -) - -result = app_client_1.algorand - .new_group() - .add_app_call_method_call( - app_client_1.params.call( - AppClientMethodCallParams( - method='my_method', - args=[payment_arg, app_call_arg], - max_fee=AlgoAmount.from_micro_algos(5000), - ) - ), - ) - .send({"cover_app_call_inner_transaction_fees": True}) -``` - -This feature should efficiently calculate the minimum fee needed to execute an app call transaction with inners, however we always recommend testing your specific scenario behaves as expected before releasing. - -## Error Transformers - -Error transformers provide a powerful mechanism for enhancing error messages and debugging information when transactions fail. They allow you to register custom functions that can transform generic blockchain errors into more meaningful, application-specific error messages. - -### How Error Transformers Work - -Error transformers are functions that take an `Exception` as input and return either a transformed `Exception` or the original exception unchanged. They are called in sequence during transaction simulation or sending when errors occur, allowing for a chain of transformations. - -```python -from typing import Exception - -def my_error_transformer(error: Exception) -> Exception: - """Transform generic errors into more meaningful ones.""" - if "asset missing" in str(error).lower(): - return Exception("Asset not found: Please check the asset ID") - return error # Return unchanged if not applicable -``` - -### Registering Error Transformers - -Error transformers can be registered at two levels: - -#### 1. AlgorandClient Level (Global) - -Register error transformers globally to apply to all transaction groups created from this client: - -```python -from algokit_utils import AlgorandClient - -algorand = AlgorandClient.default_localnet() - -# Register a global error transformer -algorand.register_error_transformer(my_error_transformer) - -# All transaction groups from this client will use the transformer -result = algorand.new_group().add_payment(payment_params).send() - -# Unregister if needed -algorand.unregister_error_transformer(my_error_transformer) -``` - -#### 2. TransactionComposer Level (Per Group) - -Register error transformers for a specific transaction group: - -```python -# Register transformer for this specific group -composer = algorand.new_group() -composer.register_error_transformer(my_error_transformer) - -result = composer.add_payment(payment_params).send() -``` - -### Error Transformer Chain - -Multiple error transformers can be registered and they will be called in the order they were registered: - -```python -def transformer_1(error: Exception) -> Exception: - if "missing from" in str(error): - return Exception("ASSET MISSING???") - return error - -def transformer_2(error: Exception) -> Exception: - if str(error) == "ASSET MISSING???": - return Exception("ASSET MISSING: Check your asset configuration") - return error - -# Register multiple transformers -algorand.register_error_transformer(transformer_1) -algorand.register_error_transformer(transformer_2) - -# They will be applied in sequence: error -> transformer_1 -> transformer_2 -``` - -### App Client Integration - -The `AppClient` automatically registers error transformers to provide enhanced debugging for application-specific logic errors. These transformers: - -- Parse logic errors from the blockchain -- Apply source map information when available -- Filter errors to only handle those relevant to the specific application -- For new applications (app_id=0), compare program bytecode to ensure error handling is applied to the correct application - -```python -from algokit_utils import AppClient - -# Error transformer is automatically registered -app_client = AppClient( - app_spec=app_spec, - app_id=123, # Existing app - algorand=algorand -) - -# App-specific logic errors will be enhanced with source maps and debugging info -try: - result = app_client.send.call("my_method", args=[]) -except LogicError as e: - # Enhanced error with source information - print(f"Logic error at PC {e.pc}: {e.message}") - print(f"Source trace:\n{e.trace()}") -``` - -### Best Practices - -1. **Keep transformers focused**: Each transformer should handle a specific type of error or transformation. - -2. **Return original on no match**: Always return the original error if your transformer doesn't apply: - ```python - def my_transformer(error: Exception) -> Exception: - if not should_handle(error): - return error # Important: return unchanged - return transform_error(error) - ``` - -3. **Chain appropriately**: Register transformers in logical order, from most specific to most general. - -4. **Handle exceptions**: Ensure your transformer doesn't raise exceptions: - ```python - def safe_transformer(error: Exception) -> Exception: - try: - return transform_error(error) - except Exception: - return error # Fallback to original - ``` - -5. **Use type information**: Consider the error type when transforming: - ```python - def typed_transformer(error: Exception) -> Exception: - if isinstance(error, AlgodHTTPError): - return handle_algod_error(error) - elif isinstance(error, LogicError): - return enhance_logic_error(error) - return error - ``` - -### Error Types - -Common error types you might encounter and transform: - -- **`AlgodHTTPError`**: Network or node-related errors -- **`LogicError`**: Smart contract logic errors (automatically handled by AppClient) -- **Generic `Exception`**: General transaction or validation errors - -Error transformers work with both `send()` and `simulate()` operations, providing consistent error enhancement across all transaction execution paths. - -#### Read-only calls - -When invoking a readonly method, the transaction is simulated rather than being fully processed by the network. This allows users to call these methods without paying a fee. - -Even though no actual fee is paid, the simulation still evaluates the transaction as if a fee was being paid, therefore op budget and fee coverage checks are still performed. - -Because no fee is actually paid, calculating the minimum fee required to successfully execute the transaction is not required, and therefore we don't need to send an additional simulate call to calculate the minimum fee, like we do with a non readonly method call. - -The behaviour of enabling `cover_app_call_inner_transaction_fees` for readonly method calls is very similar to non readonly method calls, however is subtly different as we use `max_fee` as the transaction fee when executing the readonly method call. - -### Covering App Call Op Budget - -The high level Algorand contract authoring languages all have support for ensuring appropriate app op budget is available via `ensure_budget` in Algorand Python, `ensureBudget` in Algorand TypeScript and `increaseOpcodeBudget` in TEALScript. This is great, as it allows contract authors to ensure appropriate budget is available by automatically sending op-up inner transactions to increase the budget available. These op-up inner transactions require the fees to be covered by an account, which is generally the responsibility of the application consumer. - -Application consumers may not be immediately aware of the number of op-up inner transactions sent, so it can be difficult for them to determine the exact fees required to successfully execute an application call. Fortunately the `cover_app_call_inner_transaction_fees` setting above can be leveraged to automatically cover the fees for any op-up inner transaction that an application sends. Additionally if a contract author decides to cover the fee for an op-up inner transaction, then the application consumer will not be charged a fee for that transaction. diff --git a/docs/source/capabilities/transaction.md b/docs/source/capabilities/transaction.md deleted file mode 100644 index e10a8e7b..00000000 --- a/docs/source/capabilities/transaction.md +++ /dev/null @@ -1,147 +0,0 @@ -# Transaction management - -Transaction management is one of the core capabilities provided by AlgoKit Utils. It allows you to construct, simulate and send single or grouped transactions with consistent and highly configurable semantics, including configurable control of transaction notes, logging, fees, multiple sender account types, and sending behavior. - -## Transaction Results - -All AlgoKit Utils functions that send transactions return either a `SendSingleTransactionResult` or `SendAtomicTransactionComposerResults`, providing consistent mechanisms to interpret transaction outcomes. - -### SendSingleTransactionResult - -The base `SendSingleTransactionResult` class is used for single transactions: - -```python -@dataclass(frozen=True, kw_only=True) -class SendSingleTransactionResult: - transaction: TransactionWrapper # Last transaction - confirmation: AlgodResponseType # Last confirmation - group_id: str - tx_id: str | None = None # Transaction ID of the last transaction - tx_ids: list[str] # All transaction IDs in the group - transactions: list[TransactionWrapper] - confirmations: list[AlgodResponseType] - returns: list[ABIReturn] | None = None # ABI returns if applicable -``` - -Common variations include: - -- `SendSingleAssetCreateTransactionResult` - Adds `asset_id` -- `SendAppTransactionResult` - Adds `abi_return` -- `SendAppUpdateTransactionResult` - Adds compilation results -- `SendAppCreateTransactionResult` - Adds `app_id` and `app_address` - -### SendAtomicTransactionComposerResults - -When using the atomic transaction composer directly via `TransactionComposer.send()` or `TransactionComposer.simulate()`, you'll receive a `SendAtomicTransactionComposerResults`: - -```python -@dataclass -class SendAtomicTransactionComposerResults: - group_id: str # The group ID if this was a transaction group - confirmations: list[AlgodResponseType] # The confirmation info for each transaction - tx_ids: list[str] # The transaction IDs that were sent - transactions: list[TransactionWrapper] # The transactions that were sent - returns: list[ABIReturn] # The ABI return values from any ABI method calls - simulate_response: dict[str, Any] | None = None # Simulation response if simulated -``` - -### Application-specific Result Types - -When working with applications via `AppClient` or `AppFactory`, you'll get enhanced result types that provide direct access to parsed ABI values: - -- `SendAppFactoryTransactionResult` -- `SendAppUpdateFactoryTransactionResult` -- `SendAppCreateFactoryTransactionResult` - -These types extend the base transaction results to add an `abi_value` field that contains the parsed ABI return value according to the ARC-56 specification. The `Arc56ReturnValueType` can be: - -- A primitive ABI value (bool, int, str, bytes) -- An ABI struct (as a Python dict) -- None (for void returns) - -### Where You'll Encounter Each Result Type - -Different interfaces return different result types: - -1. **Direct Transaction Composer** - - - `TransactionComposer.send()` → `SendAtomicTransactionComposerResults` - - `TransactionComposer.simulate()` → `SendAtomicTransactionComposerResults` - -2. **AlgorandClient Methods** - - - `.send.payment()` → `SendSingleTransactionResult` - - `.send.asset_create()` → `SendSingleAssetCreateTransactionResult` - - `.send.app_call()` → `SendAppTransactionResult` (contains raw ABI return) - - `.send.app_create()` → `SendAppCreateTransactionResult` (with app ID/address) - - `.send.app_update()` → `SendAppUpdateTransactionResult` (with compilation info) - -3. **AppClient Methods** - - - `.call()` → `SendAppTransactionResult` - - `.create()` → `SendAppCreateTransactionResult` - - `.update()` → `SendAppUpdateTransactionResult` - -4. **AppFactory Methods** - - `.create()` → `SendAppCreateFactoryTransactionResult` - - `.call()` → `SendAppFactoryTransactionResult` - - `.update()` → `SendAppUpdateFactoryTransactionResult` - -Example usage with AppFactory for easy access to ABI returns: - -```python -# Using AppFactory -result = app_factory.send.call(AppCallMethodCallParams( - method="my_method", - args=[1, 2, 3], - sender=sender -)) -# Access the parsed ABI return value directly -parsed_value = result.abi_value # Already decoded per ARC-56 spec - -# Compared to base AppClient where you need to parse manually -base_result = app_client.send.call(AppCallMethodCallParams( - method="my_method", - args=[1, 2, 3], - sender=sender -)) -# Need to manually handle ABI return parsing -if base_result.abi_return: - parsed_value = base_result.abi_return.value -``` - -Key differences between result types: - -1. **Base Transaction Results** (`SendSingleTransactionResult`) - - - Focus on transaction confirmation details - - Include group support but optimized for single transactions - - No direct ABI value parsing - -2. **Atomic Transaction Results** (`SendAtomicTransactionComposerResults`) - - - Built for transaction groups - - Include simulation support - - Raw ABI returns via `.returns` - - No single transaction convenience fields - -3. **Application Results** (`SendAppTransactionResult` family) - - - Add application-specific fields (`app_id`, compilation results) - - Include raw ABI returns via `.abi_return` - - Base application transaction support - -4. **Factory Results** (`SendAppFactoryTransactionResult` family) - - Highest level of abstraction - - Direct access to parsed ABI values via `.abi_value` - - Automatic ARC-56 compliant value parsing - - Combines app-specific fields with parsed ABI returns - -## Further reading - -To understand how to create, simulate and send transactions consult: - -- The [`TransactionComposer`](./transaction-composer.md) documentation for composing transaction groups -- The [`AlgorandClient`](./algorand-client.md) documentation for a high-level interface to send transactions - -The transaction composer documentation covers the details of constructing transactions and transaction groups, while the Algorand client documentation covers the high-level interface for sending transactions. diff --git a/docs/source/capabilities/transfer.md b/docs/source/capabilities/transfer.md deleted file mode 100644 index 07f2a9b0..00000000 --- a/docs/source/capabilities/transfer.md +++ /dev/null @@ -1,151 +0,0 @@ -# Algo transfers (payments) - -Algo transfers, or [payments](https://dev.algorand.co/concepts/transactions/types#payment-transaction), is a higher-order use case capability provided by AlgoKit Utils that builds on top of the core capabilities, particularly [Algo amount handling](./amount.md) and [Transaction management](./transaction.md). It allows you to easily initiate Algo transfers between accounts, including dispenser management and idempotent account funding. - -To see some usage examples check out the automated tests in the repository. - -## `payment` - -The key function to facilitate Algo transfers is `algorand.send.payment(params)` (immediately send a single payment transaction), `algorand.create_transaction.payment(params)` (construct a payment transaction), or `algorand.new_group().add_payment(params)` (add payment to a group of transactions) per [`AlgorandClient`](./algorand-client.md) [transaction semantics](./algorand-client.md#creating-and-issuing-transactions). - -The base type for specifying a payment transaction is `PaymentParams`, which has the following parameters in addition to the [common transaction parameters](./algorand-client.md#transaction-parameters): - -- `receiver: str` - The address of the account that will receive the Algo -- `amount: AlgoAmount` - The amount of Algo to send -- `close_remainder_to: Optional[str]` - If given, close the sender account and send the remaining balance to this address (**warning:** use this carefully as it can result in loss of funds if used incorrectly) - -```python -# Minimal example -result = algorand_client.send.payment( - PaymentParams( - sender="SENDERADDRESS", - receiver="RECEIVERADDRESS", - amount=AlgoAmount(4, "algo") - ) -) - -# Advanced example -result2 = algorand_client.send.payment( - PaymentParams( - sender="SENDERADDRESS", - receiver="RECEIVERADDRESS", - amount=AlgoAmount(4, "algo"), - close_remainder_to="CLOSEREMAINDERTOADDRESS", - lease="lease", - note=b"note", - # Use this with caution, it's generally better to use algorand_client.account.rekey_account - rekey_to="REKEYTOADDRESS", - # You wouldn't normally set this field - first_valid_round=1000, - validity_window=10, - extra_fee=AlgoAmount(1000, "microalgo"), - static_fee=AlgoAmount(1000, "microalgo"), - # Max fee doesn't make sense with extra_fee AND static_fee - # already specified, but here for completeness - max_fee=AlgoAmount(3000, "microalgo"), - # Signer only needed if you want to provide one, - # generally you'd register it with AlgorandClient - # against the sender and not need to pass it in - signer=transaction_signer, - ), - send_params=SendParams( - max_rounds_to_wait=5, - suppress_log=True, - ) -) -``` - -## `ensure_funded` - -The `ensure_funded` function automatically funds an account to maintain a minimum amount of [disposable Algo](https://dev.algorand.co/concepts/smart-contracts/costs-constraints#mbr). This is particularly useful for automation and deployment scripts that get run multiple times and consume Algo when run. - -There are 3 variants of this function: - -- `algorand_client.account.ensure_funded(account_to_fund, dispenser_account, min_spending_balance, options)` - Funds a given account using a dispenser account as a funding source such that the given account has a certain amount of Algo free to spend (accounting for Algo locked in minimum balance requirement). -- `algorand_client.account.ensure_funded_from_environment(account_to_fund, min_spending_balance, options)` - Funds a given account using a dispenser account retrieved from the environment, per the `dispenser_from_environment` method, as a funding source such that the given account has a certain amount of Algo free to spend (accounting for Algo locked in minimum balance requirement). - - **Note:** requires environment variables to be set. - - The dispenser account is retrieved from the account mnemonic stored in `DISPENSER_MNEMONIC` and optionally `DISPENSER_SENDER` - if it's a rekeyed account, or against default LocalNet if no environment variables present. -- `algorand_client.account.ensure_funded_from_testnet_dispenser_api(account_to_fund, dispenser_client, min_spending_balance, options)` - Funds a given account using the [TestNet Dispenser API](https://github.com/algorandfoundation/algokit/blob/main/docs/testnet_api.md) as a funding source such that the account has a certain amount of Algo free to spend (accounting for Algo locked in minimum balance requirement). - -The general structure of these calls is similar, they all take: - -- `account_to_fund: str | Account` - Address or signing account of the account to fund -- The source (dispenser): - - In `ensure_funded`: `dispenser_account: str | Account` - the address or signing account of the account to use as a dispenser - - In `ensure_funded_from_environment`: Not specified, loaded automatically from the ephemeral environment - - In `ensure_funded_from_testnet_dispenser_api`: `dispenser_client: TestNetDispenserApiClient` - a client instance of the TestNet dispenser API -- `min_spending_balance: AlgoAmount` - The minimum balance of Algo that the account should have available to spend (i.e., on top of the minimum balance requirement) -- An `options` object, which has: - - [Common transaction parameters](./algorand-client.md#transaction-parameters) (not for TestNet Dispenser API) - - [Execution parameters](./algorand-client.md#sending-a-single-transaction) (not for TestNet Dispenser API) - - `min_funding_increment: Optional[AlgoAmount]` - When issuing a funding amount, the minimum amount to transfer; this avoids many small transfers if this function gets called often on an active account - -### Examples - -```python -# From account - -# Basic example -algorand_client.account.ensure_funded("ACCOUNTADDRESS", "DISPENSERADDRESS", AlgoAmount(1, "algo")) -# With configuration -algorand_client.account.ensure_funded( - "ACCOUNTADDRESS", - "DISPENSERADDRESS", - AlgoAmount(1, "algo"), - min_funding_increment=AlgoAmount(2, "algo"), - fee=AlgoAmount(1000, "microalgo"), - send_params=SendParams( - suppress_log=True, - ), -) - -# From environment - -# Basic example -algorand_client.account.ensure_funded_from_environment("ACCOUNTADDRESS", AlgoAmount(1, "algo")) -# With configuration -algorand_client.account.ensure_funded_from_environment( - "ACCOUNTADDRESS", - AlgoAmount(1, "algo"), - min_funding_increment=AlgoAmount(2, "algo"), - fee=AlgoAmount(1000, "microalgo"), - send_params=SendParams( - suppress_log=True, - ), -) - -# TestNet Dispenser API - -# Basic example -algorand_client.account.ensure_funded_from_testnet_dispenser_api( - "ACCOUNTADDRESS", - algorand_client.client.get_testnet_dispenser_from_environment(), - AlgoAmount(1, "algo") -) -# With configuration -algorand_client.account.ensure_funded_from_testnet_dispenser_api( - "ACCOUNTADDRESS", - algorand_client.client.get_testnet_dispenser_from_environment(), - AlgoAmount(1, "algo"), - min_funding_increment=AlgoAmount(2, "algo"), -) -``` - -All 3 variants return an `EnsureFundedResponse` (and the first two also return a [single transaction result](./algorand-client.md#sending-a-single-transaction)) if a funding transaction was needed, or `None` if no transaction was required: - -- `amount_funded: AlgoAmount` - The number of Algo that was paid -- `transaction_id: str` - The ID of the transaction that funded the account - -If you are using the TestNet Dispenser API then the `transaction_id` is useful if you want to use the [refund functionality](./dispenser-client.md#registering-a-refund). - -## Dispenser - -If you want to programmatically send funds to an account so it can transact then you will often need a "dispenser" account that has a store of Algo that can be sent and a private key available for that dispenser account. - -There's a number of ways to get a dispensing account in AlgoKit Utils: - -- Get a dispenser via [account manager](./account.md#dispenser) - either automatically from [LocalNet](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/localnet.md) or from the environment -- By programmatically creating one of the many account types via [account manager](./account.md#accounts) -- By programmatically interacting with [KMD](./account.md#kmd-account-management) if running against LocalNet -- By using the [AlgoKit TestNet Dispenser API client](./dispenser-client.md) which can be used to fund accounts on TestNet via a dedicated API service diff --git a/docs/source/capabilities/typed-app-clients.md b/docs/source/capabilities/typed-app-clients.md deleted file mode 100644 index f6fd7795..00000000 --- a/docs/source/capabilities/typed-app-clients.md +++ /dev/null @@ -1,184 +0,0 @@ -# Typed application clients - -Typed application clients are automatically generated, typed Python deployment and invocation clients for smart contracts that have a defined [ARC-56](https://github.com/algorandfoundation/ARCs/pull/258) or [ARC-32](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0032.md) application specification so that the development experience is easier with less upskill ramp-up and less deployment errors. These clients give you a type-safe, intellisense-driven experience for invoking the smart contract. - -Typed application clients are the recommended way of interacting with smart contracts. If you don't have/want a typed client, but have an ARC-56/ARC-32 app spec then you can use the [non-typed application clients](./app-client.md) and if you want to call a smart contract you don't have an app spec file for you can use the underlying [app management](./app.md) and [app deployment](./app-deploy.md) functionality to manually construct transactions. - -## Generating an app spec - -You can generate an app spec file: - -- Using [Algorand Python](https://algorandfoundation.github.io/puya/#quick-start) -- Using [TEALScript](https://tealscript.netlify.app/tutorials/hello-world/0004-artifacts/) -- By hand by following the specification [ARC-56](https://github.com/algorandfoundation/ARCs/pull/258)/[ARC-32](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0032.md) -- Using [Beaker](https://algorand-devrel.github.io/beaker/html/usage.html) (PyTEAL) _(DEPRECATED)_ - -## Generating a typed client - -To generate a typed client from an app spec file you can use [AlgoKit CLI](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/generate.md#1-typed-clients): - -``` -> algokit generate client application.json --output /absolute/path/to/client.py -``` - -Note: AlgoKit Utils >= 3.0.0 is compatible with the older 1.x.x generated typed clients, however if you want to utilise the new features or leverage ARC-56 support, you will need to generate using >= 2.x.x. See [AlgoKit CLI generator version pinning](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/generate.md#version-pinning) for more information on how to lock to a specific version. - -## Getting a typed client instance - -To get an instance of a typed client you can use an [`AlgorandClient`](./algorand-client.md) instance or a typed app [`Factory`](#creating-a-typed-factory-instance) instance. - -The approach to obtaining a client instance depends on how many app clients you require for a given app spec and if the app has already been deployed: - -### App is deployed - -#### Resolve App by ID - -**Single Typed App Client Instance:** - -```python -# Typed: Using the AlgorandClient extension method -typed_client = algorand.client.get_typed_app_client_by_id( - MyContractClient, # Generated typed client class - app_id=1234, - # ... -) -# or Typed: Using the generated client class directly -typed_client = MyContractClient( - algorand, - app_id=1234, - # ... -) -``` - -**Multiple Typed App Client Instances:** - -```python -# Typed: Using a typed factory to get multiple client instances -typed_client1 = typed_factory.get_app_client_by_id( - app_id=1234, - # ... -) -typed_client2 = typed_factory.get_app_client_by_id( - app_id=4321, - # ... -) -``` - -#### Resolve App by Creator and Name - -**Single Typed App Client Instance:** - -```python -# Typed: Using the AlgorandClient extension method -typed_client = algorand.client.get_typed_app_client_by_creator_and_name( - MyContractClient, # Generated typed client class - creator_address="CREATORADDRESS", - app_name="contract-name", - # ... -) -# or Typed: Using the static method on the generated client class -typed_client = MyContractClient.from_creator_and_name( - algorand, - creator_address="CREATORADDRESS", - app_name="contract-name", - # ... -) -``` - -**Multiple Typed App Client Instances:** - -```python -# Typed: Using a typed factory to get multiple client instances by name -typed_client1 = typed_factory.get_app_client_by_creator_and_name( - creator_address="CREATORADDRESS", - app_name="contract-name", - # ... -) -typed_client2 = typed_factory.get_app_client_by_creator_and_name( - creator_address="CREATORADDRESS", - app_name="contract-name-2", - # ... -) -``` - -### App is not deployed - -#### Deploy a New App - -```python -# Typed: For typed clients, you call a specific creation method rather than generic 'create' -typed_client, response = typed_factory.send.create.{METHODNAME}( - # ... -) -``` - -#### Deploy or Resolve App Idempotently by Creator and Name - -```python -# Typed: Using the deploy method on a typed factory -typed_client, response = typed_factory.deploy( - on_update=OnUpdate.UpdateApp, - on_schema_break=OnSchemaBreak.ReplaceApp, - # The parameters for create/update/delete would be specific to your generated client - app_name="contract-name", - # ... -) -``` - -### Creating a typed factory instance - -If your scenario calls for an app factory, you can create one using the below: - -```python -# Typed: Using the AlgorandClient extension method -typed_factory = algorand.client.get_typed_app_factory(MyContractFactory) # Generated factory class -# or Typed: Using the factory class constructor directly -typed_factory = MyContractFactory(algorand) -``` - -## Client usage - -See the [official usage docs](https://github.com/algorandfoundation/algokit-client-generator-py/blob/main/docs/usage.md) for full details about typed clients. - -Below is a realistic example that deploys a contract, funds it if newly created, and calls a `"hello"` method: - -```python -# Typed: Complete example using a typed application client -import algokit_utils -from artifacts.hello_world.hello_world_client import ( - HelloArgs, # Generated args class - HelloWorldFactory, # Generated factory class -) - -# Get Algorand client from environment variables -algorand = algokit_utils.AlgorandClient.from_environment() -deployer = algorand.account.from_environment("DEPLOYER") - -# Create the typed app factory -typed_factory = algorand.client.get_typed_app_factory( - HelloWorldFactory, default_sender=deployer.address -) - -# Deploy idempotently - creates if it doesn't exist or updates if changed -typed_client, result = typed_factory.deploy( - on_update=algokit_utils.OnUpdate.AppendApp, - on_schema_break=algokit_utils.OnSchemaBreak.AppendApp, -) - -# Fund the app with 1 ALGO if it's newly created -if result.operation_performed in [ - algokit_utils.OperationPerformed.Create, - algokit_utils.OperationPerformed.Replace, -]: - algorand.send.payment( - algokit_utils.PaymentParams( - amount=algokit_utils.AlgoAmount(algo=1), - sender=deployer.address, - receiver=typed_client.app_address, - ) - ) - -# Call the hello method on the smart contract -name = "world" -response = typed_client.send.hello(args=HelloArgs(name=name)) # Using generated args class -``` diff --git a/docs/source/conf.py b/docs/source/conf.py deleted file mode 100644 index c3171ccd..00000000 --- a/docs/source/conf.py +++ /dev/null @@ -1,189 +0,0 @@ -# Configuration file for the Sphinx documentation builder. -# -# For the full list of built-in configuration values, see the documentation: -# https://www.sphinx-doc.org/en/master/usage/configuration.html - -# -- Project information ----------------------------------------------------- -# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information -from __future__ import annotations - -from typing import TYPE_CHECKING - -if TYPE_CHECKING: - from sphinx.application import Sphinx - from sphinx.domains.python import PyObject - -project = 'algokit-utils-py' -copyright = '2025, Algorand Foundation' -author = 'Algorand Foundation' -release = '3.0' - -# -- General configuration --------------------------------------------------- -# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration - -extensions = ['myst_parser', 'autoapi.extension', "sphinx.ext.autosectionlabel"] - -templates_path = ['_templates'] -exclude_patterns = [] - -autoapi_dirs = ['../../src/algokit_utils'] -autoapi_options = ['members', - 'undoc-members', - 'show-inheritance', - 'show-module-summary', - ] - -autoapi_ignore = ['*algokit_utils/beta/__init__.py', - '*algokit_utils/beta/account_manager.py', - '*algokit_utils/beta/algorand_client.py', - '*algokit_utils/beta/client_manager.py', - '*algokit_utils/beta/composer.py', - '*algokit_utils/asset.py', - '*algokit_utils/deploy.py', - "*algokit_utils/network_clients.py", - "*algokit_utils/common.py", - "*algokit_utils/account.py", - "*algokit_utils/application_client.py", - "*algokit_utils/application_specification.py", - "*algokit_utils/logic_error.py", - "*algokit_utils/dispenser_api.py"] - -myst_heading_anchors = 5 -myst_all_links_external = False -autosectionlabel_prefix_document = True - -# -- Options for HTML output ------------------------------------------------- -# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output - -html_theme = 'furo' -html_static_path = ['_static'] -pygments_style = "sphinx" -pygments_dark_style = "monokai" -exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] - -# Copy images for markdown build -import os -import shutil -from pathlib import Path -from docutils import nodes - -def copy_images_for_markdown(app, exception): - """Copy images from source/images to markdown/images for markdown builds.""" - if app.builder.name == 'markdown': - source_images = Path(app.srcdir) / 'images' - dest_images = Path(app.outdir) / 'images' - - if source_images.exists(): - # Ensure destination directory exists - dest_images.mkdir(parents=True, exist_ok=True) - - # Copy all image files - for image_file in source_images.iterdir(): - if image_file.is_file() and image_file.suffix.lower() in ['.jpg', '.jpeg', '.png', '.gif', '.svg']: - shutil.copy2(image_file, dest_images / image_file.name) - print(f"Copied {image_file.name} to {dest_images}") - -def fix_image_paths_in_doctree(app, doctree, docname): - """Fix image paths in doctree to preserve relative paths for markdown output.""" - if app.builder.name == 'markdown': - for node in doctree.traverse(nodes.image): - if 'uri' in node: - uri = node['uri'] - # If the URI was resolved from ../images/ to images/, change it back - if uri.startswith('images/') and not uri.startswith('../'): - node['uri'] = '../' + uri - print(f"Fixed image path: {uri} -> {node['uri']}") - -def _strip_pycon_prompts(text: str) -> str: - """Return text with leading REPL prompts (>>>/...) stripped from each line. - - This converts doctest-style examples into plain Python code for builders that - don't support the "pycon" lexer. - """ - cleaned_lines: list[str] = [] - for line in text.splitlines(): - # Normalize common doctest continuation variants (ASCII '...' and typographic '…') - if line.startswith('>>> '): - cleaned_lines.append(line[4:]) - continue - if line.startswith('>>>'): - cleaned_lines.append(line[3:].lstrip()) - continue - if line.startswith('... '): - cleaned_lines.append(line[4:]) - continue - if line.startswith('...'): - cleaned_lines.append(line[3:].lstrip()) - continue - if line.startswith('… '): # typographic ellipsis - cleaned_lines.append(line[2:]) - continue - if line.startswith('…'): - cleaned_lines.append(line[1:].lstrip()) - continue - cleaned_lines.append(line) - return "\n".join(cleaned_lines) - -def convert_pycon_blocks_to_python(app, doctree, docname): - """Convert pycon/doctest code blocks to python and strip prompts for Markdown. - - Some downstream renderers (e.g. Starlight's Expressive Code) don't support - the "pycon" language. This hook normalizes such blocks to "python" and - removes REPL prompts so syntax highlighting works and warnings are avoided. - """ - if app.builder.name != 'markdown': - return - - # Handle literal code blocks tagged as pycon/doctest - for node in list(doctree.traverse(nodes.literal_block)): - language = node.get('language') - if language in {'pycon', 'doctest'}: - text = node.astext() - node['language'] = 'python' - node.children = [nodes.Text(_strip_pycon_prompts(text))] - - # Handle explicit doctest block nodes if present - doctest_block = getattr(nodes, 'doctest_block', None) - if doctest_block is not None: - for node in list(doctree.traverse(doctest_block)): - text = node.astext() - code_text = _strip_pycon_prompts(text) - replacement = nodes.literal_block(code_text, code_text) - replacement['language'] = 'python' - node.replace_self(replacement) - - # Normalize doctest-style paragraphs and block quotes within Example fields - for field in doctree.traverse(nodes.field): - # Expect children: field_name, field_body - if len(field) < 2 or not isinstance(field[0], nodes.field_name): - continue - field_name_text = field[0].astext().strip().lower() - if field_name_text not in {'example', 'examples'}: - continue - field_body = field[1] - if not isinstance(field_body, nodes.field_body): - continue - for child in list(field_body.children): - if not isinstance(child, (nodes.paragraph, nodes.block_quote)): - continue - text = child.astext() - # Heuristic: treat as doctest if any line starts with '>>>', '...'(ascii) or '…'(typographic) - lines = text.splitlines() - is_doctest = any(l.strip().startswith(('>>>', '...', '…')) for l in lines) - if not is_doctest: - continue - code_text = _strip_pycon_prompts(text) - replacement = nodes.literal_block(code_text, code_text) - replacement['language'] = 'python' - child.replace_self(replacement) - -def setup(app): - """Sphinx extension setup function.""" - app.connect('build-finished', copy_images_for_markdown) - app.connect('doctree-resolved', fix_image_paths_in_doctree) - app.connect('doctree-resolved', convert_pycon_blocks_to_python) - return { - 'version': '1.0', - 'parallel_read_safe': True, - 'parallel_write_safe': True, - } diff --git a/docs/source/images/lifecycle.jpg b/docs/source/images/lifecycle.jpg deleted file mode 100644 index 4c4c2af6..00000000 Binary files a/docs/source/images/lifecycle.jpg and /dev/null differ diff --git a/docs/source/index.md b/docs/source/index.md deleted file mode 100644 index f3378aed..00000000 --- a/docs/source/index.md +++ /dev/null @@ -1,155 +0,0 @@ -# AlgoKit Python Utilities - -A set of core Algorand utilities written in Python and released via PyPi that make it easier to build solutions on Algorand. This project is part of [AlgoKit](https://github.com/algorandfoundation/algokit-cli). - -The goal of this library is to provide intuitive, productive utility functions that make it easier, quicker and safer to build applications on Algorand. Largely these functions wrap the underlying Algorand SDK, but provide a higher level interface with sensible defaults and capabilities for common tasks. - -```{note} -If you prefer TypeScript there's an equivalent [TypeScript utility library](https://github.com/algorandfoundation/algokit-utils-ts). -``` - -{ref}`Core principles ` | {ref}`Installation ` | {ref}`Usage ` | {ref}`Config and logging ` | {ref}`Capabilities ` | {ref}`Reference docs ` - -```{toctree} ---- -maxdepth: 2 -caption: Contents ---- - -capabilities/account -capabilities/algorand-client -capabilities/amount -capabilities/app-client -capabilities/app-deploy -capabilities/app -capabilities/asset -capabilities/client -capabilities/debugging -capabilities/dispenser-client -capabilities/testing -capabilities/transaction-composer -capabilities/transaction -capabilities/transfer -capabilities/typed-app-clients -v3-migration-guide -``` - -(core-principles)= - -# Core principles - -This library follows the [Guiding Principles of AlgoKit](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/algokit.md#guiding-principles) and is designed with the following principles: - -- **Modularity** - This library is a thin wrapper of modular building blocks over the Algorand SDK; the primitives from the underlying Algorand SDK are exposed and used wherever possible so you can opt-in to which parts of this library you want to use without having to use an all or nothing approach. -- **Type-safety** - This library provides strong type hints with effort put into creating types that provide good type safety and intellisense when used with tools like MyPy. -- **Productivity** - This library is built to make solution developers highly productive; it has a number of mechanisms to make common code easier and terser to write. - -(installation)= - -# Installation - -This library can be installed from PyPi using pip or poetry: - -```bash -pip install algokit-utils -# or -poetry add algokit-utils -``` - -(usage)= - -# Usage - -The main entrypoint to the bulk of the functionality in AlgoKit Utils is the `AlgorandClient` class. You can get started by using one of the static initialization methods to create an Algorand client: - -```python -# Point to the network configured through environment variables or -# if no environment variables it will point to the default LocalNet configuration -algorand = AlgorandClient.from_environment() -# Point to default LocalNet configuration -algorand = AlgorandClient.default_localnet() -# Point to TestNet using AlgoNode free tier -algorand = AlgorandClient.testnet() -# Point to MainNet using AlgoNode free tier -algorand = AlgorandClient.mainnet() -# Point to a pre-created algod client -algorand = AlgorandClient.from_clients(algod=...) -# Point to a pre-created algod and indexer client -algorand = AlgorandClient.from_clients(algod=..., indexer=..., kmd=...) -# Point to custom configuration for algod -algod_config = AlgoClientNetworkConfig(server=..., token=..., port=...) -algorand = AlgorandClient.from_config(algod_config=algod_config) -# Point to custom configuration for algod and indexer and kmd -algod_config = AlgoClientNetworkConfig(server=..., token=..., port=...) -indexer_config = AlgoClientNetworkConfig(server=..., token=..., port=...) -kmd_config = AlgoClientNetworkConfig(server=..., token=..., port=...) -algorand = AlgorandClient.from_config(algod_config=algod_config, indexer_config=indexer_config, kmd_config=kmd_config) -``` - -# Testing - -AlgoKit Utils provides a dedicated documentation page on various useful snippets that can be reused for testing with tools like [Pytest](https://docs.pytest.org/en/latest/): - -- [Testing](capabilities/testing) - -# Types - -The library leverages Python's native type hints and is fully compatible with [MyPy](https://mypy-lang.org/) for static type checking. - -All public abstractions and methods are organized in logical modules matching their domain functionality. You can import types either directly from the root module or from their source submodules. Refer to [API documentation](autoapi/index) for more details. - -(config-logging)= - -# Config and logging - -To configure the AlgoKit Utils library you can make use of the [`Config`](autoapi/algokit_utils/config/index) object, which has a configure method that lets you configure some or all of the configuration options. - -## Config singleton - -The AlgoKit Utils configuration singleton can be updated using `config.configure()`. Refer to the [Config API documentation](autoapi/algokit_utils/config/index) for more details. - -## Logging - -AlgoKit has an in-built logging abstraction through the {py:obj}`algokit_utils.config.AlgoKitLogger` class that provides standardized logging capabilities. The logger is accessible through the `config.logger` property and provides various logging levels. - -Each method supports optional suppression of output using the `suppress_log` parameter. - -## Debug mode - -To turn on debug mode you can use the following: - -```python -from algokit_utils.config import config -config.configure(debug=True) -``` - -To retrieve the current debug state you can use `debug` property. - -This will turn on things like automatic tracing, more verbose logging and [advanced debugging](capabilities/debugging). It's likely this option will result in extra HTTP calls to algod and it's worth being careful when it's turned on. - -(capabilities)= - -# Capabilities - -The library helps you interact with and develop against the Algorand blockchain with a series of end-to-end capabilities as described below: - -- [**AlgorandClient**](./capabilities/algorand-client.md) - The key entrypoint to the AlgoKit Utils functionality -- **Core capabilities** - - [**Client management**](./capabilities/client.md) - Creation of (auto-retry) algod, indexer and kmd clients against various networks resolved from environment or specified configuration, and creation of other API clients (e.g. TestNet Dispenser API and app clients) - - [**Account management**](./capabilities/account.md) - Creation, use, and management of accounts including mnemonic, rekeyed, multisig, transaction signer, idempotent KMD accounts and environment variable injected - - [**Algo amount handling**](./capabilities/amount.md) - Reliable, explicit, and terse specification of microAlgo and Algo amounts and safe conversion between them - - [**Transaction management**](./capabilities/transaction.md) - Ability to construct, simulate and send transactions with consistent and highly configurable semantics, including configurable control of transaction notes, logging, fees, validity, signing, and sending behaviour -- **Higher-order use cases** - - [**Asset management**](./capabilities/asset.md) - Creation, transfer, destroying, opting in and out and managing Algorand Standard Assets - - [**Typed application clients**](./capabilities/typed-app-clients.md) - Type-safe application clients that are [generated](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/generate.md#1-typed-clients) from ARC-56 or ARC-32 application spec files and allow you to intuitively and productively interact with a deployed app, which is the recommended way of interacting with apps and builds on top of the following capabilities: - - [**ARC-56 / ARC-32 App client and App factory**](./capabilities/app-client.md) - Builds on top of the App management and App deployment capabilities (below) to provide a high productivity application client that works with ARC-56 and ARC-32 application spec defined smart contracts - - [**App management**](./capabilities/app.md) - Creation, updating, deleting, calling (ABI and otherwise) smart contract apps and the metadata associated with them (including state and boxes) - - [**App deployment**](./capabilities/app-deploy.md) - Idempotent (safely retryable) deployment of an app, including deploy-time immutability and permanence control and TEAL template substitution - - [**Algo transfers (payments)**](./capabilities/transfer.md) - Ability to easily initiate Algo transfers between accounts, including dispenser management and idempotent account funding - - [**Automated testing**](./capabilities/testing.md) - Reusable snippets to leverage AlgoKit Utils abstractions in a manner that are useful for when writing tests in tools like [Pytest](https://docs.pytest.org/en/latest/). - -(reference-documentation)= - -# Reference documentation - -For detailed API documentation, see the {py:obj}`algokit_utils` diff --git a/docs/sphinx/conf.py b/docs/sphinx/conf.py new file mode 100644 index 00000000..aee83524 --- /dev/null +++ b/docs/sphinx/conf.py @@ -0,0 +1,134 @@ +# Isolated Sphinx configuration for API-only markdown generation. +# This config is used by docs/api_build.py to generate API reference +# markdown that is consumed by Starlight. It intentionally omits HTML +# themes, MyST, and other presentation-layer extensions. + +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from sphinx.application import Sphinx + +from docutils import nodes + +project = "algokit-utils-py" +copyright = "2026, Algorand Foundation" +author = "Algorand Foundation" +release = "3.0" + +extensions = ["autoapi.extension"] + +templates_path = [] +exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] + +# -- AutoAPI configuration --------------------------------------------------- + +autoapi_dirs = ["../../src/algokit_utils"] +autoapi_options = [ + "members", + "undoc-members", + "show-inheritance", + "show-module-summary", +] + +autoapi_ignore = [ + "*algokit_utils/beta/__init__.py", + "*algokit_utils/beta/account_manager.py", + "*algokit_utils/beta/algorand_client.py", + "*algokit_utils/beta/client_manager.py", + "*algokit_utils/beta/composer.py", + "*algokit_utils/asset.py", + "*algokit_utils/deploy.py", + "*algokit_utils/network_clients.py", + "*algokit_utils/common.py", + "*algokit_utils/account.py", + "*algokit_utils/application_client.py", + "*algokit_utils/application_specification.py", + "*algokit_utils/logic_error.py", + "*algokit_utils/dispenser_api.py", +] + + +# -- Pycon-to-Python conversion hook ----------------------------------------- +# Starlight's Expressive Code doesn't support the "pycon" lexer. +# This hook converts pycon/doctest code blocks to plain Python and +# strips REPL prompts so syntax highlighting works correctly. + + +def _strip_pycon_prompts(text: str) -> str: + """Return text with leading REPL prompts (>>>/...) stripped from each line.""" + cleaned_lines: list[str] = [] + for line in text.splitlines(): + if line.startswith(">>> "): + cleaned_lines.append(line[4:]) + continue + if line.startswith(">>>"): + cleaned_lines.append(line[3:].lstrip()) + continue + if line.startswith("... "): + cleaned_lines.append(line[4:]) + continue + if line.startswith("..."): + cleaned_lines.append(line[3:].lstrip()) + continue + if line.startswith("\u2026 "): # typographic ellipsis + cleaned_lines.append(line[2:]) + continue + if line.startswith("\u2026"): + cleaned_lines.append(line[1:].lstrip()) + continue + cleaned_lines.append(line) + return "\n".join(cleaned_lines) + + +def convert_pycon_blocks_to_python(app, doctree, docname): + """Convert pycon/doctest code blocks to python and strip prompts for Markdown.""" + if app.builder.name != "markdown": + return + + for node in list(doctree.traverse(nodes.literal_block)): + language = node.get("language") + if language in {"pycon", "doctest"}: + text = node.astext() + node["language"] = "python" + node.children = [nodes.Text(_strip_pycon_prompts(text))] + + doctest_block = getattr(nodes, "doctest_block", None) + if doctest_block is not None: + for node in list(doctree.traverse(doctest_block)): + text = node.astext() + code_text = _strip_pycon_prompts(text) + replacement = nodes.literal_block(code_text, code_text) + replacement["language"] = "python" + node.replace_self(replacement) + + for field in doctree.traverse(nodes.field): + if len(field) < 2 or not isinstance(field[0], nodes.field_name): + continue + field_name_text = field[0].astext().strip().lower() + if field_name_text not in {"example", "examples"}: + continue + field_body = field[1] + if not isinstance(field_body, nodes.field_body): + continue + for child in list(field_body.children): + if not isinstance(child, (nodes.paragraph, nodes.block_quote)): + continue + text = child.astext() + lines = text.splitlines() + is_doctest = any(l.strip().startswith((">>>", "...", "\u2026")) for l in lines) + if not is_doctest: + continue + code_text = _strip_pycon_prompts(text) + replacement = nodes.literal_block(code_text, code_text) + replacement["language"] = "python" + child.replace_self(replacement) + + +def setup(app): + """Sphinx extension setup function.""" + app.connect("doctree-resolved", convert_pycon_blocks_to_python) + return { + "version": "1.0", + "parallel_read_safe": True, + "parallel_write_safe": True, + } diff --git a/docs/sphinx/index.rst b/docs/sphinx/index.rst new file mode 100644 index 00000000..5efbb903 --- /dev/null +++ b/docs/sphinx/index.rst @@ -0,0 +1,10 @@ +API Reference +============= + +.. This is a minimal master document required by Sphinx. + The actual output is generated by sphinx-autoapi. + +.. toctree:: + :glob: + + autoapi/index diff --git a/docs/src/components/DescriptionRenderer.astro b/docs/src/components/DescriptionRenderer.astro new file mode 100644 index 00000000..eafc90e8 --- /dev/null +++ b/docs/src/components/DescriptionRenderer.astro @@ -0,0 +1,46 @@ +--- +interface Props { + text: string +} + +const { text } = Astro.props + +const lines = text.split('\n') + +type Element = { tag: 'p'; content: string } | { tag: 'ul'; items: string[] } +const elements: Element[] = [] +let bulletBuffer: string[] = [] + +const flushBullets = () => { + if (bulletBuffer.length > 0) { + elements.push({ tag: 'ul', items: [...bulletBuffer] }) + bulletBuffer = [] + } +} + +for (const line of lines) { + const trimmed = line.trim() + if (!trimmed) continue + if (/^[-•]\s/.test(trimmed)) { + bulletBuffer.push(trimmed.replace(/^[-•]\s*/, '')) + } else { + flushBullets() + elements.push({ tag: 'p', content: trimmed }) + } +} +flushBullets() +--- + +{ + elements.map((el) => + el.tag === 'ul' ? ( +
    + {el.items.map((item) => ( +
  • + ))} +
+ ) : ( +

+ ), + ) +} diff --git a/docs/src/content.config.ts b/docs/src/content.config.ts new file mode 100644 index 00000000..d9ee8c9d --- /dev/null +++ b/docs/src/content.config.ts @@ -0,0 +1,7 @@ +import { defineCollection } from 'astro:content'; +import { docsLoader } from '@astrojs/starlight/loaders'; +import { docsSchema } from '@astrojs/starlight/schema'; + +export const collections = { + docs: defineCollection({ loader: docsLoader(), schema: docsSchema() }), +}; diff --git a/docs/src/content/docs/concepts/advanced/debugging.md b/docs/src/content/docs/concepts/advanced/debugging.md new file mode 100644 index 00000000..82b79f33 --- /dev/null +++ b/docs/src/content/docs/concepts/advanced/debugging.md @@ -0,0 +1,104 @@ +--- +title: "Debugger" +description: "The AlgoKit Python Utilities package provides a set of debugging tools that can be used to simulate and trace transactions on the Algorand blockchain. These tools and methods are optimized for developers who are building applications on Algorand and need to test and debug their smart contracts via [AlgoKit AVM Debugger extension](https://github.com/algorandfoundation/algokit-avm-vscode-debugger)." +--- + +The AlgoKit Python Utilities package provides a set of debugging tools that can be used to simulate and trace transactions on the Algorand blockchain. These tools and methods are optimized for developers who are building applications on Algorand and need to test and debug their smart contracts via [AlgoKit AVM Debugger extension](https://marketplace.visualstudio.com/items?itemName=algorandfoundation.algokit-avm-vscode-debugger). + +## Configuration + +The [`UpdatableConfig`](../../../../api/algokit_utils/config/#updatableconfig) class (source: `src/algokit_utils/config.py`) manages configuration settings for the AlgoKit project. A singleton instance is available as `config`: + +```python +from algokit_utils.config import config + +config.configure( + debug=True, + project_root=Path("/my/project"), + trace_all=True, + trace_buffer_size_mb=128, + max_search_depth=5, + populate_app_call_resources=False, +) +``` + +### Config flags + +| Flag | Type | Default | Description | +| --- | --- | --- | --- | +| `debug` | `bool` | `False` | Enables debug mode. When `True`, transaction traces are automatically generated and the logger level is set to `DEBUG`. | +| `project_root` | `Path \| None` | Auto-detected | Root directory used for storing trace files and source maps. Auto-detected by searching up for `.algokit.toml`, or from the `ALGOKIT_PROJECT_ROOT` env var. | +| `trace_all` | `bool` | `False` | When enabled, simulation traces are persisted for **all** operations, not just failed ones. | +| `trace_buffer_size_mb` | `float` | `256` | Maximum disk space (MB) for stored trace files. Oldest traces are cleaned up when the limit is exceeded. | +| `max_search_depth` | `int` | `10` | Maximum number of parent directories to traverse when auto-detecting `project_root`. | +| `populate_app_call_resources` | `bool` | `True` | When enabled, automatically populates required resources (accounts, assets, apps, boxes) on application call transactions via simulation. | +| `logger` | `logging.Logger` | `AlgoKitLogger()` | The logger instance used by the library. Can be replaced with any `logging.Logger`, including a null logger (see below). | + +## AlgoKitLogger + +[`AlgoKitLogger`](../../../../api/algokit_utils/config/#algokitlogger) is a custom `logging.Logger` subclass that provides fine-grained control over log output. It is the default logger for the library. + +### Per-call suppression + +Suppress an individual log call by passing `suppress_log=True` in the `extra` dict: + +```python +logger.info("This will be suppressed", extra={"suppress_log": True}) +logger.info("This will appear normally") +``` + +When `suppress_log=True` is set, the `_log` method returns immediately without emitting the record. + +### Global suppression + +To silence all library logging, replace the default logger with a null logger: + +```python +from algokit_utils.config import config, AlgoKitLogger + +config.configure(logger=AlgoKitLogger.get_null_logger()) +``` + +`get_null_logger()` returns a standard `logging.Logger` with only a `NullHandler` attached and propagation disabled, so no output is produced regardless of log level. + +## Debugging utilities + +Unlike the TypeScript version (which uses a [separate addon package](https://github.com/algorandfoundation/algokit-utils-ts-debug)), the Python debugging utilities are built directly into `algokit-utils-py`. When debug mode is enabled, AlgoKit Utils will automatically: + +- Generate transaction traces compatible with the AVM Debugger +- Manage trace file storage with automatic cleanup +- Provide source map generation for TEAL contracts + +### Manual debugging operations + +The following methods are provided for manual debugging operations: + +- `persist_sourcemaps`: Persists sourcemaps for given TEAL contracts as AVM Debugger-compliant artifacts. Parameters: + + - `sources`: List of `PersistSourceMapInput` sources to generate sourcemaps for + - `project_root`: Project root directory for storage + - `client`: `AlgodClient` instance + - `with_sources`: Whether to include TEAL source files (default: `True`) + +- `simulate_and_persist_response`: Simulates transactions and persists debug traces. Parameters: + - `composer`: `TransactionComposer` containing transactions + - `project_root`: Project root directory for storage + - `algod`: `AlgodClient` instance + - `buffer_size_mb`: Maximum trace storage in MB (default: `None`; when `None` and `trace_all` is enabled, falls back to `config.trace_buffer_size_mb` which defaults to `256`) + - `result`: Optional pre-existing simulation result + +### Trace filename format + +The trace files are named in a specific format to provide useful information about the transactions they contain. The format is as follows: + +``` +${timestamp}_lr${last_round}_${transaction_types}.trace.avm.json +``` + +Where: + +- `timestamp`: The time when the trace file was created in UTC, formatted as `YYYYMMDD_HHMMSS` (e.g., `20220301_123456`). +- `last_round`: The last round when the simulation was performed. +- `transaction_types`: A string representing the types and counts of transactions in the atomic group. Each transaction type is represented as `${count}${type}`, and different transaction types are separated by underscores. + +For example, a trace file might be named `20220301_123456_lr1000_2pay_1axfer.trace.avm.json`, indicating that the trace file was created at `2022-03-01 12:34:56 UTC`, the last round was `1000`, and the atomic group contained 2 payment transactions and 1 asset transfer transaction. diff --git a/docs/source/capabilities/dispenser-client.md b/docs/src/content/docs/concepts/advanced/dispenser-client.md similarity index 65% rename from docs/source/capabilities/dispenser-client.md rename to docs/src/content/docs/concepts/advanced/dispenser-client.md index d9370f0a..ecf70940 100644 --- a/docs/source/capabilities/dispenser-client.md +++ b/docs/src/content/docs/concepts/advanced/dispenser-client.md @@ -1,4 +1,7 @@ -# TestNet Dispenser Client +--- +title: "TestNet Dispenser Client" +description: "The TestNet Dispenser Client is a utility for interacting with the AlgoKit TestNet Dispenser API. It provides methods to fund an account, register a refund for a transaction, and get the current limit for an account." +--- The TestNet Dispenser Client is a utility for interacting with the AlgoKit TestNet Dispenser API. It provides methods to fund an account, register a refund for a transaction, and get the current limit for an account. @@ -7,13 +10,13 @@ The TestNet Dispenser Client is a utility for interacting with the AlgoKit TestN To create a Dispenser Client, you need to provide an authorization token. This can be done in two ways: 1. Pass the token directly to the client constructor as `auth_token`. -2. Set the token as an environment variable `ALGOKIT_DISPENSER_ACCESS_TOKEN` (see [docs](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/dispenser.md#login) on how to obtain the token). +2. Set the token as an environment variable `ALGOKIT_DISPENSER_ACCESS_TOKEN` (see [docs](https://github.com/algorandfoundation/algokit/blob/main/docs/testnet_api.md#error-handling) on how to obtain the token). If both methods are used, the constructor argument takes precedence. -```python -import algokit_utils +The recommended way to get a TestNet dispenser API client is [via `ClientManager`](../../core/client): +```python # With auth token dispenser = algorand.client.get_testnet_dispenser( auth_token="your_auth_token", @@ -27,29 +30,29 @@ dispenser = algorand.client.get_testnet_dispenser( # From environment variables # i.e. os.environ['ALGOKIT_DISPENSER_ACCESS_TOKEN'] = 'your_auth_token' -dispenser = algorand.client.get_testnet_dispenser_from_environment() +dispenser = algorand.client.get_testnet_dispenser() +``` + +Alternatively, you can construct it directly. -# Alternatively, you can construct it directly +```python from algokit_utils import TestNetDispenserApiClient # Using constructor argument -client = TestNetDispenserApiClient(auth_token="your_auth_token") +dispenser = TestNetDispenserApiClient(auth_token="your_auth_token") # Using environment variable import os -os.environ['ALGOKIT_DISPENSER_ACCESS_TOKEN'] = 'your_auth_token' -client = TestNetDispenserApiClient() +os.environ["ALGOKIT_DISPENSER_ACCESS_TOKEN"] = "your_auth_token" +dispenser = TestNetDispenserApiClient() ``` ## Funding an Account -To fund an account with Algo from the dispenser API, use the `fund` method. This method requires the receiver's address and the amount to be funded. +To fund an account with Algo from the dispenser API, use the `fund` method. This method requires the receiver's address and the amount to be funded (in microAlgos). ```python -response = dispenser.fund( - receiver="RECEIVER_ADDRESS", - amount=1000, # Amount in microAlgos -) +response = dispenser.fund("receiver_address", 1000) ``` The `fund` method returns a `DispenserFundResponse` object, which contains the transaction ID (`tx_id`) and the amount funded. @@ -66,10 +69,10 @@ dispenser.refund("transaction_id") ## Getting Current Limit -To get the current limit for an account with Algo from the dispenser API, use the `get_limit` method. +To get the current limit for an account with Algo from the dispenser API, use the `get_limit` method. This method requires the account address. ```python -response = dispenser.get_limit() +response = dispenser.get_limit("YOUR_ADDRESS") ``` The `get_limit` method returns a `DispenserLimitResponse` object, which contains the current limit amount. @@ -78,14 +81,21 @@ The `get_limit` method returns a `DispenserLimitResponse` object, which contains If an error occurs while making a request to the dispenser API, an exception will be raised with a message indicating the type of error. Refer to [Error Handling docs](https://github.com/algorandfoundation/algokit/blob/main/docs/testnet_api.md#error-handling) for details on how you can handle each individual error `code`. -Here's an example of handling errors: - ```python try: - response = dispenser.fund( - receiver="RECEIVER_ADDRESS", - amount=1000, - ) + response = dispenser.fund("receiver_address", 1_000_000) + print(f"Funded: {response.tx_id}") +except Exception as e: + print(f"Fund failed: {e}") + +try: + dispenser.refund("transaction_id") +except Exception as e: + print(f"Refund failed: {e}") + +try: + response = dispenser.get_limit("receiver_address") + print(f"Current limit: {response.amount}") except Exception as e: - print(f"Error occurred: {str(e)}") + print(f"Get limit failed: {e}") ``` diff --git a/docs/src/content/docs/concepts/advanced/indexer.md b/docs/src/content/docs/concepts/advanced/indexer.md new file mode 100644 index 00000000..b4d97916 --- /dev/null +++ b/docs/src/content/docs/concepts/advanced/indexer.md @@ -0,0 +1,105 @@ +--- +title: "Indexer lookups / searching" +description: "Indexer lookups / searching is a higher-order use case capability provided by AlgoKit Utils that builds on top of the core capabilities. It provides type-safe indexer API wrappers (no more dict[str, Any] pain), with typed dataclass response models and built-in retry logic." +--- + +Indexer lookups / searching is a higher-order use case capability provided by AlgoKit Utils that builds on top of the core capabilities. It provides type-safe indexer API wrappers (no more `dict[str, Any]` pain), with typed dataclass response models and built-in retry logic. + +To see some usage examples check out the [automated tests](https://github.com/algorandfoundation/algokit-utils-py/tree/main/tests/modules/indexer_client). + +To access the indexer client you can get it from [`AlgorandClient`](../../core/algorand-client) via `algorand.client.indexer`: + +```python +indexer = algorand.client.indexer +``` + +All of the indexer methods are called directly on the `IndexerClient` instance, which you can get from [`AlgorandClient`](../../core/algorand-client) via `algorand.client.indexer`. These calls are not made more easy to call by exposing via `AlgorandClient` and thus not requiring the indexer SDK client to be passed in. This is because we want to add a tiny bit of friction to using indexer, given it's an expensive API to run for node providers, the data from it can sometimes be slow and stale, and there are alternatives [that](https://github.com/algorandfoundation/algokit-subscriber-ts) [allow](https://github.com/algorand/conduit) individual projects to index subsets of chain data specific to them as a preferred option. In saying that, it's a very useful API for doing ad hoc data retrieval, writing automated tests, and many other uses. + +## Indexer wrapper functions + +The `IndexerClient` (from `algokit_indexer_client`) exposes the full [indexer API](https://dev.algorand.co/reference/rest-apis/indexer) as type-safe methods with typed dataclass responses and automatic retry with exponential backoff. + +**Lookup methods:** + +- `indexer.lookup_transaction_by_id(txid)` - Finds a transaction by ID +- `indexer.lookup_account_by_id(account_id)` - Finds an account by address +- `indexer.lookup_account_transactions(account_id)` - Finds all transactions for an account +- `indexer.lookup_account_assets(account_id)` - Finds all asset holdings for an account +- `indexer.lookup_account_app_local_states(account_id)` - Finds all application local states for an account +- `indexer.lookup_account_created_applications(account_id)` - Finds all applications created by an account +- `indexer.lookup_account_created_assets(account_id)` - Finds all assets created by an account +- `indexer.lookup_application_by_id(application_id)` - Finds an application by ID +- `indexer.lookup_application_logs_by_id(application_id)` - Finds log messages for an application +- `indexer.lookup_application_box_by_id_and_name(application_id, name)` - Finds a specific application box by name +- `indexer.lookup_asset_by_id(asset_id)` - Finds an asset by ID +- `indexer.lookup_asset_balances(asset_id)` - Finds all asset holdings for the given asset +- `indexer.lookup_asset_transactions(asset_id)` - Finds all transactions for an asset +- `indexer.lookup_block(round_number)` - Finds a block by round number + +**Search methods:** + +- `indexer.search_for_transactions(...)` - Search for transactions with a given set of criteria +- `indexer.search_for_accounts(...)` - Search for accounts with a given set of criteria +- `indexer.search_for_applications(...)` - Search for applications with a given set of criteria +- `indexer.search_for_assets(...)` - Search for assets with a given set of criteria +- `indexer.search_for_application_boxes(application_id)` - Search for application boxes +- `indexer.search_for_block_headers(...)` - Search for block headers with a given set of criteria + +### Search transactions example + +To use the `indexer.search_for_transactions` method, you can follow this example as a starting point: + +```python +transactions = indexer.search_for_transactions( + tx_type="pay", + address_role="sender", + address=my_address, +) +``` + +### Automatic pagination example + +All paginated responses include a `next_token` field. You can use it to iterate through pages: + +```python +all_transactions = [] +next_token = None + +while True: + response = indexer.search_for_transactions( + tx_type="pay", + address=my_address, + limit=1000, + next_=next_token, + ) + all_transactions.extend(response.transactions or []) + + if not response.next_token: + break + next_token = response.next_token +``` + +The `next_` parameter accepts the pagination token from the previous response's `next_token` field, allowing you to iterate through all results. + +## Indexer API response types + +The response model type definitions for the [indexer API](https://dev.algorand.co/reference/rest-apis/indexer) are auto-generated typed dataclasses available from the `algokit_indexer_client` package. + +To access these types you can import them: + +```python +from algokit_indexer_client.models import ( + TransactionResponse, + TransactionsResponse, + AccountResponse, + AccountsResponse, + ApplicationResponse, + ApplicationsResponse, + AssetResponse, + AssetsResponse, + Block, + # ... +) +``` + +The types follow the naming conventions from the official Algorand indexer API specification. Singular response types (e.g., `TransactionResponse`, `AccountResponse`) are returned by lookup methods, while plural response types (e.g., `TransactionsResponse`, `AccountsResponse`) are returned by search methods and include pagination support via `next_token`. diff --git a/docs/src/content/docs/concepts/advanced/modular-imports.md b/docs/src/content/docs/concepts/advanced/modular-imports.md new file mode 100644 index 00000000..322fa0fc --- /dev/null +++ b/docs/src/content/docs/concepts/advanced/modular-imports.md @@ -0,0 +1,239 @@ +--- +title: "Modular imports" +description: "AlgoKit Utils is designed with a modular architecture that allows you to import only the functionality you need. This keeps your imports explicit and helps with code readability and IDE auto-completion." +--- + +AlgoKit Utils is designed with a modular architecture that allows you to import only the functionality you need. This keeps your imports explicit and helps with code readability and IDE auto-completion. + +## Package architecture + +The library is organized into several submodules, each containing related functionality: + +| Submodule | Purpose | Key Exports | +|-----------|---------|-------------| +| `accounts` | Account management | `AccountManager`, `KmdAccountManager` | +| `algorand` | Algorand client entry point | `AlgorandClient` | +| `applications` | App clients, deployment, specs | `AppClient`, `AppFactory`, `AppDeployer`, `AppManager`, `Arc56Contract` | +| `assets` | Asset management | `AssetManager` | +| `clients` | API client management | `ClientManager`, `AlgodClient`, `IndexerClient`, `KmdClient`, `TestNetDispenserApiClient` | +| `models` | Data models | `AlgoAmount`, `AlgoClientConfigs`, `AppState`, `SimulateTransactionResult` | +| `transactions` | Transaction composition | `TransactionComposer`, `AlgorandClientTransactionCreator`, `AlgorandClientTransactionSender` | +| `protocols` | Protocol definitions | `AddressWithTransactionSigner`, `TypedAppClientProtocol`, `TypedAppFactoryProtocol` | +| `errors` | Error handling | `LogicError` | +| `transact` | Transaction primitives (re-exported from `algokit_transact`) | `Transaction`, `TransactionSigner`, `OnApplicationComplete`, `BoxReference` | + +## Using modular imports + +### Root import vs submodule imports + +The root `algokit_utils` package re-exports everything from all submodules via `__init__.py`, so for most use cases you can import directly from the root: + +```python +from algokit_utils import AlgorandClient, AlgoAmount, AppClient +``` + +For more explicit and readable imports, use submodule imports: + +```python +# Account management +from algokit_utils.accounts import AccountManager + +# Application clients and deployment +from algokit_utils.applications import AppClient, AppFactory, AppDeployer + +# API client types +from algokit_utils.clients import ClientManager, AlgodClient, IndexerClient + +# Transaction composition +from algokit_utils.transactions import TransactionComposer +``` + +### Type-only imports + +When you only need types for annotations (not runtime values), Python's `TYPE_CHECKING` guard avoids circular imports and keeps runtime overhead minimal: + +```python +from __future__ import annotations +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from algokit_utils.applications import AppClient + from algokit_utils.models import AppState +``` + +## Submodule details + +### `accounts` + +Contains account management and KMD integration: + +```python +from algokit_utils.accounts import ( + AccountManager, + KmdAccountManager, +) +``` + +### `applications` + +Contains app client, factory, deployment, and ABI utilities: + +```python +from algokit_utils.applications import ( + # App client and factory + AppClient, + AppFactory, + + # Deployment + AppDeployer, + + # App management + AppManager, + + # ABI utilities + ABIReturn, + + # App spec + Arc56Contract, + + # Enums + OnSchemaBreak, + OnUpdate, +) +``` + +### `transactions` + +Contains transaction composition, creation, and sending: + +```python +from algokit_utils.transactions import ( + TransactionComposer, + AlgorandClientTransactionCreator, + AlgorandClientTransactionSender, +) +``` + +Transaction parameter types are also exported from the `transactions` module (via `transaction_composer`): + +```python +from algokit_utils.transactions import ( + # Payment transactions + PaymentParams, + + # App transactions + AppCreateParams, + AppCallParams, + AppCallMethodCallParams, + + # Asset transactions + AssetCreateParams, + AssetTransferParams, + AssetOptInParams, +) +``` + +The `transactions.builders` sub-package provides lower-level transaction builder functions: + +```python +from algokit_utils.transactions.builders import ( + build_payment_transaction, + build_app_create_transaction, + build_app_call_transaction, + build_asset_create_transaction, + build_asset_transfer_transaction, +) +``` + +### `clients` + +Contains API client management and dispenser client: + +```python +from algokit_utils.clients import ( + ClientManager, + AlgodClient, + IndexerClient, + KmdClient, + TestNetDispenserApiClient, +) +``` + +### `models` + +Contains data models for amounts, network config, state, and transactions: + +```python +from algokit_utils.models import ( + # Amounts + AlgoAmount, + + # Network config + AlgoClientConfigs, + + # Application state + AppState, + + # Simulation + SimulateTransactionResult, +) +``` + +### `transact` + +Re-exports core transaction primitives from the `algokit_transact` library: + +```python +from algokit_utils.transact import ( + Transaction, + TransactionSigner, + OnApplicationComplete, + BoxReference, + LogicSigAccount, +) +``` + +### `protocols` + +Contains protocol (interface) definitions: + +```python +from algokit_utils.protocols import ( + AddressWithTransactionSigner, + TypedAppClientProtocol, + TypedAppFactoryProtocol, +) +``` + +## How re-exports work + +Each submodule's `__init__.py` re-exports from its internal modules using wildcard imports. The root `algokit_utils/__init__.py` then aggregates all submodules: + +```python +# algokit_utils/__init__.py +from algokit_utils.applications import * +from algokit_utils.assets import * +from algokit_utils.protocols import * +from algokit_utils.models import * +from algokit_utils.accounts import * +from algokit_utils.clients import * +from algokit_utils.transactions import * +from algokit_utils.errors import * +from algokit_utils.algorand import * +from algokit_utils.transact import * +``` + +This means any public symbol from any submodule is available at the root level. However, using submodule imports makes your code more explicit about where each symbol comes from. + +## When to use modular imports + +**Use the root import when:** +- You're writing scripts or quick prototypes +- You need just a few commonly-used classes like `AlgorandClient` or `AlgoAmount` +- Brevity is more important than explicitness + +**Use submodule imports when:** +- You want clear, self-documenting imports +- You're building a library or larger application +- You want to avoid namespace pollution +- You need types from a specific domain (e.g., only transaction types) diff --git a/docs/src/content/docs/concepts/advanced/transaction-composer.md b/docs/src/content/docs/concepts/advanced/transaction-composer.md new file mode 100644 index 00000000..ec472b3d --- /dev/null +++ b/docs/src/content/docs/concepts/advanced/transaction-composer.md @@ -0,0 +1,422 @@ +--- +title: "Transaction composer" +description: "The `TransactionComposer` class allows you to easily compose one or more compliant Algorand transactions and execute and/or simulate them." +--- + +The `TransactionComposer` class allows you to easily compose one or more compliant Algorand transactions and execute and/or simulate them. + +It's the core of how the [`AlgorandClient`](../../core/algorand-client) class composes and sends transactions. + +To get an instance of `TransactionComposer` you can either get it from an [app client](../../building/app-client), from an [`AlgorandClient`](../../core/algorand-client), or by instantiating via the constructor. + +```python +composer_from_algorand = algorand.new_group() +composer_from_app_client = app_client.algorand.new_group() +composer_from_constructor = TransactionComposer( + TransactionComposerParams( + algod=algod, + # Return the TransactionSigner for this address + get_signer=lambda address: signer, + ) +) +composer_from_constructor_with_optional_params = TransactionComposer( + TransactionComposerParams( + algod=algod, + # Return the TransactionSigner for this address + get_signer=lambda address: signer, + get_suggested_params=lambda: algod.suggested_params(), + default_validity_window=1000, + app_manager=AppManager(algod), + ) +) +``` + +## Constructing a transaction + +To construct a transaction you need to add it to the composer, passing in the relevant `params object` for that transaction. Params are Python dataclasses and all of them extend the [common call parameters](../../core/algorand-client#transaction-parameters). + +The `methods to construct a transaction` are all named `add_{transaction_type}` and return an instance of the composer so they can be chained together fluently to construct a transaction group. + +For example: + +```python +from algokit_abi import arc56 + +my_method = arc56.Method.from_signature('my_method()void') +result = ( + algorand.new_group() + .add_payment(PaymentParams( + sender="SENDER", + receiver="RECEIVER", + amount=AlgoAmount.from_micro_algo(100), + )) + .add_app_call_method_call(AppCallMethodCallParams( + sender="SENDER", + app_id=123, + method=my_method, + args=[1, 2, 3], + )) +) +``` + +### Transaction parameter types + +Each `add_*` method accepts a corresponding params dataclass. All param types are defined in `algokit_utils.transactions.types` and extend `CommonTxnParams`. + +| Composer method | Params type | Key fields (beyond common) | +| --- | --- | --- | +| `add_payment` | `PaymentParams` | `receiver`, `amount`, `close_remainder_to` | +| `add_asset_create` | `AssetCreateParams` | `total`, `asset_name`, `unit_name`, `url`, `decimals`, `default_frozen`, `manager`, `reserve`, `freeze`, `clawback`, `metadata_hash` | +| `add_asset_config` | `AssetConfigParams` | `asset_id`, `manager`, `reserve`, `freeze`, `clawback` | +| `add_asset_freeze` | `AssetFreezeParams` | `asset_id`, `account`, `frozen` | +| `add_asset_destroy` | `AssetDestroyParams` | `asset_id` | +| `add_asset_transfer` | `AssetTransferParams` | `asset_id`, `amount`, `receiver`, `close_asset_to`, `clawback_target` | +| `add_asset_opt_in` | `AssetOptInParams` | `asset_id` | +| `add_asset_opt_out` | `AssetOptOutParams` | `asset_id`, `creator` | +| `add_app_call` | `AppCallParams` | `app_id`, `args`, `on_complete`, reference arrays | +| `add_app_create` | `AppCreateParams` | `approval_program`, `clear_state_program`, `schema`, `on_complete`, `args`, `extra_program_pages`, reference arrays | +| `add_app_update` | `AppUpdateParams` | `app_id`, `approval_program`, `clear_state_program`, `on_complete`, `args`, reference arrays | +| `add_app_delete` | `AppDeleteParams` | `app_id`, `on_complete`, `args`, reference arrays | +| `add_app_call_method_call` | `AppCallMethodCallParams` | `app_id`, `method`, `args`, `on_complete`, reference arrays | +| `add_app_create_method_call` | `AppCreateMethodCallParams` | `method`, `approval_program`, `clear_state_program`, `schema`, `extra_program_pages`, reference arrays | +| `add_app_update_method_call` | `AppUpdateMethodCallParams` | `app_id`, `method`, `approval_program`, `clear_state_program`, reference arrays | +| `add_app_delete_method_call` | `AppDeleteMethodCallParams` | `app_id`, `method`, reference arrays | +| `add_online_key_registration` | `OnlineKeyRegistrationParams` | `vote_key`, `selection_key`, `state_proof_key`, `vote_first`, `vote_last`, `vote_key_dilution`, `nonparticipation` | +| `add_offline_key_registration` | `OfflineKeyRegistrationParams` | `prevent_account_from_ever_participating_again` | + +> [!NOTE] +> "Reference arrays" refers to the optional fields `account_references`, `app_references`, `asset_references`, and `box_references` available on all app call param types. + +#### Common transaction parameters + +All param types inherit these fields from `CommonTxnParams`: + +| Field | Type | Description | +| --- | --- | --- | +| `sender` | `str` | The address of the account sending the transaction (required) | +| `signer` | `TransactionSigner \| AddressWithTransactionSigner \| None` | The signer to use; defaults to the registered signer for `sender` | +| `rekey_to` | `str \| None` | Rekey the sender account to this address | +| `note` | `bytes \| None` | Arbitrary note to attach | +| `lease` | `bytes \| None` | Lease to prevent duplicate transactions | +| `static_fee` | `AlgoAmount \| None` | Exact fee (overrides calculated fee) | +| `extra_fee` | `AlgoAmount \| None` | Additional fee on top of the calculated fee | +| `max_fee` | `AlgoAmount \| None` | Maximum fee cap; errors if exceeded | +| `validity_window` | `int \| None` | Number of rounds the transaction is valid | +| `first_valid_round` | `int \| None` | Explicit first valid round | +| `last_valid_round` | `int \| None` | Explicit last valid round | + +#### Example: `PaymentParams` structure + +```python +from algokit_utils.transactions.types import PaymentParams +from algokit_utils.models.amount import AlgoAmount + +params = PaymentParams( + sender="SENDER_ADDRESS", + receiver="RECEIVER_ADDRESS", + amount=AlgoAmount.from_algo(1), + # Optional common fields + note=b"payment note", + max_fee=AlgoAmount.from_micro_algo(2000), +) +``` + +## Sending a transaction + +Once you have constructed all the required transactions, they can be sent by calling `send()` on the `TransactionComposer`. +Additionally `send()` takes a number of parameters which allow you to opt-in to some additional behaviours as part of sending the transaction or transaction group, most significantly `populate_app_call_resources` and `cover_app_call_inner_transaction_fees`. + +### Populating App Call Resources + +`populate_app_call_resources` automatically updates the relevant app call transactions in the group to include the account, app, asset and box resources required for the transactions to execute successfully. It leverages the simulate endpoint to discover the accessed resources, which have not been explicitly specified. This setting only applies when you have constructed at least one app call transaction. You can read more about [resources and the reference arrays](https://dev.algorand.co/concepts/smart-contracts/resource-usage/#what-are-reference-arrays) in the docs. + +For example: + +```python +from algokit_abi import arc56 + +my_method = arc56.Method.from_signature('my_method()void') +result = ( + algorand.new_group() + .add_app_call_method_call(AppCallMethodCallParams( + sender="SENDER", + app_id=123, + method=my_method, + args=[1, 2, 3], + )) + .send(SendParams( + populate_app_call_resources=True, + )) +) +``` + +If `my_method` in the above example accesses any resources, they will be automatically discovered and added before sending the transaction to the network. + +#### How resource population works + +Resource population is enabled by default via `TransactionComposerConfig(populate_app_call_resources=True)`. You can override it per-send via `SendParams` or disable it globally when constructing the composer. + +When at least one `AppCall` transaction is present in the group, the composer runs the following flow before signing and sending: + +1. **Simulate** — The composer builds a copy of all transactions and submits them to the algod simulate endpoint with `allow_unnamed_resources=True` and empty signers. This tells algod to report which resources each transaction accessed without requiring real signatures. +2. **Collect results** — The simulate response provides `unnamed_resources_accessed` at both per-transaction and group level, listing accounts, apps, assets, boxes, app-local state, and asset-holding cross-references that were accessed but not explicitly included in the transaction's reference arrays. +3. **Per-transaction population** — For each app call transaction, simple resources (accounts, apps, assets) are added directly to that transaction's reference arrays, up to the maximum reference limit. +4. **Group-level population** — Cross-reference resources (app-local state lookups, asset-holding lookups, boxes) require slots in multiple reference arrays simultaneously. The composer distributes these across the group's app call transactions using a best-fit strategy: it first tries transactions that already hold one side of the cross-reference, then falls back to the first transaction with available capacity. + +The population order for group-level resources is: app-local cross-references, asset-holding cross-references, remaining accounts, boxes, remaining assets, remaining apps, and finally extra box references. + +> [!NOTE] +> If a transaction already has explicitly provided reference arrays, resource population will skip that transaction and log a warning. This prevents the composer from overwriting resources you have set manually. + +> [!NOTE] +> If the group runs out of reference slots across all app call transactions, a `ValueError` is raised suggesting you add another app call transaction to the group to provide more reference capacity. + +### Covering App Call Inner Transaction Fees + +`cover_app_call_inner_transaction_fees` automatically calculate the required fee for a parent app call transaction that sends inner transactions. It leverages the simulate endpoint to discover the inner transactions sent and calculates a fee delta to resolve the optimal fee. This feature also takes care of accounting for any surplus transaction fee at the various levels, so as to effectively minimise the fees needed to successfully handle complex scenarios. This setting only applies when you have constructed at least one app call transaction. + +For example: + +```python +from algokit_abi import arc56 + +my_method = arc56.Method.from_signature('my_method()void') +result = ( + algorand + .new_group() + .add_app_call_method_call(AppCallMethodCallParams( + sender="SENDER", + app_id=123, + method=my_method, + args=[1, 2, 3], + max_fee=AlgoAmount.from_micro_algo(5000), # NOTE: a max_fee value is required when enabling cover_app_call_inner_transaction_fees + )) + .send(SendParams(cover_app_call_inner_transaction_fees=True)) +) +``` + +Assuming the app account is not covering any of the inner transaction fees, if `my_method` in the above example sends 2 inner transactions, then the fee calculated for the parent transaction will be 3000 µALGO when the transaction is sent to the network. + +The above example also has a `max_fee` of 5000 µALGO specified. An exception will be thrown if the transaction fee exceeds that value, which allows you to set fee limits. The `max_fee` field is required when enabling `cover_app_call_inner_transaction_fees`. + +Because `max_fee` is required and a `Transaction` does not hold any max fee information, you cannot use the generic `add_transaction()` method on the composer with `cover_app_call_inner_transaction_fees` enabled. Instead use the below, which provides a better overall experience: + +```python +my_method = arc56.Method.from_signature('my_method()void') + +# Does not work +result = ( + algorand + .new_group() + .add_transaction(algorand.create_transaction.app_call_method_call( + AppCallMethodCallParams( + sender="SENDER", + app_id=123, + method=my_method, + args=[1, 2, 3], + max_fee=AlgoAmount.from_micro_algo(5000), # This is only used to create the Transaction object and isn't made available to the composer. + ) + ).transactions[0]) + .send(SendParams(cover_app_call_inner_transaction_fees=True)) +) + +# Works as expected +result = ( + algorand + .new_group() + .add_app_call_method_call(AppCallMethodCallParams( + sender="SENDER", + app_id=123, + method=my_method, + args=[1, 2, 3], + max_fee=AlgoAmount.from_micro_algo(5000), + )) + .send(SendParams(cover_app_call_inner_transaction_fees=True)) +) +``` + +A more complex valid scenario which leverages an app client to send an ABI method call with ABI method call transactions argument is below: + +```python +app_factory = algorand.client.get_app_factory( + app_spec="APP_SPEC", + default_sender=sender.addr, +) + +app_client_1, _ = app_factory.send.bare.create() +app_client_2, _ = app_factory.send.bare.create() + +payment_arg = algorand.create_transaction.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_micro_algo(1), + ) +) + +# Note the use of .params. here, this ensure that max_fee is still available to the composer +app_call_arg = app_client_2.params.call( + AppClientMethodCallParams( + method="my_other_method", + args=[], + max_fee=AlgoAmount.from_micro_algo(2000), + ) +) + +result = ( + app_client_1.algorand + .new_group() + .add_app_call_method_call( + app_client_1.params.call( + AppClientMethodCallParams( + method="my_method", + args=[payment_arg, app_call_arg], + max_fee=AlgoAmount.from_micro_algo(5000), + ) + ), + ) + .send(SendParams(cover_app_call_inner_transaction_fees=True)) +) +``` + +This feature should efficiently calculate the minimum fee needed to execute an app call transaction with inners, however we always recommend testing your specific scenario behaves as expected before releasing. + +#### Read-only calls + +When invoking a readonly method, the transaction is simulated rather than being fully processed by the network. This allows users to call these methods without paying a fee. + +Even though no actual fee is paid, the simulation still evaluates the transaction as if a fee was being paid, therefore op budget and fee coverage checks are still performed. + +Because no fee is actually paid, calculating the minimum fee required to successfully execute the transaction is not required, and therefore we don't need to send an additional simulate call to calculate the minimum fee, like we do with a non readonly method call. + +The behaviour of enabling `cover_app_call_inner_transaction_fees` for readonly method calls is very similar to non readonly method calls, however is subtly different as we use `max_fee` as the transaction fee when executing the readonly method call. + +### Covering App Call Op Budget + +The high level Algorand contract authoring languages all have support for ensuring appropriate app op budget is available via `ensure_budget` in Algorand Python, `ensureBudget` in Algorand TypeScript and `increaseOpcodeBudget` in TEALScript. This is great, as it allows contract authors to ensure appropriate budget is available by automatically sending op-up inner transactions to increase the budget available. These op-up inner transactions require the fees to be covered by an account, which is generally the responsibility of the application consumer. + +Application consumers may not be immediately aware of the number of op-up inner transactions sent, so it can be difficult for them to determine the exact fees required to successfully execute an application call. Fortunately the `cover_app_call_inner_transaction_fees` setting above can be leveraged to automatically cover the fees for any op-up inner transaction that an application sends. Additionally if a contract author decides to cover the fee for an op-up inner transaction, then the application consumer will not be charged a fee for that transaction. + +## Simulating a transaction + +Transactions can be simulated using the simulate endpoint in algod, which enables evaluating the transaction on the network without it actually being committed to a block. +This is a powerful feature, which has a number of options which are detailed in the [simulate API docs](https://dev.algorand.co/reference/rest-apis/output/#simulatetransaction). + +For example you can simulate a transaction group like below: + +```python +result = ( + algorand.new_group() + .add_payment(PaymentParams( + sender="SENDER", + receiver="RECEIVER", + amount=AlgoAmount.from_micro_algo(100), + )) + .add_app_call_method_call(AppCallMethodCallParams( + sender="SENDER", + app_id=123, + method=abi_method, + args=[1, 2, 3], + )) + .simulate() +) +``` + +The above will execute a simulate request asserting that all transactions in the group are correctly signed. + +### Simulate without signing + +There are situations where you may not be able to (or want to) sign the transactions when executing simulate. +In these instances you should set `skip_signatures=True` which automatically builds empty transaction signers and sets both `fix-signers` and `allow-empty-signatures` to `True` when sending the algod API call. + +For example: + +```python +result = ( + algorand.new_group() + .add_payment(PaymentParams( + sender="SENDER", + receiver="RECEIVER", + amount=AlgoAmount.from_micro_algo(100), + )) + .add_app_call_method_call(AppCallMethodCallParams( + sender="SENDER", + app_id=123, + method=abi_method, + args=[1, 2, 3], + )) + .simulate(skip_signatures=True) +) +``` + +## Error Transformers + +Error transformers let you intercept and transform errors raised when sending or simulating transactions. This is useful for mapping low-level Algorand errors into domain-specific exceptions. + +### Type definitions + +```python +from collections.abc import Callable + +# A transformer receives an Exception and must return an Exception +ErrorTransformer = Callable[[Exception], Exception] +``` + +Two guard-rail exceptions are defined in `algokit_utils.transactions.transaction_composer`: + +| Exception | Raised when | +| --- | --- | +| `ErrorTransformerError` | A transformer itself raises an exception | +| `InvalidErrorTransformerValueError` | A transformer returns a non-`Exception` value | + +When a transaction fails, the composer wraps the underlying error into a `TransactionComposerError` (which carries `traces`, `sent_transactions`, and `simulate_response` for debugging) before passing it through the transformer chain. + +### Registration API + +Transformers can be registered at two levels: + +**On `AlgorandClient`** — applies to all composers created via `new_group()`: + +```python +def my_transformer(err: Exception) -> Exception: + if "TRANSACTION_REJECTED" in str(err): + return MyDomainError("Transaction was rejected by the network") + return err + +algorand.register_error_transformer(my_transformer) + +# Remove it later +algorand.unregister_error_transformer(my_transformer) +``` + +`AlgorandClient` stores transformers in a set (de-duplicated). A snapshot is passed to each new composer at `new_group()` time. + +**On `TransactionComposer`** — applies only to that composer instance: + +```python +composer = algorand.new_group() +composer.register_error_transformer(my_transformer) +``` + +Transformers registered directly on the composer are appended after those inherited from the client. + +### Error flow + +When `send()` catches an exception, the following steps occur: + +1. **Interpret** — The raw error is unwrapped (e.g. extracting the algod message from HTTP status errors). +2. **Wrap** — The interpreted error is wrapped into a `TransactionComposerError` with debug context (simulation traces, sent transactions). +3. **Transform** — The composer error is passed through each registered transformer in order. Each transformer receives the output of the previous one (chained), not the original error. +4. **Raise** — The final transformed error is raised with the original exception set as the cause (`raise transformed from original`). + +```python +# Simplified flow inside send() +try: + # ... build, sign, send +except Exception as err: + interpreted = self._interpret_error(err) + composer_error = self._create_composer_error(interpreted, ...) + raise self._transform_error(composer_error) from err +``` + +If a transformer raises, the chain stops and an `ErrorTransformerError` is raised instead. If a transformer returns a non-`Exception` value, an `InvalidErrorTransformerValueError` is raised. diff --git a/docs/src/content/docs/concepts/building/app-client.md b/docs/src/content/docs/concepts/building/app-client.md new file mode 100644 index 00000000..2fcd73d8 --- /dev/null +++ b/docs/src/content/docs/concepts/building/app-client.md @@ -0,0 +1,475 @@ +--- +title: "App client and App factory" +description: "App client and App factory are higher-order use case capabilities provided by AlgoKit Utils that builds on top of the core capabilities, particularly [App deployment](./app-deploy.md) and [App management](./app.md). They allow you to access high productivity application clients that work with [ARC-56](https://github.com/algorandfoundation/ARCs/pull/258) and [ARC-32](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0032.md) application spec defined smart contracts, which you can use to create, update, delete, deploy and call a smart contract and access state data for it." +--- + +> [!NOTE] +> This page covers the untyped app client, but we recommend using [typed clients](../typed-app-clients), which will give you a better developer experience with strong typing specific to the app itself. + +App client and App factory are higher-order use case capabilities provided by AlgoKit Utils that builds on top of the core capabilities, particularly [App deployment](../app-deploy) and [App management](../app). They allow you to access high productivity application clients that work with [ARC-56](https://github.com/algorandfoundation/ARCs/pull/258) and [ARC-32](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0032.md) application spec defined smart contracts, which you can use to create, update, delete, deploy and call a smart contract and access state data for it. + +> [!NOTE] +> +> If you are confused about when to use the factory vs client the mental model is: use the client if you know the app ID, use the factory if you don't know the app ID (deferred knowledge or the instance doesn't exist yet on the blockchain) or you have multiple app IDs + +## AppFactory + +The `AppFactory` is a class that, for a given app spec, allows you to create and deploy one or more app instances and to create one or more app clients to interact with those (or other) app instances. + +To get an instance of `AppFactory` you can use either [`AlgorandClient`](../../core/algorand-client) via `algorand.client.get_app_factory` or instantiate it directly (passing in an app spec, an `AlgorandClient` instance and other optional parameters): + +```python +# Minimal example +factory = algorand.client.get_app_factory( + app_spec="{/* ARC-56 or ARC-32 compatible JSON */}", +) + +# Advanced example +factory = algorand.client.get_app_factory( + app_spec=parsed_arc32_or_arc56_app_spec, + default_sender="SENDERADDRESS", + app_name="OverriddenAppName", + version="2.0.0", + compilation_params={ + "updatable": True, + "deletable": False, + "deploy_time_params": {"ONE": 1, "TWO": "value"}, + }, +) +``` + +## AppClient + +The `AppClient` is a class that, for a given app spec, allows you to manage calls and state for a specific deployed instance of an app (with a known app ID). + +To get an instance of `AppClient` you can use either [`AlgorandClient`](../../core/algorand-client) via `algorand.client.get_app_client_*` or instantiate it directly (passing in an app ID, app spec, `AlgorandClient` instance and other optional parameters): + +```python +# Minimal examples +app_client = algorand.client.get_app_client_by_creator_and_name( + app_spec="{/* ARC-56 or ARC-32 compatible JSON */}", + # app_id resolved by looking for app ID of named app by this creator + creator_address="CREATORADDRESS", + app_name="MyApp", +) +app_client = algorand.client.get_app_client_by_id( + app_spec="{/* ARC-56 or ARC-32 compatible JSON */}", + app_id=12345, +) +app_client = algorand.client.get_app_client_by_network( + app_spec="{/* ARC-56 or ARC-32 compatible JSON */}", + # app_id resolved by using ARC-56 spec to find app ID for current network +) + +# Advanced example +app_client = algorand.client.get_app_client_by_id( + app_spec=parsed_app_spec, + app_id=12345, + app_name="OverriddenAppName", + default_sender="SENDERADDRESS", + approval_source_map=approval_teal_source_map, + clear_source_map=clear_teal_source_map, +) +``` + +You can get the `app_id` and `app_address` at any time as properties on the `AppClient` along with `app_name` and `app_spec`. + +## Dynamically creating clients for a given app spec + +As well as allowing you to control creation and deployment of apps, the `AppFactory` allows you to conveniently create multiple `AppClient` instances on-the-fly with information pre-populated. + +This is possible via two methods on the app factory: + +- `factory.get_app_client_by_id(params)` - Returns a new `AppClient` for an app instance of the given ID. Automatically populates app_name, default_sender and source maps from the factory if not specified in the params. +- `factory.get_app_client_by_creator_and_name(params)` - Returns a new `AppClient`, resolving the app by creator address and name using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). Automatically populates app_name, default_sender and source maps from the factory if not specified in the params. + +```python +app_client1 = factory.get_app_client_by_id(app_id=12345) +app_client2 = factory.get_app_client_by_id(app_id=12346) +app_client3 = factory.get_app_client_by_id( + app_id=12345, + default_sender="SENDER2ADDRESS", +) + +app_client4 = factory.get_app_client_by_creator_and_name( + creator_address="CREATORADDRESS", + app_name="MyApp", +) +app_client5 = factory.get_app_client_by_creator_and_name( + creator_address="CREATORADDRESS", + app_name="NonDefaultAppName", +) +app_client6 = factory.get_app_client_by_creator_and_name( + creator_address="CREATORADDRESS", + app_name="NonDefaultAppName", + ignore_cache=True, # Perform fresh indexer lookups + default_sender="SENDER2ADDRESS", +) +``` + +## Creating and deploying an app + +Once you have an [app factory](#appfactory) you can perform the following actions: + +- `factory.send.bare.create(...)` - Signs and sends a transaction to create an app and returns a tuple of an [`AppClient`](#appclient) instance for the created app and the [result of that call](./app.md#creation) +- `factory.deploy(...)` - Uses the [creator address and app name pattern](./app-deploy.md#lookup-deployed-apps-by-name) to find if the app has already been deployed or not and either creates, updates or replaces that app based on the [deployment rules](./app-deploy.md#performing-a-deployment) (i.e. it's an idempotent deployment) and returns a tuple of an [`AppClient`](#appclient) instance for the created/updated/existing app and the [result of the deployment](./app-deploy.md#return-value) + +### Create + +The create method is a wrapper over the `app_create` (bare calls) and `app_create_method_call` (ABI method calls) [methods](./app.md#creation), with the following differences: + +- You don't need to specify the `approval_program`, `clear_state_program`, or `schema` because these are all specified or calculated from the app spec (noting you can override the `schema`) +- `sender` is optional and if not specified then the `default_sender` from the `AppFactory` constructor is used (if it was specified, otherwise an error is thrown) +- `deploy_time_params`, `updatable` and `deletable` can be passed in to control [deploy-time parameter replacements and deploy-time immutability and permanence control](./app-deploy.md#compilation-and-template-substitution); these values can also be passed into the `AppFactory` constructor instead and if so will be used if not defined in the params to the create call + +```python +# Use no-argument bare-call +app_client, result = factory.send.bare.create() + +# Specify parameters for bare-call and override other parameters +app_client, result = factory.send.bare.create( + params=AppFactoryCreateParams( + args=[bytes([1, 2, 3, 4])], + static_fee=AlgoAmount.from_micro_algo(3000), + on_complete=OnApplicationComplete.OptIn, + ), + compilation_params={ + "deploy_time_params": { + "ONE": 1, + "TWO": "two", + }, + "updatable": True, + "deletable": False, + }, +) + +# Specify parameters for ABI method call +app_client, result = factory.send.create( + AppFactoryCreateMethodCallParams( + method="create_application", + args=[1, "something"], + ) +) +``` + +If you want to construct a custom create call, use the underlying [`algorand.send.app_create` / `algorand.create_transaction.app_create` / `algorand.send.app_create_method_call` / `algorand.create_transaction.app_create_method_call` methods](./app.md#creation) then you can get params objects: + +- `factory.params.create(params)` - ABI method create call for deploy method or an underlying [`app_create_method_call` call](./app.md#creation) +- `factory.params.bare.create(params)` - Bare create call for deploy method or an underlying [`app_create` call](./app.md#creation) + +### Deploy + +The deploy method is a wrapper over the [`AppDeployer`'s `deploy` method](./app-deploy.md#performing-a-deployment), with the following differences: + +- You don't need to specify the `approval_program`, `clear_state_program`, or `schema` in the `create_params` because these are all specified or calculated from the app spec (noting you can override the `schema`) +- `sender` is optional for `create_params`, `update_params` and `delete_params` and if not specified then the `default_sender` from the `AppFactory` constructor is used (if it was specified, otherwise an error is thrown) +- You don't need to pass in `metadata` to the deploy params - it's calculated from: + - `updatable` and `deletable`, which you can optionally pass in directly via `compilation_params` + - `version` and `name`, which are optionally passed into the `AppFactory` constructor +- `compilation_params` (`deploy_time_params`, `updatable` and `deletable`) can all be passed into the `AppFactory` and if so will be used if not defined in the params to the deploy call for the [deploy-time parameter replacements and deploy-time immutability and permanence control](./app-deploy.md#compilation-and-template-substitution) +- `create_params`, `update_params` and `delete_params` are optional, if they aren't specified then default values are used for everything and a no-argument bare call will be made for any create/update/delete calls +- If you want to call an ABI method for create/update/delete calls then you can pass in a string for `method` (as opposed to an `ABIMethod` object), which can either be the method name, or if you need to disambiguate between multiple methods of the same name it can be the ABI signature (see example below) + +```python +# Use no-argument bare-calls to deploy with default behaviour +# for when update or schema break detected (fail the deployment) +app_client, result = factory.deploy() + +# Specify parameters for bare-calls and override the schema break behaviour +app_client, result = factory.deploy( + create_params=AppClientBareCallCreateParams( + args=[bytes([1, 2, 3, 4])], + static_fee=AlgoAmount.from_micro_algo(3000), + on_complete=OnApplicationComplete.OptIn, + ), + update_params=AppClientBareCallParams( + args=[bytes([1, 2, 3])], + ), + delete_params=AppClientBareCallParams( + args=[bytes([1, 2])], + ), + compilation_params={ + "deploy_time_params": { + "ONE": 1, + "TWO": "two", + }, + "updatable": True, + "deletable": True, + }, + on_update=OnUpdate.UpdateApp, + on_schema_break=OnSchemaBreak.ReplaceApp, +) + +# Specify parameters for ABI method calls +app_client, result = factory.deploy( + create_params=AppClientMethodCallCreateParams( + method="create_application", + args=[1, "something"], + ), + update_params=AppClientMethodCallParams( + method="update", + ), + delete_params=AppClientMethodCallParams( + method="delete_app(uint64,uint64,uint64)uint64", + args=[1, 2, 3], + ), +) +``` + +If you want to construct a custom deploy call, use the underlying [`algorand.app_deployer.deploy` method](./app-deploy.md#performing-a-deployment) then you can get params objects for the `create_params`, `update_params` and `delete_params`: + +- `factory.params.create(params)` - ABI method create call for deploy method or an underlying [`app_create_method_call` call](./app.md#creation) +- `factory.params.deploy_update(params)` - ABI method update call for deploy method +- `factory.params.deploy_delete(params)` - ABI method delete call for deploy method +- `factory.params.bare.create(params)` - Bare create call for deploy method or an underlying [`app_create` call](./app.md#creation) +- `factory.params.bare.deploy_update(params)` - Bare update call for deploy method +- `factory.params.bare.deploy_delete(params)` - Bare delete call for deploy method + +## Updating and deleting an app + +Deploy method aside, the ability to make update and delete calls happens after there is an instance of an app so are done via `AppClient`. The semantics of this are no different than [other calls](#calling-the-app), with the caveat that the update call is a bit different to the others since the code will be compiled when constructing the update params and the update calls thus optionally takes compilation parameters (`deploy_time_params`, `updatable` and `deletable` via `compilation_params`) for [deploy-time parameter replacements and deploy-time immutability and permanence control](./app-deploy.md#compilation-and-template-substitution). + +## Calling the app + +You can construct a params object, transaction(s) and sign and send a transaction to call the app that a given `AppClient` instance is pointing to. + +This is done via the following properties: + +- `app_client.params.{on_complete}(params)` - Params for an ABI method call +- `app_client.params.bare.{on_complete}(params)` - Params for a bare call +- `app_client.create_transaction.{on_complete}(params)` - Transaction(s) for an ABI method call +- `app_client.create_transaction.bare.{on_complete}(params)` - Transaction for a bare call +- `app_client.send.{on_complete}(params)` - Sign and send an ABI method call +- `app_client.send.bare.{on_complete}(params)` - Sign and send a bare call + +To make one of these calls `{on_complete}` needs to be swapped with the [on complete action](https://dev.algorand.co/concepts/smart-contracts/overview#smart-contract-lifecycle) that should be made: + +- `update` - An update call +- `opt_in` - An opt-in call +- `delete` - A delete application call +- `clear_state` - A clear state call (note: calls the clear program and only applies to bare calls) +- `close_out` - A close-out call +- `call` - A no-op call (or other call if `on_complete` is specified to anything other than update) + +The input payload for all of these calls is the same as the [underlying app methods](./app.md#calling-apps) with the caveat that the `app_id` is not passed in (since the `AppClient` already knows the app ID), `sender` is optional (it uses `default_sender` from the `AppClient` constructor if it was specified) and `method` (for ABI method calls) is a string rather than an `ABIMethod` object (which can either be the method name, or if you need to disambiguate between multiple methods of the same name it can be the ABI signature). + +The return payload for all of these is the same as the [underlying methods](./app.md#calling-apps). + +```python +call1 = app_client.send.update( + AppClientMethodCallParams( + method="update_abi", + args=["string_io"], + ), + compilation_params={"deploy_time_params": deploy_time_params}, +) + +call2 = app_client.send.delete( + AppClientMethodCallParams( + method="delete_abi", + args=["string_io"], + ) +) + +call3 = app_client.send.opt_in( + AppClientMethodCallParams(method="opt_in") +) + +call4 = app_client.send.bare.clear_state() + +transaction = app_client.create_transaction.bare.close_out( + AppClientBareCallParams( + args=[bytes([1, 2, 3])] + ) +) + +params = app_client.params.opt_in( + AppClientMethodCallParams(method="optin") +) +``` + +### Nested ABI Method Call Transactions + +The ARC4 ABI specification supports ABI method calls as arguments to other ABI method calls, enabling some interesting use cases. While this conceptually resembles a function call hierarchy, in practice, the transactions are organized as a flat, ordered transaction group. Unfortunately, this logically hierarchical structure cannot always be correctly represented as a flat transaction group, making some scenarios impossible. + +To illustrate this, let's consider an example of two ABI methods with the following signatures: + +- `myMethod(pay,appl)void` +- `myOtherMethod(pay)void` + +These signatures are compatible, so `myOtherMethod` can be passed as an ABI method call argument to `myMethod`, which would look like: + +Hierarchical method call + +``` +myMethod(pay, myOtherMethod(pay)) +``` + +Flat transaction group + +``` +pay (pay) +appl (myOtherMethod) +appl (myMethod) +``` + +An important limitation to note is that the flat transaction group representation does not allow having two different pay transactions. This invariant is represented in the hierarchical call interface of the app client by passing a `None` value. This acts as a placeholder and tells the app client that another ABI method call argument will supply the value for this argument. For example: + +```python +payment = algorand.create_transaction.payment( + PaymentParams( + sender=alice.address, + receiver=alice.address, + amount=AlgoAmount.from_micro_algo(1), + ) +) + +my_other_method_call = app_client.params.call( + AppClientMethodCallParams( + method="myOtherMethod", + args=[payment], + ) +) + +my_method_call = app_client.send.call( + AppClientMethodCallParams( + method="myMethod", + args=[None, my_other_method_call], + ) +) +``` + +`my_other_method_call` supplies the pay transaction to the transaction group and, by association, `my_other_method_call` has access to it as defined in its signature. +To ensure the app client builds the correct transaction group, you must supply a value for every argument in a method call signature. + +## Funding the app account + +Often there is a need to fund an app account to cover minimum balance requirements for boxes and other scenarios. There is an app client method that will do this for you `fund_app_account(params)`. + +The input parameters are: + +- A `FundAppAccountParams`, which has the same properties as a [payment transaction](./transfer.md#payment) except `receiver` is not required and `sender` is optional (if not specified then it will be set to the app client's default sender if configured). + +Note: If you are passing the funding payment in as an ABI argument so it can be validated by the ABI method then you'll want to get the funding call as a transaction, e.g.: + +```python +result = app_client.send.call( + AppClientMethodCallParams( + method="bootstrap", + args=[ + app_client.create_transaction.fund_app_account( + FundAppAccountParams( + amount=AlgoAmount.from_micro_algo(200_000) + ) + ) + ], + box_references=["Box1"], + ) +) +``` + +You can also get the funding call as a params object via `app_client.params.fund_app_account(params)`. + +## Reading state + +`AppClient` has a number of mechanisms to read state (global, local and box storage) from the app instance. + +### App spec methods + +The ARC-56 app spec can specify detailed information about the encoding format of state values and as such allows for a more advanced ability to automatically read state values and decode them as their high-level language types rather than the limited `int` / `bytes` / `str` ability that the [generic methods](#generic-methods) give you. + +You can access this functionality via: + +- `app_client.state.global_state.{method}()` - Global state +- `app_client.state.local_state(address).{method}()` - Local state +- `app_client.state.box.{method}()` - Box storage + +Where `{method}` is one of: + +- `get_all()` - Returns all single-key state values in a dict keyed by the key name and the value a decoded ABI value. +- `get_value(name)` - Returns a single state value for the current app with the value a decoded ABI value. +- `get_map_value(map_name, key)` - Returns a single value from the given map for the current app with the value a decoded ABI value. Key can either be `bytes` with the binary value of the key value on-chain (without the map prefix) or the high level (decoded) value that will be encoded to bytes for the app spec specified `key_type` +- `get_map(map_name)` - Returns all map values for the given map in a key=>value dict. It's recommended that this is only done when you have a unique `prefix` for the map otherwise there's a high risk that incorrect values will be included in the map. + +```python +values = app_client.state.global_state.get_all() +value = app_client.state.local_state("ADDRESS").get_value("value1") +map_value = app_client.state.box.get_map_value("map1", "mapKey") +map_dict = app_client.state.global_state.get_map("myMap") +``` + +### Generic methods + +There are various methods defined that let you read state from the smart contract app: + +- `get_global_state()` - Gets the current global state using `algorand.app.get_global_state` +- `get_local_state(address)` - Gets the current local state for the given account address using `algorand.app.get_local_state` +- `get_box_names()` - Gets the current box names using `algorand.app.get_box_names` +- `get_box_value(name)` - Gets the current value of the given box using `algorand.app.get_box_value` +- `get_box_value_from_abi_type(name, abi_type)` - Gets the current value of the given box decoded according to an ABI type using `algorand.app.get_box_value_from_abi_type` +- `get_box_values(filter_func)` - Gets the current values of the boxes, optionally filtered by a function, using `algorand.app.get_box_values` +- `get_box_values_from_abi_type(abi_type, filter_func)` - Gets the current values of the boxes decoded according to an ABI type, optionally filtered by a function, using `algorand.app.get_box_values_from_abi_type` + +```python +global_state = app_client.get_global_state() +local_state = app_client.get_local_state("ACCOUNTADDRESS") + +box_name = "my-box" +box_name2 = "my-box2" + +box_names = app_client.get_box_names() +box_value = app_client.get_box_value(box_name) +box_values = app_client.get_box_values() # Returns all box values +box_abi_value = app_client.get_box_value_from_abi_type( + box_name, + abi.ABIType.from_string("string"), +) +box_abi_values = app_client.get_box_values_from_abi_type( + abi.ABIType.from_string("string"), +) +``` + +## Handling logic errors and diagnosing errors + +Often when calling a smart contract during development you will get logic errors that cause an exception to throw. This may be because of a failing assertion, a lack of fees, exhaustion of opcode budget, or any number of other reasons. + +When this occurs, you will generally get an error that looks something like: `TransactionPool.Remember: transaction {TRANSACTION_ID}: logic eval error: {ERROR_MESSAGE}. Details: pc={PROGRAM_COUNTER_VALUE}, opcodes={LIST_OF_OP_CODES}`. + +The information in that error message can be parsed and when combined with the [source map from compilation](./app-deploy.md#compilation-and-template-substitution) you can expose debugging information that makes it much easier to understand what's happening. The ARC-56 app spec, if provided, can also specify human-readable error messages against certain program counter values and further augment the error message. + +The app client and app factory automatically provide this functionality for all smart contract calls through an automatically registered error transformer (via `algorand.register_error_transformer`). + +Custom error transformers can be registered via `algorand.register_error_transformer` to provide additional error handling logic. + +When an error is thrown then the resulting error that is re-thrown will be a `LogicError` object, which has the following fields: + +- `message: str` - The formatted error message +- `logic_error: Exception | None` - The original logic error exception +- `logic_error_str: str` - The string representation of the logic error +- `program: str` - The TEAL program source code +- `source_map: ProgramSourceMap | None` - The source map if available +- `transaction_id: str` - The transaction ID that triggered the error +- `pc: int` - The program counter value where error occurred +- `traces: list[SimulateTransactionResult] | None` - Simulation traces if debug enabled +- `line_no: int | None` - The line number in the TEAL source code +- `lines: list[str]` - The TEAL program split into individual lines + +Note: This information will only show if the app client / app factory has a source map. This will occur if: + +- You have called `create`, `update` or `deploy` +- You have called `import_source_maps(source_maps)` and provided the source maps (which you can get by calling `export_source_maps()` after variously calling `create`, `update`, or `deploy` and it returns a serialisable value) +- You had source maps present in an app factory and then used it to [create an app client](#dynamically-creating-clients-for-a-given-app-spec) (they are automatically passed through) + +If you want to go a step further and automatically issue a simulated transaction and get trace information when there is an error when an ABI method is called you can turn on debug mode: + +```python +config.configure(debug=True) +``` + +If you do that then the exception will have the `traces` property within the underlying exception will have key information from the simulation within it and this will get populated into the `traces` property of the thrown error. + +When this debug flag is set, it will also emit debugging symbols to allow break-point debugging of the calls if the [project root is also configured](../../advanced/debugging). + +## Default arguments + +If an ABI method call specifies default argument values for any of its arguments you can pass in `None` for the value of that argument for the default value to be automatically populated. diff --git a/docs/source/capabilities/app-deploy.md b/docs/src/content/docs/concepts/building/app-deploy.md similarity index 55% rename from docs/source/capabilities/app-deploy.md rename to docs/src/content/docs/concepts/building/app-deploy.md index 8808088c..14eadd62 100644 --- a/docs/source/capabilities/app-deploy.md +++ b/docs/src/content/docs/concepts/building/app-deploy.md @@ -1,12 +1,15 @@ -# App deployment +--- +title: "App deployment" +description: "AlgoKit contains advanced smart contract deployment capabilities that allow you to have idempotent (safely retryable) deployment of a named app, including deploy-time immutability and permanence control and TEAL template substitution. This allows you to control the smart contract development lifecycle of a single-instance app across multiple environments (e.g. LocalNet, TestNet, MainNet)." +--- AlgoKit contains advanced smart contract deployment capabilities that allow you to have idempotent (safely retryable) deployment of a named app, including deploy-time immutability and permanence control and TEAL template substitution. This allows you to control the smart contract development lifecycle of a single-instance app across multiple environments (e.g. LocalNet, TestNet, MainNet). It's optional to use this functionality, since you can construct your own deployment logic using create / update / delete calls and your own mechanism to maintaining app metadata (like app IDs etc.), but this capability is an opinionated out-of-the-box solution that takes care of the heavy lifting for you. -App deployment is a higher-order use case capability provided by AlgoKit Utils that builds on top of the core capabilities, particularly [App management](./app.md). +App deployment is a higher-order use case capability provided by AlgoKit Utils that builds on top of the core capabilities, particularly [App management](../app). -To see some usage examples check out the [automated tests](https://github.com/algorandfoundation/algokit-utils-py/blob/main/tests/test_deploy_scenarios.py). +To see some usage examples check out the [automated tests](https://github.com/algorandfoundation/algokit-utils-py/tree/main/tests/applications). ## Smart contract development lifecycle @@ -26,7 +29,7 @@ Namely, it described the concept of a smart contract development lifecycle: 1. **Validate** the deployed app via automated testing of the smart contracts to provide confidence in their correctness 2. **Call** deployed smart contract with runtime parameters to utilise it -![App deployment lifecycle](../images/lifecycle.jpg) +![App deployment lifecycle](/algokit-utils-py/images/lifecycle.jpg) The App deployment capability provided by AlgoKit Utils helps implement **#2 Deployment**. @@ -41,12 +44,12 @@ This design allows you to have the same deployment code across environments with ## `AppDeployer` -The {py:obj}`AppDeployer ` is a class that is used to manage app deployments and deployment metadata. +The `AppDeployer` is a class that is used to manage app deployments and deployment metadata. -To get an instance of `AppDeployer` you can use either [`AlgorandClient`](./algorand-client.md) via `algorand.appDeployer` or instantiate it directly (passing in an [`AppManager`](./app.md#appmanager), [`AlgorandClientTransactionSender`](./algorand-client.md#sending-a-single-transaction) and optionally an indexer client instance): +To get an instance of `AppDeployer` you can use either [`AlgorandClient`](../../core/algorand-client) via `algorand.app_deployer` or instantiate it directly (passing in an [`AppManager`](./app.md#appmanager), [`AlgorandClientTransactionSender`](../../core/algorand-client#sending-a-single-transaction) and optionally an indexer client instance): ```python -from algokit_utils.app_deployer import AppDeployer +from algokit_utils.applications.app_deployer import AppDeployer app_deployer = AppDeployer(app_manager, transaction_sender, indexer) ``` @@ -55,12 +58,15 @@ app_deployer = AppDeployer(app_manager, transaction_sender, indexer) When AlgoKit performs a deployment of an app it creates metadata to describe that deployment and includes this metadata in an [ARC-2](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0002.md) transaction note on any creation and update transactions. -The deployment metadata is defined in {py:obj}`AppDeployMetadata `, which is an object with: +The deployment metadata is defined in `AppDeploymentMetaData`, which is an object with: - `name: str` - The unique name identifier of the app within the creator account - `version: str` - The version of app that is / will be deployed; can be an arbitrary string, but we recommend using [semver](https://semver.org/) -- `deletable: bool | None` - Whether or not the app is deletable (`true`) / permanent (`false`) / unspecified (`None`) -- `updatable: bool | None` - Whether or not the app is updatable (`true`) / immutable (`false`) / unspecified (`None`) +- `deletable: bool | None` - Whether or not the app is deletable (`True`) / permanent (`False`) / unspecified (`None`) +- `updatable: bool | None` - Whether or not the app is updatable (`True`) / immutable (`False`) / unspecified (`None`) + +> [!NOTE] +> As of v3.0.0, the contract version is no longer auto-incremented. You must explicitly set the `version` field in `AppDeploymentMetaData` for each deployment. An example of the ARC-2 transaction note that is attached as an app creation / update transaction note to specify this metadata is: @@ -68,20 +74,18 @@ An example of the ARC-2 transaction note that is attached as an app creation / u ALGOKIT_DEPLOYER:j{name:"MyApp",version:"1.0",updatable:true,deletable:false} ``` -> NOTE: Starting from v3.0.0, AlgoKit Utils no longer automatically increments the contract version by default. It is the user's responsibility to explicitly manage versioning of their smart contracts (if desired). - ## Lookup deployed apps by name -In order to resolve what apps have been previously deployed and their metadata, AlgoKit provides a method that does a series of indexer lookups and returns a map of name to app metadata via `get_creator_apps_by_name(creator_address)`. +In order to resolve what apps have been previously deployed and their metadata, AlgoKit provides a method that does a series of indexer lookups and returns a map of name to app metadata via `algorand.app_deployer.get_creator_apps_by_name(creator_address=...)`. ```python -app_lookup = algorand.app_deployer.get_creator_apps_by_name("CREATORADDRESS") +app_lookup = algorand.app_deployer.get_creator_apps_by_name(creator_address="CREATORADDRESS") app1_metadata = app_lookup.apps["app1"] ``` This method caches the result of the lookup, since it's a reasonably heavyweight call (N+1 indexer calls for N deployed apps by the creator). If you want to skip the cache to get a fresh version then you can pass in a second parameter `ignore_cache=True`. This should only be needed if you are performing parallel deployments outside of the current `AppDeployer` instance, since it will keep its cache updated based on its own deployments. -The return type of `get_creator_apps_by_name` is {py:obj}`ApplicationLookup `, which is an object with: +The return type of `get_creator_apps_by_name` is `ApplicationLookup`: ```python @dataclasses.dataclass @@ -90,13 +94,60 @@ class ApplicationLookup: apps: dict[str, ApplicationMetaData] = dataclasses.field(default_factory=dict) ``` -The `apps` property contains a lookup by app name that resolves to the current {py:obj}`ApplicationMetaData `. +The `apps` property contains a lookup by app name that resolves to the current `ApplicationMetaData` value: + +```python +@dataclasses.dataclass(frozen=True) +class ApplicationReference: + app_id: int + app_address: str + +@dataclasses.dataclass(frozen=True) +class ApplicationMetaData: + # App ID and address (wrapped in ApplicationReference) + reference: ApplicationReference + # The deployment metadata (name, version, deletable, updatable) + deploy_metadata: AppDeploymentMetaData + # The round the app was created + created_round: int + # The last round that the app was updated + updated_round: int + # Whether or not the app is deleted + deleted: bool = False + + # Convenience properties (delegated from reference / deploy_metadata): + # app_id, app_address, name, version, deletable, updatable +``` + +An example `ApplicationLookup` might look like this: -> Refer to the {py:obj}`ApplicationLookup ` for latest information on exact types. +```python +ApplicationLookup( + creator="", + apps={ + "": ApplicationMetaData( + reference=ApplicationReference( + app_id=1, + app_address="", + ), + deploy_metadata=AppDeploymentMetaData( + name="", + version="2.0.0", + deletable=False, + updatable=False, + ), + created_round=1, + updated_round=2, + deleted=False, + ), + # ... + }, +) +``` ## Performing a deployment -In order to perform a deployment, AlgoKit provides the {py:meth}`deploy ` method. +In order to perform a deployment, AlgoKit provides the `algorand.app_deployer.deploy(deployment)` method. For example: @@ -113,7 +164,7 @@ deployment_result = algorand.app_deployer.deploy( sender="CREATORADDRESS", approval_program=approval_teal_template_or_byte_code, clear_state_program=clear_state_teal_template_or_byte_code, - schema=StateSchema( + schema=AppCreateSchema( global_ints=1, global_byte_slices=2, local_ints=3, @@ -123,21 +174,24 @@ deployment_result = algorand.app_deployer.deploy( ), update_params=AppUpdateParams( sender="SENDERADDRESS", - # Other parameters if an update call is made... + app_id=0, # Placeholder — overridden by deploy() + approval_program="", # Placeholder — overridden by deploy() + clear_state_program="", # Placeholder — overridden by deploy() ), delete_params=AppDeleteParams( sender="SENDERADDRESS", - # Other parameters if a delete call is made... + app_id=0, # Placeholder — overridden by deploy() ), deploy_time_params={ - "VALUE": 1, # TEAL template variables to replace + # Key => value of any TEAL template variables to replace before compilation + "VALUE": 1, }, - on_schema_break=OnSchemaBreak.Append, - on_update=OnUpdate.Update, - send_params=SendParams( - populate_app_call_resources=True, - # Other execution control parameters - ), + # How to handle a schema break + on_schema_break=OnSchemaBreak.AppendApp, + # How to handle a contract code update + on_update=OnUpdate.UpdateApp, + # Optional send parameters + send_params={"populate_app_call_resources": True}, ) ) ``` @@ -147,25 +201,26 @@ This method performs an idempotent (safely retryable) deployment. It will detect - Detect if the app has been updated (i.e. the program logic has changed) and either fail, perform an update, deploy a new version or perform a replacement (delete old app and create new app) based on the deployment configuration. - Detect if the app has a breaking schema change (i.e. more global or local storage is needed than were originally requested) and either fail, deploy a new version or perform a replacement (delete old app and create new app) based on the deployment configuration. -It will automatically [add metadata to the transaction note of the create or update transactions](#deployment-metadata) that indicates the name, version, updatability and deletability of the contract. This metadata works in concert with [`appDeployer.get_creator_apps_by_name`](#lookup-deployed-apps-by-name) to allow the app to be reliably retrieved against that creator in it's currently deployed state. It will automatically update it's lookup cache so subsequent calls to `get_creator_apps_by_name` or `deploy` will use the latest metadata without needing to call indexer again. +It will automatically [add metadata to the transaction note of the create or update transactions](#deployment-metadata) that indicates the name, version, updatability and deletability of the contract. This metadata works in concert with [`app_deployer.get_creator_apps_by_name`](#lookup-deployed-apps-by-name) to allow the app to be reliably retrieved against that creator in it's currently deployed state. It will automatically update it's lookup cache so subsequent calls to `get_creator_apps_by_name` or `deploy` will use the latest metadata without needing to call indexer again. `deploy` also automatically executes [template substitution](#compilation-and-template-substitution) including deploy-time control of permanence and immutability if the requisite template parameters are specified in the provided TEAL template. ### Input parameters -The first parameter `deployment` is an {py:obj}`AppDeployParams `, which is an object with: - -- `metadata: AppDeployMetadata` - determines the [deployment metadata](#deployment-metadata) of the deployment -- `create_params: AppCreateParams | CreateCallABI` - the parameters for an [app creation call](./app.md) (raw parameters or ABI method call) -- `update_params: AppUpdateParams | UpdateCallABI` - the parameters for an [app update call](./app.md) (raw parameters or ABI method call) without the `app_id`, `approval_program`, or `clear_state_program` as these are handled by the deploy logic -- `delete_params: AppDeleteParams | DeleteCallABI` - the parameters for an [app delete call](./app.md) (raw parameters or ABI method call) without the `app_id` parameter -- `deploy_time_params: TealTemplateParams | None` - optional parameters for [TEAL template substitution](#compilation-and-template-substitution) - - {py:obj}`TealTemplateParams ` is a dict that replaces `TMPL_{key}` with `value` (strings/Uint8Arrays are properly encoded) -- `on_schema_break: OnSchemaBreak | str | None` - determines {py:obj}`OnSchemaBreak ` if schema requirements increase (values: 'replace', 'fail', 'append') -- `on_update: OnUpdate | str | None` - determines {py:obj}`OnUpdate ` if contract logic changes (values: 'update', 'replace', 'fail', 'append') -- `existing_deployments: ApplicationLookup | None` - optional pre-fetched app lookup data to skip indexer queries -- `ignore_cache: bool | None` - if True, bypasses cached deployment metadata -- Additional fields from {py:obj}`SendParams ` - transaction execution parameters +The first parameter `deployment` is an `AppDeployParams`, which is an object with: + +- `metadata: AppDeploymentMetaData` - determines the [deployment metadata](#deployment-metadata) of the deployment +- `create_params: AppCreateParams | AppCreateMethodCallParams` - the parameters for an [app creation call](./app.md#creation) (raw or ABI method call) +- `update_params: AppUpdateParams | AppUpdateMethodCallParams` - the parameters for an [app update call](./app.md#updating) (raw or ABI method call) without the `app_id`, `approval_program` or `clear_state_program`, since these are calculated by the `deploy` method +- `delete_params: AppDeleteParams | AppDeleteMethodCallParams` - the parameters for an [app delete call](./app.md#deleting) (raw or ABI method call) without the `app_id`, since this is calculated by the `deploy` method +- `deploy_time_params: TealTemplateParams | None` - allows automatic substitution of [deploy-time TEAL template variables](#compilation-and-template-substitution) + - `TealTemplateParams` is a `key => value` dict that will result in `TMPL_{key}` being replaced with `value` (where a string or `bytes` will be appropriately encoded as bytes within the TEAL code) +- `on_schema_break: Literal["replace", "fail", "append"] | OnSchemaBreak | None` - determines `what should happen` if a breaking change to the schema is detected (e.g. if you need more global or local state that was previously requested when the contract was originally created) +- `on_update: Literal["update", "replace", "fail", "append"] | OnUpdate | None` - determines `what should happen` if an update to the smart contract is detected (e.g. the TEAL code has changed since last deployment) +- `existing_deployments: ApplicationLookup | None` - optionally allows the [app lookup retrieval](#lookup-deployed-apps-by-name) to be skipped if it's already been retrieved outside of this `AppDeployer` instance +- `ignore_cache: bool` - optionally allows the [lookup cache](#lookup-deployed-apps-by-name) to be ignored and force retrieval of fresh deployment metadata from indexer (default `False`) +- `max_fee: int | None` - optional maximum fee +- `send_params: SendParams | None` - optional [transaction execution control parameters](../../core/algorand-client#transaction-parameters) ### Idempotency @@ -181,16 +236,13 @@ In order for a smart contract to opt-in to use this functionality, it must have - `TMPL_UPDATABLE` - Which will be replaced with a `1` if an app should be updatable and `0` if it shouldn't (immutable) - `TMPL_DELETABLE` - Which will be replaced with a `1` if an app should be deletable and `0` if it shouldn't (permanent) -If you passed in a TEAL template for the `approval_program` or `clear_state_program` (i.e. a `str` rather than a `bytes`) then `deploy` will return the {py:obj}`CompiledTeal ` of substituting then compiling the TEAL template(s) in the following properties of the return value: - -- `compiled_approval: CompiledTeal | None` -- `compiled_clear: CompiledTeal | None` +If you passed in a TEAL template for the `approval_program` or `clear_state_program` (i.e. a `str` rather than `bytes`) then `deploy` will automatically compile the templates and use the resulting bytecode for the deployment. -Template substitution is done by executing `algorand.app.compile_teal_template(teal_template_code, template_params, deployment_metadata)`, which in turn calls the following in order and returns the compilation result per above (all of which can also be invoked directly): +Template substitution is done internally via `AppManager.compile_teal_template(teal_template_code, template_params, deployment_metadata)`, which calls the following in order (all of which can also be invoked directly): - `AppManager.strip_teal_comments(teal_code)` - Strips out any TEAL comments to reduce the payload that is sent to algod and reduce the likelihood of hitting the max payload limit - `AppManager.replace_template_variables(teal_template_code, template_values)` - Replaces the template variables by looking for `TMPL_{key}` -- `AppManager.replace_teal_template_deploy_time_control_params(teal_template_code, params)` - If `params` is provided, it allows for deploy-time immutability and permanence control by replacing `TMPL_UPDATABLE` with `params.get("updatable")` if not `None` and replacing `TMPL_DELETABLE` with `params.get("deletable")` if not `None` +- `AppManager.replace_teal_template_deploy_time_control_params(teal_template_code, params)` - If `params` is provided, it allows for deploy-time immutability and permanence control by replacing `TMPL_UPDATABLE` with `params.get("updatable")` if it's not `None` and replacing `TMPL_DELETABLE` with `params.get("deletable")` if it's not `None` - `algorand.app.compile_teal(teal_code)` - Sends the final TEAL to algod for compilation and returns the result including the source map and caches the compilation result within the `AppManager` instance #### Making updatable/deletable apps @@ -229,30 +281,45 @@ With the above code, when deploying your application, you can pass in the follow ```python my_factory.deploy( - ... # other deployment parameters ... + ... # other deployment parameters compilation_params={ - "updatable": True, # resulting app will be updatable, and this metadata will be set in the ARC-2 transaction note - "deletable": False, # resulting app will not be deletable, and this metadata will be set in the ARC-2 transaction note + "updatable": True, # resulting app will be updatable, and this metadata will be set in the ARC-2 transaction note + "deletable": False, # resulting app will not be deletable, and this metadata will be set in the ARC-2 transaction note } ) ``` ### Return value -When `deploy` executes it will return a {py:obj}`AppDeployResult ` object that describes exactly what it did and has comprehensive metadata to describe the end result of the deployed app. +When `deploy` executes it will return a `comprehensive result` object that describes exactly what it did and has comprehensive metadata to describe the end result of the deployed app. The `deploy` call itself may do one of the following (which you can determine by looking at the `operation_performed` field on the return value from the function): -- `OperationPerformed.CREATE` - The smart contract app was created -- `OperationPerformed.UPDATE` - The smart contract app was updated -- `OperationPerformed.REPLACE` - The smart contract app was deleted and created again (in an atomic transaction) -- `OperationPerformed.NOTHING` - Nothing was done since it was detected the existing smart contract app deployment was up to date +- `OperationPerformed.Create` - The smart contract app was created +- `OperationPerformed.Update` - The smart contract app was updated +- `OperationPerformed.Replace` - The smart contract app was deleted and created again (in an atomic transaction) +- `OperationPerformed.Nothing` - Nothing was done since it was detected the existing smart contract app deployment was up to date + +The return type is `AppDeployResult`: + +```python +@dataclass(frozen=True) +class AppDeployResult: + app: ApplicationMetaData + operation_performed: OperationPerformed + create_result: SendAppCreateTransactionResult | None = None + update_result: SendAppUpdateTransactionResult | None = None + delete_result: SendAppTransactionResult | None = None +``` + +Based on the value of `operation_performed`, the corresponding result fields will be populated: -As well as the `operation_performed` parameter and the [optional compilation result](#compilation-and-template-substitution), the return value will have the {py:obj}`ApplicationMetaData ` [fields](#deployment-metadata) present. +- If `Create` then `create_result` will contain the [`SendAppCreateTransactionResult`](./app.md#calling-an-app) +- If `Update` then `update_result` will contain the [`SendAppUpdateTransactionResult`](./app.md#calling-an-app) +- If `Replace` then both `create_result` and `delete_result` will be populated (the old app is deleted and a new one is created in an atomic transaction) +- If `Nothing` then all result fields will be `None` -Based on the value of `operation_performed`, there will be other data available in the return value: +Both `SendAppCreateTransactionResult` and `SendAppUpdateTransactionResult` include compilation results when TEAL templates were compiled during deployment: -- If `CREATE`, `UPDATE` or `REPLACE` then it will have the relevant {py:obj}`SendAppTransactionResult ` values: - - `create_result` for create operations - - `update_result` for update operations -- If `REPLACE` then it will also have `delete_result` to capture the result of deleting the existing app +- `compiled_approval: CompiledTeal | bytes | None` - The compiled approval program (a `CompiledTeal` object if compiled from a TEAL template, raw `bytes` if bytecode was provided directly, or `None` if not available) +- `compiled_clear: CompiledTeal | bytes | None` - The compiled clear state program (same semantics as above) diff --git a/docs/src/content/docs/concepts/building/app.md b/docs/src/content/docs/concepts/building/app.md new file mode 100644 index 00000000..20dbb596 --- /dev/null +++ b/docs/src/content/docs/concepts/building/app.md @@ -0,0 +1,454 @@ +--- +title: "App management" +description: "App management is a higher-order use case capability provided by AlgoKit Utils that builds on top of the core capabilities. It allows you to create, update, delete, call (ABI and otherwise) smart contract apps and the metadata associated with them (including state and boxes)." +--- + +App management is a higher-order use case capability provided by AlgoKit Utils that builds on top of the core capabilities. It allows you to create, update, delete, call (ABI and otherwise) smart contract apps and the metadata associated with them (including state and boxes). + +## AppManager + +The `AppManager` is a class that is used to manage app information. + +To get an instance of `AppManager` you can use either [`AlgorandClient`](../../core/algorand-client) via `algorand.app` or instantiate it directly (passing in an algod client instance): + +```python +from algokit_utils import AppManager + +app_manager = AppManager(algod_client) +``` + +## Calling apps + +### App Clients + +The recommended way of interacting with apps is via [Typed app clients](../typed-app-clients) or if you can't use a typed app client then an [untyped app client](../app-client). The methods shown on this page are the underlying mechanisms that app clients use and are for advanced use cases when you want more control. + +### Calling an app + +When calling an app there are two types of transactions: + +- Raw app transactions - Constructing a raw Algorand transaction to call the method; you have full control and are dealing with binary values directly +- ABI method calls - Constructing a call to an [ABI method](https://dev.algorand.co/concepts/smart-contracts/abi) + +Calling an app involves providing some [common parameters](#common-app-parameters) and some parameters that will depend on the type of app call (create vs update vs other) per below sections. + +When [sending transactions directly via AlgorandClient](../../core/algorand-client#sending-a-single-transaction) the `SendSingleTransactionResult` return value is expanded with extra fields depending on the type of app call: + +- All app calls extend `SendAppTransactionResult`, which has: + - `abi_return: ABIReturn | None` - Which will contain an ABI return value if a non-void ABI method was called: + - `raw_value: bytes` - The raw binary of the return value + - `value: ABIValue | None` - The decoded value in the appropriate Python object + - `decode_error: Exception | None` - If there was a decoding error the above 2 values will be `None`/empty and this will have the error +- Update and create calls extend `SendAppUpdateTransactionResult`, which has: + - `compiled_approval: CompiledTeal | bytes | None` - The compilation result of approval, if approval program was supplied as a string and thus compiled by algod + - `compiled_clear: CompiledTeal | bytes | None` - The compilation result of clear state, if clear state program was supplied as a string and thus compiled by algod +- Create calls extend `SendAppCreateTransactionResult`, which has: + - `app_id: int` - The id of the created app + - `app_address: str` - The Algorand address of the account associated with the app + +There is a static method on [`AppManager`](#appmanager) that allows you to parse an ABI return value from an algod transaction confirmation: + +```python +confirmation = algod_client.pending_transaction_information(transaction_id) + +abi_return = AppManager.get_abi_return(confirmation, abi_method) +``` + +### Creation + +To create an app via a raw app transaction you can use `algorand.send.app_create(params)` (immediately send a single app creation transaction), `algorand.create_transaction.app_create(params)` (construct an app creation transaction), or `algorand.new_group().add_app_create(params)` (add app creation to a group of transactions) per [`AlgorandClient`](../../core/algorand-client) [transaction semantics](../../core/algorand-client#creating-and-issuing-transactions). + +To create an app via an ABI method call you can use `algorand.send.app_create_method_call(params)` (immediately send a single app creation transaction), `algorand.create_transaction.app_create_method_call(params)` (construct an app creation transaction), or `algorand.new_group().add_app_create_method_call(params)` (add app creation to a group of transactions). + +The base type for specifying an app creation transaction is `AppCreateParams` (extended as `AppCreateMethodCallParams` for ABI method call version), which has the following parameters in addition to the [common parameters](#common-app-parameters): + +- `on_complete: OnApplicationComplete | None` - The on-completion action to specify for the call; defaults to NoOp. +- `approval_program: str | bytes` - The program to execute for all OnCompletes other than ClearState as raw TEAL that will be compiled (str) or compiled TEAL (bytes). +- `clear_state_program: str | bytes` - The program to execute for ClearState OnComplete as raw TEAL that will be compiled (str) or compiled TEAL (bytes). +- `schema: AppCreateSchema | None` - The storage schema to request for the created app. This is immutable once the app is created. It is a `TypedDict` with: + - `global_ints: int` - The number of integers saved in global state. + - `global_byte_slices: int` - The number of byte slices saved in global state. + - `local_ints: int` - The number of integers saved in local state. + - `local_byte_slices: int` - The number of byte slices saved in local state. +- `extra_program_pages: int | None` - Number of extra pages required for the programs. This is immutable once the app is created. + +If you pass in `approval_program` or `clear_state_program` as a string then it will automatically be compiled using Algod and the compilation result will be available via `algorand.app.get_compilation_result` (including the source map). To skip this behaviour you can pass in the compiled TEAL as `bytes`. + +```python +from algokit_abi import abi, arc56 +from algokit_utils import AppCreateParams, AppCreateMethodCallParams, OnApplicationComplete + +# Basic raw example +result = algorand.send.app_create(AppCreateParams( + sender="CREATORADDRESS", + approval_program="TEALCODE", + clear_state_program="TEALCODE", +)) +created_app_id = result.app_id + +# Advanced raw example +algorand.send.app_create(AppCreateParams( + sender="CREATORADDRESS", + approval_program="TEALCODE", + clear_state_program="TEALCODE", + schema={ + "global_ints": 1, + "global_byte_slices": 2, + "local_ints": 3, + "local_byte_slices": 4, + }, + extra_program_pages=1, + on_complete=OnApplicationComplete.OptIn, + args=[bytes([1, 2, 3, 4])], + account_references=["ACCOUNT_1"], + app_references=[123, 1234], + asset_references=[12345], + box_references=["box1", BoxReference(app_id=1234, name=b"box2")], + lease=b"lease", + note=b"note", + # You wouldn't normally set this field + first_valid_round=1000, + validity_window=10, + extra_fee=AlgoAmount(micro_algo=1000), + static_fee=AlgoAmount(micro_algo=1000), + # Max fee doesn't make sense with extra_fee AND static_fee + # already specified, but here for completeness + max_fee=AlgoAmount(micro_algo=3000), + # Signer only needed if you want to provide one, + # generally you'd register it with AlgorandClient + # against the sender and not need to pass it in + signer=transaction_signer, +)) + +# Basic ABI call example +method = arc56.Method( + name="method", + args=[arc56.Argument(name="arg1", type=abi.ABIType.from_string("string"))], + returns=arc56.Returns(type=abi.ABIType.from_string("string")), +) +result = algorand.send.app_create_method_call(AppCreateMethodCallParams( + sender="CREATORADDRESS", + approval_program="TEALCODE", + clear_state_program="TEALCODE", + method=method, + args=["arg1_value"], +)) +created_app_id = result.app_id +``` + +### Updating + +To update an app via a raw app transaction you can use `algorand.send.app_update(params)` (immediately send a single app update transaction), `algorand.create_transaction.app_update(params)` (construct an app update transaction), or `algorand.new_group().add_app_update(params)` (add app update to a group of transactions) per [`AlgorandClient`](../../core/algorand-client) [transaction semantics](../../core/algorand-client#creating-and-issuing-transactions). + +To update an app via an ABI method call you can use `algorand.send.app_update_method_call(params)` (immediately send a single app update transaction), `algorand.create_transaction.app_update_method_call(params)` (construct an app update transaction), or `algorand.new_group().add_app_update_method_call(params)` (add app update to a group of transactions). + +The base type for specifying an app update transaction is `AppUpdateParams` (extended as `AppUpdateMethodCallParams` for ABI method call version), which has the following parameters in addition to the [common parameters](#common-app-parameters): + +- `on_complete: OnApplicationComplete` - On Complete defaults to `UpdateApplication` +- `approval_program: str | bytes` - The program to execute for all OnCompletes other than ClearState as raw TEAL that will be compiled (str) or compiled TEAL (bytes). +- `clear_state_program: str | bytes` - The program to execute for ClearState OnComplete as raw TEAL that will be compiled (str) or compiled TEAL (bytes). + +If you pass in `approval_program` or `clear_state_program` as a string then it will automatically be compiled using Algod and the compilation result will be available via `algorand.app.get_compilation_result` (including the source map). To skip this behaviour you can pass in the compiled TEAL as `bytes`. + +```python +from algokit_utils import AppUpdateParams, AppUpdateMethodCallParams + +# Basic raw example +algorand.send.app_update(AppUpdateParams( + sender="SENDERADDRESS", + app_id=app_id, + approval_program="TEALCODE", + clear_state_program="TEALCODE", +)) + +# Advanced raw example +algorand.send.app_update(AppUpdateParams( + sender="SENDERADDRESS", + app_id=app_id, + approval_program="TEALCODE", + clear_state_program="TEALCODE", + on_complete=OnApplicationComplete.UpdateApplication, + args=[bytes([1, 2, 3, 4])], + account_references=["ACCOUNT_1"], + app_references=[123, 1234], + asset_references=[12345], + box_references=["box1", BoxReference(app_id=1234, name=b"box2")], + lease=b"lease", + note=b"note", + # You wouldn't normally set this field + first_valid_round=1000, + validity_window=10, + extra_fee=AlgoAmount(micro_algo=1000), + static_fee=AlgoAmount(micro_algo=1000), + # Max fee doesn't make sense with extra_fee AND static_fee + # already specified, but here for completeness + max_fee=AlgoAmount(micro_algo=3000), + # Signer only needed if you want to provide one, + # generally you'd register it with AlgorandClient + # against the sender and not need to pass it in + signer=transaction_signer, +)) + +# Basic ABI call example +method = arc56.Method( + name="method", + args=[arc56.Argument(name="arg1", type=abi.ABIType.from_string("string"))], + returns=arc56.Returns(type=abi.ABIType.from_string("string")), +) +algorand.send.app_update_method_call(AppUpdateMethodCallParams( + sender="SENDERADDRESS", + app_id=app_id, + approval_program="TEALCODE", + clear_state_program="TEALCODE", + method=method, + args=["arg1_value"], +)) +``` + +### Deleting + +To delete an app via a raw app transaction you can use `algorand.send.app_delete(params)` (immediately send a single app deletion transaction), `algorand.create_transaction.app_delete(params)` (construct an app deletion transaction), or `algorand.new_group().add_app_delete(params)` (add app deletion to a group of transactions) per [`AlgorandClient`](../../core/algorand-client) [transaction semantics](../../core/algorand-client#creating-and-issuing-transactions). + +To delete an app via an ABI method call you can use `algorand.send.app_delete_method_call(params)` (immediately send a single app deletion transaction), `algorand.create_transaction.app_delete_method_call(params)` (construct an app deletion transaction), or `algorand.new_group().add_app_delete_method_call(params)` (add app deletion to a group of transactions). + +The base type for specifying an app deletion transaction is `AppDeleteParams` (extended as `AppDeleteMethodCallParams` for ABI method call version), which has the following parameters in addition to the [common parameters](#common-app-parameters): + +- `on_complete: OnApplicationComplete | None` - On Complete can either be omitted or set to delete + +```python +from algokit_utils import AppDeleteParams, AppDeleteMethodCallParams + +# Basic raw example +algorand.send.app_delete(AppDeleteParams( + sender="SENDERADDRESS", + app_id=app_id, +)) + +# Advanced raw example +algorand.send.app_delete(AppDeleteParams( + sender="SENDERADDRESS", + app_id=app_id, + on_complete=OnApplicationComplete.DeleteApplication, + args=[bytes([1, 2, 3, 4])], + account_references=["ACCOUNT_1"], + app_references=[123, 1234], + asset_references=[12345], + box_references=["box1", BoxReference(app_id=1234, name=b"box2")], + lease=b"lease", + note=b"note", + # You wouldn't normally set this field + first_valid_round=1000, + validity_window=10, + extra_fee=AlgoAmount(micro_algo=1000), + static_fee=AlgoAmount(micro_algo=1000), + # Max fee doesn't make sense with extra_fee AND static_fee + # already specified, but here for completeness + max_fee=AlgoAmount(micro_algo=3000), + # Signer only needed if you want to provide one, + # generally you'd register it with AlgorandClient + # against the sender and not need to pass it in + signer=transaction_signer, +)) + +# Basic ABI call example +method = arc56.Method( + name="method", + args=[arc56.Argument(name="arg1", type=abi.ABIType.from_string("string"))], + returns=arc56.Returns(type=abi.ABIType.from_string("string")), +) +algorand.send.app_delete_method_call(AppDeleteMethodCallParams( + sender="SENDERADDRESS", + app_id=app_id, + method=method, + args=["arg1_value"], +)) +``` + +## Calling + +To call an app via a raw app transaction you can use `algorand.send.app_call(params)` (immediately send a single app call transaction), `algorand.create_transaction.app_call(params)` (construct an app call transaction), or `algorand.new_group().add_app_call(params)` (add app call to a group of transactions) per [`AlgorandClient`](../../core/algorand-client) [transaction semantics](../../core/algorand-client#creating-and-issuing-transactions). + +To call an app via an ABI method call you can use `algorand.send.app_call_method_call(params)` (immediately send a single app call transaction), `algorand.create_transaction.app_call_method_call(params)` (construct an app call transaction), or `algorand.new_group().add_app_call_method_call(params)` (add app call to a group of transactions). + +The base type for specifying an app call transaction is `AppCallParams` (extended as `AppCallMethodCallParams` for ABI method call version), which has the following parameters in addition to the [common parameters](#common-app-parameters): + +- `on_complete: OnApplicationComplete | None` - On Complete can either be omitted (which will result in no-op) or set to any on-complete apart from update + +```python +from algokit_utils import AppCallParams, AppCallMethodCallParams + +# Basic raw example +algorand.send.app_call(AppCallParams( + sender="SENDERADDRESS", + app_id=app_id, +)) + +# Advanced raw example +algorand.send.app_call(AppCallParams( + sender="SENDERADDRESS", + app_id=app_id, + on_complete=OnApplicationComplete.OptIn, + args=[bytes([1, 2, 3, 4])], + account_references=["ACCOUNT_1"], + app_references=[123, 1234], + asset_references=[12345], + box_references=["box1", BoxReference(app_id=1234, name=b"box2")], + lease=b"lease", + note=b"note", + # You wouldn't normally set this field + first_valid_round=1000, + validity_window=10, + extra_fee=AlgoAmount(micro_algo=1000), + static_fee=AlgoAmount(micro_algo=1000), + # Max fee doesn't make sense with extra_fee AND static_fee + # already specified, but here for completeness + max_fee=AlgoAmount(micro_algo=3000), + # Signer only needed if you want to provide one, + # generally you'd register it with AlgorandClient + # against the sender and not need to pass it in + signer=transaction_signer, +)) + +# Basic ABI call example +method = arc56.Method( + name="method", + args=[arc56.Argument(name="arg1", type=abi.ABIType.from_string("string"))], + returns=arc56.Returns(type=abi.ABIType.from_string("string")), +) +algorand.send.app_call_method_call(AppCallMethodCallParams( + sender="SENDERADDRESS", + app_id=app_id, + method=method, + args=["arg1_value"], +)) +``` + +## Accessing state + +### Global state + +To access global state you can use the following method from an [`AppManager`](#appmanager) instance: + +- `algorand.app.get_global_state(app_id)` - Returns the current global state for the given app ID decoded into a dict keyed by the UTF-8 representation of the state key with various parsed versions of the value (base64, UTF-8 and raw binary) + +```python +global_state = algorand.app.get_global_state(12345) +``` + +Global state is parsed from the underlying algod response via the following static method from [`AppManager`](#appmanager): + +- `AppManager.decode_app_state(state)` - Takes the raw response from the algod API for global state and returns a friendly dict keyed by the UTF-8 value of the key + +```python +global_app_state = ... # value from algod +app_state = AppManager.decode_app_state(global_app_state) + +key_as_binary = app_state["value1"].key_raw +key_as_base64 = app_state["value1"].key_base64 +if isinstance(app_state["value1"].value, str): + value_as_string = app_state["value1"].value + value_as_binary = app_state["value1"].value_raw + value_as_base64 = app_state["value1"].value_base64 +else: + value_as_int = app_state["value1"].value +``` + +### Local state + +To access local state you can use the following method from an [`AppManager`](#appmanager) instance: + +- `algorand.app.get_local_state(app_id, address)` - Returns the current local state for the given app ID and account address decoded into a dict keyed by the UTF-8 representation of the state key with various parsed versions of the value (base64, UTF-8 and raw binary) + +```python +local_state = algorand.app.get_local_state(12345, "ACCOUNTADDRESS") +``` + +### Boxes + +To access and parse box values and names for an app you can use the following methods from an [`AppManager`](#appmanager) instance: + +- `algorand.app.get_box_names(app_id)` - Returns the current box names for the given app ID +- `algorand.app.get_box_value(app_id, box_name)` - Returns the binary value of the given box name for the given app ID +- `algorand.app.get_box_values(app_id, box_names)` - Returns the binary values of the given box names for the given app ID +- `algorand.app.get_box_value_from_abi_type(app_id, box_name, abi_type)` - Returns the parsed ABI value of the given box name for the given app ID for the provided ABI type +- `algorand.app.get_box_values_from_abi_type(app_id, box_names, abi_type)` - Returns the parsed ABI values of the given box names for the given app ID for the provided ABI type +- `AppManager.get_box_reference(box_id)` - Returns a `tuple[int, bytes]` of `(app_id, box_name_bytes)` for the given [box identifier / reference](#box-references), which is useful when constructing a transaction + +```python +from algokit_abi.abi import ABIType + +app_id = 12345 +box_name = "my-box" +box_name2 = "my-box2" + +box_names = algorand.app.get_box_names(app_id) +box_value = algorand.app.get_box_value(app_id, box_name) +box_values = algorand.app.get_box_values(app_id, [box_name, box_name2]) +box_abi_value = algorand.app.get_box_value_from_abi_type(app_id, box_name, ABIType.from_string("string")) +box_abi_values = algorand.app.get_box_values_from_abi_type(app_id, [box_name, box_name2], ABIType.from_string("string")) +``` + +## Getting app information + +To get reference information and metadata about an existing app you can use the following methods: + +- `algorand.app.get_by_id(app_id)` - Returns current app information by app ID from an [`AppManager`](#appmanager) instance + +## Common app parameters + +When interacting with apps (creating, updating, deleting, calling), there are some common parameters that you will be able to pass in to all calls in addition to the [common transaction parameters](../../core/algorand-client#transaction-parameters): + +- `app_id: int` - ID of the application; only specified if the application is not being created. +- `on_complete: OnApplicationComplete | None` - The [on-complete](https://dev.algorand.co/concepts/smart-contracts/avm#oncomplete) action of the call (noting each call type will have restrictions that affect this value). +- `args: list[bytes] | None` - Any [arguments to pass to the smart contract call](https://dev.algorand.co/concepts/smart-contracts/languages/teal/#argument-passing). +- `account_references: list[str] | None` - Any account addresses to add to the [accounts array](https://dev.algorand.co/concepts/smart-contracts/resource-usage#what-are-reference-arrays). +- `app_references: list[int] | None` - The ID of any apps to load to the [foreign apps array](https://dev.algorand.co/concepts/smart-contracts/resource-usage#what-are-reference-arrays). +- `asset_references: list[int] | None` - The ID of any assets to load to the [foreign assets array](https://dev.algorand.co/concepts/smart-contracts/resource-usage#what-are-reference-arrays). +- `box_references: list[BoxReference | BoxIdentifier] | None` - Any [boxes](#box-references) to load to the [boxes array](https://dev.algorand.co/concepts/smart-contracts/resource-usage#what-are-reference-arrays) + +When making an ABI call, the `args` parameter is replaced with a different type and there is also a `method` parameter: + +- `method: arc56.Method` +- `args: list | None` - The arguments to pass to the ABI call, which can be one of: + - `ABIValue` - Which can be one of: + - `bool` + - `int` + - `str` + - `bytes` + - A list of one of the above types + - `TransactionWithSigner` + - `Transaction` + - An ABI method call params object - parameters that define another (nested) ABI method call, which will in turn get resolved to one or more transactions + +## Box references + +Referencing boxes can by done by either `BoxIdentifier` (which identifies the name of the box and app ID `0` will be used (i.e. the current app)) or `BoxReference`: + +```python +# BoxIdentifier can be: +# - str (that will be encoded to bytes) +# - bytes (the actual binary of the box name) +# - AddressWithTransactionSigner (that will be encoded into the +# public key address of the corresponding account) + +BoxIdentifier = str | bytes | AddressWithTransactionSigner + +# BoxReference groups the app ID and name as raw bytes +@dataclass(slots=True, frozen=True) +class BoxReference: + app_id: int = 0 + name: bytes = b"" +``` + +## Compilation + +The [`AppManager`](#appmanager) class allows you to compile TEAL code with caching semantics that allows you to avoid duplicate compilation and keep track of source maps from compiled code. + +If you call `algorand.app.compile_teal(teal_code)` then the compilation result will be stored and retrievable from `algorand.app.get_compilation_result(teal_code)`. + +```python +teal_code = "return 1" +compilation_result = algorand.app.compile_teal(teal_code) +# ... +previous_compilation_result = algorand.app.get_compilation_result(teal_code) +``` diff --git a/docs/src/content/docs/concepts/building/asset.md b/docs/src/content/docs/concepts/building/asset.md new file mode 100644 index 00000000..8b628ea8 --- /dev/null +++ b/docs/src/content/docs/concepts/building/asset.md @@ -0,0 +1,500 @@ +--- +title: "Assets" +description: "The Algorand Standard Asset (asset) management functions include creating, opting in and transferring assets, which are fundamental to asset interaction in a blockchain environment." +--- + +The Algorand Standard Asset (asset) management functions include creating, opting in and transferring assets, which are fundamental to asset interaction in a blockchain environment. + +## `AssetManager` + +The `AssetManager` is a class that is used to manage asset information. + +To get an instance of `AssetManager`, you can use either [`AlgorandClient`](../../core/algorand-client) via `algorand.asset` or instantiate it directly: + +```python +from algokit_utils import AssetManager, TransactionComposer, TransactionComposerParams + +asset_manager = AssetManager( + algod_client=algod_client, + new_group=lambda: TransactionComposer( + TransactionComposerParams( + algod=algod_client, + get_signer=lambda addr: get_signer(addr), + ) + ), +) +``` + +## Creation + +To create an asset you can use `algorand.send.asset_create(params)` (immediately send a single asset creation transaction), `algorand.create_transaction.asset_create(params)` (construct an asset creation transaction), or `algorand.new_group().add_asset_create(params)` (add asset creation to a group of transactions) per [`AlgorandClient`](../../core/algorand-client) [transaction semantics](../../core/algorand-client#creating-and-issuing-transactions). + +The base type for specifying an asset creation transaction is `AssetCreateParams`, which has the following parameters in addition to the [common transaction parameters](../../core/algorand-client#transaction-parameters): + +- `total: int` - The total amount of the smallest divisible (decimal) unit to create. For example, if `decimals` is, say, 2, then for every 100 `total` there would be 1 whole unit. This field can only be specified upon asset creation. +- `decimals: int | None` - The amount of decimal places the asset should have. If unspecified then the asset will be in whole units (i.e. `0`). If 0, the asset is not divisible. If 1, the base unit of the asset is in tenths, and so on up to 19 decimal places. This field can only be specified upon asset creation. +- `asset_name: str | None` - The optional name of the asset. Max size is 32 bytes. This field can only be specified upon asset creation. +- `unit_name: str | None` - The optional name of the unit of this asset (e.g. ticker name). Max size is 8 bytes. This field can only be specified upon asset creation. +- `url: str | None` - Specifies an optional URL where more information about the asset can be retrieved. Max size is 96 bytes. This field can only be specified upon asset creation. +- `metadata_hash: bytes | None` - 32-byte hash of some metadata that is relevant to your asset and/or asset holders. The format of this metadata is up to the application. This field can only be specified upon asset creation. +- `default_frozen: bool | None` - Whether to freeze holdings for this asset by default. Defaults to `False`. If `True` then for anyone apart from the creator to hold the asset it needs to be unfrozen using an asset freeze transaction from the `freeze` account, which must be set on creation. This field can only be specified upon asset creation. +- `manager: str | None` - The address of the optional account that can manage the configuration of the asset and destroy it. The configuration fields it can change are `manager`, `reserve`, `clawback`, and `freeze`. If not set (`None` or `""`) at asset creation or subsequently set to empty by the `manager` the asset becomes permanently immutable. +- `reserve: str | None` - The address of the optional account that holds the reserve (uncirculated supply) units of the asset. This address has no specific authority in the protocol itself and is informational only. Some standards like [ARC-19](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0019.md) rely on this field to hold meaningful data. It can be used in the case where you want to signal to holders of your asset that the uncirculated units of the asset reside in an account that is different from the default creator account. If not set (`None` or `""`) at asset creation or subsequently set to empty by the manager the field is permanently empty. +- `freeze: str | None` - The address of the optional account that can be used to freeze or unfreeze holdings of this asset for any account. If empty, freezing is not permitted. If not set (`None` or `""`) at asset creation or subsequently set to empty by the manager the field is permanently empty. +- `clawback: str | None` - The address of the optional account that can clawback holdings of this asset from any account. **This field should be used with caution** as the clawback account has the ability to **unconditionally take assets from any account**. If empty, clawback is not permitted. If not set (`None` or `""`) at asset creation or subsequently set to empty by the manager the field is permanently empty. + +### Examples + +```python +# Basic example +result = algorand.send.asset_create(AssetCreateParams(sender="CREATORADDRESS", total=100)) +created_asset_id = result.asset_id + +# Advanced example +algorand.send.asset_create( + AssetCreateParams( + sender="CREATORADDRESS", + total=100, + decimals=2, + asset_name="asset", + unit_name="unit", + url="url", + metadata_hash=b"metadataHash", + default_frozen=False, + manager="MANAGERADDRESS", + reserve="RESERVEADDRESS", + freeze="FREEZEADDRESS", + clawback="CLAWBACKADDRESS", + lease=b"lease", + note=b"note", + # You wouldn't normally set this field + first_valid_round=1000, + validity_window=10, + extra_fee=AlgoAmount(micro_algo=1000), + static_fee=AlgoAmount(micro_algo=1000), + # Max fee doesn't make sense with extra_fee AND static_fee + # already specified, but here for completeness + max_fee=AlgoAmount(micro_algo=3000), + # Signer only needed if you want to provide one, + # generally you'd register it with AlgorandClient + # against the sender and not need to pass it in + signer=transaction_signer, + ), + send_params=SendParams( + max_rounds_to_wait=5, + suppress_log=True, + ), +) +``` + +## Reconfigure + +If you have a `manager` address set on an asset, that address can send a reconfiguration transaction to change the `manager`, `reserve`, `freeze` and `clawback` fields of the asset if they haven't been set to empty. + +> [!WARNING] +> If you issue a reconfigure transaction and don't set the _existing_ values for any of the below fields then that field will be permanently set to empty. + +To reconfigure an asset you can use `algorand.send.asset_config(params)` (immediately send a single asset config transaction), `algorand.create_transaction.asset_config(params)` (construct an asset config transaction), or `algorand.new_group().add_asset_config(params)` (add asset config to a group of transactions) per [`AlgorandClient`](../../core/algorand-client) [transaction semantics](../../core/algorand-client#creating-and-issuing-transactions). + +The base type for specifying an asset configuration transaction is `AssetConfigParams`, which has the following parameters in addition to the [common transaction parameters](../../core/algorand-client#transaction-parameters): + +- `asset_id: int` - ID of the asset to reconfigure +- `manager: str | None` - The address of the optional account that can manage the configuration of the asset and destroy it. The configuration fields it can change are `manager`, `reserve`, `clawback`, and `freeze`. If not set (`None` or `""`) the asset will become permanently immutable. +- `reserve: str | None` - The address of the optional account that holds the reserve (uncirculated supply) units of the asset. This address has no specific authority in the protocol itself and is informational only. Some standards like [ARC-19](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0019.md) rely on this field to hold meaningful data. It can be used in the case where you want to signal to holders of your asset that the uncirculated units of the asset reside in an account that is different from the default creator account. If not set (`None` or `""`) the field will become permanently empty. +- `freeze: str | None` - The address of the optional account that can be used to freeze or unfreeze holdings of this asset for any account. If empty, freezing is not permitted. If not set (`None` or `""`) the field will become permanently empty. +- `clawback: str | None` - The address of the optional account that can clawback holdings of this asset from any account. **This field should be used with caution** as the clawback account has the ability to **unconditionally take assets from any account**. If empty, clawback is not permitted. If not set (`None` or `""`) the field will become permanently empty. + +### Examples + +```python +# Basic example +algorand.send.asset_config( + AssetConfigParams(sender="MANAGERADDRESS", asset_id=123456, manager="MANAGERADDRESS") +) + +# Advanced example +algorand.send.asset_config( + AssetConfigParams( + sender="MANAGERADDRESS", + asset_id=123456, + manager="MANAGERADDRESS", + reserve="RESERVEADDRESS", + freeze="FREEZEADDRESS", + clawback="CLAWBACKADDRESS", + lease=b"lease", + note=b"note", + # You wouldn't normally set this field + first_valid_round=1000, + validity_window=10, + extra_fee=AlgoAmount(micro_algo=1000), + static_fee=AlgoAmount(micro_algo=1000), + # Max fee doesn't make sense with extra_fee AND static_fee + # already specified, but here for completeness + max_fee=AlgoAmount(micro_algo=3000), + # Signer only needed if you want to provide one, + # generally you'd register it with AlgorandClient + # against the sender and not need to pass it in + signer=transaction_signer, + ), + send_params=SendParams( + max_rounds_to_wait=5, + suppress_log=True, + ), +) +``` + +## Freeze + +To freeze or unfreeze an asset holding for a specific account you can use `algorand.send.asset_freeze(params)` (immediately send a single asset freeze transaction), `algorand.create_transaction.asset_freeze(params)` (construct an asset freeze transaction), or `algorand.new_group().add_asset_freeze(params)` (add asset freeze to a group of transactions) per [`AlgorandClient`](../../core/algorand-client) [transaction semantics](../../core/algorand-client#creating-and-issuing-transactions). + +**Note:** The `sender` of the freeze transaction must be the `freeze` account of the asset. + +The base type for specifying an asset freeze transaction is `AssetFreezeParams`, which has the following parameters in addition to the [common transaction parameters](../../core/algorand-client#transaction-parameters): + +- `asset_id: int` - The ID of the asset to freeze/unfreeze +- `account: str` - The address of the account to freeze or unfreeze the asset for +- `frozen: bool` - Whether the assets of this account should be frozen for this asset + +### Examples + +```python +# Basic example (freeze) +algorand.send.asset_freeze( + AssetFreezeParams(sender="FREEZEADDRESS", asset_id=123456, account="TARGETADDRESS", frozen=True) +) + +# Basic example (unfreeze) +algorand.send.asset_freeze( + AssetFreezeParams(sender="FREEZEADDRESS", asset_id=123456, account="TARGETADDRESS", frozen=False) +) + +# Advanced example +algorand.send.asset_freeze( + AssetFreezeParams( + sender="FREEZEADDRESS", + asset_id=123456, + account="TARGETADDRESS", + frozen=True, + lease=b"lease", + note=b"note", + # You wouldn't normally set this field + first_valid_round=1000, + validity_window=10, + extra_fee=AlgoAmount(micro_algo=1000), + static_fee=AlgoAmount(micro_algo=1000), + # Max fee doesn't make sense with extra_fee AND static_fee + # already specified, but here for completeness + max_fee=AlgoAmount(micro_algo=3000), + # Signer only needed if you want to provide one, + # generally you'd register it with AlgorandClient + # against the sender and not need to pass it in + signer=transaction_signer, + ), + send_params=SendParams( + max_rounds_to_wait=5, + suppress_log=True, + ), +) +``` + +## Destroy + +To destroy an asset you can use `algorand.send.asset_destroy(params)` (immediately send a single asset destroy transaction), `algorand.create_transaction.asset_destroy(params)` (construct an asset destroy transaction), or `algorand.new_group().add_asset_destroy(params)` (add asset destroy to a group of transactions) per [`AlgorandClient`](../../core/algorand-client) [transaction semantics](../../core/algorand-client#creating-and-issuing-transactions). + +**Note:** The `sender` of the destroy transaction must be the `manager` account of the asset, and the asset must have zero total supply (all units must be held by the creator). + +The base type for specifying an asset destroy transaction is `AssetDestroyParams`, which has the following parameters in addition to the [common transaction parameters](../../core/algorand-client#transaction-parameters): + +- `asset_id: int` - The ID of the asset to destroy + +### Examples + +```python +# Basic example +algorand.send.asset_destroy( + AssetDestroyParams(sender="MANAGERADDRESS", asset_id=123456) +) + +# Advanced example +algorand.send.asset_destroy( + AssetDestroyParams( + sender="MANAGERADDRESS", + asset_id=123456, + lease=b"lease", + note=b"note", + # You wouldn't normally set this field + first_valid_round=1000, + validity_window=10, + extra_fee=AlgoAmount(micro_algo=1000), + static_fee=AlgoAmount(micro_algo=1000), + # Max fee doesn't make sense with extra_fee AND static_fee + # already specified, but here for completeness + max_fee=AlgoAmount(micro_algo=3000), + # Signer only needed if you want to provide one, + # generally you'd register it with AlgorandClient + # against the sender and not need to pass it in + signer=transaction_signer, + ), + send_params=SendParams( + max_rounds_to_wait=5, + suppress_log=True, + ), +) +``` + +## Transfer + +To transfer unit(s) of an asset between accounts you can use `algorand.send.asset_transfer(params)` (immediately send a single asset transfer transaction), `algorand.create_transaction.asset_transfer(params)` (construct an asset transfer transaction), or `algorand.new_group().add_asset_transfer(params)` (add asset transfer to a group of transactions) per [`AlgorandClient`](../../core/algorand-client) [transaction semantics](../../core/algorand-client#creating-and-issuing-transactions). + +**Note:** For an account to receive an asset it needs to have [opted-in](#opt-inout). + +The base type for specifying an asset transfer transaction is `AssetTransferParams`, which has the following parameters in addition to the [common transaction parameters](../../core/algorand-client#transaction-parameters): + +- `asset_id: int` - ID of the asset to transfer. +- `amount: int` - Amount of the asset to transfer (in smallest divisible (decimal) units). +- `receiver: str` - The address of the account that will receive the asset unit(s). +- `clawback_target: str | None` - Optional address of an account to clawback the asset from. Requires the sender to be the clawback account. **Warning:** Be careful with this parameter as it can lead to unexpected loss of funds if not used correctly. +- `close_asset_to: str | None` - Optional address of an account to close the asset position to. **Warning:** Be careful with this parameter as it can lead to loss of funds if not used correctly. + +### Examples + +```python +# Basic example +algorand.send.asset_transfer( + AssetTransferParams(sender="HOLDERADDRESS", asset_id=123456, amount=1, receiver="RECEIVERADDRESS") +) + +# Advanced example (with clawback and close asset to) +algorand.send.asset_transfer( + AssetTransferParams( + sender="CLAWBACKADDRESS", + asset_id=123456, + amount=1, + receiver="RECEIVERADDRESS", + clawback_target="HOLDERADDRESS", + # This field needs to be used with caution + close_asset_to="ADDRESSTOCLOSETO", + lease=b"lease", + note=b"note", + # You wouldn't normally set this field + first_valid_round=1000, + validity_window=10, + extra_fee=AlgoAmount(micro_algo=1000), + static_fee=AlgoAmount(micro_algo=1000), + # Max fee doesn't make sense with extra_fee AND static_fee + # already specified, but here for completeness + max_fee=AlgoAmount(micro_algo=3000), + # Signer only needed if you want to provide one, + # generally you'd register it with AlgorandClient + # against the sender and not need to pass it in + signer=transaction_signer, + ), + send_params=SendParams( + max_rounds_to_wait=5, + suppress_log=True, + ), +) +``` + +## Opt-in/out + +Before an account can receive a specific asset, it must [`opt-in`](https://dev.algorand.co/concepts/assets/opt-in-out#receiving-an-asset) to receive it. An opt-in transaction places an asset holding of 0 into the account and increases the [minimum balance](https://dev.algorand.co/concepts/smart-contracts/costs-constraints#mbr) of that account by [100,000 microAlgos](https://dev.algorand.co/concepts/assets/overview/). + +An account can opt out of an asset at any time by closing out it's asset position to another account (usually to the asset creator). This means that the account will no longer hold the asset, and the account will no longer be able to receive the asset. The account also recovers the Minimum Balance Requirement for the asset (100,000 microAlgos). + +When opting-out you generally want to be careful to ensure you have a zero-balance otherwise you will forfeit the balance you do have. AlgoKit Utils can protect you from making this mistake by checking you have a zero-balance before issuing the opt-out transaction. You can turn this check off if you want to avoid the extra calls to Algorand and are confident in what you are doing. + +AlgoKit Utils gives you functions that allow you to do opt-ins and opt-outs in bulk or as a single operation. The bulk operations give you less control over the sending semantics as they automatically send the transactions to Algorand in the most optimal way using transaction groups of 16 at a time. + +### `asset_opt_in` + +To opt-in to an asset you can use `algorand.send.asset_opt_in(params)` (immediately send a single asset opt-in transaction), `algorand.create_transaction.asset_opt_in(params)` (construct an asset opt-in transaction), or `algorand.new_group().add_asset_opt_in(params)` (add asset opt-in to a group of transactions) per [`AlgorandClient`](../../core/algorand-client) [transaction semantics](../../core/algorand-client#creating-and-issuing-transactions). + +The base type for specifying an asset opt-in transaction is `AssetOptInParams`, which has the following parameters in addition to the [common transaction parameters](../../core/algorand-client#transaction-parameters): + +- `asset_id: int` - The ID of the asset that will be opted-in to + +```python +# Basic example +algorand.send.asset_opt_in(AssetOptInParams(sender="SENDERADDRESS", asset_id=123456)) + +# Advanced example +algorand.send.asset_opt_in( + AssetOptInParams( + sender="SENDERADDRESS", + asset_id=123456, + lease=b"lease", + note=b"note", + # You wouldn't normally set this field + first_valid_round=1000, + validity_window=10, + extra_fee=AlgoAmount(micro_algo=1000), + static_fee=AlgoAmount(micro_algo=1000), + # Max fee doesn't make sense with extra_fee AND static_fee + # already specified, but here for completeness + max_fee=AlgoAmount(micro_algo=3000), + # Signer only needed if you want to provide one, + # generally you'd register it with AlgorandClient + # against the sender and not need to pass it in + signer=transaction_signer, + ), + send_params=SendParams( + max_rounds_to_wait=5, + suppress_log=True, + ), +) +``` + +### `asset_opt_out` + +To opt-out of an asset you can use `algorand.send.asset_opt_out(params)` (immediately send a single asset opt-out transaction), `algorand.create_transaction.asset_opt_out(params)` (construct an asset opt-out transaction), or `algorand.new_group().add_asset_opt_out(params)` (add asset opt-out to a group of transactions) per [`AlgorandClient`](../../core/algorand-client) [transaction semantics](../../core/algorand-client#creating-and-issuing-transactions). + +The base type for specifying an asset opt-out transaction is `AssetOptOutParams`, which has the following parameters in addition to the [common transaction parameters](../../core/algorand-client#transaction-parameters): + +- `asset_id: int` - The ID of the asset that will be opted-out of +- `creator: str` - The address of the asset creator account to close the asset position to (any remaining asset units will be sent to this account). + +If you are using the `send` variant then there is an additional parameter: + +- `ensure_zero_balance: bool` - Whether or not to check if the account has a zero balance first or not. Defaults to `True`. If this is set to `True` and the account has an asset balance it will throw an error. If this is set to `False` and the account has an asset balance it will lose those assets to the asset creator. + +> [!WARNING] +> If you are using the `create_transaction` or `add_asset_opt_out` variants then you need to take responsibility to ensure the asset holding balance is `0` to avoid losing assets. + +```python +# Basic example (with creator) +algorand.send.asset_opt_out( + AssetOptOutParams(sender="SENDERADDRESS", asset_id=123456, creator="CREATORADDRESS"), + ensure_zero_balance=True, +) + +# Advanced example +algorand.send.asset_opt_out( + AssetOptOutParams( + sender="SENDERADDRESS", + asset_id=123456, + creator="CREATORADDRESS", + lease=b"lease", + note=b"note", + # You wouldn't normally set this field + first_valid_round=1000, + validity_window=10, + extra_fee=AlgoAmount(micro_algo=1000), + static_fee=AlgoAmount(micro_algo=1000), + # Max fee doesn't make sense with extra_fee AND static_fee + # already specified, but here for completeness + max_fee=AlgoAmount(micro_algo=3000), + # Signer only needed if you want to provide one, + # generally you'd register it with AlgorandClient + # against the sender and not need to pass it in + signer=transaction_signer, + ), + send_params=SendParams( + max_rounds_to_wait=5, + suppress_log=True, + ), + ensure_zero_balance=True, +) +``` + +### `asset.bulk_opt_in` + +The `asset.bulk_opt_in` function facilitates the opt-in process for an account to multiple assets, allowing the account to receive and hold those assets. + +```python +# Basic example +algorand.asset.bulk_opt_in(account="ACCOUNTADDRESS", asset_ids=[12345, 67890]) + +# Advanced example +algorand.asset.bulk_opt_in( + account="ACCOUNTADDRESS", + asset_ids=[12345, 67890], + max_fee=AlgoAmount(micro_algo=1000), + send_params=SendParams(suppress_log=True), +) +``` + +### `asset.bulk_opt_out` + +The `asset.bulk_opt_out` function facilitates the opt-out process for an account from multiple assets, permitting the account to discontinue holding a group of assets. + +```python +# Basic example +algorand.asset.bulk_opt_out(account="ACCOUNTADDRESS", asset_ids=[12345, 67890]) + +# Advanced example +algorand.asset.bulk_opt_out( + account="ACCOUNTADDRESS", + asset_ids=[12345, 67890], + ensure_zero_balance=True, + max_fee=AlgoAmount(micro_algo=1000), + send_params=SendParams(suppress_log=True), +) +``` + +## Get information + +### Getting current parameters for an asset + +You can get the current parameters of an asset from algod by using `algorand.asset.get_by_id(asset_id)`, which returns an [`AssetInformation`](#assetinformation) instance. + +```python +asset_info = algorand.asset.get_by_id(12353) +``` + +### Getting current holdings of an asset for an account + +You can get the current holdings of an asset for a given account from algod by using `algorand.asset.get_account_information(address, asset_id)`, which returns an [`AccountAssetInformation`](#accountassetinformation) instance. + +```python +address = "XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA" +asset_id = 12345 +account_info = algorand.asset.get_account_information(address, asset_id) +``` + +## Return types + +These dataclasses are defined in `algokit_utils.assets.asset_manager`. + +### `AssetInformation` + +Returned by `algorand.asset.get_by_id()`. Contains the current on-chain parameters for an Algorand Standard Asset. + +| Field | Type | Description | +| --- | --- | --- | +| `asset_id` | `int` | The ID of the asset | +| `creator` | `str` | The address of the account that created the asset | +| `total` | `int` | The total amount of the smallest divisible units that were created of the asset | +| `decimals` | `int` | The amount of decimal places the asset was created with | +| `default_frozen` | `bool \| None` | Whether the asset was frozen by default for all accounts, defaults to `None` | +| `manager` | `str \| None` | The address of the optional account that can manage the configuration of the asset and destroy it, defaults to `None` | +| `reserve` | `str \| None` | The address of the optional account that holds the reserve (uncirculated supply) units of the asset, defaults to `None` | +| `freeze` | `str \| None` | The address of the optional account that can be used to freeze or unfreeze holdings of this asset, defaults to `None` | +| `clawback` | `str \| None` | The address of the optional account that can clawback holdings of this asset from any account, defaults to `None` | +| `unit_name` | `str \| None` | The optional name of the unit of this asset (e.g. ticker name), defaults to `None` | +| `unit_name_b64` | `bytes \| None` | The optional name of the unit of this asset as bytes, defaults to `None` | +| `asset_name` | `str \| None` | The optional name of the asset, defaults to `None` | +| `asset_name_b64` | `bytes \| None` | The optional name of the asset as bytes, defaults to `None` | +| `url` | `str \| None` | The optional URL where more information about the asset can be retrieved, defaults to `None` | +| `url_b64` | `bytes \| None` | The optional URL where more information about the asset can be retrieved as bytes, defaults to `None` | +| `metadata_hash` | `bytes \| None` | The 32-byte hash of some metadata that is relevant to the asset and/or asset holders, defaults to `None` | + +### `AccountAssetInformation` + +Returned by `algorand.asset.get_account_information()`. Contains an account's holding of a particular asset. + +| Field | Type | Description | +| --- | --- | --- | +| `asset_id` | `int` | The ID of the asset | +| `balance` | `int` | The amount of the asset held by the account | +| `frozen` | `bool` | Whether the asset is frozen for this account | +| `round` | `int` | The round this information was retrieved at | + +### `BulkAssetOptInOutResult` + +Returned by `algorand.asset.bulk_opt_in()` and `algorand.asset.bulk_opt_out()`. Contains the result for each asset in a bulk operation. + +| Field | Type | Description | +| --- | --- | --- | +| `asset_id` | `int` | The ID of the asset opted into / out of | +| `transaction_id` | `str` | The transaction ID of the resulting opt in / out | diff --git a/docs/src/content/docs/concepts/building/testing.md b/docs/src/content/docs/concepts/building/testing.md new file mode 100644 index 00000000..461a2a31 --- /dev/null +++ b/docs/src/content/docs/concepts/building/testing.md @@ -0,0 +1,599 @@ +--- +title: "Automated testing" +description: "A collection of useful snippets and patterns for testing Algorand applications using AlgoKit Utils with pytest." +--- + +Automated testing is a higher-order use case capability provided by AlgoKit Utils that builds on top of the core capabilities. It allows you to use terse, robust automated testing primitives that work with [pytest](https://docs.pytest.org/en/latest/) to facilitate fixture management, quickly generating isolated and funded test accounts, transaction logging, and log capture. + +To see some usage examples check out all of the [automated tests](https://github.com/algorandfoundation/algokit-utils-py/tree/main/tests). Alternatively, you can see examples of using this library to test smart contracts with the various test files in the repository (AlgoKit Utils [dogfoods](https://en.wikipedia.org/wiki/Eating_your_own_dog_food) its own testing library). + +## Module import + +AlgoKit Utils testing functionality is accessed through the main `algokit_utils` module along with standard pytest patterns: + +```python +import pytest +from algokit_utils import AlgorandClient, AddressWithSigners +from algokit_utils.models.amount import AlgoAmount +``` + +## Algorand fixture + +In general, the primary entrypoint for testing is creating a pytest fixture that provides an [`AlgorandClient`](../../core/algorand-client) configured for LocalNet. This fixture, combined with account fixtures, exposes all the functionality you need to write isolated, repeatable tests. + +```python +import pytest +from algokit_utils import AlgorandClient + +@pytest.fixture +def algorand() -> AlgorandClient: + return AlgorandClient.default_localnet() +``` + +### Using with pytest + +To integrate with [pytest](https://docs.pytest.org/en/latest/) you define fixtures and use them in your test functions. Pytest's fixture system provides automatic dependency injection and scope control. + +#### Per-test isolation + +```python +import pytest +from algokit_utils import AlgorandClient, AddressWithSigners +from algokit_utils.models.amount import AlgoAmount + +@pytest.fixture +def algorand() -> AlgorandClient: + return AlgorandClient.default_localnet() + +@pytest.fixture +def test_account(algorand: AlgorandClient) -> AddressWithSigners: + new_account = algorand.account.random() + dispenser = algorand.account.localnet_dispenser() + algorand.account.ensure_funded( + new_account, + dispenser, + min_spending_balance=AlgoAmount.from_algo(10), + ) + algorand.set_signer(sender=new_account.addr, signer=new_account.signer) + return new_account + +def test_my_test(algorand: AlgorandClient, test_account: AddressWithSigners): + # Test stuff! + pass +``` + +#### Test suite isolation + +```python +import pytest +from algokit_utils import AlgorandClient, AddressWithSigners +from algokit_utils.models.amount import AlgoAmount + +@pytest.fixture(scope="module") +def algorand() -> AlgorandClient: + return AlgorandClient.default_localnet() + +@pytest.fixture(scope="module") +def test_account(algorand: AlgorandClient) -> AddressWithSigners: + new_account = algorand.account.random() + dispenser = algorand.account.localnet_dispenser() + algorand.account.ensure_funded( + new_account, + dispenser, + min_spending_balance=AlgoAmount.from_algo(10), + ) + algorand.set_signer(sender=new_account.addr, signer=new_account.signer) + return new_account + +def test_my_test(algorand: AlgorandClient, test_account: AddressWithSigners): + # Test stuff! + pass +``` + +Refer to [pytest fixture scopes](https://docs.pytest.org/en/latest/how-to/fixtures.html#fixture-scopes) for more information on how to control the lifecycle of fixtures. + +### Fixture configuration + +When creating your `AlgorandClient` fixture you can optionally configure the client setup: + +- `AlgorandClient.default_localnet()` - Creates a client against default LocalNet (default, no configuration needed) +- `AlgorandClient.from_environment()` - Creates a client against environment variables defined network +- `AlgorandClient.from_clients(algod=..., indexer=..., kmd=...)` - Creates a client from specific SDK client instances +- `AlgorandClient.from_config(algod_config=..., indexer_config=..., kmd_config=...)` - Creates a client from specific client configurations + +For test account funding, you can control the amount: + +```python +@pytest.fixture +def test_account(algorand: AlgorandClient) -> AddressWithSigners: + new_account = algorand.account.random() + dispenser = algorand.account.localnet_dispenser() + algorand.account.ensure_funded( + new_account, + dispenser, + min_spending_balance=AlgoAmount.from_algo(100), # Custom funding amount + ) + return new_account +``` + +### Using the fixture context + +The `algorand` fixture provides access to an [`AlgorandClient`](../../core/algorand-client) instance which exposes the following properties commonly used in testing: + +- `algorand.client.algod` - Algod client instance +- `algorand.client.indexer` - Indexer client instance (if configured) +- `algorand.client.kmd` - KMD client instance (if configured) +- `algorand.account` - [`AccountManager`](../../core/account) for creating and managing test accounts +- `algorand.send` - Methods for sending transactions +- `algorand.app` - Methods for interacting with applications + +You can create additional test account fixtures for specific test needs: + +```python +@pytest.fixture +def funded_account(algorand: AlgorandClient) -> AddressWithSigners: + new_account = algorand.account.random() + dispenser = algorand.account.localnet_dispenser() + algorand.account.ensure_funded( + new_account, + dispenser, + min_spending_balance=AlgoAmount.from_algo(10), + ) + algorand.set_signer(sender=new_account.addr, signer=new_account.signer) + return new_account +``` + +## Log capture fixture + +If you want to capture log messages from AlgoKit that are issued within your test so that you can assert on them or parse them for debugging information, you can configure the AlgoKit logger in a pytest fixture. + +```python +import logging + +@pytest.fixture(autouse=True) +def capture_logs(caplog: pytest.LogCaptureFixture): + with caplog.at_level(logging.DEBUG): + yield caplog +``` + +### Using with pytest + +To capture logs in pytest, use the built-in `caplog` fixture: + +```python +import logging +import pytest + +@pytest.fixture(autouse=True) +def capture_logs(caplog: pytest.LogCaptureFixture): + with caplog.at_level(logging.DEBUG): + yield caplog + +def test_my_test(algorand: AlgorandClient, test_account: AddressWithSigners, capture_logs): + # Test stuff! + + # Access captured logs + captured = capture_logs.text + # do stuff with the logs +``` + +### Snapshot testing the logs + +If you want to quickly pin some behaviour of what logic you have does in terms of invoking AlgoKit methods you can use [pytest-snapshot](https://pypi.org/project/pytest-snapshot/) or [syrupy](https://github.com/toptal/syrupy) for snapshot / approval testing of captured log output. + +This might look something like this: + +```python +def test_deploy_logging(algorand, test_account, capture_logs, snapshot): + factory = algorand.client.get_app_factory( + app_spec=app_spec, + default_sender=test_account.addr, + ) + app_client, result = factory.deploy() + + assert capture_logs.text == snapshot +``` + +## Getting a test account + +When testing, it's often useful to ephemerally generate random accounts, fund them with some number of Algo and then use that account to perform transactions. By creating an ephemeral, random account you naturally get isolation between tests and test runs and don't need to start from a specific blockchain network state. This makes tests less flakey, and also means the same test can be run against LocalNet and (say) TestNet. + +The key when generating a test account is getting hold of a [dispenser](./transfer#dispenser) and then [ensuring the test account is funded](./transfer#ensure_funded). + +To make it easier to quickly get a test account, the following mechanisms are available: + +- `algorand.account.random()` - Generates a new random Algorand account +- `algorand.account.localnet_dispenser()` - Gets the LocalNet [dispenser](./transfer#dispenser) account for funding +- `algorand.account.dispenser_from_environment()` - Gets dispenser from environment variables or LocalNet +- `algorand.account.ensure_funded(account, dispenser, min_spending_balance=...)` - [Ensures the account is funded](./transfer#ensure_funded) with a minimum balance +- `algorand.account.from_environment(name)` - Loads an account from environment variables (auto-creates on LocalNet) + +A typical pattern for creating funded test accounts is: + +```python +def generate_account(algorand: AlgorandClient, initial_funds: AlgoAmount = AlgoAmount.from_algo(10)) -> AddressWithSigners: + account = algorand.account.random() + dispenser = algorand.account.localnet_dispenser() + algorand.account.ensure_funded( + account, + dispenser, + min_spending_balance=initial_funds, + ) + algorand.set_signer(sender=account.addr, signer=account.signer) + return account +``` + +## Creating test assets + +When testing functionality that involves [Algorand Standard Assets (ASAs)](./asset), you can create test assets using a pytest fixture or helper function. This pairs with a funded test account fixture to create ephemeral assets for each test or test suite. + +### Fixture approach + +```python +import pytest +from algokit_utils import AlgorandClient, AddressWithSigners +from algokit_utils.models.amount import AlgoAmount +from algokit_utils.transactions.types import AssetCreateParams + +@pytest.fixture +def algorand() -> AlgorandClient: + return AlgorandClient.default_localnet() + +@pytest.fixture +def test_account(algorand: AlgorandClient) -> AddressWithSigners: + new_account = algorand.account.random() + dispenser = algorand.account.localnet_dispenser() + algorand.account.ensure_funded( + new_account, + dispenser, + min_spending_balance=AlgoAmount.from_algo(10), + ) + algorand.set_signer(sender=new_account.addr, signer=new_account.signer) + return new_account + +@pytest.fixture +def test_asset_id(algorand: AlgorandClient, test_account: AddressWithSigners) -> int: + result = algorand.send.asset_create( + AssetCreateParams( + sender=test_account.addr, + total=1000, + decimals=0, + default_frozen=False, + unit_name="TEST", + asset_name="Test Asset", + url="https://example.com", + manager=test_account.addr, + reserve=test_account.addr, + freeze=test_account.addr, + clawback=test_account.addr, + ) + ) + assert result.confirmation.asset_id is not None + return int(result.confirmation.asset_id) + +def test_asset_transfer(algorand: AlgorandClient, test_account: AddressWithSigners, test_asset_id: int): + # Use the created asset in your test + pass +``` + +### Helper function approach + +For more flexibility (e.g. varying the total supply per test), use a helper function instead of a fixture: + +```python +import math +import random +from algokit_utils import AlgorandClient, AddressWithSigners +from algokit_utils.transactions.types import AssetCreateParams + +def generate_test_asset(algorand: AlgorandClient, sender: AddressWithSigners, total: int | None = None) -> int: + if total is None: + total = math.floor(random.random() * 100) + 20 + + result = algorand.send.asset_create( + AssetCreateParams( + sender=sender.addr, + total=total, + decimals=0, + default_frozen=False, + unit_name="TST", + asset_name=f"Test Asset {math.floor(random.random() * 1000)}", + url="https://example.com", + manager=sender.addr, + reserve=sender.addr, + freeze=sender.addr, + clawback=sender.addr, + ) + ) + assert result.confirmation.asset_id is not None + return int(result.confirmation.asset_id) + +def test_with_asset(algorand: AlgorandClient, test_account: AddressWithSigners): + asset_id = generate_test_asset(algorand, test_account, total=500) + # Use asset_id in your test + pass +``` + +## Testing asset transfers + +When testing [asset transfers](./asset), the receiver must first opt in to the asset before receiving it. You can then transfer assets and assert on the resulting balances. + +```python +import pytest +from algokit_utils import AlgorandClient, AddressWithSigners +from algokit_utils.models.amount import AlgoAmount +from algokit_utils.transactions.types import AssetCreateParams, AssetOptInParams, AssetTransferParams + +@pytest.fixture +def algorand() -> AlgorandClient: + return AlgorandClient.default_localnet() + +@pytest.fixture +def sender(algorand: AlgorandClient) -> AddressWithSigners: + new_account = algorand.account.random() + dispenser = algorand.account.localnet_dispenser() + algorand.account.ensure_funded( + new_account, + dispenser, + min_spending_balance=AlgoAmount.from_algo(10), + ) + algorand.set_signer(sender=new_account.addr, signer=new_account.signer) + return new_account + +@pytest.fixture +def receiver(algorand: AlgorandClient) -> AddressWithSigners: + new_account = algorand.account.random() + dispenser = algorand.account.localnet_dispenser() + algorand.account.ensure_funded( + new_account, + dispenser, + min_spending_balance=AlgoAmount.from_algo(10), + ) + algorand.set_signer(sender=new_account.addr, signer=new_account.signer) + return new_account + +@pytest.fixture +def test_asset_id(algorand: AlgorandClient, sender: AddressWithSigners) -> int: + result = algorand.send.asset_create( + AssetCreateParams( + sender=sender.addr, + total=1000, + decimals=0, + default_frozen=False, + unit_name="TEST", + asset_name="Test Asset", + manager=sender.addr, + reserve=sender.addr, + freeze=sender.addr, + clawback=sender.addr, + ) + ) + assert result.confirmation.asset_id is not None + return int(result.confirmation.asset_id) + +def test_asset_transfer( + algorand: AlgorandClient, + sender: AddressWithSigners, + receiver: AddressWithSigners, + test_asset_id: int, +): + # Opt the receiver in to the asset + algorand.send.asset_opt_in( + AssetOptInParams( + sender=receiver.addr, + asset_id=test_asset_id, + ) + ) + + # Transfer assets from sender to receiver + algorand.send.asset_transfer( + AssetTransferParams( + sender=sender.addr, + receiver=receiver.addr, + asset_id=test_asset_id, + amount=50, + ) + ) + + # Assert on resulting balances + receiver_info = algorand.asset.get_account_information(receiver, test_asset_id) + assert receiver_info.balance == 50 + + sender_info = algorand.asset.get_account_information(sender, test_asset_id) + assert sender_info.balance == 950 +``` + +## Testing application deployments + +When testing [smart contract deployments](./app-deploy), you can use the [`AppFactory`](./app-client#appfactory) to deploy an application and then assert on the deployment result. The deploy result includes the operation performed, the app ID, and the app address. + +```python +import json +from pathlib import Path +import pytest +from algokit_utils import AlgorandClient, AddressWithSigners +from algokit_utils.applications.app_factory import AppFactory +from algokit_utils.applications.app_deployer import OperationPerformed, OnUpdate +from algokit_utils.models.amount import AlgoAmount + +@pytest.fixture +def algorand() -> AlgorandClient: + return AlgorandClient.default_localnet() + +@pytest.fixture +def test_account(algorand: AlgorandClient) -> AddressWithSigners: + new_account = algorand.account.random() + dispenser = algorand.account.localnet_dispenser() + algorand.account.ensure_funded( + new_account, + dispenser, + min_spending_balance=AlgoAmount.from_algo(10), + ) + algorand.set_signer(sender=new_account.addr, signer=new_account.signer) + return new_account + +@pytest.fixture +def factory(algorand: AlgorandClient, test_account: AddressWithSigners) -> AppFactory: + app_spec = json.loads(Path("path/to/application.json").read_text()) + return algorand.client.get_app_factory( + app_spec=app_spec, + default_sender=test_account.addr, + ) + +def test_deploy_creates_app(factory: AppFactory): + app_client, deploy_result = factory.deploy() + + assert deploy_result.operation_performed == OperationPerformed.Create + assert deploy_result.create_result + assert deploy_result.create_result.app_id > 0 + assert app_client.app_id == deploy_result.create_result.app_id + +def test_deploy_updates_existing_app(factory: AppFactory): + # First deploy creates the app + _, create_result = factory.deploy(on_update=OnUpdate.UpdateApp) + assert create_result.operation_performed == OperationPerformed.Create + + # Second deploy with same name triggers an update + _, update_result = factory.deploy(on_update=OnUpdate.UpdateApp) + assert update_result.operation_performed == OperationPerformed.Update + assert update_result.update_result + assert update_result.app.app_id == create_result.app.app_id +``` + +## Testing application calls + +When testing [application calls](./app-client), you can use an [`AppClient`](./app-client#appclient) to call ABI methods and assert on the return values. The `app_client.send.call()` method returns a result with an `abi_return` field containing the decoded ABI return value. + +```python +import json +from pathlib import Path +import pytest +from algokit_utils import AlgorandClient, AddressWithSigners +from algokit_utils.applications.app_client import AppClient, AppClientMethodCallParams +from algokit_utils.models.amount import AlgoAmount + +@pytest.fixture +def algorand() -> AlgorandClient: + return AlgorandClient.default_localnet() + +@pytest.fixture +def test_account(algorand: AlgorandClient) -> AddressWithSigners: + new_account = algorand.account.random() + dispenser = algorand.account.localnet_dispenser() + algorand.account.ensure_funded( + new_account, + dispenser, + min_spending_balance=AlgoAmount.from_algo(10), + ) + algorand.set_signer(sender=new_account.addr, signer=new_account.signer) + return new_account + +@pytest.fixture +def app_client(algorand: AlgorandClient, test_account: AddressWithSigners) -> AppClient: + app_spec = json.loads(Path("path/to/application.json").read_text()) + factory = algorand.client.get_app_factory( + app_spec=app_spec, + default_sender=test_account.addr, + ) + app_client, _ = factory.deploy() + return app_client + +def test_abi_method_call(app_client: AppClient): + # Call an ABI method and assert on the return value + result = app_client.send.call( + AppClientMethodCallParams(method="hello", args=["world"]) + ) + assert result.abi_return == "Hello, world" + +def test_abi_struct_return(app_client: AppClient): + # ABI struct return values are decoded as dicts + result = app_client.send.call( + AppClientMethodCallParams(method="get_record", args=[1]) + ) + assert result.abi_return == {"id": 1, "name": "Alice"} +``` + +## Testing box storage + +When testing [box storage](./app-client#boxes) operations, you need to fund the application account to cover the minimum balance requirement (MBR) for boxes, then create, write, and read boxes via the [`AppClient`](./app-client#appclient). Box references must be included in the transaction so the AVM can access them. + +```python +import base64 +import json +from pathlib import Path +import pytest +from algokit_utils import AlgorandClient, AddressWithSigners +from algokit_utils.applications.app_client import AppClient, AppClientMethodCallParams, FundAppAccountParams +from algokit_utils.models.amount import AlgoAmount + +@pytest.fixture +def algorand() -> AlgorandClient: + return AlgorandClient.default_localnet() + +@pytest.fixture +def test_account(algorand: AlgorandClient) -> AddressWithSigners: + new_account = algorand.account.random() + dispenser = algorand.account.localnet_dispenser() + algorand.account.ensure_funded( + new_account, + dispenser, + min_spending_balance=AlgoAmount.from_algo(10), + ) + algorand.set_signer(sender=new_account.addr, signer=new_account.signer) + return new_account + +@pytest.fixture +def app_client(algorand: AlgorandClient, test_account: AddressWithSigners) -> AppClient: + app_spec = json.loads(Path("path/to/application.json").read_text()) + factory = algorand.client.get_app_factory( + app_spec=app_spec, + default_sender=test_account.addr, + ) + app_client, _ = factory.deploy() + # Fund the app account so it can hold boxes + app_client.fund_app_account(FundAppAccountParams(amount=AlgoAmount.from_algo(1))) + return app_client + +def test_box_create_and_read(app_client: AppClient): + box_name = bytes([0, 0, 0, 1]) + + # Write a value to a box + app_client.send.call( + AppClientMethodCallParams( + method="set_box", + args=[box_name, "value1"], + box_references=[box_name], + ) + ) + + # Read a single box value + box_value = app_client.get_box_value(box_name) + assert box_value == b"value1" + +def test_box_list_all(app_client: AppClient): + box_name1 = bytes([0, 0, 0, 1]) + box_name2 = bytes([0, 0, 0, 2]) + + # Create two boxes + app_client.send.call( + AppClientMethodCallParams( + method="set_box", + args=[box_name1, "value1"], + box_references=[box_name1], + ) + ) + app_client.send.call( + AppClientMethodCallParams( + method="set_box", + args=[box_name2, "value2"], + box_references=[box_name2], + ) + ) + + # List all boxes and assert on values + box_values = app_client.get_box_values() + box1 = next(b for b in box_values if b.name.name_raw == box_name1) + box2 = next(b for b in box_values if b.name.name_raw == box_name2) + assert box1.value == b"value1" + assert box2.value == b"value2" +``` diff --git a/docs/src/content/docs/concepts/building/transfer.md b/docs/src/content/docs/concepts/building/transfer.md new file mode 100644 index 00000000..72788100 --- /dev/null +++ b/docs/src/content/docs/concepts/building/transfer.md @@ -0,0 +1,154 @@ +--- +title: "Algo transfers (payments)" +description: "Algo transfers, or [payments](https://dev.algorand.co/concepts/transactions/types/#payment-transaction), is a higher-order use case capability provided by AlgoKit Utils that builds on top of the core capabilities, particularly [Algo amount handling](../core/amount.md) and [Transaction management](../core/transaction.md). It allows you to easily initiate Algo transfers between accounts, including dispenser management and idempotent account funding." +--- + +Algo transfers, or [payments](https://dev.algorand.co/concepts/transactions/types/#payment-transaction), is a higher-order use case capability provided by AlgoKit Utils that builds on top of the core capabilities, particularly [Algo amount handling](../../core/amount) and [Transaction management](../../core/transaction). It allows you to easily initiate Algo transfers between accounts, including dispenser management and idempotent account funding. + +To see some usage examples check out the `automated tests`. + +## payment + +The key function to facilitate Algo transfers is `algorand.send.payment(params)` (immediately send a single payment transaction), `algorand.create_transaction.payment(params)` (construct a payment transaction), or `algorand.new_group().add_payment(params)` (add payment to a group of transactions) per [`AlgorandClient`](../../core/algorand-client) [transaction semantics](../../core/algorand-client#creating-and-issuing-transactions). + +The base type for specifying a payment transaction is `PaymentParams`, which has the following parameters in addition to the [common transaction parameters](../../core/algorand-client#transaction-parameters): + +- `receiver: str` - The address of the account that will receive the Algo +- `amount: AlgoAmount` - The amount of Algo to send +- `close_remainder_to: str | None` - If given, close the sender account and send the remaining balance to this address (**warning:** use this carefully as it can result in loss of funds if used incorrectly) + +```python +# Minimal example +result = algorand.send.payment( + PaymentParams( + sender="SENDERADDRESS", + receiver="RECEIVERADDRESS", + amount=AlgoAmount(algo=4), + ) +) + +# Advanced example +result2 = algorand.send.payment( + PaymentParams( + sender="SENDERADDRESS", + receiver="RECEIVERADDRESS", + amount=AlgoAmount(algo=4), + close_remainder_to="CLOSEREMAINDERTOADDRESS", + lease=b"lease", + note=b"note", + # Use this with caution, it's generally better to use algorand.account.rekey_account + rekey_to="REKEYTOADDRESS", + # You wouldn't normally set this field + first_valid_round=1000, + validity_window=10, + extra_fee=AlgoAmount(micro_algo=1000), + static_fee=AlgoAmount(micro_algo=1000), + # Max fee doesn't make sense with extra_fee AND static_fee + # already specified, but here for completeness + max_fee=AlgoAmount(micro_algo=3000), + # Signer only needed if you want to provide one, + # generally you'd register it with AlgorandClient + # against the sender and not need to pass it in + signer=transaction_signer, + ), + send_params=SendParams( + max_rounds_to_wait=5, + suppress_log=True, + ), +) +``` + +## ensure_funded + +The `ensure_funded` function automatically funds an account to maintain a minimum amount of [disposable Algo](https://dev.algorand.co/concepts/smart-contracts/costs-constraints#mbr). This is particularly useful for automation and deployment scripts that get run multiple times and consume Algo when run. + +There are 3 variants of this function: + +- `algorand.account.ensure_funded(account_to_fund, dispenser_account, min_spending_balance, options)` - Funds a given account using a dispenser account as a funding source such that the given account has a certain amount of Algo free to spend (accounting for Algo locked in minimum balance requirement). +- `algorand.account.ensure_funded_from_environment(account_to_fund, min_spending_balance, options)` - Funds a given account using a dispenser account retrieved from the environment, per the [`dispenser_from_environment`](#dispenser) method, as a funding source such that the given account has a certain amount of Algo free to spend (accounting for Algo locked in minimum balance requirement). + - **Note:** requires environment variables to be set. + - The dispenser account is retrieved from the account mnemonic stored in `DISPENSER_MNEMONIC` and optionally `DISPENSER_SENDER` + if it's a rekeyed account, or against default LocalNet if no environment variables present. +- `algorand.account.ensure_funded_from_testnet_dispenser_api(account_to_fund, dispenser_client, min_spending_balance, options)` - Funds a given account using the [TestNet Dispenser API](https://github.com/algorandfoundation/algokit/blob/main/docs/testnet_api.md) as a funding source such that the account has a certain amount of Algo free to spend (accounting for Algo locked in minimum balance requirement). + +The general structure of these calls is similar, they all take: + +- `account_to_fund: str | AddressWithTransactionSigner | AddressWithSigners` - Address or signing account of the account to fund +- The source (dispenser): + - In `ensure_funded`: `dispenser_account: str | AddressWithTransactionSigner | AddressWithSigners` - the address or signing account of the account to use as a dispenser + - In `ensure_funded_from_environment`: Not specified, loaded automatically from the ephemeral environment + - In `ensure_funded_from_testnet_dispenser_api`: `dispenser_client: TestNetDispenserApiClient` - a client instance of the [TestNet dispenser API](../../advanced/dispenser-client) +- `min_spending_balance: AlgoAmount` - The minimum balance of Algo that the account should have available to spend (i.e., on top of the minimum balance requirement) +- An `options` object, which has: + - [Common transaction parameters](../../core/algorand-client#transaction-parameters) (not for TestNet Dispenser API) + - [Execution parameters](../../core/algorand-client#sending-a-single-transaction) (not for TestNet Dispenser API) + - `min_funding_increment: AlgoAmount | None` - When issuing a funding amount, the minimum amount to transfer; this avoids many small transfers if this function gets called often on an active account + +### Examples + +```python +# From account + +# Basic example +algorand.account.ensure_funded("ACCOUNTADDRESS", "DISPENSERADDRESS", AlgoAmount(algo=1)) +# With configuration +algorand.account.ensure_funded( + "ACCOUNTADDRESS", + "DISPENSERADDRESS", + AlgoAmount(algo=1), + min_funding_increment=AlgoAmount(algo=2), + static_fee=AlgoAmount(micro_algo=1000), + send_params=SendParams( + suppress_log=True, + ), +) + +# From environment + +# Basic example +algorand.account.ensure_funded_from_environment("ACCOUNTADDRESS", AlgoAmount(algo=1)) +# With configuration +algorand.account.ensure_funded_from_environment( + "ACCOUNTADDRESS", + AlgoAmount(algo=1), + min_funding_increment=AlgoAmount(algo=2), + static_fee=AlgoAmount(micro_algo=1000), + send_params=SendParams( + suppress_log=True, + ), +) + +# TestNet Dispenser API + +# Basic example +algorand.account.ensure_funded_from_testnet_dispenser_api( + "ACCOUNTADDRESS", + algorand.client.get_testnet_dispenser(), + AlgoAmount(algo=1), +) +# With configuration +algorand.account.ensure_funded_from_testnet_dispenser_api( + "ACCOUNTADDRESS", + algorand.client.get_testnet_dispenser(), + AlgoAmount(algo=1), + min_funding_increment=AlgoAmount(algo=2), +) +``` + +The first two variants return an `EnsureFundedResult` (which also extends the [single transaction result](../../core/algorand-client#sending-a-single-transaction)) if a funding transaction was needed, or `None` if no transaction was required. The TestNet Dispenser API variant returns an `EnsureFundedFromTestnetDispenserApiResult` or `None`. All result types share these common fields: + +- `amount_funded: AlgoAmount` - The number of Algo that was paid +- `transaction_id: str` - The ID of the transaction that funded the account + +If you are using the TestNet Dispenser API then the `transaction_id` is useful if you want to use the [refund functionality](../../advanced/dispenser-client#registering-a-refund). + +## Dispenser + +If you want to programmatically send funds to an account so it can transact then you will often need a "dispenser" account that has a store of Algo that can be sent and a private key available for that dispenser account. + +There's a number of ways to get a dispensing account in AlgoKit Utils: + +- Get a dispenser via [account manager](../../core/account#dispenser) - either automatically from [LocalNet](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/localnet.md) or from the environment +- By programmatically creating one of the many account types via [account manager](../../core/account#accounts) +- By programmatically interacting with [KMD](../../core/account#kmd-account-management) if running against LocalNet +- By using the [AlgoKit TestNet Dispenser API client](../../advanced/dispenser-client) which can be used to fund accounts on TestNet via a dedicated API service diff --git a/docs/src/content/docs/concepts/building/typed-app-clients.md b/docs/src/content/docs/concepts/building/typed-app-clients.md new file mode 100644 index 00000000..0d1eab40 --- /dev/null +++ b/docs/src/content/docs/concepts/building/typed-app-clients.md @@ -0,0 +1,200 @@ +--- +title: "Typed application clients" +description: "Typed application clients are automatically generated, typed Python deployment and invocation clients for smart contracts that have a defined [ARC-56](https://github.com/algorandfoundation/ARCs/pull/258) or [ARC-32](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0032.md) application specification so that the development experience is easier with less upskill ramp-up and less deployment errors. These clients give you a type-safe, intellisense-driven experience for invoking the smart contract." +--- + +Typed application clients are automatically generated, typed Python deployment and invocation clients for smart contracts that have a defined [ARC-56](https://github.com/algorandfoundation/ARCs/pull/258) or [ARC-32](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0032.md) application specification so that the development experience is easier with less upskill ramp-up and less deployment errors. These clients give you a type-safe, intellisense-driven experience for invoking the smart contract. + +Typed application clients are the recommended way of interacting with smart contracts. If you don't have/want a typed client, but have an ARC-56/ARC-32 app spec then you can use the [non-typed application clients](../app-client) and if you want to call a smart contract you don't have an app spec file for you can use the underlying [app management](../app) and [app deployment](../app-deploy) functionality to manually construct transactions. + +## Generating an app spec + +You can generate an app spec file: + +- Using [Algorand Python](https://algorandfoundation.github.io/puya/#quick-start) +- By hand by following the specification [ARC-56](https://github.com/algorandfoundation/ARCs/pull/258)/[ARC-32](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0032.md) + +## Generating a typed client + +To generate a typed client from an app spec file you can use [AlgoKit CLI](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/generate.md#1-typed-clients): + +``` +> algokit generate client application.json --output /absolute/path/to/client.py +``` + +Note: AlgoKit Utils >= 3.0.0 is compatible with the older 1.x.x generated typed clients, however if you want to utilise the new features or leverage ARC-56 support, you will need to generate using >= 2.x.x. See [AlgoKit CLI generator version pinning](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/generate.md#version-pinning) for more information on how to lock to a specific version. + +## Getting a typed client instance + +To get an instance of a typed client you can use an [`AlgorandClient`](../../core/algorand-client) instance or a typed app [`Factory`](#creating-a-typed-factory-instance) instance. + +The approach to obtaining a client instance depends on how many app clients you require for a given app spec and if the app has already been deployed, which is summarised below: + +### App is deployed + + + + + + + + + + + + + + + + + + + + + + +
Resolve App by IDResolve App by Creator and Name
Single App Client InstanceMultiple App Client InstancesSingle App Client InstanceMultiple App Client Instances
+ +```python +app_client = algorand.client.get_typed_app_client_by_id( + MyContractClient, + app_id=1234, + # ... +) +# or +app_client = MyContractClient( + algorand=algorand, + app_id=1234, + # ... +) +``` + + + +```python +app_client1 = factory.get_app_client_by_id( + app_id=1234, + # ... +) +app_client2 = factory.get_app_client_by_id( + app_id=4321, + # ... +) +``` + + + +```python +app_client = algorand.client.get_typed_app_client_by_creator_and_name( + MyContractClient, + creator_address="CREATORADDRESS", + app_name="contract-name", + # ... +) +# or +app_client = MyContractClient.from_creator_and_name( + algorand=algorand, + creator_address="CREATORADDRESS", + app_name="contract-name", + # ... +) +``` + + + +```python +app_client1 = factory.get_app_client_by_creator_and_name( + creator_address="CREATORADDRESS", + app_name="contract-name", + # ... +) +app_client2 = factory.get_app_client_by_creator_and_name( + creator_address="CREATORADDRESS", + app_name="contract-name-2", + # ... +) +``` + +
+ +To understand the difference between resolving by ID vs by creator and name see the underlying [app client documentation](./app-client.md#appclient). + +### App is not deployed + + + + + + + + + + + + + + +
Deploy a New AppDeploy or Resolve App Idempotently by Creator and Name
+ +```python +app_client, result = factory.send.bare.create( + # ... +) +# or +app_client, result = factory.send.create( + # method call params ... +) +``` + + + +```python +app_client, result = factory.deploy( + app_name="contract-name", + # ... +) +``` + +
+ +### Creating a typed factory instance + +If your scenario calls for an app factory, you can create one using the below: + +```python +factory = algorand.client.get_typed_app_factory(MyContractFactory) +# or +factory = MyContractFactory(algorand) +``` + +## Client usage + +See the [official usage docs](https://github.com/algorandfoundation/algokit-client-generator-py/blob/main/docs/usage.md) for full details. + +For a simple example that deploys a contract and calls a `"hello"` method, see below: + +```python +# A similar working example can be seen in the AlgoKit init production smart contract templates +# In this case the generated factory is called `HelloWorldAppFactory` and is in `./artifacts/hello_world/client.py` +from artifacts.hello_world.client import HelloWorldAppFactory, HelloWorldAppClient, HelloArgs +from algokit_utils import AlgorandClient + +# These require environment variables to be present, or it will retrieve from default LocalNet +algorand = AlgorandClient.from_environment() +deployer = algorand.account.from_environment("DEPLOYER") + +# Create the typed app factory +factory = algorand.client.get_typed_app_factory( + HelloWorldAppFactory, + default_sender=deployer.addr, +) + +# Create the app and get a typed app client for the created app (note: this creates a new instance of the app every time, +# you can use .deploy() to deploy idempotently if the app wasn't previously +# deployed or needs to be updated if that's allowed) +app_client, result = factory.send.bare.create() + +# Make a call to an ABI method and print the result +response = app_client.send.hello(args=HelloArgs(name="world")) +print(response) +``` diff --git a/docs/src/content/docs/concepts/core/account.md b/docs/src/content/docs/concepts/core/account.md new file mode 100644 index 00000000..093d8acb --- /dev/null +++ b/docs/src/content/docs/concepts/core/account.md @@ -0,0 +1,275 @@ +--- +title: "Account management" +description: "Account management is one of the core capabilities provided by AlgoKit Utils. It allows you to create mnemonic, rekeyed, multisig, transaction signer, idempotent KMD and environment variable injected accounts that can be used to sign transactions as well as representing a sender address at the same time. This significantly simplifies management of transaction signing." +--- + +Account management is one of the core capabilities provided by AlgoKit Utils. It allows you to create mnemonic, rekeyed, multisig, transaction signer, idempotent KMD and environment variable injected accounts that can be used to sign transactions as well as representing a sender address at the same time. This significantly simplifies management of transaction signing. + +## `AccountManager` + +The `AccountManager` is a class that is used to get, create, and fund accounts and perform account-related actions such as funding. The `AccountManager` also keeps track of signers for each address so when using the [`TransactionComposer`](../advanced/transaction-composer) to send transactions, a signer function does not need to manually be specified for each transaction - instead it can be inferred from the sender address automatically! + +To get an instance of `AccountManager`, you can use either [`AlgorandClient`](../algorand-client) via `algorand.account` or instantiate it directly: + +```python +from algokit_utils import AccountManager + +account_manager = AccountManager(client_manager) +``` + +## `AddressWithTransactionSigner` + +The core internal type that holds information about a signer/sender pair for a transaction is `AddressWithTransactionSigner`, which represents a `TransactionSigner` (`signer`) along with a sender address (`addr`). + +Many methods in `AccountManager` expose an `AddressWithTransactionSigner`. `AddressWithTransactionSigner` can be used with [`TransactionComposer`](../advanced/transaction-composer). + +`AddressWithTransactionSigner` is a `Protocol` — any object that provides an `addr: str` property (via the `Addressable` protocol) and a `signer: TransactionSigner` property structurally conforms to it. The following built-in types satisfy this protocol: + +| Type | Description | Created via | +| --- | --- | --- | +| [`AddressWithSigners`](#underlying-account-classes) | Standard account with private key | `algorand.account.random()`, `algorand.account.from_mnemonic()` | +| [`LogicSigAccount`](#logicsigaccount) | Logic signature account | `algorand.account.logicsig()` | +| [`MultisigAccount`](#multisigaccount) | Multisig account | `algorand.account.multisig()` | + +You can also create your own conforming type by implementing a class with `addr` and `signer` properties. Since `AddressWithTransactionSigner` is decorated with `@runtime_checkable`, you can verify conformance at runtime with `isinstance()`. + +Source: [`src/algokit_transact/signer.py`](https://github.com/algorandfoundation/algokit-utils-py/blob/main/src/algokit_transact/signer.py) + +## Registering a signer + +The `AccountManager` keeps track of which signer is associated with a given sender address. This is used by [`AlgorandClient`](../algorand-client) to automatically sign transactions by that sender. Any of the [methods](#accounts) within `AccountManager` that return an account will automatically register the signer with the sender. If however, you are creating a signer external to the `AccountManager`, then you need to register the signer with the `AccountManager` if you want it to be able to automatically sign transactions from that sender. + +There are two methods that can be used for this, `set_signer_from_account`, which takes any `AddressWithTransactionSigner` conforming object (such as `AddressWithSigners`, `LogicSigAccount`, or `MultisigAccount`), or `set_signer` which takes the sender address and the `TransactionSigner`: + +```python +algorand.account \ + .set_signer_from_account(algorand.account.random()) \ + .set_signer_from_account(algorand.account.logicsig(program, args)) \ + .set_signer_from_account( + algorand.account.multisig( + MultisigMetadata(version=1, threshold=1, addrs=["ADDRESS1...", "ADDRESS2..."]), + [account1, account2], + ) + ) \ + .set_signer("SENDERADDRESS", transaction_signer) +``` + +You can also merge all signers from another `AccountManager` into the current one using `set_signers`: + +```python +algorand.account.set_signers(another_account_manager=other_manager, overwrite_existing=True) +``` + +## Default signer + +If you want to have a default signer that is used to sign transactions without a registered signer (rather than throwing an exception) then you can register a default signer. The parameter accepts either a `TransactionSigner` or an `AddressWithTransactionSigner`: + +```python +algorand.account.set_default_signer(my_default_signer) +``` + +## Get a signer + +[`AlgorandClient`](../algorand-client) will automatically retrieve a signer when signing a transaction, but if you need to get a `TransactionSigner` externally to do something more custom then you can retrieve the signer for a given sender address (or an `AddressWithTransactionSigner`): + +```python +signer = algorand.account.get_signer("SENDER_ADDRESS") +``` + +If there is no signer registered for that sender address it will either return the default signer ([if registered](#default-signer)) or throw an exception. + +## Get an account + +If you need to retrieve the full account object (e.g. `AddressWithSigners`, `LogicSigAccount`, or `MultisigAccount`) that was previously registered for a given sender address: + +```python +account = algorand.account.get_account("SENDER_ADDRESS") +``` + +## Get account information + +You can retrieve the current on-chain information for a given account (balance, minimum balance, status, etc.): + +```python +info = algorand.account.get_information("SENDER_ADDRESS") +# Returns an AccountInformation dataclass with properties like: +# info.amount (AlgoAmount), info.min_balance (AlgoAmount), info.status (str), etc. +``` + +The `sender` parameter accepts either a `str` address or an `AddressWithTransactionSigner`. + +## Accounts + +In order to get/register accounts for signing operations you can use the following methods on [`AccountManager`](#accountmanager) (expressed here as `algorand.account` to denote the syntax via an [`AlgorandClient`](../algorand-client)): + +- `algorand.account.from_environment(name, fund_with)` - Registers and returns an account with private key loaded by convention based on the given name identifier - either by idempotently creating the account in KMD or from environment variable via `os.environ['{NAME}_MNEMONIC']` and (optionally) `os.environ['{NAME}_SENDER']` (if account is rekeyed) + - This allows you to have powerful code that will automatically create and fund an account by name locally and when deployed against TestNet/MainNet will automatically resolve from environment variables, without having to have different code + - Note: `fund_with` allows you to control how many Algo are seeded into an account created in KMD +- `algorand.account.from_mnemonic(mnemonic, sender)` - Registers and returns an account with secret key loaded by taking the mnemonic secret +- `algorand.account.multisig(metadata, sub_signers)` - Registers and returns a multisig account with one or more signing keys loaded +- `algorand.account.rekeyed(sender, account)` - Registers and returns an account representing the given rekeyed sender/signer combination. `account` accepts `AddressWithTransactionSigner | AddressWithSigners` +- `algorand.account.random()` - Returns a new, cryptographically randomly generated account with private key loaded +- `algorand.account.from_kmd(name, predicate, sender)` - Returns an account with private key loaded from the given KMD wallet (identified by name) +- `algorand.account.logicsig(program, args)` - Returns an account that represents a logic signature + +### Underlying account classes + +While `AddressWithTransactionSigner` is the main interface used to represent an account that can sign, there are underlying account classes that can underpin the signer. + +- `AddressWithSigners` - An account that holds a private key and conforms to `AddressWithTransactionSigner`, created via `algorand.account.random()` or `algorand.account.from_mnemonic()` +- `LogicSigAccount` - A logic signature account for signing with a TEAL program +- `MultisigAccount` - A multisig account that supports multisig transactions with one or more signers present + +> [!NOTE] +> In v4, `SigningAccount` was replaced by `AddressWithSigners`. If you are migrating from an earlier version, update any references to `SigningAccount` accordingly. + +> [!NOTE] +> All account types support rekeyed accounts. You can use `algorand.account.rekeyed(sender, account)` to register a rekeyed sender/signer combination. See [Rekey account](#rekey-account) for details. + +#### `LogicSigAccount` + +A logic signature account for signing with a TEAL program. Extends `LogicSig` with delegation support. + +| Property | Type | Description | +| --- | --- | --- | +| `sig` | `bytes \| None` | Single signature for delegation (if delegated to a single account) | +| `msig` | `MultisigSignature \| None` | Multisig signature (if part of a multisig) | +| `lmsig` | `MultisigSignature \| None` | Multisig-delegated logic sig signature | +| `is_delegated` | `bool` | Whether this LogicSig is delegated to an account | +| `signer` | `TransactionSigner` | Transaction signer callable for use with `TransactionComposer` | +| `addr` | `str` | The logic signature account address (conforms to `AddressWithTransactionSigner` protocol) | + +Source: [`src/algokit_transact/logicsig.py`](https://github.com/algorandfoundation/algokit-utils-py/blob/main/src/algokit_transact/logicsig.py) + +#### `MultisigAccount` + +A multisig account that supports multisig transactions with one or more signers present. + +| Property | Type | Description | +| --- | --- | --- | +| `params` | `MultisigMetadata` | The multisig account parameters (`version`, `threshold`, `addrs`) | +| `sub_signers` | `Sequence[AddressWithSigners]` | The list of signing accounts | +| `signer` | `TransactionSigner` | Transaction signer callable for use with `TransactionComposer` | +| `address` | `str` | The multisig account address | +| `addr` | `str` | Alias for `address` (conforms to `AddressWithTransactionSigner` protocol) | + +Source: [`src/algokit_transact/multisig.py`](https://github.com/algorandfoundation/algokit-utils-py/blob/main/src/algokit_transact/multisig.py) + +### Dispenser + +- `algorand.account.dispenser_from_environment()` - Returns an account (with private key loaded) that can act as a dispenser from environment variables, or against default LocalNet if no environment variables present +- `algorand.account.localnet_dispenser()` - Returns an account with private key loaded that can act as a dispenser for the default LocalNet dispenser account + +## Rekey account + +One of the unique features of Algorand is the ability to change the private key that can authorise transactions for an account. This is called [rekeying](https://dev.algorand.co/concepts/accounts/rekeying). + +> [!WARNING] +> Rekeying should be done with caution as a rekey transaction can result in permanent loss of control of an account. + +You can issue a transaction to rekey an account by using the `algorand.account.rekey_account(account, rekey_to, **options)` function: + +- `account: str` - The account address of the account that will be rekeyed +- `rekey_to: str | AddressWithTransactionSigner` - The account address or signing account of the account that will be used to authorise transactions for the rekeyed account going forward. If a signing account is provided that will now be tracked as the signer for `account` in the `AccountManager` instance. +- Additional keyword-only options: + - [Common transaction parameters](../algorand-client#transaction-parameters) + - `suppress_log: bool | None` - Optionally suppress log output + +You can also pass in `rekey_to` as a [common transaction parameter](../algorand-client#transaction-parameters) to any transaction. + +### Examples + +```python +# Basic example (with string addresses) +algorand.account.rekey_account( + account="ACCOUNTADDRESS", + rekey_to="NEWADDRESS", +) + +# Basic example (with signer account for rekey_to) +algorand.account.rekey_account( + account="ACCOUNTADDRESS", + rekey_to=new_signer_account, +) + +# Advanced example +algorand.account.rekey_account( + account="ACCOUNTADDRESS", + rekey_to="NEWADDRESS", + lease=b"lease", + note=b"note", + first_valid_round=1000, + validity_window=10, + extra_fee=AlgoAmount.from_micro_algo(1000), + static_fee=AlgoAmount.from_micro_algo(1000), + # Max fee doesn't make sense with extra_fee AND static_fee + # already specified, but here for completeness + max_fee=AlgoAmount.from_micro_algo(3000), + suppress_log=True, +) + +# Using a rekeyed account +# Note: if a signing account is passed into `algorand.account.rekey_account` +# then you don't need to call `rekeyed` to register the new signer +rekeyed_account = algorand.account.rekeyed(sender=account, account=new_account) +# rekeyed_account can be used to sign transactions on behalf of account... +``` + +# KMD account management + +When running LocalNet, you have an instance of the [Key Management Daemon](https://github.com/algorand/go-algorand/blob/master/daemon/kmd/README.md), which is useful for: + +- Accessing the private key of the default accounts that are pre-seeded with Algo so that other accounts can be funded and it's possible to use LocalNet +- Idempotently creating new accounts against a name that will stay intact while the LocalNet instance is running without you needing to store private keys anywhere (i.e. completely automated) + +The KMD SDK is fairly low level so to make use of it there is a fair bit of boilerplate code that's needed. This code has been abstracted away into the `KmdAccountManager` class. + +To get an instance of the `KmdAccountManager` class you can access it from [`AlgorandClient`](../algorand-client) via `algorand.account.kmd` or instantiate it directly (passing in a [`ClientManager`](../client)): + +```python +from algokit_utils import KmdAccountManager + +kmd_account_manager = KmdAccountManager(client_manager) +``` + +The methods that are available are: + +- `get_wallet_account(wallet_name, predicate, sender)` - Returns an Algorand signing account with private key loaded from the given KMD wallet (identified by name). +- `get_or_create_wallet_account(name, fund_with)` - Gets an account with private key loaded from a KMD wallet of the given name, or alternatively creates one with funds in it via a KMD wallet of the given name. +- `get_localnet_dispenser_account()` - Returns an Algorand account with private key loaded for the default LocalNet dispenser account (that can be used to fund other accounts). + +```python +# Get a wallet account that seeded the LocalNet network +default_dispenser_account = kmd_account_manager.get_wallet_account( + "unencrypted-default-wallet", + lambda a: a["status"] != "Offline" and a["amount"] > 1_000_000_000, +) +# Same as above, but dedicated method call for convenience +localnet_dispenser_account = kmd_account_manager.get_localnet_dispenser_account() +# Idempotently get (if exists) or create (if it doesn't exist yet) an account by name using KMD +# if creating it then fund it with 2 ALGO from the default dispenser account +new_account = kmd_account_manager.get_or_create_wallet_account( + "account1", + AlgoAmount.from_algo(2), +) +# This will return the same account as above since the name matches +existing_account = kmd_account_manager.get_or_create_wallet_account("account1") +``` + +Some of this functionality is directly exposed from [`AccountManager`](#accountmanager), which has the added benefit of registering the account as a signer so they can be automatically used to sign transactions when using via [`AlgorandClient`](../algorand-client): + +```python +# Get and register LocalNet dispenser +localnet_dispenser = algorand.account.localnet_dispenser() +# Get and register a dispenser by environment variable, or if not set then LocalNet dispenser via KMD +dispenser = algorand.account.dispenser_from_environment() +# Get an account from KMD idempotently by name. In this case we'll get the default dispenser account +dispenser_via_kmd = algorand.account.from_kmd( + "unencrypted-default-wallet", + lambda a: a["status"] != "Offline" and a["amount"] > 1_000_000_000, +) +# Get / create and register account from KMD idempotently by name +fresh_account_via_kmd = algorand.account.kmd.get_or_create_wallet_account( + "account1", AlgoAmount.from_algo(2) +) +``` diff --git a/docs/src/content/docs/concepts/core/algorand-client.md b/docs/src/content/docs/concepts/core/algorand-client.md new file mode 100644 index 00000000..1be9102a --- /dev/null +++ b/docs/src/content/docs/concepts/core/algorand-client.md @@ -0,0 +1,214 @@ +--- +title: "Algorand client" +description: "`AlgorandClient` is a client class that brokers easy access to Algorand functionality. It's the `default entrypoint` into AlgoKit Utils functionality." +--- + +`AlgorandClient` is a client class that brokers easy access to Algorand functionality. It's the `default entrypoint` into AlgoKit Utils functionality. + +The main entrypoint to the bulk of the functionality in AlgoKit Utils is the `AlgorandClient` class, most of the time you can get started by typing `AlgorandClient.` and choosing one of the static initialisation methods to create an [Algorand client](./), e.g.: + +```python +# Point to the network configured through environment variables or +# if no environment variables it will point to the default LocalNet +# configuration +algorand = AlgorandClient.from_environment() +# Point to default LocalNet configuration +algorand = AlgorandClient.default_localnet() +# Point to TestNet using AlgoNode free tier +algorand = AlgorandClient.testnet() +# Point to MainNet using AlgoNode free tier +algorand = AlgorandClient.mainnet() +# Point to a pre-created algod client +algorand = AlgorandClient.from_clients(algod=algod) +# Point to pre-created algod, indexer and kmd clients +algorand = AlgorandClient.from_clients(algod=algod, indexer=indexer, kmd=kmd) +# Point to custom configuration for algod +algorand = AlgorandClient.from_config(algod_config=algod_config) +# Point to custom configuration for algod, indexer and kmd +algorand = AlgorandClient.from_config( + algod_config=algod_config, + indexer_config=indexer_config, + kmd_config=kmd_config +) +``` + +## Accessing API clients + +Once you have an `AlgorandClient` instance, you can access the API clients for the various Algorand APIs via the `algorand.client` property. + +```python +algorand = AlgorandClient.default_localnet() + +algod_client = algorand.client.algod +indexer_client = algorand.client.indexer +kmd_client = algorand.client.kmd +``` + +## Accessing manager class instances + +The `AlgorandClient` has a number of manager class instances that help you quickly use intellisense to get access to advanced functionality. + +- [`AccountManager`](../account) via `algorand.account`, there are also some chainable convenience methods which wrap specific methods in `AccountManager`: + - `algorand.set_default_signer(signer)` - Sets the default signer to use if no other signer is specified + - `algorand.set_signer_from_account(account)` - Registers the provided account as the default signer + - `algorand.set_signer(sender, signer)` - Sets the signer for the given sender address +- [`AssetManager`](../../building/asset) via `algorand.asset` +- `AppManager` via `algorand.app` +- [`AppDeployer`](../../building/app-deploy) via `algorand.app_deployer` +- [`ClientManager`](../client) via `algorand.client` + +## Creating and issuing transactions + +`AlgorandClient` exposes a series of methods that allow you to create, execute, and compose groups of transactions (all via the [`TransactionComposer`](../../advanced/transaction-composer)). + +### Creating transactions + +You can compose a transaction via `algorand.create_transaction.`, which gives you an instance of the `AlgorandClientTransactionCreator` class. Intellisense will guide you on the different options. + +The signature for the calls to send a single transaction usually look like: + +``` +algorand.create_transaction.{method}(params: {ComposerTransactionTypeParams} & CommonTxnParams) -> Transaction +``` + +- To get intellisense on the params, use your IDE's intellisense keyboard shortcut (e.g. ctrl+space). +- `{ComposerTransactionTypeParams}` will be the parameters that are specific to that transaction type e.g. `PaymentParams`, `see the full list` +- `CommonTxnParams` are the [common transaction parameters](#transaction-parameters) that can be specified for every single transaction +- `Transaction` is an unsigned transaction object, ready to be signed and sent + +The return type for the ABI method call methods are slightly different: + +``` +algorand.create_transaction.app_{call_type}_method_call(params: {ComposerTransactionTypeParams} & CommonTxnParams) -> BuiltTransactions +``` + +Where `BuiltTransactions` looks like this: + +```python +@dataclass(slots=True, frozen=True) +class BuiltTransactions: + transactions: list[Transaction] + method_calls: dict[int, ABIMethod] + signers: dict[int, TransactionSigner] +``` + +This signifies the fact that an ABI method call can actually result in multiple transactions (which in turn may have different signers), that you need ABI metadata to be able to extract the return value from the transaction result. + +### Sending a single transaction + +You can compose a single transaction via `algorand.send...`, which gives you an instance of the `AlgorandClientTransactionSender` class. Intellisense will guide you on the different options. + +Further documentation is present in the related capabilities: + +- [App management](../../building/app) +- [Asset management](../../building/asset) +- [Algo transfers](../../building/transfer) + +The signature for the calls to send a single transaction usually look like: + +`algorand.send.{method}(params: {ComposerTransactionTypeParams} & CommonTxnParams & SendParams) -> SendSingleTransactionResult` + +- To get intellisense on the params, use your IDE's intellisense keyboard shortcut (e.g. ctrl+space). +- `{ComposerTransactionTypeParams}` will be the parameters that are specific to that transaction type e.g. `PaymentParams`, `see the full list` +- `CommonTxnParams` are the [common transaction parameters](#transaction-parameters) that can be specified for every single transaction +- `SendParams` are the [parameters](#transaction-parameters) that control execution semantics when sending transactions to the network +- `SendSingleTransactionResult` is all of the information that is relevant when [sending a single transaction to the network](../transaction) + +Generally, the functions to immediately send a single transaction will emit log messages before and/or after sending the transaction. You can opt-out of this by passing `suppress_log=True`. + +### Composing a group of transactions + +You can compose a group of transactions for execution by using the `new_group()` method on `AlgorandClient` and then use the various `.add_{type}()` methods on [`TransactionComposer`](../../advanced/transaction-composer) to add a series of transactions. + +```python +result = (algorand + .new_group() + .add_payment( + PaymentParams( + sender="SENDERADDRESS", + receiver="RECEIVERADDRESS", + amount=AlgoAmount.from_micro_algo(1) + ) + ) + .add_asset_opt_in( + AssetOptInParams( + sender="SENDERADDRESS", + asset_id=12345 + ) + ) + .send()) +``` + +`new_group()` returns a new [`TransactionComposer`](../../advanced/transaction-composer) instance, which can also return the group of transactions, simulate them and other things. + +### Transaction parameters + +To create a transaction you instantiate a relevant transaction parameters dataclass from `algokit_utils`. + +There are two common base parameter groups that get reused: + +- `CommonTxnParams` + - `sender: str` - The address of the account sending the transaction. + - `signer: TransactionSigner | AddressWithTransactionSigner | None` - The function used to sign transaction(s); if not specified then an attempt will be made to find a registered signer for the given `sender` or use a default signer (if configured). + - `rekey_to: str | None` - Change the signing key of the sender to the given address. **Warning:** Please be careful with this parameter and be sure to read the [official rekey guidance](https://dev.algorand.co/concepts/accounts/rekeying). + - `note: bytes | None` - Note to attach to the transaction. Max of 1000 bytes. + - `lease: bytes | None` - Prevent multiple transactions with the same lease being included within the validity window. A [lease](https://dev.algorand.co/concepts/transactions/leases) enforces a mutually exclusive transaction (useful to prevent double-posting and other scenarios). + - Fee management + - `static_fee: AlgoAmount | None` - The static transaction fee. In most cases you want to use `extra_fee` unless setting the fee to 0 to be covered by another transaction. + - `extra_fee: AlgoAmount | None` - The fee to pay IN ADDITION to the suggested fee. Useful for covering inner transaction fees. + - `max_fee: AlgoAmount | None` - Throw an error if the fee for the transaction is more than this amount; prevents overspending on fees during high congestion periods. + - Round validity management + - `validity_window: int | None` - How many rounds the transaction should be valid for, if not specified then the registered default validity window will be used. + - `first_valid_round: int | None` - Set the first round this transaction is valid. If left undefined, the value from algod will be used. We recommend you only set this when you intentionally want this to be some time in the future. + - `last_valid_round: int | None` - The last round this transaction is valid. It is recommended to use `validity_window` instead. +- `SendParams` + - `max_rounds_to_wait: int | None` - The number of rounds to wait for confirmation. By default until the latest lastValid has past. + - `suppress_log: bool | None` - Whether to suppress log messages from transaction send, default: do not suppress. + - `populate_app_call_resources: bool | None` - Whether to use simulate to automatically populate app call resources in the txn objects. Defaults to `config.populate_app_call_resources`. + - `cover_app_call_inner_transaction_fees: bool | None` - Whether to use simulate to automatically calculate required app call inner transaction fees and cover them in the parent app call transaction fee + +Then on top of that the base type gets extended for the specific type of transaction you are issuing. These are all defined as part of [`TransactionComposer`](../../advanced/transaction-composer) and we recommend reading these docs, especially when leveraging either `populate_app_call_resources` or `cover_app_call_inner_transaction_fees`. + +### Error handling + +`AlgorandClient` lets you register error transformers that intercept and transform errors raised when sending or simulating transactions. This is useful for mapping low-level Algorand errors into domain-specific exceptions. + +The `ErrorTransformer` type alias is defined as: + +```python +from collections.abc import Callable + +ErrorTransformer = Callable[[Exception], Exception] +``` + +Register and unregister transformers via chainable methods: + +```python +from algokit_utils import AlgorandClient + +def my_transformer(err: Exception) -> Exception: + if "TRANSACTION_REJECTED" in str(err): + return MyDomainError("Transaction was rejected by the network") + return err + +algorand = AlgorandClient.default_localnet() +algorand.register_error_transformer(my_transformer) + +# Remove it later +algorand.unregister_error_transformer(my_transformer) +``` + +`AlgorandClient` stores transformers in a `set` (de-duplicated). A snapshot is passed to each new composer created via `new_group()`. Transformers can also be registered directly on individual [`TransactionComposer`](../../advanced/transaction-composer) instances. + +If a transformer itself raises, an `ErrorTransformerError` is raised. If a transformer returns a non-`Exception` value, an `InvalidErrorTransformerValueError` is raised. Both are defined in `algokit_utils.transactions.transaction_composer`. + +For full details on the error flow and per-composer registration, see [Error Transformers](../../advanced/transaction-composer#error-transformers). + +### Transaction configuration + +AlgorandClient caches network provided transaction values for you automatically to reduce network traffic. It has a set of default configurations that control this behaviour, but you have the ability to override and change the configuration of this behaviour: + +- `algorand.set_default_validity_window(validity_window)` - Set the default validity window (number of rounds from the current known round that the transaction will be valid to be accepted for), having a smallish value for this is usually ideal to avoid transactions that are valid for a long future period and may be submitted even after you think it failed to submit if waiting for a particular number of rounds for the transaction to be successfully submitted. The validity window defaults to 10, except in [automated testing](../../building/testing) where it's set to 1000 when targeting LocalNet. +- `algorand.set_suggested_params_cache(suggested_params, until=None)` - Set the suggested network parameters to use (optionally until the given time) +- `algorand.set_suggested_params_cache_timeout(timeout)` - Set the timeout that is used to cache the suggested network parameters (by default 3 seconds) +- `algorand.get_suggested_params()` - Get the current suggested network parameters object, either the cached value, or if the cache has expired a fresh value diff --git a/docs/src/content/docs/concepts/core/amount.md b/docs/src/content/docs/concepts/core/amount.md new file mode 100644 index 00000000..07e6e36e --- /dev/null +++ b/docs/src/content/docs/concepts/core/amount.md @@ -0,0 +1,109 @@ +--- +title: "Algo amount handling" +description: "Algo amount handling is one of the core capabilities provided by AlgoKit Utils. It allows you to reliably and tersely specify amounts of microAlgo and Algo and safely convert between them." +--- + +Algo amount handling is one of the core capabilities provided by AlgoKit Utils. It allows you to reliably and tersely specify amounts of microAlgo and Algo and safely convert between them. + +Any AlgoKit Utils function that needs an Algo amount will take an `AlgoAmount` object, which ensures that there is never any confusion about what value is being passed around. You can safely and explicitly convert to microAlgo or Algo when needed. + +To see some usage examples check out the `automated tests`. Alternatively, you see the `reference documentation` for `AlgoAmount`. + +## `AlgoAmount` + +The `AlgoAmount` class provides a safe wrapper around an underlying amount of microAlgo where any value entering or existing the `AlgoAmount` class must be explicitly stated to be in microAlgo or Algo. This makes it much safer to handle Algo amounts rather than passing them around as raw numbers where it's easy to make a (potentially costly!) mistake and not perform a conversion when one is needed (or perform one when it shouldn't be!). + +To import the AlgoAmount class you can access it via: + +```python +from algokit_utils import AlgoAmount +``` + +### Creating an `AlgoAmount` + +There are a few ways to create an `AlgoAmount`: + +- Algo (accepts `int` or `Decimal`) + - Constructor: `AlgoAmount(algo=10)` + - Static helper: `AlgoAmount.from_algo(10)` +- microAlgo (accepts `int`) + - Constructor: `AlgoAmount(micro_algo=10_000)` + - Static helper: `AlgoAmount.from_micro_algo(10_000)` + +### Extracting a value from `AlgoAmount` + +The `AlgoAmount` class has properties to return Algo and microAlgo: + +- `amount.algo` - Returns the value in Algo as `Decimal` +- `amount.micro_algo` - Returns the value in microAlgo as `int` + +`AlgoAmount` will coerce to an integer automatically (in microAlgo) when using `int(amount)`. + +`AlgoAmount` objects support the following comparison operators against other `AlgoAmount` instances or plain `int` values (treated as microAlgo): + +| Operator | Description | +| -------- | ----------- | +| `==` | Equal to | +| `!=` | Not equal to | +| `<` | Less than | +| `<=` | Less than or equal to | +| `>` | Greater than | +| `>=` | Greater than or equal to | + +> [!NOTE] +> Only `__eq__` and `__lt__` are explicitly defined. The remaining operators (`!=`, `<=`, `>`, `>=`) are derived automatically via Python's [`@total_ordering`](https://docs.python.org/3/library/functools.html#functools.total_ordering) decorator. + +You can also call `str(amount)` or use an `AlgoAmount` directly in string interpolation to convert it to a nice user-facing formatted amount expressed in microAlgo. + +### Convenience functions + +There are also standalone convenience functions for creating `AlgoAmount` instances: + +```python +from algokit_utils import algo, micro_algo + +amount1 = algo(1) # equivalent to AlgoAmount.from_algo(1) +amount2 = micro_algo(1_000) # equivalent to AlgoAmount.from_micro_algo(1_000) +``` + +### Constants and helpers + +`ALGORAND_MIN_TX_FEE` is a pre-defined `AlgoAmount` representing the minimum transaction fee (1,000 µALGO): + +```python +from algokit_utils import ALGORAND_MIN_TX_FEE, transaction_fees + +fee = ALGORAND_MIN_TX_FEE # AlgoAmount(micro_algo=1_000) +total = transaction_fees(3) # AlgoAmount(micro_algo=3_000) +``` + +### Arithmetic operations + +`AlgoAmount` supports arithmetic operations with other `AlgoAmount` instances or plain `int` values (treated as microAlgo): + +| Operator | Right operand | Return type | Description | +| -------- | ------------- | ----------- | ----------- | +| `+` | `AlgoAmount \| int` | `AlgoAmount` | Addition | +| `-` | `AlgoAmount \| int` | `AlgoAmount` | Subtraction | +| `*` | `int` | `AlgoAmount` | Scalar multiplication | +| `/` | `int` | `AlgoAmount` | Division (integer, floors result) | +| `//` | `int` | `AlgoAmount` | Floor division | +| `+=` | `AlgoAmount \| int` | `AlgoAmount` | In-place addition | +| `-=` | `AlgoAmount \| int` | `AlgoAmount` | In-place subtraction | + +Division by zero raises `ZeroDivisionError`. + +```python +a = AlgoAmount.from_algo(1) +b = AlgoAmount.from_algo(2) + +# Addition and subtraction (AlgoAmount or int) +c = a + b # AlgoAmount(micro_algo=3_000_000) +d = b - a # AlgoAmount(micro_algo=1_000_000) + +# Multiplication and division (int only) +e = a * 3 # AlgoAmount(micro_algo=3_000_000) +f = b / 2 # AlgoAmount(micro_algo=1_000_000) +``` + +> Source: [`src/algokit_utils/models/amount.py`](https://github.com/algorandfoundation/algokit-utils-py/blob/main/src/algokit_utils/models/amount.py) diff --git a/docs/src/content/docs/concepts/core/client.md b/docs/src/content/docs/concepts/core/client.md new file mode 100644 index 00000000..1d6310d8 --- /dev/null +++ b/docs/src/content/docs/concepts/core/client.md @@ -0,0 +1,113 @@ +--- +title: "Client management" +description: "Client management is one of the core capabilities provided by AlgoKit Utils. It allows you to create (auto-retry) [algod](https://dev.algorand.co/reference/rest-apis/algod), [indexer](https://dev.algorand.co/reference/rest-apis/indexer) and [kmd](https://dev.algorand.co/reference/rest-apis/kmd) clients against various networks resolved from environment or specified configuration." +--- + +Client management is one of the core capabilities provided by AlgoKit Utils. It allows you to create (auto-retry) [algod](https://dev.algorand.co/reference/rest-apis/algod), [indexer](https://dev.algorand.co/reference/rest-apis/indexer) and [kmd](https://dev.algorand.co/reference/rest-apis/kmd) clients against various networks resolved from environment or specified configuration. + +To see some usage examples check out the [automated tests](https://github.com/algorandfoundation/algokit-utils-py/blob/main/tests/clients/). + +## `ClientManager` + +The `ClientManager` is a class that is used to manage client instances. + +To get an instance of `ClientManager` you can get it from either [`AlgorandClient`](./algorand-client) via `algorand.client` or instantiate it directly: + +```python +from algokit_utils import ClientManager, AlgoSdkClients, AlgoClientConfigs + +# Algod client only +client_manager = ClientManager(AlgoSdkClients(algod=algod_client), algorand_client) +# All clients +client_manager = ClientManager(AlgoSdkClients(algod=algod_client, indexer=indexer_client, kmd=kmd_client), algorand_client) +# Algod config only +client_manager = ClientManager(AlgoClientConfigs(algod_config=algod_config, indexer_config=None, kmd_config=None), algorand_client) +# All client configs +client_manager = ClientManager(AlgoClientConfigs(algod_config=algod_config, indexer_config=indexer_config, kmd_config=kmd_config), algorand_client) +``` + +## Network configuration + +The network configuration is specified using the `AlgoClientNetworkConfig` dataclass. + +There are a number of ways to produce one of these configuration objects: + +- Manually specifying a dataclass, e.g. + ```python + from algokit_utils import AlgoClientNetworkConfig + + config = AlgoClientNetworkConfig( + server="https://myalgodnode.com", + token="SECRET_TOKEN" # optional + ) + ``` +- `ClientManager.get_config_from_environment_or_localnet()` - Loads the Algod client config, the Indexer client config and the Kmd config from well-known environment variables or if not found then default LocalNet; this is useful to have code that can work across multiple blockchain environments (including LocalNet), without having to change +- `ClientManager.get_algod_config_from_environment()` - Loads an Algod client config from well-known environment variables +- `ClientManager.get_indexer_config_from_environment()` - Loads an Indexer client config from well-known environment variables; useful to have code that can work across multiple blockchain environments (including LocalNet), without having to change +- `ClientManager.get_algonode_config(network, config)` - Loads an Algod or Indexer config against [AlgoNode free tier](https://nodely.io/docs/free/start) to either MainNet or TestNet, where `config` is `"algod"` or `"indexer"` +- `ClientManager.get_default_localnet_config(config_or_port)` - Loads an Algod, Indexer or Kmd config against [LocalNet](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/localnet.md) using the default configuration, where `config_or_port` is `"algod"`, `"indexer"`, `"kmd"`, or a port number + +## Clients + +### Creating an SDK client instance + +Once you have the configuration for a client, to get a new client you can use the following functions: + +- `ClientManager.get_algod_client(config)` - Returns an Algod client for the given configuration; the client automatically retries on transient HTTP errors +- `ClientManager.get_indexer_client(config)` - Returns an Indexer client for given configuration +- `ClientManager.get_kmd_client(config)` - Returns a Kmd client for the given configuration + +You can also shortcut needing to write the likes of `ClientManager.get_algod_client(ClientManager.get_algod_config_from_environment())` with environment shortcut methods: + +- `ClientManager.get_algod_client_from_environment()` - Returns an Algod client by loading the config from environment variables +- `ClientManager.get_indexer_client_from_environment()` - Returns an indexer client by loading the config from environment variables +- `ClientManager.get_kmd_client_from_environment()` - Returns a kmd client by loading the config from environment variables + +### Accessing SDK clients via ClientManager instance + +Once you have a `ClientManager` instance, you can access the SDK clients for the various Algorand APIs from it (expressed here as `algorand.client` to denote the syntax via an [`AlgorandClient`](./algorand-client)): + +```python +algorand = AlgorandClient.default_localnet() + +algod_client = algorand.client.algod +indexer_client = algorand.client.indexer +kmd_client = algorand.client.kmd +``` + +If the method to create the `ClientManager` doesn't configure indexer or kmd ([both of which are optional](#client-management)), then accessing those clients will trigger an error: + +```python +algorand = AlgorandClient.from_clients(algod=algod_client) + +algod_client = algorand.client.algod # OK +algorand.client.indexer # Raises error +algorand.client.kmd # Raises error +``` + +### Creating an app client instance + +See [how to create app clients via ClientManager via AlgorandClient](../building/app-client#dynamically-creating-clients-for-a-given-app-spec). + +### Creating a TestNet dispenser API client instance + +You can also create a [TestNet dispenser API client instance](../advanced/dispenser-client) from `ClientManager` too. + +## Automatic retry + +The Algod client returned by AlgoKit Utils (via `ClientManager.get_algod_client()` or `AlgorandClient`) has built-in retry logic that automatically retries transient HTTP failures with exponential backoff. + +## Network information + +To get information about the current network you are connected to, you can use the `network()` method on `ClientManager` or the `is_{network}()` methods (which in turn call `network()`) as shown below (expressed here as `algorand.client` to denote the syntax via an [`AlgorandClient`](./algorand-client)): + +```python +algorand = AlgorandClient.default_localnet() + +network = algorand.client.network() +is_mainnet = algorand.client.is_mainnet() +is_testnet = algorand.client.is_testnet() +is_localnet = algorand.client.is_localnet() +``` + +The first time `network()` is called it will make a HTTP call to algod to get the network parameters, but from then on it will be cached within that `ClientManager` instance for subsequent calls. diff --git a/docs/src/content/docs/concepts/core/secret-management.md b/docs/src/content/docs/concepts/core/secret-management.md new file mode 100644 index 00000000..f69bb089 --- /dev/null +++ b/docs/src/content/docs/concepts/core/secret-management.md @@ -0,0 +1,261 @@ +--- +title: Secret management +description: AlgoKit utils provides interfaces and concrete functions to enable secure management of secret material for signing transactions. This includes support for using an external KMS or key wrapping and unwrapping with a secrets manager. +--- + +In general, there are three levels of security when it comes to signing transactions with secret material: + +1. KMS - The secret material is never exposed to the application +1. Key Wrapping and Unwrapping - The secret material is stored outside of the app (i.e. keychain) and only loaded in memory when signing +1. Plaintext - The secret material is stored in plaintext (i.e. in the environment) and is accessible throughout the runtime of the application + +While using plaintext environment variables may be the easier to setup, it is **not recommended** for production use. A compromised environment and/or dependency could lead to the secret material being compromised. Additionally, it is easy to accidentally leak secrets in plaintext through git commits. + +The most secure option is to use an external KMS that completely isolates the secret material from the application. KMS', however, can have a high setup cost which may be difficult for a solo developer or small team to manage properly. In this case, the next recommended option is to use key wrapping and unwrapping with a secrets manager. This allows the secret material to be stored securely outside of the application and only loaded in memory when signing is necessary. For example, on a local machine, the OS keyring can be used to store the secret material and only load it when signing transactions. + +## Signing with a Wrapped Secret + +### Using Keyring Secrets + +To read a mnemonic from the OS keyring, you can use the `keyring` library. This prevents the mnemonic from being stored in +plaintext and ensures it is only loaded in memory when signing. + +#### Ed25519 Seed or Mnemonic + +When working with a ed25519 seed or mnemonic, you can implement the `WrappedEd25519Seed` interface which allows you to wrap and unwrap the seed as needed. For example, with `keyring`: + +```python +import keyring + +from algokit_algo25 import seed_from_mnemonic +from algokit_crypto import WrappedEd25519Seed, ed25519_signing_key_from_wrapped_secret +from algokit_transact import generate_address_with_signers +from algokit_utils import AlgoAmount, AlgorandClient, PaymentParams + +MNEMONIC_NAME = "algorand-mainnet-mnemonic" + + +class KeyringWrappedSeed(WrappedEd25519Seed): + def unwrap_ed25519_seed(self) -> bytearray: + mnemonic = keyring.get_password("algorand", MNEMONIC_NAME) + if mnemonic is None: + raise ValueError(f"No mnemonic found in keyring for {MNEMONIC_NAME}") + return bytearray(seed_from_mnemonic(mnemonic)) + + def wrap_ed25519_seed(self) -> None: + pass + + +wrapped_seed = KeyringWrappedSeed() +signing_key = ed25519_signing_key_from_wrapped_secret(wrapped_seed) +algorand_account = generate_address_with_signers( + signing_key["ed25519_pubkey"], + signing_key["raw_ed25519_signer"], +) + +algorand = AlgorandClient.default_localnet() + +algorand.account.ensure_funded_from_environment(algorand_account.addr, AlgoAmount.from_algo(1)) +algorand.set_signer_from_account(algorand_account) + +algorand.send.payment( + PaymentParams( + sender=algorand_account.addr, + receiver=algorand_account.addr, + amount=AlgoAmount.from_micro_algo(0), + ) +) +``` + +### HD Expanded Secret Key + +HD accounts have a 96-byte expanded secret key that can be used in a similar manner to the ed25519 seed, except we need to implement the `WrappedHdExtendedPrivateKey` interface. For example, with `keyring`: + +```python +import base64 + +import keyring + +from algokit_crypto import ( + WrappedHdExtendedPrivateKey, + ed25519_signing_key_from_wrapped_secret, +) +from algokit_transact import generate_address_with_signers +from algokit_utils import AlgoAmount, AlgorandClient, PaymentParams + +SECRET_NAME = "algorand-hd-extended-key" + + +class KeyringWrappedHdKey(WrappedHdExtendedPrivateKey): + def unwrap_hd_extended_private_key(self) -> bytearray: + secret_b64 = keyring.get_password("algorand", SECRET_NAME) + if secret_b64 is None: + raise ValueError(f"No HD key found in keyring for {SECRET_NAME}") + + esk = bytearray(base64.b64decode(secret_b64)) + + # The last 32 bytes of the extended private key is the chain code, which is not + # needed for signing. This means in most cases you can just store the first 64 + # bytes and then pad the secret to 96 bytes in the unwrap function. If you are + # storing the full 96 bytes, you can just return the secret as is. + if len(esk) == 64: + padded = bytearray(96) + padded[:64] = esk + return padded + + return esk + + def wrap_hd_extended_private_key(self) -> None: + pass + + +wrapped_key = KeyringWrappedHdKey() +signing_key = ed25519_signing_key_from_wrapped_secret(wrapped_key) +algorand_account = generate_address_with_signers( + signing_key["ed25519_pubkey"], + signing_key["raw_ed25519_signer"], +) + +algorand = AlgorandClient.default_localnet() + +algorand.account.ensure_funded_from_environment(algorand_account.addr, AlgoAmount.from_algo(1)) +algorand.set_signer_from_account(algorand_account) + +algorand.send.payment( + PaymentParams( + sender=algorand_account.addr, + receiver=algorand_account.addr, + amount=AlgoAmount.from_micro_algo(0), + ) +) +``` + +## Signing with a KMS + +### Note on KMS Authentication in CI + +If you are using a KMS in CI, the best practice for performing signing operations is to use OIDC. For guides for setting up OIDC, refer to the [GitHub documentation](https://docs.github.com/en/actions/how-tos/secure-your-work/security-harden-deployments). + +### Signing with AWS KMS + +Using the KMS, you can retrieve the public key and implement a `raw_ed25519_signer` callback which can then be used to generate an Algorand address and all Algorand-specific signing functions. For example, with AWS: + +```python +import os + +import boto3 + +from algokit_transact import generate_address_with_signers +from algokit_utils import AlgoAmount, AlgorandClient, PaymentParams + +# The following environment variables must be set for this to work: +# - AWS_REGION +# - KEY_ID +# - AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY +kms = boto3.client("kms", region_name=os.environ["AWS_REGION"]) +key_id = os.environ["KEY_ID"] + +# Ed25519 SPKI prefix (DER-encoded SubjectPublicKeyInfo) +ED25519_SPKI_PREFIX = bytes([0x30, 0x2A, 0x30, 0x05, 0x06, 0x03, 0x2B, 0x65, 0x70, 0x03, 0x21, 0x00]) + + +def raw_ed25519_signer(data: bytes) -> bytes: + response = kms.sign( + KeyId=key_id, + Message=data, + MessageType="RAW", + SigningAlgorithm="ED25519_SHA_512", + ) + signature = response["Signature"] + if signature is None: + raise ValueError("No signature returned from KMS") + return bytes(signature) if isinstance(signature, memoryview) else signature + + +pubkey_response = kms.get_public_key(KeyId=key_id) +spki_pubkey = bytes(pubkey_response["PublicKey"]) + +if not spki_pubkey[:12] == ED25519_SPKI_PREFIX: + raise ValueError("Unexpected public key format") + +ed25519_pubkey = spki_pubkey[12:] # 32 bytes + +algorand_account = generate_address_with_signers(ed25519_pubkey, raw_ed25519_signer) + +algorand = AlgorandClient.default_localnet() + +algorand.account.ensure_funded_from_environment(algorand_account.addr, AlgoAmount.from_algo(1)) +algorand.set_signer_from_account(algorand_account) + +algorand.send.payment( + PaymentParams( + sender=algorand_account.addr, + receiver=algorand_account.addr, + amount=AlgoAmount.from_micro_algo(0), + ) +) +``` + +## Sharing Secrets and Multisig + +It's common for an application to have multiple developers that can deploy changes to mainnet. It may be tempting to share a secret for a single account (manually or through a secrets manager), but this is **not recommended**. Instead, it is recommended to setup a multisig account between all the developers. The multisig account can be a 1/N threshold, which would still allow a single developer to make changes. The benefit of a multisig is that secrets do not need to be shared and all actions are immutably auditable on-chain. Each developer should then follow the practices outlined above. + +```python +from algokit_transact import MultisigAccount, MultisigMetadata, generate_address_with_signers +from algokit_utils import AlgoAmount, AlgorandClient, PaymentParams + +addr_with_signers = generate_address_with_signers(ed25519_pubkey, raw_ed25519_signer) + +msig_metadata = MultisigMetadata( + version=1, + threshold=1, + addrs=[ + other_signer_addr, # Address of the other signer + addr_with_signers.addr, + ], +) + +algorand = AlgorandClient.default_localnet() + +# Create a multisig account that can be used to sign as a 1/N signer +msig_account = algorand.account.multisig(msig_metadata, [addr_with_signers]) + +# Send a transaction using the multisig account +algorand.send.payment( + PaymentParams( + sender=msig_account.addr, + receiver=other_signer_addr, + amount=AlgoAmount.from_micro_algo(0), + ) +) +``` + +## Key Rotation + +Algorand has native support for key rotation through a feature called rekeying. Rekeying allows the blockchain address to stay the same while allowing for rotation of the underlying keypair. For example, a common pattern is to have an admin address that can deploy changes to a production contract. Rekeying allows the admin address to remain constant in the contract but allow the secrets used to authorize transactions to rotate. Rekeying can be done with any transaction type, but the simplest is to do a 0 ALGO payment to oneself with the `rekey_to` field set. + +```python +from algokit_transact import generate_address_with_signers +from algokit_utils import AlgoAmount, AlgorandClient, PaymentParams + +original_addr_with_signers = generate_address_with_signers(original_pubkey, original_signer) + +new_addr_with_signers = generate_address_with_signers( + new_pubkey, + new_signer, + # NOTE: We are specifying sending_address so we can properly sign transactions + # on behalf of the original address + sending_address=original_addr_with_signers.addr, +) + +algorand = AlgorandClient.default_localnet() + +algorand.send.payment( + PaymentParams( + sender=original_addr_with_signers.addr, + receiver=original_addr_with_signers.addr, + amount=AlgoAmount.from_micro_algo(0), + rekey_to=new_addr_with_signers.addr, + ) +) +``` diff --git a/docs/src/content/docs/concepts/core/transaction.md b/docs/src/content/docs/concepts/core/transaction.md new file mode 100644 index 00000000..fb41a198 --- /dev/null +++ b/docs/src/content/docs/concepts/core/transaction.md @@ -0,0 +1,182 @@ +--- +title: "Transaction management" +description: "Transaction management is one of the core capabilities provided by AlgoKit Utils. It allows you to construct, simulate and send single, or grouped transactions with consistent and highly configurable semantics, including configurable control of transaction notes, logging, fees, multiple sender account types, and sending behaviour." +--- + +Transaction management is one of the core capabilities provided by AlgoKit Utils. It allows you to construct, simulate and send single, or grouped transactions with consistent and highly configurable semantics, including configurable control of transaction notes, logging, fees, multiple sender account types, and sending behaviour. + +## `SendSingleTransactionResult` + +All AlgoKit Utils functions that send a transaction will generally return a variant of the `SendSingleTransactionResult` dataclass or some superset of that. This provides a consistent mechanism to interpret the results of a transaction send. + +```python +@dataclass(frozen=True, kw_only=True) +class SendSingleTransactionResult: + transaction: Transaction # Last transaction sent + confirmation: PendingTransactionResponse # Confirmation of last transaction + group_id: str # Group ID + tx_id: str | None = None # Transaction ID of last transaction + tx_ids: list[str] # All transaction IDs in the group + transactions: list[Transaction] # All transactions in the group + confirmations: list[PendingTransactionResponse] # All confirmations + returns: list[ABIReturn] | None = None # ABI return values (if applicable) +``` + +### `SendSingleAssetCreateTransactionResult` + +Extends `SendSingleTransactionResult` with the ID of the newly created ASA. + +```python +@dataclass(frozen=True, kw_only=True) +class SendSingleAssetCreateTransactionResult(SendSingleTransactionResult): + asset_id: int # ID of the newly created asset +``` + +### `SendAppTransactionResult` + +Result from an application call. Adds the parsed ABI return value. + +```python +@dataclass(frozen=True) +class SendAppTransactionResult(SendSingleTransactionResult, Generic[ABIReturnT]): + abi_return: ABIReturnT | None = None # Parsed ABI method return value +``` + +### `SendAppUpdateTransactionResult` + +Extends `SendAppTransactionResult` with the compiled TEAL programs used in the update. + +```python +@dataclass(frozen=True) +class SendAppUpdateTransactionResult(SendAppTransactionResult[ABIReturnT]): + compiled_approval: CompiledTeal | bytes | None = None # Compiled approval program + compiled_clear: CompiledTeal | bytes | None = None # Compiled clear state program +``` + +### `SendAppCreateTransactionResult` + +Extends `SendAppUpdateTransactionResult` with the app ID and address of the newly created application. + +```python +@dataclass(frozen=True, kw_only=True) +class SendAppCreateTransactionResult(SendAppUpdateTransactionResult[ABIReturnT]): + app_id: int # ID of the newly created application + app_address: str # Address of the newly created application +``` + +#### ARC-56 return value parsing + +The `abi_return` field is generic over `ABIReturnT`. When you call methods through `AlgorandClient.send`, the type parameter is `ABIReturn` — a wrapper that carries the raw bytes, decoded value, and any decode error: + +```python +# Via AlgorandClient — abi_return is an ABIReturn object +result = algorand.send.app_call_method_call(AppCallMethodCallParams(...)) +result.abi_return # ABIReturn +result.abi_return.value # The decoded ABI value (ABIValue | None) +result.abi_return.method # The ARC-56 method descriptor +``` + +When you call methods through `AppClient` or `AppFactory`, the ARC-56 return value is automatically unwrapped. `AppClient` extracts `ABIReturn.value` and returns `SendAppTransactionResult[Arc56ReturnValueType]`, so `abi_return` is the decoded value directly: + +```python +# Via AppClient — abi_return is already the decoded value +result = app_client.send.call(AppClientMethodCallParams(method="hello", args=["world"])) +result.abi_return # Arc56ReturnValueType (ABIValue | ABIStruct | None) +``` + +### `SendTransactionComposerResults` + +The result from sending all transactions within a `TransactionComposer`. + +```python +@dataclass(frozen=True) +class SendTransactionComposerResults: + tx_ids: list[str] # All transaction IDs + transactions: list[Transaction] # All transactions + confirmations: list[PendingTransactionResponse] # All confirmations + returns: list[ABIReturn] # ABI return values + group_id: str | None = None # Group ID + simulate_response: SimulateResponse | None = None # Simulation response (if simulated) +``` + +### Factory result types + +`SendAppFactoryTransactionResult`, `SendAppCreateFactoryTransactionResult`, and `SendAppUpdateFactoryTransactionResult` mirror their non-factory counterparts, but `abi_return` is the already-parsed ARC-56 return value (typed as `Arc56ReturnValueType`) rather than the raw `ABIReturn` object. + +## Comparison of result types + +| Type | `abi_return` | `app_id` / `app_address` | `compiled_approval` / `compiled_clear` | `asset_id` | `simulate_response` | +| --- | --- | --- | --- | --- | --- | +| `SendSingleTransactionResult` | — | — | — | — | — | +| `SendSingleAssetCreateTransactionResult` | — | — | — | yes | — | +| `SendAppTransactionResult` | `ABIReturn` | — | — | — | — | +| `SendAppUpdateTransactionResult` | `ABIReturn` | — | yes | — | — | +| `SendAppCreateTransactionResult` | `ABIReturn` | yes | yes | — | — | +| `SendAppFactoryTransactionResult` | `Arc56ReturnValueType` | — | — | — | — | +| `SendAppCreateFactoryTransactionResult` | `Arc56ReturnValueType` | yes | yes | — | — | +| `SendTransactionComposerResults` | — (list in `returns`) | — | — | — | yes | + +## Where you'll encounter each result type + +| Method | Return type | +| --- | --- | +| `TransactionComposer.send()` | `SendTransactionComposerResults` | +| `.send.payment()` | `SendSingleTransactionResult` | +| `.send.asset_create()` | `SendSingleAssetCreateTransactionResult` | +| `.send.asset_config()` | `SendSingleTransactionResult` | +| `.send.asset_freeze()` | `SendSingleTransactionResult` | +| `.send.asset_destroy()` | `SendSingleTransactionResult` | +| `.send.asset_transfer()` | `SendSingleTransactionResult` | +| `.send.asset_opt_in()` | `SendSingleTransactionResult` | +| `.send.asset_opt_out()` | `SendSingleTransactionResult` | +| `.send.app_call()` | `SendAppTransactionResult` | +| `.send.app_create()` | `SendAppCreateTransactionResult` | +| `.send.app_update()` | `SendAppUpdateTransactionResult` | +| `.send.app_delete()` | `SendAppTransactionResult` | +| `.send.app_call_method_call()` | `SendAppTransactionResult` | +| `.send.app_create_method_call()` | `SendAppCreateTransactionResult` | +| `.send.app_update_method_call()` | `SendAppUpdateTransactionResult` | +| `.send.app_delete_method_call()` | `SendAppTransactionResult` | +| `.send.online_key_registration()` | `SendSingleTransactionResult` | +| `.send.offline_key_registration()` | `SendSingleTransactionResult` | + +## Usage example + +```python +# Send a payment and inspect the result +result = algorand.send.payment(PaymentParams( + sender="SENDERADDRESS", + receiver="RECEIVERADDRESS", + amount=AlgoAmount(algo=1), +)) + +print(result.tx_id) # Transaction ID +print(result.confirmation) # Confirmation details from algod +print(result.group_id) # Group ID + +# Create an app and access the new app ID +app_result = algorand.send.app_create(AppCreateParams( + sender="CREATORADDRESS", + approval_program="TEALCODE", + clear_state_program="TEALCODE", +)) + +print(app_result.app_id) # ID of the newly created application +print(app_result.app_address) # Address of the newly created application + +# Call an ABI method and read the return value +call_result = algorand.send.app_call_method_call(AppCallMethodCallParams( + sender="CALLERADDRESS", + app_id=app_result.app_id, + method=arc56.Method.from_signature("hello(string)string"), + args=["world"], +)) + +print(call_result.abi_return) # Parsed ABI return value +``` + +## Further reading + +To understand how to create, simulate and send transactions consult the [`AlgorandClient`](../algorand-client) and [`TransactionComposer`](../../advanced/transaction-composer) documentation. + +**Source:** [`src/algokit_utils/transactions/transaction_sender.py`](https://github.com/algorandfoundation/algokit-utils-py/blob/main/src/algokit_utils/transactions/transaction_sender.py) diff --git a/docs/src/content/docs/index.mdx b/docs/src/content/docs/index.mdx new file mode 100644 index 00000000..81164368 --- /dev/null +++ b/docs/src/content/docs/index.mdx @@ -0,0 +1,82 @@ +--- +title: AlgoKit Utils Python +description: A set of core Algorand utilities that make it easier to build solutions on Algorand +template: splash +hero: + title: AlgoKit Utils Python + tagline: Build on Algorand with confidence using a comprehensive Python SDK + actions: + - text: Get Started + link: tutorials/quick-start/ + icon: right-arrow + - text: API Reference + link: api/algokit_utils/ + variant: minimal +--- + +import { Card, CardGrid, Tabs, TabItem } from '@astrojs/starlight/components'; + +## Installation + + + + ```bash + pip install algokit-utils + ``` + + + ```bash + poetry add algokit-utils + ``` + + + ```bash + uv add algokit-utils + ``` + + + +## Quick Example + +```python +from algokit_utils import AlgorandClient, AlgoAmount, PaymentParams + +# Connect to LocalNet +algorand = AlgorandClient.from_environment() + +# Create and fund a test account +account = algorand.account.random() +algorand.account.ensure_funded( + account_to_fund=account, + dispenser_account=algorand.account.localnet_dispenser(), + min_spending_balance=AlgoAmount.from_algo(10), +) + +# Send a payment +result = algorand.send.payment( + PaymentParams( + sender=account.addr, + receiver="RECEIVERADDRESS", + amount=AlgoAmount.from_algo(1), + ) +) + +print("Transaction ID:", result.tx_id) +``` + +## Features + + + + The main entry point for interacting with Algorand networks. + + + Build and send atomic transaction groups with ease. + + + Deploy and interact with smart contracts. + + + Comprehensive testing support for LocalNet. + + diff --git a/docs/source/v3-migration-guide.md b/docs/src/content/docs/migration/v3-migration-guide.md similarity index 89% rename from docs/source/v3-migration-guide.md rename to docs/src/content/docs/migration/v3-migration-guide.md index 57976460..3da923ff 100644 --- a/docs/source/v3-migration-guide.md +++ b/docs/src/content/docs/migration/v3-migration-guide.md @@ -1,6 +1,9 @@ -# Migration Guide - v3 +--- +title: "v3 Migration Guide" +description: "Guide for migrating from algokit-utils-py v2.x to v3.x — from stateless functions to the new AlgorandClient class-based interface." +--- -Version 3 of `algokit-utils-ts` moved from a stateless function-based interface to a stateful class-based interfaces. This change allows for: +Version 3 of `algokit-utils-py` moved from a stateless function-based interface to a stateful class-based interfaces. This change allows for: - Easier and simpler consumption experience guided by IDE autocompletion - Less redundant parameter passing (e.g., `algod` client) @@ -39,7 +42,7 @@ The remaining set of guidelines are outlining migrations for specific abstractio It is important to reiterate that if you have previously relied on `beta` versions of `algokit-utils-py` v2.x, you will need to update your imports to rely on the new interfaces. Errors thrown during import from `beta` will provide a description of the new expected import path. -> As with `v2.x` all public abstractions in `algokit_utils` are available for direct imports `from algokit_utils import ...`, however underlying modules have been refined to be structured loosely around common AVM domains such as `applications`, `transactions`, `accounts`, `assets`, etc. See [API reference](https://algokit-utils-py.readthedocs.io/en/latest/api_reference/index.html) for latest and detailed overview. +> As with `v2.x` all public abstractions in `algokit_utils` are available for direct imports `from algokit_utils import ...`, however underlying modules have been refined to be structured loosely around common AVM domains such as `applications`, `transactions`, `accounts`, `assets`, etc. ### Step 1 - Replace SDK Clients with AlgorandClient @@ -80,7 +83,7 @@ dispenser = algokit_utils.get_dispenser_account(algod) #### After: ```python -account = algorand.account.from_mnemonic(os.getenv("MY_ACCOUNT_MNEMONIC")) +account = algorand.account.from_mnemonic(mnemonic=os.getenv("MY_ACCOUNT_MNEMONIC")) dispenser = algorand.account.dispenser_from_environment() ``` @@ -115,11 +118,15 @@ result = algokit_utils.execute_atc_with_logic_error(atc, algod) #### After: ```python +from algokit_utils import PaymentParams, AlgoAmount + # Single transaction result = algorand.send.payment( - sender=account.address, - receiver="RECEIVER", - amount=AlgoAmount.from_algo(1), + PaymentParams( + sender=account.addr, + receiver="RECEIVER", + amount=AlgoAmount.from_algo(1), + ) ) # Transaction groups @@ -140,18 +147,18 @@ Key changes: `ApplicationSpecification` abstraction is largely identical to v2, however it's been renamed to `Arc32Contract` to better reflect the fact that it's a contract specification for a specific ARC and addition of `Arc56Contract` supporting the latest recommended conventions. Hence the main actionable change is to update your import to `from algokit_utils import Arc32Contract` and rename `ApplicationSpecification` to `Arc32Contract`. -You can instantiate an `Arc56Contract` instance from an `Arc32Contract` instance using the `Arc56Contract.from_arc32` method. For instance: +You can instantiate an `Arc56Contract` instance from an `Arc32Contract` instance using the `arc32_to_arc56` helper. For instance: ```python testing_app_arc32_app_spec = Arc32Contract.from_json(app_spec_json) -arc56_app_spec = Arc56Contract.from_arc32(testing_app_arc32_app_spec) +arc56_app_spec = arc32_to_arc56(testing_app_arc32_app_spec) ``` > Despite auto conversion of ARC-32 to ARC-56, we recommend recompiling your contract to a fully compliant ARC-56 specification given that auto conversion would skip populating information that can't be parsed from raw ARC-32. ### Step 5 - Replace `ApplicationClient` usage -The existing `ApplicationClient` (untyped app client) class is still present until at least v4, but it's worthwhile migrating to the new [`AppClient` and `AppFactory` classes](./capabilities/app-client.md). These new clients are [ARC-56](https://github.com/algorandfoundation/ARCs/pull/258) compatible, but also support [ARC-32](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0032.md) app specs and will continue to support this indefinitely until such time the community deems they are deprecated. +The existing `ApplicationClient` (untyped app client) class is still present until at least v4, but it's worthwhile migrating to the new [`AppClient` and `AppFactory` classes](../../concepts/building/app-client/). These new clients are [ARC-56](https://github.com/algorandfoundation/ARCs/pull/258) compatible, but also support [ARC-32](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0032.md) app specs and will continue to support this indefinitely until such time the community deems they are deprecated. All of the functionality in `ApplicationClient` is available within the new classes, but their interface is slightly different to make it easier to use and more consistent with the new `AlgorandClient` functionality. The key existing methods that have changed all have `@deprecation` notices to help guide you on this, but broadly the changes are: @@ -159,14 +166,14 @@ All of the functionality in `ApplicationClient` is available within the new clas - If you want to call `create` or `deploy` then you need an `AppFactory` to do that, and then it will in turn give you an `AppClient` instance that is connected to the app you just created / deployed. This significantly simplifies the app client because now the app client has a clear operating purpose: allow for calls and state management for an _instance_ of an app, whereas the app factory handles all of the calls when you don't have an instance yet (or may or may not have an instance in the case of `deploy`). - This means that you can simply access `client.app_id` and `client.app_address` on `AppClient` since these values are known statically and won't change (previously associated calls to `app_address`, `app_id` properties potentially required extra API calls as the values weren't always available). - Adding `fund_app_account` which serves as a convenience method to top up the balance of address associated with application. -- All of the methods that return or execute a transaction (`update`, `call`, `opt_in`, etc.) are now exposed in an interface similar to the one in [`AlgorandClient`](./capabilities/algorand-client.md#creating-and-issuing-transactions), namely (where `{call_type}` is one of: `update` / `delete` / `opt_in` / `close_out` / `clear_state` / `call`): +- All of the methods that return or execute a transaction (`update`, `call`, `opt_in`, etc.) are now exposed in an interface similar to the one in [`AlgorandClient`](../../concepts/core/algorand-client/#creating-and-issuing-transactions), namely (where `{call_type}` is one of: `update` / `delete` / `opt_in` / `close_out` / `clear_state` / `call`): - `appClient.create_transaction.{callType}` to get a transaction for an ABI method call - `appClient.send.{call_type}` to sign and send a transaction for an ABI method call - - `appClient.params.{call_type}` to get a [params object](./capabilities/algorand-client.md#transaction-parameters) for an ABI method call + - `appClient.params.{call_type}` to get a params object for an ABI method call - `appClient.create_transaction.bare.{call_type}` to get a transaction for a bare app call - `appClient.send.bare.{call_type}` to sign and send a transaction for a bare app call - - `appClient.params.bare.{call_type}` to get a [params object](./capabilities/algorand-client.md#transaction-parameters) for a bare app call -- The semantics to resolve the application is now available via [simpler entrypoints within `algorand.client`](./capabilities/app-client.md#appclient) + - `appClient.params.bare.{call_type}` to get a params object for a bare app call +- The semantics to resolve the application is now available via [simpler entrypoints within `algorand.client`](../../concepts/building/app-client/#appclient) - When making an ABI method call, the method arguments property is are now passed via explicit `args` field in a parameters dataclass applicable to the method call. - The foreign reference arrays have been renamed to align with typed parameters on `ts` and related core `algosdk`: - `boxes` -> `box_references` @@ -220,8 +227,8 @@ result = algokit_utils.opt_in(algod, account, [asset_id]) """After""" result = algorand.send.asset_opt_in( - params=AssetOptInParams( - sender=account.address, + AssetOptInParams( + sender=account.addr, asset_id=asset_id, ) ) @@ -267,9 +274,9 @@ result = algorand.send.asset_opt_in( ## Best Practices 1. Use the new `AlgorandClient` as the main entry point -2. Leverage IDE autocompletion to discover available functionality, consult with [API reference](https://algokit-utils-py.readthedocs.io/en/latest/api_reference/index.html) when unsure +2. Leverage IDE autocompletion to discover available functionality 3. Use the transaction parameter builders for type-safe transaction creation (`algorand.params.{}`) -4. Use the state accessor patterns for cleaner state management {`algorand.state.{}`} +4. Use the state accessor patterns for cleaner state management (`app_client.state.{}`) 5. Use high level `TransactionComposer` interface over low level `algosdk` abstractions (where possible) 6. Use source maps and debug mode to quickly troubleshoot on-chain errors 7. Use idempotent deployment patterns with versioning diff --git a/docs/src/content/docs/migration/v5-migration-guide.md b/docs/src/content/docs/migration/v5-migration-guide.md new file mode 100644 index 00000000..388f38c2 --- /dev/null +++ b/docs/src/content/docs/migration/v5-migration-guide.md @@ -0,0 +1,913 @@ +--- +title: "v5 Migration Guide" +description: "Guide for migrating from algokit-utils-py v4.x to v5.x — from algosdk-dependent to standalone multi-module architecture." +--- + +## Overview + +Version 5 represents a **major architectural overhaul** of AlgoKit Utils for Python. The library has been decoupled from `py-algorand-sdk` (`algosdk`) and restructured into a multi-module package with custom-generated API clients. This enables: + +- **No algosdk dependency** — The library now uses generated clients and first-party transaction primitives instead of `algosdk` +- **Unified AlgorandClient** — Still the single entry point for all Algorand interactions +- **Type-safe generated clients** — Algod, Indexer, and KMD clients are generated from OpenAPI specs with full typing +- **Cross-SDK alignment** — Naming conventions aligned with `algokit-utils-ts` for consistency across the Algorand SDK ecosystem + +This guide covers both developers migrating their applications and the specific changes needed at each layer of the API. + +> **Who is this for?** If you are using `algokit-utils` v4 (including any legacy v2 APIs still available in v4), this guide will walk you through every breaking change. + +--- + +## Quick Reference Tables + +### Entry Points + +| v4 | v5 | Notes | +| :---------------------------------- | :----------------------------------- | :---------------------- | +| `AlgorandClient.default_localnet()` | `AlgorandClient.default_localnet()` | Unchanged | +| `AlgorandClient.testnet()` | `AlgorandClient.testnet()` | Unchanged | +| `AlgorandClient.mainnet()` | `AlgorandClient.mainnet()` | Unchanged | +| `AlgorandClient.from_environment()` | `AlgorandClient.from_environment()` | Unchanged | +| `get_algod_client()` | **Removed** — use `AlgorandClient.*` | Legacy function deleted | +| `get_indexer_client()` | **Removed** — use `AlgorandClient.*` | Legacy function deleted | + +### Common Operations + +| Operation | v4 (legacy) | v4 (modern) / v5 | +| :------------- | :--------------------------------------------- | :-------------------------------------------------------- | +| Payment | `transfer(TransferParameters(...))` | `algorand.send.payment(PaymentParams(...))` | +| Asset transfer | `transfer_asset(TransferAssetParameters(...))` | `algorand.send.asset_transfer(AssetTransferParams(...))` | +| Asset opt-in | `opt_in(algod, account, asset_id)` | `algorand.send.asset_opt_in(AssetOptInParams(...))` | +| Ensure funded | `ensure_funded(EnsureBalanceParameters(...))` | `algorand.account.ensure_funded(addr, dispenser, amount)` | +| App deploy | `app_client.deploy(...)` | `app_factory.deploy(...)` | +| App call | `ApplicationClient.call(...)` | `app_client.send.call(...)` | + +### Naming Standardizations + +| v4 | v5 | Notes | +| :------------------------------------- | :------------------------------- | :------------------- | +| `SigningAccount` | `AddressWithSigners` | `.address` → `.addr` | +| `TransactionSignerAccountProtocol` | `AddressWithTransactionSigner` | `.address` → `.addr` | +| `MultisigMetadata.addresses` | `MultisigMetadata.addrs` | Field renamed | +| `MultiSigAccount` | `MultisigAccount` | Class renamed | +| `SendAtomicTransactionComposerResults` | `SendTransactionComposerResults` | Class renamed | +| `SourceMap` | `ProgramSourceMap` | Class renamed | +| `OnComplete.NoOpOC` | `OnApplicationComplete.NoOp` | Enum renamed | +| `populate_app_call_resources` | `populate_group_resources` | Function renamed | + +--- + +## Part 1: Architecture Changes + +### 1.1 New Package Structure + +v4 was a single `algokit_utils` package that depended on `py-algorand-sdk`. v5 bundles 8 top-level Python modules into a single `algokit-utils` distribution: + +| Module | Purpose | Replaces | +| :----------------------- | :--------------------------------------------------------- | :----------------------------------------------------------- | +| `algokit_utils` | High-level orchestration (AlgorandClient, AppClient, etc.) | Slimmed down from v4 | +| `algokit_transact` | Transaction building, signing, encoding | `algosdk.transaction`, `algosdk.atomic_transaction_composer` | +| `algokit_algod_client` | Typed Algod REST client (OAS-generated) | `algosdk.v2client.algod.AlgodClient` | +| `algokit_indexer_client` | Typed Indexer REST client (OAS-generated) | `algosdk.v2client.indexer.IndexerClient` | +| `algokit_kmd_client` | Typed KMD REST client (OAS-generated) | `algosdk.kmd.KMDClient` | +| `algokit_abi` | ABI encoding/decoding, ARC-32/ARC-56 app specs | `algosdk.abi` + custom ARC code | +| `algokit_algo25` | Mnemonic/key generation (25-word scheme) | `algosdk.mnemonic` | +| `algokit_common` | Shared primitives (address, hashing, constants) | Various `algosdk` internals | + +All 8 modules install together via `pip install algokit-utils`. You can import directly from any module: + +```python +# High-level (most common) +from algokit_utils import AlgorandClient, AppClient, PaymentParams + +# Or import from specific modules +from algokit_transact import Transaction, TransactionType, OnApplicationComplete +from algokit_algod_client import AlgodClient +from algokit_abi.arc56 import Arc56Contract +from algokit_algo25 import mnemonic_from_seed +``` + +### 1.2 Build System Change + +The project build system has changed from **Poetry** to **uv**: + +- `poetry.lock` → `uv.lock` +- Build backend: `poetry-core` → `uv_build` + +If you are contributing to algokit-utils-py, you'll need to install [uv](https://docs.astral.sh/uv/) instead of Poetry. + +### 1.3 Dependency Changes + +**Removed:** + +- `py-algorand-sdk` (`algosdk`) — completely removed + +**Added:** + +- `httpx` — HTTP client for generated API clients +- `msgpack` / `msgpack-types` — MessagePack encoding (previously via algosdk) +- `pynacl` — Ed25519 signing (previously via algosdk) +- `pycryptodomex` — Cryptographic operations (previously via algosdk) + +If your code imports from `algosdk` directly, you will need to replace all those imports with the equivalent `algokit_*` module. + +### 1.4 Import Path Migration + +| What you need | v4 import | v5 import | +| :----------------- | :-------------------------------------------------------------------- | :---------------------------------------------------------------------------- | +| Algod client | `from algosdk.v2client.algod import AlgodClient` | `from algokit_algod_client import AlgodClient` | +| Indexer client | `from algosdk.v2client.indexer import IndexerClient` | `from algokit_indexer_client import IndexerClient` | +| KMD client | `from algosdk.kmd import KMDClient` | `from algokit_kmd_client import KmdClient` | +| Transaction types | `from algosdk.transaction import PaymentTxn` | `from algokit_transact import Transaction, PaymentTransactionFields` | +| Transaction signer | `from algosdk.atomic_transaction_composer import TransactionSigner` | `from algokit_transact import TransactionSigner` | +| OnComplete | `from algosdk.transaction import OnComplete` | `from algokit_transact import OnApplicationComplete` | +| Mnemonics | `from algosdk import mnemonic` | `from algokit_algo25 import mnemonic_from_seed, seed_from_mnemonic` | +| ABI types | `from algosdk.abi import ABIType` | `from algokit_abi.abi import ...` | +| ARC-56 spec | `from algokit_utils.applications.app_spec.arc56 import Arc56Contract` | `from algokit_abi.arc56 import Arc56Contract` | +| ARC-32 spec | `from algokit_utils.applications.app_spec.arc32 import Arc32Contract` | `from algokit_abi.arc32 import Arc32Contract` | +| Address utilities | `from algosdk import encoding` | `from algokit_common import address_from_public_key, public_key_from_address` | +| Constants | `from algosdk import constants` | `from algokit_common import MIN_TXN_FEE, ZERO_ADDRESS` | +| Source map | `from algosdk.source_map import SourceMap` | `from algokit_common import ProgramSourceMap` | + +You can also access most transaction types via the `algokit_utils.transact` facade: + +```python +# These are equivalent: +from algokit_transact import Transaction, OnApplicationComplete +from algokit_utils.transact import Transaction, OnApplicationComplete +``` + +--- + +## Part 2: Client Changes + +### 2.1 AlgorandClient + +`AlgorandClient` remains the primary entry point. Its public API is largely unchanged: + +```python +from algokit_utils import AlgorandClient + +# These all work the same as v4 +algorand = AlgorandClient.default_localnet() +algorand = AlgorandClient.testnet() +algorand = AlgorandClient.mainnet() +algorand = AlgorandClient.from_environment() +``` + +The internal client types have changed (see below), but if you only interact through `AlgorandClient`, most of your code should continue to work. + +### 2.2 Algod/Indexer/KMD Client Types + +The underlying client types are now generated from OpenAPI specs instead of coming from `algosdk`: + +```python +# v4 +from algosdk.v2client.algod import AlgodClient +from algosdk.v2client.indexer import IndexerClient +from algosdk.kmd import KMDClient + +# v5 +from algokit_algod_client import AlgodClient +from algokit_indexer_client import IndexerClient +from algokit_kmd_client import KmdClient # Note: lowercase 'md' +``` + +If you access raw clients via `algorand.client.algod`, the returned type is now `algokit_algod_client.AlgodClient` instead of `algosdk.v2client.algod.AlgodClient`. Update any type annotations accordingly. + +### 2.3 Client Configuration + +Client configuration types are now per-package: + +```python +# v4 +from algokit_utils.models.network import AlgoClientNetworkConfig + +# v5 — AlgoClientNetworkConfig still works, but underlying clients use: +from algokit_algod_client import ClientConfig as AlgodClientConfig +from algokit_indexer_client import ClientConfig as IndexerClientConfig +from algokit_kmd_client import ClientConfig as KmdClientConfig +``` + +### 2.4 SuggestedParams Changes + +The `SuggestedParams` type now comes from the generated Algod client with different field names: + +```python +# v4 (algosdk) +params.gen # genesis ID +params.gh # genesis hash + +# v5 (algokit_algod_client) +params.genesis_id # genesis ID +params.genesis_hash # genesis hash +``` + +### 2.5 ClientManager.close() + +v5 adds a `close()` method to `ClientManager` for properly closing HTTP connections (the generated clients use `httpx`): + +```python +algorand = AlgorandClient.default_localnet() +# ... use the client ... +algorand.client.close() # Clean up HTTP connections +``` + +--- + +## Part 3: Account and Signer Changes + +### 3.1 SigningAccount → AddressWithSigners + +The primary account type has been replaced with a **secretless signing architecture**. `SigningAccount` stored the raw private key as a field (`account.private_key`). `AddressWithSigners` never exposes the key — it is held in closures, enabling KMS/HSM compatibility: + +```python +# v4 +from algokit_utils import SigningAccount + +account = SigningAccount(private_key=key) +print(account.address) # string address +print(account.private_key) # raw key was readable + +# v5 +from algokit_transact import AddressWithSigners + +# Or generate via AlgorandClient (recommended) +account = algorand.account.random() +print(account.addr) # .address → .addr +# account.private_key does not exist — key is in a signing closure +``` + +> **Note:** There is **no backward-compatible alias** for `SigningAccount`. All usages must be updated. + +If you have existing code that holds a raw base64 private key string (e.g. loaded from environment or storage), use `make_basic_account_transaction_signer` as the bridge: + +```python +from algokit_transact import make_basic_account_transaction_signer +from algokit_common import address_from_public_key +import base64 + +# Bridge for legacy raw-key code +signer = make_basic_account_transaction_signer(private_key_b64) + +# Or create a full AddressWithSigners from an existing key: +from algokit_transact import generate_address_with_signers +import nacl.signing + +key_bytes = base64.b64decode(private_key_b64) +seed = key_bytes[:32] +public_key = key_bytes[32:] +signing_key = nacl.signing.SigningKey(seed) +account = generate_address_with_signers( + ed25519_pubkey=public_key, + raw_ed25519_signer=lambda data: signing_key.sign(data).signature, +) +``` + +### 3.2 TransactionSignerAccountProtocol → AddressWithTransactionSigner + +```python +# v4 +from algokit_utils import TransactionSignerAccountProtocol + +def my_function(account: TransactionSignerAccountProtocol): + print(account.address) + +# v5 +from algokit_transact import AddressWithTransactionSigner + +def my_function(account: AddressWithTransactionSigner): + print(account.addr) # .address → .addr +``` + +### 3.3 MultisigAccount/MultisigMetadata Relocation and Renames + +These types have moved to `algokit_transact` with naming changes: + +```python +# v4 +from algokit_utils.models.account import MultiSigAccount, MultisigMetadata + +metadata = MultisigMetadata(version=1, threshold=2, addresses=["addr1", "addr2"]) +msig = MultiSigAccount(metadata, [signer1, signer2]) + +# v5 +from algokit_transact import MultisigAccount, MultisigMetadata + +metadata = MultisigMetadata(version=1, threshold=2, addrs=["addr1", "addr2"]) # .addresses → .addrs +msig = MultisigAccount(metadata, [signer1, signer2]) # MultiSigAccount → MultisigAccount +``` + +Backward-compatible re-exports for `MultisigAccount`, `MultisigMetadata`, and `LogicSigAccount` exist via `algokit_utils.transact` and `algokit_utils.models.account`. Note that `SigningAccount` has **no** compat re-export — see [3.1](#31-signingaccount--addresswithsigners). + +### 3.4 LogicSigAccount Relocation + +```python +# v4 +from algokit_utils.models.account import LogicSigAccount + +# v5 +from algokit_transact import LogicSigAccount + +# Or via AlgorandClient +lsig_account = algorand.account.logicsig(program) +``` + +### 3.5 New Signer Types + +v5 introduces a richer signer hierarchy from `algokit_transact`: + +| Type | Purpose | +| :-------------------- | :---------------------------------------------------- | +| `TransactionSigner` | Signs transactions (callable protocol, no longer ABC) | +| `BytesSigner` | Signs raw bytes | +| `ProgramDataSigner` | Signs program data | +| `MxBytesSigner` | Signs MX-prefixed bytes | +| `DelegatedLsigSigner` | Creates delegated logic signatures | +| `AddressWithSigners` | Address + all signer types bundled together | + +--- + +## Part 4: Transaction Changes + +### 4.1 OnApplicationComplete Enum + +The `OnComplete` enum from `algosdk` is replaced by `OnApplicationComplete` from `algokit_transact`: + +```python +# v4 +from algosdk.transaction import OnComplete + +on_complete = OnComplete.NoOpOC +on_complete = OnComplete.OptInOC +on_complete = OnComplete.CloseOutOC +on_complete = OnComplete.ClearStateOC +on_complete = OnComplete.UpdateApplicationOC +on_complete = OnComplete.DeleteApplicationOC + +# v5 +from algokit_transact import OnApplicationComplete + +on_complete = OnApplicationComplete.NoOp +on_complete = OnApplicationComplete.OptIn +on_complete = OnApplicationComplete.CloseOut +on_complete = OnApplicationComplete.ClearState +on_complete = OnApplicationComplete.UpdateApplication +on_complete = OnApplicationComplete.DeleteApplication +``` + +### 4.2 TransactionSigner + +The `TransactionSigner` is now a callable protocol instead of an abstract base class: + +```python +# v4 +from algosdk.atomic_transaction_composer import TransactionSigner # ABC with .sign_transactions() + +# v5 +from algokit_transact import TransactionSigner # Callable protocol +``` + +### 4.3 TransactionComposer Changes + +The `TransactionComposer` constructor now takes a `TransactionComposerParams` dataclass: + +```python +# v4 +composer = TransactionComposer( + algod=algod_client, + get_signer=get_signer_fn, + get_suggested_params=get_params_fn, +) + +# v5 +from algokit_utils.transactions import TransactionComposer, TransactionComposerParams + +composer = TransactionComposer( + params=TransactionComposerParams( + algod=algod_client, + get_signer=get_signer_fn, + get_suggested_params=get_params_fn, + ) +) +``` + +Composer-level fee and resource behaviour is controlled via the separate `TransactionComposerConfig` dataclass, passed as `composer_config` inside `TransactionComposerParams`: + +```python +from algokit_utils.transactions import TransactionComposer, TransactionComposerParams, TransactionComposerConfig + +composer = TransactionComposer( + params=TransactionComposerParams( + algod=algod_client, + get_signer=get_signer_fn, + composer_config=TransactionComposerConfig( + cover_app_call_inner_transaction_fees=True, # default: False + populate_app_call_resources=False, # default: True + ), + ) +) +``` + +Result types have been renamed: + +```python +# v4 +from algokit_utils import SendAtomicTransactionComposerResults + +# v5 +from algokit_utils import SendTransactionComposerResults +``` + +### 4.4 Transaction Parameter Types + +Transaction parameter dataclasses have moved to `algokit_utils.transactions.types`: + +```python +from algokit_utils import ( + PaymentParams, + AssetCreateParams, + AssetTransferParams, + AssetOptInParams, + AssetOptOutParams, + AppCallParams, + AppCreateParams, + AppUpdateParams, + AppDeleteParams, + OnlineKeyRegistrationParams, + OfflineKeyRegistrationParams, +) +``` + +The types themselves (`PaymentParams`, `AppCallParams`, etc.) keep the same names and fields. + +### 4.5 New Transaction Builders + +v5 adds a `transactions/builders/` package with functions for constructing low-level `algokit_transact.Transaction` objects: + +```python +from algokit_utils.transactions.builders import ( + build_payment_transaction, + build_app_call_transaction, + build_app_create_transaction, + build_asset_create_transaction, + build_asset_transfer_transaction, + build_asset_opt_in_transaction, + # ... etc. +) +``` + +These are useful when you need fine-grained control over transaction construction at the `algokit_transact` level. + +### 4.6 Resource Population + +```python +# v4 +from algokit_utils import populate_app_call_resources + +# v5 +from algokit_utils.transactions.composer_resources import ( + populate_group_resources, + populate_transaction_resources, +) +``` + +The helper functions `prepare_group_for_sending` and `send_atomic_transaction_composer` have been removed from the public API. + +### 4.7 Fee Types + +New types for fee management: + +```python +from algokit_utils.transactions.fee_coverage import FeeDeltaType, FeeDelta, FeePriority +``` + +`FeeDeltaType` is an enum discriminant on `FeeDelta.delta_type` indicating whether the fee delta is a fixed amount or a multiplier. `FeePriority` configures priority fee strategies. + +--- + +## Part 5: App Client and Smart Contract Changes + +### 5.1 Legacy ApplicationClient Removed + +The old `ApplicationClient` class from `_legacy_v2` has been completely removed: + +```python +# v4 (legacy) +from algokit_utils import ApplicationClient + +app_client = ApplicationClient(algod_client, app_spec, sender=account) +result = app_client.call("hello", name="world") + +# v5 — use AppClient and AppFactory instead +from algokit_utils import AlgorandClient + +algorand = AlgorandClient.default_localnet() + +# For deploying new apps, use AppFactory +factory = algorand.client.get_app_factory(app_spec=arc56_spec, default_sender=sender) +app_client, result = factory.deploy(...) + +# For interacting with existing apps, use AppClient +app_client = algorand.client.get_app_client_by_id(app_spec=arc56_spec, app_id=app_id, default_sender=sender) +result = app_client.send.call(method="hello", args=["world"]) +``` + +### 5.2 ApplicationSpecification Removed + +The old `ApplicationSpecification` class is no longer accepted: + +```python +# v4 +from algokit_utils import ApplicationSpecification + +spec = ApplicationSpecification(...) + +# v5 — use Arc56Contract (ARC-32 specs are auto-converted) +from algokit_abi.arc56 import Arc56Contract +from algokit_abi.arc32 import Arc32Contract +``` + +`get_app_factory()` and `get_app_client_by_id()` now only accept `Arc56Contract | str`, not `ApplicationSpecification`. + +### 5.3 App Spec Location + +ARC-32 and ARC-56 contract specifications have moved to the `algokit_abi` package: + +```python +# v4 +from algokit_utils.applications.app_spec.arc56 import Arc56Contract +from algokit_utils.applications.app_spec.arc32 import Arc32Contract + +# v5 +from algokit_abi.arc56 import Arc56Contract +from algokit_abi.arc32 import Arc32Contract + +# Still re-exported for convenience: +from algokit_utils.applications.app_spec import Arc56Contract, Arc32Contract +``` + +### 5.4 Confirmation Results + +Transaction confirmation results are now typed objects instead of dictionaries: + +```python +# v4 — dict-style access +result = algorand.send.payment(PaymentParams(...)) +app_id = result.confirmation["application-index"] +asset_id = result.confirmation["asset-index"] + +# v5 — typed attribute access +result = algorand.send.payment(PaymentParams(...)) +app_id = result.confirmation.app_id +asset_id = result.confirmation.asset_id +``` + +The `confirmation` field is now `algod_models.PendingTransactionResponse` (a typed dataclass) instead of `AlgodResponseType` (a dict-like object). + +--- + +## Part 6: ABI Changes + +### 6.1 Return Type Changes + +> **⚠️ Silent runtime risk:** These type changes do **not** produce `ImportError` or `AttributeError` at startup — they will only fail at runtime when your code processes the return value. Make sure to test all ABI method call paths, not just import paths. + +ABI decoding now returns more Pythonic types: + +| ABI Type | v4 returns | v5 returns | +| :------------------------------------- | :---------- | :---------------- | +| `byte`, `byte[]`, `byte[n]` | `list[int]` | `bytes` | +| `ufixedx` | `int` | `decimal.Decimal` | +| Tuple types (e.g., `(uint64,address)`) | `list` | `tuple` | + +If your code processes ABI return values, update type expectations: + +```python +# v4 +result = app_client.call("get_bytes") +byte_list: list[int] = result.return_value # [72, 101, 108, 108, 111] + +# v5 +result = app_client.send.call(method="get_bytes") +byte_data: bytes = result.abi_return.return_value # b"Hello" +``` + +### 6.2 Encoding Changes + +| ABI Type | v4 accepts | v5 accepts | +| :-------------- | :--------- | :------------------------- | +| `byte` | `int` | `bytes` or `int` | +| `ufixedx` | `int` | `decimal.Decimal` or `int` | + +--- + +## Part 7: Generated Client Model Changes + +### 7.1 Block Model Restructuring + +Block models from the generated Algod client have been reorganized: + +```python +# v4 +from algokit_algod_client.models import GetBlock + +response: GetBlock = algod_client.get_block(...) +fee_sink = response.block.header.fee_sink +protocol = response.block.header.current_protocol +proposal = response.block.header.upgrade_propose +tx_root = response.block.header.transactions_root + +# v5 +from algokit_algod_client.models import BlockResponse + +response: BlockResponse = algod_client.get_block(...) +fee_sink = response.block.header.reward_state.fee_sink +protocol = response.block.header.upgrade_state.current_protocol +proposal = response.block.header.upgrade_vote.upgrade_propose +tx_root = response.block.header.txn_commitments.transactions_root +``` + +Header fields have been reorganized into nested types: + +- Reward fields → `header.reward_state.*` +- Protocol fields → `header.upgrade_state.*` +- Upgrade vote fields → `header.upgrade_vote.*` +- Transaction root fields → `header.txn_commitments.*` + +Other changes: + +- `BlockEvalDelta.bytes` → `BlockEvalDelta.bytes_value` (avoids Python keyword conflict) +- `previous_block_hash` and `genesis_hash` are now non-optional with `bytes(32)` defaults + +### 7.2 Fixed-Length Byte Validation + +v5 enforces runtime validation for fixed-length byte fields (32 and 64 bytes). Fields that previously accepted any length now raise `ValueError`: + +```python +# v4 — silently accepted wrong lengths +txn.group = bytes(10) # No error + +# v5 — raises ValueError +txn.group = bytes(10) # ValueError: Expected 32 bytes, got 10 +txn.group = bytes(32) # OK +``` + +Affected fields: `group`, `lease`, transaction hashes, block hashes, keys (32 bytes), signatures, SHA-512 hashes (64 bytes). + +### 7.3 Confirmation/Response Type Changes + +Response types from the generated Algod client are now proper typed dataclasses. If you were accessing responses as dictionaries (e.g., `response["key"]`), switch to attribute access (e.g., `response.key`). + +--- + +## Part 8: Utility Changes + +### 8.1 Common Utilities + +The `algokit_common` module provides constants and functions that were previously scattered across `algosdk`: + +```python +from algokit_common import ( + # Constants + ADDRESS_LENGTH, + CHECKSUM_BYTE_LENGTH, + HASH_BYTES_LENGTH, + MAX_TRANSACTION_GROUP_SIZE, + MICROALGOS_TO_ALGOS_RATIO, + MIN_TXN_FEE, + PUBLIC_KEY_BYTE_LENGTH, + SIGNATURE_BYTE_LENGTH, + TRANSACTION_ID_LENGTH, + ZERO_ADDRESS, + + # Functions + address_from_public_key, + get_application_address, + public_key_from_address, + sha512_256, + + # Source map + ProgramSourceMap, +) +``` + +These are also accessible via `algokit_utils.common`. + +### 8.2 SourceMap → ProgramSourceMap + +```python +# v4 +from algosdk.source_map import SourceMap + +# v5 +from algokit_common import ProgramSourceMap +``` + +### 8.3 AlgoAmount Enhancements + +`AlgoAmount` now supports full comparison operations and accepts `int` in arithmetic: + +```python +from algokit_utils import AlgoAmount + +a = AlgoAmount.from_algo(5) +b = AlgoAmount.from_algo(3) + +# New in v5: full comparison support +assert a > b +assert a >= b +assert b < a + +# New in v5: arithmetic with int (treated as micro-algos) +result = a + 1_000_000 # adds 1 Algo worth of micro-algos +result = a - 500_000 +``` + +### 8.4 Mnemonic Utilities + +Mnemonic operations are now in the `algokit_algo25` package: + +```python +# v4 +from algosdk import mnemonic + +words = mnemonic.from_private_key(private_key) +key = mnemonic.to_private_key(words) + +# v5 +from algokit_algo25 import ( + mnemonic_from_seed, + seed_from_mnemonic, + secret_key_to_mnemonic, + master_derivation_key_to_mnemonic, + mnemonic_to_master_derivation_key, +) + +words = secret_key_to_mnemonic(secret_key) +seed = seed_from_mnemonic(words) +``` + +Also accessible via `algokit_utils.algo25`. + +--- + +## Part 9: Removed/Deprecated APIs + +### 9.1 Removed Legacy v2 Functions + +| Removed Function | v5 Replacement | +| :----------------------------------- | :---------------------------------------------------------------- | +| `get_algod_client()` | `AlgorandClient.default_localnet()` / `.testnet()` / `.mainnet()` | +| `get_indexer_client()` | Access via `algorand.client.indexer` | +| `get_kmd_client_from_algod_client()` | Access via `algorand.client.kmd` | +| `get_account()` | `algorand.account.from_environment(name)` | +| `get_account_from_mnemonic()` | `algorand.account.from_mnemonic(mnemonic)` | +| `get_localnet_default_account()` | `algorand.account.localnet_dispenser()` | +| `get_dispenser_account()` | `algorand.account.dispenser_from_environment()` | +| `create_kmd_wallet_account()` | `algorand.account.from_kmd(...)` | +| `get_or_create_kmd_wallet_account()` | `algorand.account.from_kmd(...)` | +| `get_kmd_wallet_account()` | `algorand.account.from_kmd(...)` | +| `ensure_funded()` | `algorand.account.ensure_funded(addr, dispenser, amount)` | +| `transfer()` | `algorand.send.payment(PaymentParams(...))` | +| `transfer_asset()` | `algorand.send.asset_transfer(AssetTransferParams(...))` | +| `opt_in()` | `algorand.send.asset_opt_in(AssetOptInParams(...))` | +| `opt_out()` | `algorand.send.asset_opt_out(AssetOptOutParams(...))` | +| `is_localnet()` | `algorand.client.network` returns `NetworkDetail` | +| `is_mainnet()` | `algorand.client.network.is_mainnet` | +| `is_testnet()` | `algorand.client.network.is_testnet` | +| `execute_atc_with_logic_error()` | Use `TransactionComposer` directly | +| `get_next_version()` | Internal to deploy logic | +| `get_sender_from_signer()` | No longer needed | +| `num_extra_program_pages()` | `calculate_extra_program_pages()` in `transactions/helpers.py` | +| `replace_template_variables()` | Internal to deploy logic | +| `get_app_id_from_tx_id()` | Access `result.app_id` from send result | +| `get_creator_apps()` | Use `AppDeployer` directly | + +### 9.2 Removed Legacy v2 Classes + +| Removed Class | v5 Replacement | +| :----------------------------------------------------------------- | :-------------------------------------------------------------------------------------------- | +| `ApplicationClient` | `AppClient` / `AppFactory` via `algorand.client.get_app_client_by_id()` / `get_app_factory()` | +| `ApplicationSpecification` | `Arc56Contract` from `algokit_abi` | +| `Account` (NamedTuple) | `AddressWithSigners` from `algokit_transact` | +| `Program` | Compile via `AppClient` or `AppManager` | +| `AlgoClientConfig` | `AlgoClientNetworkConfig` | +| `ABITransactionResponse` | Typed result objects from `.send.*()` calls | +| `CommonCallParameters` / `CommonCallParametersDict` | `CommonTxnParams` | +| `CreateCallParameters` / `CreateCallParametersDict` | `AppCreateParams` | +| `TransactionParameters` / `TransactionParametersDict` | Specific param types (`PaymentParams`, etc.) | +| `OnCompleteCallParameters` | `AppCallParams` with `on_complete` field | +| `EnsureBalanceParameters` | `algorand.account.ensure_funded()` params | +| `EnsureFundedResponse` | Typed result from `ensure_funded()` | +| `TransferParameters` | `PaymentParams` | +| `TransferAssetParameters` | `AssetTransferParams` | +| `AppDeployMetaData` / `AppMetaData` / `AppLookup` / `AppReference` | Internal to `AppDeployer` | +| `DeployResponse` / `DeploymentFailedError` | Result types from `AppFactory.deploy()` | +| `ABICallArgs` / `DeployCallArgs` / `DeployCreateCallArgs` | Method call params in `AppFactory` | +| `MethodHints` / `MethodConfigDict` / `CallConfig` | ARC-56 natively handles these | +| `TemplateValueDict` / `TemplateValueMapping` | `deploy_time_params` in `AppFactory` | + +### 9.3 Removed Beta Shims + +The `algokit_utils.beta` package (which contained deprecation-warning shims for `account_manager`, `algorand_client`, `client_manager`, `composer`) is removed. Import directly from `algokit_utils` instead: + +```python +# v4 (beta imports — deprecated) +from algokit_utils.beta.algorand_client import AlgorandClient +from algokit_utils.beta.account_manager import AccountManager +from algokit_utils.beta.composer import TransactionComposer + +# v5 (direct imports) +from algokit_utils import AlgorandClient +from algokit_utils.accounts import AccountManager +from algokit_utils.transactions import TransactionComposer +``` + +### 9.4 Removed Top-Level Shim Modules + +These files that re-exported legacy v2 code with deprecation warnings are deleted: + +- `algokit_utils.account` +- `algokit_utils.application_client` +- `algokit_utils.application_specification` +- `algokit_utils.asset` +- `algokit_utils.deploy` +- `algokit_utils.dispenser_api` +- `algokit_utils.logic_error` +- `algokit_utils.network_clients` + +--- + +## Migration Checklist + +### Step 1: Update Dependencies + +```bash +# Remove algosdk from your dependencies +pip uninstall py-algorand-sdk + +# Install the latest algokit-utils (v5 includes all sub-packages) +pip install --upgrade algokit-utils +``` + +### Step 2: Update Entry Point + +- [ ] If using `get_algod_client()` / `get_indexer_client()`, replace with `AlgorandClient.*` +- [ ] If already using `AlgorandClient`, no changes needed + +### Step 3: Update Imports + +- [ ] Replace all `from algosdk` imports with equivalent `algokit_*` imports (see [1.4](#14-import-path-migration)) +- [ ] Replace `from algokit_utils._legacy_v2` imports +- [ ] Replace `from algokit_utils.beta` imports +- [ ] Update `Arc56Contract` / `Arc32Contract` imports to `algokit_abi` + +### Step 4: Update Account Types + +- [ ] `SigningAccount` → `AddressWithSigners` +- [ ] `.address` → `.addr` on all account/signer types +- [ ] `TransactionSignerAccountProtocol` → `AddressWithTransactionSigner` +- [ ] `MultiSigAccount` → `MultisigAccount` +- [ ] `MultisigMetadata.addresses` → `.addrs` + +### Step 5: Update Transaction Code + +- [ ] `OnComplete.NoOpOC` → `OnApplicationComplete.NoOp` (and similar) +- [ ] `SendAtomicTransactionComposerResults` → `SendTransactionComposerResults` +- [ ] `populate_app_call_resources` → `populate_group_resources` +- [ ] Update `TransactionComposer` constructor if using directly + +### Step 6: Update App Client Code + +- [ ] Replace `ApplicationClient` with `AppClient` / `AppFactory` +- [ ] Replace `ApplicationSpecification` with `Arc56Contract` +- [ ] Update method call patterns to use `app_client.send.call(...)` interface + +### Step 7: Update ABI Handling + +- [ ] Update code expecting `list[int]` from byte types — now returns `bytes` +- [ ] Update code expecting `int` from `ufixed` types — now returns `decimal.Decimal` +- [ ] Update code expecting `list` from tuple types — now returns `tuple` + +### Step 8: Update Direct algosdk Usage + +- [ ] Replace `algosdk.v2client.algod.AlgodClient` type annotations with `algokit_algod_client.AlgodClient` +- [ ] Replace `algosdk.v2client.indexer.IndexerClient` with `algokit_indexer_client.IndexerClient` +- [ ] Replace `algosdk.kmd.KMDClient` with `algokit_kmd_client.KmdClient` +- [ ] Update `SuggestedParams` field access: `.gen` → `.genesis_id`, `.gh` → `.genesis_hash` +- [ ] Replace `algosdk.source_map.SourceMap` with `algokit_common.ProgramSourceMap` + +### Step 9: Update Model Access Patterns + +- [ ] Replace dict-style confirmation access (`["application-index"]`) with attribute access (`.app_id`) +- [ ] Replace dict-style confirmation access (`["asset-index"]`) with attribute access (`.asset_id`) +- [ ] Update block model access for nested header fields (see [7.1](#71-block-model-restructuring)) + +### Step 10: Verify + +- [ ] Run your test suite +- [ ] Check for `ImportError` / `ModuleNotFoundError` (indicates missed import updates) +- [ ] Check for `AttributeError` on `.address` (should be `.addr`) +- [ ] Check for `TypeError` on ABI return values (type changes) +- [ ] Test transaction signing and sending end-to-end diff --git a/docs/src/content/docs/tutorials/quick-start.md b/docs/src/content/docs/tutorials/quick-start.md new file mode 100644 index 00000000..ebf1bc03 --- /dev/null +++ b/docs/src/content/docs/tutorials/quick-start.md @@ -0,0 +1,76 @@ +--- +title: "Quick Start" +description: "Get up and running with AlgoKit Utils in 5 minutes." +--- + +Get up and running with AlgoKit Utils in 5 minutes. + +## Prerequisites + +- Python 3.10+ +- [AlgoKit CLI](https://github.com/algorandfoundation/algokit-cli) installed +- LocalNet running (`algokit localnet start`) + +## Installation + +```bash +pip install algokit-utils +# or +poetry add algokit-utils +# or +uv add algokit-utils +``` + +## Your First Transaction + +Create a file called `hello_algorand.py`: + +```python +from algokit_utils import AlgorandClient, AlgoAmount, PaymentParams + +# 1. Connect to LocalNet +algorand = AlgorandClient.default_localnet() + +# 2. Create a new random account +sender = algorand.account.random() +print(f"Created account: {sender.addr}") + +# 3. Fund the account from the LocalNet dispenser +algorand.account.ensure_funded(sender, algorand.account.localnet_dispenser(), min_spending_balance=AlgoAmount.from_algo(10)) +print("Funded account with 10 ALGO") + +# 4. Check the balance +info = algorand.account.get_information(sender) +print(f"Balance: {info.amount.algo} ALGO") + +# 5. Create a second account and send a payment +receiver = algorand.account.random() + +result = algorand.send.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_algo(1), + ) +) + +print(f"Payment sent! Transaction ID: {result.tx_id}") + +# 6. Check receiver balance +receiver_info = algorand.account.get_information(receiver) +print(f"Receiver balance: {receiver_info.amount.algo} ALGO") +``` + +Run it: + +```bash +python hello_algorand.py +``` + +## What's Next? + +- [AlgorandClient](../../concepts/core/algorand-client/) — Learn about the main entry point +- [Account Management](../../concepts/core/account/) — Different ways to create and manage accounts +- [Transaction Management](../../concepts/core/transaction/) — Build and send transactions +- [App Client](../../concepts/building/app-client/) — Deploy and interact with smart contracts +- [Examples](../../examples/) — Browse 100+ runnable examples diff --git a/docs/src/loaders/examples-loader.ts b/docs/src/loaders/examples-loader.ts new file mode 100644 index 00000000..b643966c --- /dev/null +++ b/docs/src/loaders/examples-loader.ts @@ -0,0 +1,206 @@ +import type { Loader } from 'astro/loaders' +import fs from 'node:fs' +import path from 'node:path' + +type ExampleEntry = { + id: string + title: string + description: string + prerequisites: string + code: string + category: string + categoryLabel: string + order: number + filename: string + runCommand: string +} + +interface CategoryMeta { + label: string + description: string + slug: string +} + +const CATEGORIES: Record = { + abi: { + label: 'ABI Encoding', + description: 'ABI type parsing, encoding, and decoding following the ARC-4 specification.', + slug: 'abi', + }, + algo25: { + label: 'Mnemonic Utilities', + description: 'Mnemonic and seed conversion utilities following the Algorand 25-word mnemonic standard.', + slug: 'algo25', + }, + algod_client: { + label: 'Algod Client', + description: 'Algorand node operations and queries using the AlgodClient.', + slug: 'algod-client', + }, + algorand_client: { + label: 'Algorand Client', + description: 'High-level AlgorandClient API for simplified blockchain interactions.', + slug: 'algorand-client', + }, + common: { + label: 'Common Utilities', + description: 'Utility functions and helpers.', + slug: 'common', + }, + indexer_client: { + label: 'Indexer Client', + description: 'Blockchain data queries using the IndexerClient.', + slug: 'indexer-client', + }, + kmd_client: { + label: 'KMD Client', + description: 'Key Management Daemon operations for wallet and key management.', + slug: 'kmd-client', + }, + signing: { + label: 'Signing', + description: 'Secure secret management and external KMS signing for production-grade security.', + slug: 'signing', + }, + transact: { + label: 'Transactions', + description: 'Low-level transaction construction and signing.', + slug: 'transact', + }, +} + +export function lineSeparator(text: string, isBullet: boolean, lastWasBullet: boolean): string { + if (!text) return '' + if (isBullet || lastWasBullet) return '\n' + return ' ' +} + +export function parseDocstring(content: string): { title: string; description: string; prerequisites: string } { + const docstringMatch = content.match(/"""([\s\S]*?)"""/) + + if (!docstringMatch) { + return { title: 'Example', description: '', prerequisites: '' } + } + + const docstringContent = docstringMatch[1] + const lines = docstringContent.split('\n').map((line) => line.trim()) + + // Extract title from "Example: Title" line + const titleMatch = docstringContent.match(/Example:\s*(.+)/) + const title = titleMatch?.[1]?.trim() || 'Example' + + let description = '' + let prerequisites = '' + let lastLineWasBullet = false + + for (const line of lines) { + if (line.startsWith('Example:')) continue + + if (!line) { + lastLineWasBullet = false + if (description) { + description += '\n' + } + continue + } + + // Detect prerequisite lines (last meaningful line(s) about LocalNet) + if (/^(no )?localnet/i.test(line) || /localnet (required|running)/i.test(line)) { + prerequisites = line + continue + } + + const isBullet = line.startsWith('-') || line.startsWith('•') + description += lineSeparator(description, isBullet, lastLineWasBullet) + line + lastLineWasBullet = isBullet + } + + return { + title, + description: description.trim(), + prerequisites: prerequisites.trim() || 'LocalNet running (`algokit localnet start`)', + } +} + +/** + * Extract order number from filename (e.g., "01_example.py" -> 1) + */ +export function extractOrder(filename: string): number { + const match = filename.match(/^(\d+)_/) + return match ? parseInt(match[1], 10) : 999 +} + +export function createSlug(filename: string): string { + return filename.replace(/\.py$/, '').replace(/_/g, '-') +} + +export function examplesLoader(): Loader { + return { + name: 'examples-loader', + load: async ({ store, logger }) => { + const examplesDir = path.resolve(process.cwd(), '..', 'examples') + + logger.info(`Loading examples from ${examplesDir}`) + + if (!fs.existsSync(examplesDir)) { + logger.error(`Examples directory not found: ${examplesDir}`) + return + } + + const entries: ExampleEntry[] = [] + + for (const [categoryDir, meta] of Object.entries(CATEGORIES)) { + const categoryPath = path.join(examplesDir, categoryDir) + + if (!fs.existsSync(categoryPath)) { + logger.warn(`Category directory not found: ${categoryPath}`) + continue + } + + const files = fs.readdirSync(categoryPath).filter((f) => f.endsWith('.py') && !f.startsWith('_')) + + for (const filename of files) { + const filePath = path.join(categoryPath, filename) + const content = fs.readFileSync(filePath, 'utf-8') + const { title, description, prerequisites } = parseDocstring(content) + const order = extractOrder(filename) + const slug = createSlug(filename) + + const entry: ExampleEntry = { + id: `${meta.slug}/${slug}`, + title, + description, + prerequisites, + code: content, + category: categoryDir, + categoryLabel: meta.label, + order, + filename, + runCommand: `uv run python ${categoryDir}/${filename}`, + } + + entries.push(entry) + } + } + + entries.sort((a, b) => { + if (a.category !== b.category) { + return a.category.localeCompare(b.category) + } + return a.order - b.order + }) + + logger.info(`Found ${entries.length} examples across ${Object.keys(CATEGORIES).length} categories`) + + for (const entry of entries) { + store.set({ + id: entry.id, + data: entry, + }) + } + }, + } +} + +export { CATEGORIES } +export type { ExampleEntry, CategoryMeta } diff --git a/docs/src/styles/api-reference.css b/docs/src/styles/api-reference.css new file mode 100644 index 00000000..c8fd9f12 --- /dev/null +++ b/docs/src/styles/api-reference.css @@ -0,0 +1,51 @@ +/* + * API Reference styling for auto-generated sphinx-autoapi docs. + * + * Modelled after the Python/Furo theme: + * - Class/type definitions (H3 with ) get a subtle rounded box + * - Module-level functions (H3 without ) are inline, no box + * - Attributes, methods, properties (H4) are compact inline declarations + */ + +/* ── Base H3 — monospace, reduced size, no box ── */ +.api-ref h3 { + font-family: var(--sl-font-mono, ui-monospace, monospace); + font-size: var(--sl-text-base, 1rem); + font-weight: 400; + margin-top: 2rem; + padding: 0.25rem 0; + border-bottom: 1px solid var(--sl-color-gray-6, #343841); +} + +/* ── Class/type definitions (H3 with ) — boxed like Furo ── */ +.api-ref h3:has(> em) { + padding: 0.5rem 0.75rem; + background: var(--sl-color-gray-7, #23262f); + border-left: 3px solid var(--sl-color-accent, #6366f1); + border-bottom: none; + border-radius: 0.25rem; +} + +/* Keyword styling: class, type, property in blue italic */ +.api-ref h3 em { + color: var(--sl-color-blue, #60a5fa); + font-style: italic; +} + +/* ── Attributes, methods, properties (H4) — compact field style ── */ +.api-ref h4 { + font-family: var(--sl-font-mono, ui-monospace, monospace); + font-size: var(--sl-text-sm, 0.875rem); + font-weight: 600; + margin-top: 1.25rem; + margin-bottom: 0.25rem; + padding: 0.25rem 0; + border-bottom: 1px solid var(--sl-color-gray-6, #343841); +} + +/* Type annotations and keywords in H4 — subdued */ +.api-ref h4 em { + font-weight: 400; + color: var(--sl-color-gray-3, #9ca3af); + font-style: normal; +} diff --git a/docs/tsconfig.json b/docs/tsconfig.json new file mode 100644 index 00000000..70887920 --- /dev/null +++ b/docs/tsconfig.json @@ -0,0 +1,8 @@ +{ + "extends": "astro/tsconfigs/strict", + "compilerOptions": { + "types": ["node"] + }, + "include": [".astro/types.d.ts", "**/*"], + "exclude": ["dist"] +} diff --git a/examples/README.md b/examples/README.md new file mode 100644 index 00000000..782a010b --- /dev/null +++ b/examples/README.md @@ -0,0 +1,253 @@ +# AlgoKit Utils Python Examples + +Runnable code examples demonstrating every major feature of the `algokit-utils` Python library. + +## Overview + +This folder contains 109 self-contained examples organized into 8 categories. Each example is a standalone Python file that demonstrates specific functionality, progressing from basic to advanced usage within each category. + +## Prerequisites + +- Python >= 3.12 +- [AlgoKit LocalNet](https://github.com/algorandfoundation/algokit-cli) running (for network examples) + +Some examples (marked "No LocalNet required") work with pure utility functions and don't need a running network. + +## Quick Start + +All commands are run from the `examples/` directory: + +```bash +cd examples + +# Install dependencies (resolves algokit-utils from parent directory) +uv sync + +# Run a single example +uv run python transact/01_payment_transaction.py + +# Run all examples in a category +./transact/verify-all.sh + +# Run all examples +./verify-all.sh +``` + +## Examples by Package + +### ABI (`abi/`) + +ABI type parsing, encoding, and decoding following the ARC-4 specification. + +| File | Description | +| ------------------------------- | --------------------------------------------------------------------- | +| `01_type_parsing.py` | Parse ABI type strings into type objects with `ABIType.from_string()` | +| `02_primitive_types.py` | Encode/decode uint, bool, and byte types | +| `03_address_type.py` | Encode/decode Algorand addresses (32-byte public keys) | +| `04_string_type.py` | Encode/decode dynamic strings with length prefix | +| `05_static_array.py` | Fixed-length arrays like `byte[32]` and `uint64[3]` | +| `06_dynamic_array.py` | Variable-length arrays with head/tail encoding | +| `07_tuple_type.py` | Encode/decode tuples with mixed types | +| `08_struct_type.py` | Named structs with field metadata | +| `09_struct_tuple_conversion.py` | Convert between struct objects and tuple arrays | +| `10_bool_packing.py` | Efficient bool array packing (8 bools per byte) | +| `11_abi_method.py` | Parse method signatures and compute 4-byte selectors | +| `12_avm_types.py` | AVM-specific types (AVMBytes, AVMString, AVMUint64) | +| `13_type_guards.py` | Type guard functions for argument/type categorization | +| `14_complex_nested.py` | Deeply nested types combining arrays, tuples, structs | +| `15_arc56_storage.py` | ARC-56 storage helpers for contract state inspection | + +### Algo25 (`algo25/`) + +Mnemonic and seed conversion utilities following the Algorand 25-word mnemonic standard. No LocalNet required. + +| File | Description | +| ------------------------------ | --------------------------------------------------- | +| `01_mnemonic_from_seed.py` | Convert 32-byte seed to 25-word mnemonic | +| `02_seed_from_mnemonic.py` | Convert 25-word mnemonic back to 32-byte seed | +| `03_secret_key_to_mnemonic.py` | Convert 64-byte secret key to mnemonic | +| `04_master_derivation_key.py` | MDK alias functions for wallet derivation workflows | +| `05_error_handling.py` | Handle invalid words, checksums, and seed lengths | + +### Algod Client (`algod_client/`) + +Algorand node operations and queries using the AlgodClient. + +| File | Description | +| ---------------------------- | -------------------------------------------------------------- | +| `01_node_health_status.py` | Check node health with `health_check()`, `ready()`, `status()` | +| `02_version_genesis.py` | Get node version and genesis configuration | +| `03_ledger_supply.py` | Query total, online, and circulating supply | +| `04_account_info.py` | Get account balances, assets, and application state | +| `05_transaction_params.py` | Get suggested params for transaction construction | +| `06_send_transaction.py` | Submit transactions and wait for confirmation | +| `07_pending_transactions.py` | Query pending transactions in the mempool | +| `08_block_data.py` | Retrieve block info, hash, and transaction IDs | +| `09_asset_info.py` | Get asset parameters by ID | +| `10_application_info.py` | Get application state and parameters by ID | +| `11_application_boxes.py` | Query application box storage | +| `12_teal_compile.py` | Compile TEAL source and disassemble bytecode | +| `13_simulation.py` | Simulate transactions before submitting | +| `14_state_deltas.py` | Get ledger state changes for rounds/transactions | +| `15_transaction_proof.py` | Get Merkle proofs for transaction inclusion | +| `16_lightblock_proof.py` | Get light block header proofs for state verification | +| `17_state_proof.py` | Get cryptographic state proofs for cross-chain verification | +| `18_devmode_timestamp.py` | Control block timestamps in DevMode | +| `19_sync_round.py` | Manage node sync round for storage optimization | + +### Algorand Client (`algorand_client/`) + +High-level AlgorandClient API for simplified blockchain interactions. + +| File | Description | +| ---------------------------- | --------------------------------------------------------------------------------------------------------------- | +| `01_client_instantiation.py` | Create AlgorandClient via `default_localnet()`, `testnet()`, `mainnet()`, `from_environment()`, `from_config()` | +| `02_algo_amount.py` | AlgoAmount utility for safe ALGO/microALGO arithmetic and formatting | +| `03_signer_config.py` | Configure transaction signers with `set_default_signer()`, `set_signer_from_account()`, `set_signer()` | +| `04_params_config.py` | Configure suggested params: validity window, caching, cache timeout | +| `05_account_manager.py` | Create/import accounts: random, mnemonic, KMD, multisig, logicsig, rekeyed | +| `06_send_payment.py` | Send ALGO payments with amount, note, and close_remainder_to | +| `07_send_asset_ops.py` | ASA operations: create, config, opt-in, transfer, freeze, clawback, destroy | +| `08_send_app_ops.py` | Application operations: create, update, call, opt-in, close-out, delete | +| `09_create_transaction.py` | Create unsigned transactions for inspection and custom signing workflows | +| `10_transaction_composer.py` | Build atomic transaction groups with `new_group()`, `simulate()`, `send()` | +| `11_asset_manager.py` | Query assets and perform bulk opt-in/opt-out operations | +| `12_app_manager.py` | Query app info, global/local state, box storage, compile TEAL | +| `13_app_deployer.py` | Idempotent app deployment with update/replace strategies | +| `14_client_manager.py` | Access raw algod/indexer/kmd clients and typed app clients | +| `15_error_transformers.py` | Register custom error transformers for enhanced debugging | + +### Common (`common/`) + +Utility functions and helpers. No LocalNet required. + +| File | Description | +| ------------------------ | ------------------------------------------------------ | +| `01_address_basics.py` | Parse, validate, and compare addresses | +| `02_address_encoding.py` | Encode/decode addresses, compute application addresses | +| `03_array_utilities.py` | Compare and concatenate byte arrays | +| `04_constants.py` | Protocol constants (limits, sizes, separators) | +| `05_crypto_hash.py` | SHA-512/256 hashing for transaction IDs and checksums | +| `06_logger.py` | Logger interface for consistent SDK logging | +| `07_json_bigint.py` | Parse/stringify JSON with large integer support | +| `08_msgpack.py` | MessagePack encoding for transaction serialization | +| `09_primitive_codecs.py` | Codecs for numbers, strings, bytes, addresses | +| `10_composite_codecs.py` | Array, Map, and Record codecs | +| `11_model_codecs.py` | Object model codecs with field metadata | +| `12_sourcemap.py` | Map TEAL program counters to source locations | + +### Indexer Client (`indexer_client/`) + +Blockchain data queries using the IndexerClient. + +| File | Description | +| ---------------------------- | ----------------------------------------------- | +| `01_health_check.py` | Check indexer health status | +| `02_account_lookup.py` | Lookup and search accounts | +| `03_account_assets.py` | Query account asset holdings and created assets | +| `04_account_applications.py` | Query account app relationships and local state | +| `05_account_transactions.py` | Get account transaction history | +| `06_transaction_lookup.py` | Lookup single transaction by ID | +| `07_transaction_search.py` | Search transactions with filters | +| `08_asset_lookup.py` | Lookup and search assets | +| `09_asset_balances.py` | Get all holders of an asset | +| `10_asset_transactions.py` | Get transactions for a specific asset | +| `11_application_lookup.py` | Lookup and search applications | +| `12_application_logs.py` | Query application log emissions | +| `13_application_boxes.py` | Search application box storage | +| `14_block_lookup.py` | Lookup block information | +| `15_block_headers.py` | Search block headers | +| `16_pagination.py` | Handle pagination with limit/next parameters | + +### KMD Client (`kmd_client/`) + +Key Management Daemon operations for wallet and key management. + +| File | Description | +| -------------------------------- | -------------------------------------------------- | +| `01_version.py` | Get KMD server version information | +| `02_wallet_management.py` | Create, list, rename, and get wallet info | +| `03_wallet_sessions.py` | Manage wallet handle tokens (init, renew, release) | +| `04_key_generation.py` | Generate deterministic keys in a wallet | +| `05_key_import_export.py` | Import external keys and export private keys | +| `06_key_listing_deletion.py` | List and delete keys from a wallet | +| `07_master_key_export.py` | Export master derivation key for backup | +| `08_multisig_setup.py` | Create multisig accounts with M-of-N threshold | +| `09_multisig_management.py` | List, export, and delete multisig accounts | +| `10_transaction_signing.py` | Sign transactions using wallet keys | +| `11_multisig_signing.py` | Sign multisig transactions (partial + complete) | +| `12_program_signing.py` | Create delegated logic signatures | +| `13_multisig_program_signing.py` | Create delegated multisig logic signatures | + +### Signing (`signing/`) + +Secure secret management and external KMS signing for production-grade security. + +| File | Description | +| ---------------------------- | -------------------------------------------------------------- | +| `01_ed25519_from_keyring.py` | Store and sign with Ed25519 seed from OS keyring | +| `02_hd_from_keyring.py` | Store and sign with HD extended private key from keyring | +| `03_aws_kms.py` | Sign transactions using AWS KMS (with mock client for testing) | + +### Transact (`transact/`) + +Low-level transaction construction and signing. + +| File | Description | +| --------------------------- | ------------------------------------------------ | +| `01_payment_transaction.py` | Send ALGO between accounts | +| `02_payment_close.py` | Close account by transferring all remaining ALGO | +| `03_asset_create.py` | Create Algorand Standard Assets (ASA) | +| `04_asset_transfer.py` | Opt-in and transfer assets between accounts | +| `05_asset_freeze.py` | Freeze and unfreeze asset holdings | +| `06_asset_clawback.py` | Clawback assets using clawback address | +| `07_atomic_group.py` | Group transactions atomically (all-or-nothing) | +| `08_atomic_swap.py` | Swap ALGO for ASA between two parties | +| `09_single_sig.py` | Create ed25519 keypairs and sign transactions | +| `10_multisig.py` | Create and use 2-of-3 multisig accounts | +| `11_logic_sig.py` | Use logic signatures to authorize transactions | +| `12_fee_calculation.py` | Estimate size and calculate transaction fees | +| `13_encoding_decoding.py` | Serialize/deserialize transactions to msgpack | +| `14_app_call.py` | Deploy and interact with smart contracts | + +## Shared Utilities + +The `shared/` directory contains common utilities: + +- **`utils.py`** - Helper functions for client creation, account management, formatting, and common operations +- **`constants.py`** - LocalNet configuration (servers, ports, tokens) +- **`artifacts/`** - TEAL smart contract files for testing + +## Development + +### Adding New Examples + +1. Create a file following naming: `NN_descriptive_name.py` +2. Add a docstring header describing the example +3. Add to the category's `verify-all.sh` script + +### Example Header Format + +```python +""" +Example: [Title] + +This example demonstrates [description]. +- Key operation 1 +- Key operation 2 + +Prerequisites: +- LocalNet running (or "No LocalNet required") +""" +``` + +### Running Tests + +```bash +# Run all verification scripts (from examples/) +./verify-all.sh +``` + +## License + +MIT - see [LICENSE](../LICENSE) for details. diff --git a/examples/abi/01_type_parsing.py b/examples/abi/01_type_parsing.py new file mode 100644 index 00000000..db1e6add --- /dev/null +++ b/examples/abi/01_type_parsing.py @@ -0,0 +1,191 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: ABI Type Parsing + +This example demonstrates how to parse ABI type strings into type objects using ABIType.from_string(). +It shows parsing of: +- Primitive types: uint8, uint64, uint256, bool, byte, address, string +- Array types: uint64[], byte[32], address[5] +- Tuple types: (uint64,address), (bool,string,uint256) + +And demonstrates type properties and isinstance checks for type category detection. + +No LocalNet required - pure ABI encoding/decoding +""" + +from shared import print_header, print_info, print_step, print_success + +from algokit_abi import abi + + +def main() -> None: + print_header("ABI Type Parsing Example") + + # Step 1: Parse primitive unsigned integer types + print_step(1, "Parse Unsigned Integer Types") + + uint8_type = abi.ABIType.from_string("uint8") + uint64_type = abi.ABIType.from_string("uint64") + uint256_type = abi.ABIType.from_string("uint256") + + print_info(f"Parsed 'uint8': {uint8_type}") + print_info(f"Parsed 'uint64': {uint64_type}") + print_info(f"Parsed 'uint256': {uint256_type}") + + # Show uint-specific properties + if isinstance(uint8_type, abi.UintType): + print_info(f" uint8 bit_size: {uint8_type.bit_size}") + print_info(f" uint8 byte_len: {uint8_type.byte_len()}") + print_info(f" uint8 is_dynamic: {uint8_type.is_dynamic()}") + if isinstance(uint64_type, abi.UintType): + print_info(f" uint64 bit_size: {uint64_type.bit_size}") + print_info(f" uint64 byte_len: {uint64_type.byte_len()}") + if isinstance(uint256_type, abi.UintType): + print_info(f" uint256 bit_size: {uint256_type.bit_size}") + print_info(f" uint256 byte_len: {uint256_type.byte_len()}") + + # Step 2: Parse other primitive types + print_step(2, "Parse Other Primitive Types") + + bool_type = abi.ABIType.from_string("bool") + byte_type = abi.ABIType.from_string("byte") + address_type = abi.ABIType.from_string("address") + string_type = abi.ABIType.from_string("string") + + print_info(f"Parsed 'bool': {bool_type}") + print_info(f" bool byte_len: {bool_type.byte_len()}") + print_info(f" bool is_dynamic: {bool_type.is_dynamic()}") + + print_info(f"Parsed 'byte': {byte_type}") + print_info(f" byte byte_len: {byte_type.byte_len()}") + print_info(f" byte is_dynamic: {byte_type.is_dynamic()}") + + print_info(f"Parsed 'address': {address_type}") + print_info(f" address byte_len: {address_type.byte_len()}") + print_info(f" address is_dynamic: {address_type.is_dynamic()}") + + print_info(f"Parsed 'string': {string_type}") + print_info(f" string is_dynamic: {string_type.is_dynamic()}") + + # Step 3: Parse dynamic array types + print_step(3, "Parse Dynamic Array Types") + + uint64_array_type = abi.ABIType.from_string("uint64[]") + address_array_type = abi.ABIType.from_string("address[]") + + print_info(f"Parsed 'uint64[]': {uint64_array_type}") + if isinstance(uint64_array_type, abi.DynamicArrayType): + print_info(f" element: {uint64_array_type.element}") + print_info(f" is_dynamic: {uint64_array_type.is_dynamic()}") + + print_info(f"Parsed 'address[]': {address_array_type}") + if isinstance(address_array_type, abi.DynamicArrayType): + print_info(f" element: {address_array_type.element}") + + # Step 4: Parse static array types + print_step(4, "Parse Static Array Types") + + byte32_type = abi.ABIType.from_string("byte[32]") + address5_type = abi.ABIType.from_string("address[5]") + + print_info(f"Parsed 'byte[32]': {byte32_type}") + if isinstance(byte32_type, abi.StaticArrayType): + print_info(f" element: {byte32_type.element}") + print_info(f" size: {byte32_type.size}") + print_info(f" byte_len: {byte32_type.byte_len()}") + print_info(f" is_dynamic: {byte32_type.is_dynamic()}") + + print_info(f"Parsed 'address[5]': {address5_type}") + if isinstance(address5_type, abi.StaticArrayType): + print_info(f" element: {address5_type.element}") + print_info(f" size: {address5_type.size}") + print_info(f" byte_len: {address5_type.byte_len()}") + + # Step 5: Parse tuple types + print_step(5, "Parse Tuple Types") + + simple_tuple_type = abi.ABIType.from_string("(uint64,address)") + complex_tuple_type = abi.ABIType.from_string("(bool,string,uint256)") + + print_info(f"Parsed '(uint64,address)': {simple_tuple_type}") + if isinstance(simple_tuple_type, abi.TupleType): + print_info(f" elements count: {len(simple_tuple_type.elements)}") + for index, element in enumerate(simple_tuple_type.elements): + print_info(f" [{index}]: {element}") + print_info(f" is_dynamic: {simple_tuple_type.is_dynamic()}") + print_info(f" byte_len: {simple_tuple_type.byte_len()}") + + print_info(f"Parsed '(bool,string,uint256)': {complex_tuple_type}") + if isinstance(complex_tuple_type, abi.TupleType): + print_info(f" elements count: {len(complex_tuple_type.elements)}") + for index, element in enumerate(complex_tuple_type.elements): + print_info(f" [{index}]: {element}") + print_info(f" is_dynamic: {complex_tuple_type.is_dynamic()} (contains 'string' which is dynamic)") + + # Step 6: Parse nested tuple types + print_step(6, "Parse Nested Tuple Types") + + nested_tuple_type = abi.ABIType.from_string("((uint64,bool),address[])") + + print_info(f"Parsed '((uint64,bool),address[])': {nested_tuple_type}") + if isinstance(nested_tuple_type, abi.TupleType): + print_info(f" elements count: {len(nested_tuple_type.elements)}") + for index, element in enumerate(nested_tuple_type.elements): + print_info(f" [{index}]: {element}") + if isinstance(element, abi.TupleType): + for nested_index, nested_element in enumerate(element.elements): + print_info(f" [{nested_index}]: {nested_element}") + print_info(f" is_dynamic: {nested_tuple_type.is_dynamic()}") + + # Step 7: Type category detection using isinstance + print_step(7, "Type Category Detection with isinstance") + + test_types = ["uint64", "bool", "byte", "address", "string", "uint64[]", "byte[32]", "(uint64,address)"] + + for type_str in test_types: + parsed_type = abi.ABIType.from_string(type_str) + category = "Unknown" + + if isinstance(parsed_type, abi.UintType): + category = "UintType" + elif isinstance(parsed_type, abi.BoolType): + category = "BoolType" + elif isinstance(parsed_type, abi.ByteType): + category = "ByteType" + elif isinstance(parsed_type, abi.AddressType): + category = "AddressType" + elif isinstance(parsed_type, abi.StringType): + category = "StringType" + elif isinstance(parsed_type, abi.DynamicArrayType): + category = "DynamicArrayType" + elif isinstance(parsed_type, abi.StaticArrayType): + category = "StaticArrayType" + elif isinstance(parsed_type, abi.TupleType): + category = "TupleType" + + print_info(f"'{type_str}' -> {category}") + + # Step 8: Demonstrate type equality + print_step(8, "Type Equality Comparison") + + type1 = abi.ABIType.from_string("uint64") + type2 = abi.ABIType.from_string("uint64") + type3 = abi.ABIType.from_string("uint32") + + print_info(f"ABIType.from_string('uint64') == ABIType.from_string('uint64'): {type1 == type2}") + print_info(f"ABIType.from_string('uint64') == ABIType.from_string('uint32'): {type1 == type3}") + + tuple1 = abi.ABIType.from_string("(uint64,address)") + tuple2 = abi.ABIType.from_string("(uint64,address)") + tuple3 = abi.ABIType.from_string("(uint64,bool)") + + print_info( + f"ABIType.from_string('(uint64,address)') == ABIType.from_string('(uint64,address)'): {tuple1 == tuple2}" + ) + print_info(f"ABIType.from_string('(uint64,address)') == ABIType.from_string('(uint64,bool)'): {tuple1 == tuple3}") + + print_success("ABI Type Parsing example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/abi/02_primitive_types.py b/examples/abi/02_primitive_types.py new file mode 100644 index 00000000..cd08da1f --- /dev/null +++ b/examples/abi/02_primitive_types.py @@ -0,0 +1,195 @@ +# ruff: noqa: N999, PLR0915, FBT003 +""" +Example: ABI Primitive Types + +This example demonstrates how to encode and decode primitive ABI types: +- UintType: Unsigned integers of various bit sizes (8, 16, 32, 64, 128, 256, 512) +- BoolType: Boolean values encoded as a single byte +- ByteType: Single byte values + +Shows encode() and decode() methods, hex format display, and round-trip verification. + +No LocalNet required - pure ABI encoding/decoding +""" + +from shared import format_hex, print_header, print_info, print_step, print_success + +from algokit_abi import abi + + +def main() -> None: + print_header("ABI Primitive Types Example") + + # Step 1: UintType with various bit sizes + print_step(1, "UintType - Various Bit Sizes") + + uint_sizes = [8, 16, 32, 64, 128, 256, 512] + + for bit_size in uint_sizes: + uint_type = abi.UintType(bit_size) + print_info(f"\n{uint_type}:") + print_info(f" bit_size: {uint_type.bit_size}") + print_info(f" byte_len: {uint_type.byte_len()}") + print_info(f" is_dynamic: {uint_type.is_dynamic()}") + + # Step 2: Encoding and decoding small uint values + print_step(2, "Encoding/Decoding Small Uint Values") + + uint8_type = abi.UintType(8) + uint8_value = 42 + uint8_encoded = uint8_type.encode(uint8_value) + uint8_decoded = uint8_type.decode(uint8_encoded) + + print_info(f"uint8 value: {uint8_value}") + print_info(f" encoded: {format_hex(uint8_encoded)}") + print_info(f" decoded: {uint8_decoded}") + print_info(f" round-trip verified: {uint8_decoded == uint8_value}") + + uint16_type = abi.UintType(16) + uint16_value = 1000 + uint16_encoded = uint16_type.encode(uint16_value) + uint16_decoded = uint16_type.decode(uint16_encoded) + + print_info(f"uint16 value: {uint16_value}") + print_info(f" encoded: {format_hex(uint16_encoded)}") + print_info(f" decoded: {uint16_decoded}") + print_info(f" round-trip verified: {uint16_decoded == uint16_value}") + + uint32_type = abi.UintType(32) + uint32_value = 1_000_000 + uint32_encoded = uint32_type.encode(uint32_value) + uint32_decoded = uint32_type.decode(uint32_encoded) + + print_info(f"uint32 value: {uint32_value}") + print_info(f" encoded: {format_hex(uint32_encoded)}") + print_info(f" decoded: {uint32_decoded}") + print_info(f" round-trip verified: {uint32_decoded == uint32_value}") + + uint64_type = abi.UintType(64) + uint64_value = 9_007_199_254_740_991 # Max safe integer in JavaScript + uint64_encoded = uint64_type.encode(uint64_value) + uint64_decoded = uint64_type.decode(uint64_encoded) + + print_info(f"uint64 value: {uint64_value}") + print_info(f" encoded: {format_hex(uint64_encoded)}") + print_info(f" decoded: {uint64_decoded}") + print_info(f" round-trip verified: {uint64_decoded == uint64_value}") + + # Step 3: Encoding large uint values + print_step(3, "Encoding Large Uint Values") + + uint128_type = abi.UintType(128) + uint128_value = 2**128 - 1 # max uint128 + uint128_encoded = uint128_type.encode(uint128_value) + uint128_decoded = uint128_type.decode(uint128_encoded) + + print_info(f"uint128 max value: {uint128_value}") + print_info(f" encoded: {format_hex(uint128_encoded)}") + print_info(f" decoded: {uint128_decoded}") + print_info(f" round-trip verified: {uint128_decoded == uint128_value}") + + uint256_type = abi.UintType(256) + uint256_value = 2**256 - 1 # max uint256 + uint256_encoded = uint256_type.encode(uint256_value) + uint256_decoded = uint256_type.decode(uint256_encoded) + + print_info(f"uint256 max value: {uint256_value}") + print_info(f" encoded: {format_hex(uint256_encoded)}") + print_info(f" decoded: {uint256_decoded}") + print_info(f" round-trip verified: {uint256_decoded == uint256_value}") + + uint512_type = abi.UintType(512) + uint512_value = 2**512 - 1 # max uint512 + uint512_encoded = uint512_type.encode(uint512_value) + uint512_decoded = uint512_type.decode(uint512_encoded) + + print_info(f"uint512 max value: {uint512_value}") + print_info(f" encoded: {format_hex(uint512_encoded)}") + print_info(f" decoded: {uint512_decoded}") + print_info(f" round-trip verified: {uint512_decoded == uint512_value}") + + # Step 4: BoolType encoding true/false + print_step(4, "BoolType - Encoding Boolean Values") + + bool_type = abi.BoolType() + + print_info(f"bool type: {bool_type}") + print_info(f" byte_len: {bool_type.byte_len()}") + print_info(f" is_dynamic: {bool_type.is_dynamic()}") + + # Encode true + true_encoded = bool_type.encode(True) + true_decoded = bool_type.decode(true_encoded) + + print_info("\nbool value: True") + print_info(f" encoded: {format_hex(true_encoded)}") + print_info(f" decoded: {true_decoded}") + print_info(f" round-trip verified: {true_decoded is True}") + + # Encode false + false_encoded = bool_type.encode(False) + false_decoded = bool_type.decode(false_encoded) + + print_info("\nbool value: False") + print_info(f" encoded: {format_hex(false_encoded)}") + print_info(f" decoded: {false_decoded}") + print_info(f" round-trip verified: {false_decoded is False}") + + # Step 5: ByteType encoding single byte values + print_step(5, "ByteType - Encoding Single Byte Values") + + byte_type = abi.ByteType() + + print_info(f"byte type: {byte_type}") + print_info(f" byte_len: {byte_type.byte_len()}") + print_info(f" is_dynamic: {byte_type.is_dynamic()}") + + # Encode minimum byte value (0) + byte0_value = 0 + byte0_encoded = byte_type.encode(byte0_value) + byte0_decoded = byte_type.decode(byte0_encoded) + + print_info(f"\nbyte value: {byte0_value} (0x00)") + print_info(f" encoded: {format_hex(byte0_encoded)}") + print_info(f" decoded: {format_hex(byte0_decoded)}") + print_info(f" round-trip verified: {byte0_decoded == bytes([byte0_value])}") + + # Encode a middle byte value (127) + byte127_value = 127 + byte127_encoded = byte_type.encode(byte127_value) + byte127_decoded = byte_type.decode(byte127_encoded) + + print_info(f"\nbyte value: {byte127_value} (0x7F)") + print_info(f" encoded: {format_hex(byte127_encoded)}") + print_info(f" decoded: {format_hex(byte127_decoded)}") + print_info(f" round-trip verified: {byte127_decoded == bytes([byte127_value])}") + + # Encode maximum byte value (255) + byte255_value = 255 + byte255_encoded = byte_type.encode(byte255_value) + byte255_decoded = byte_type.decode(byte255_encoded) + + print_info(f"\nbyte value: {byte255_value} (0xFF)") + print_info(f" encoded: {format_hex(byte255_encoded)}") + print_info(f" decoded: {format_hex(byte255_decoded)}") + print_info(f" round-trip verified: {byte255_decoded == bytes([byte255_value])}") + + # Step 6: Summary of encoded byte lengths + print_step(6, "Summary - Encoded Byte Lengths") + + print_info("Primitive type byte lengths:") + print_info(f" uint8: {abi.UintType(8).byte_len()} byte") + print_info(f" uint16: {abi.UintType(16).byte_len()} bytes") + print_info(f" uint32: {abi.UintType(32).byte_len()} bytes") + print_info(f" uint64: {abi.UintType(64).byte_len()} bytes") + print_info(f" uint128: {abi.UintType(128).byte_len()} bytes") + print_info(f" uint256: {abi.UintType(256).byte_len()} bytes") + print_info(f" uint512: {abi.UintType(512).byte_len()} bytes") + print_info(f" bool: {abi.BoolType().byte_len()} byte") + print_info(f" byte: {abi.ByteType().byte_len()} byte") + + print_success("ABI Primitive Types example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/abi/03_address_type.py b/examples/abi/03_address_type.py new file mode 100644 index 00000000..75b2b0b0 --- /dev/null +++ b/examples/abi/03_address_type.py @@ -0,0 +1,196 @@ +# ruff: noqa: N999, PLR0915 +""" +Example: ABI Address Type + +This example demonstrates how to encode and decode Algorand addresses using AddressType: +- Encoding address strings (base32 format) to 32 bytes +- Encoding raw 32-byte public key (bytes) +- Decoding bytes back to address string +- Verifying address encoding is exactly 32 bytes (no length prefix) +- Understanding relationship between Algorand address and public key bytes + +Algorand addresses are 58 characters in base32 encoding, which includes: +- 32 bytes of public key +- 4 bytes of checksum (computed from public key) + +The ABI encoding is just the raw 32-byte public key without checksum. + +No LocalNet required - pure ABI encoding/decoding +""" + +from shared import format_bytes, format_hex, print_header, print_info, print_step, print_success + +from algokit_abi import abi +from algokit_common import address_from_public_key, public_key_from_address +from algokit_common.constants import ZERO_ADDRESS + + +def main() -> None: + print_header("ABI Address Type Example") + + # Step 1: Create AddressType and inspect properties + print_step(1, "AddressType Properties") + + address_type = abi.AddressType() + + print_info(f"Type name: {address_type}") + print_info(f"Byte length: {address_type.byte_len()} bytes") + print_info(f"Is dynamic: {address_type.is_dynamic()}") + + # Step 2: Encode a base32 address string to bytes + print_step(2, "Encode Address String (Base32) to Bytes") + + # Example address - the zero address + zero_address_string = ZERO_ADDRESS + print_info(f"Zero address string: {zero_address_string}") + print_info(f"Address string length: {len(zero_address_string)} characters") + + zero_encoded = address_type.encode(zero_address_string) + print_info(f"Encoded bytes: {format_hex(zero_encoded)}") + print_info(f"Encoded length: {len(zero_encoded)} bytes (exactly 32, no length prefix)") + + # Verify the zero address encodes to all zeros + all_zeros = all(byte == 0 for byte in zero_encoded) + print_info(f"All bytes are zero: {all_zeros}") + + # Step 3: Encode another address string + print_step(3, "Encode a Real Address String") + + # Create a sample address from a known public key (32 bytes of incrementing values) + sample_public_key = bytes(range(32)) + + # Create Address string from public key + sample_address_string = address_from_public_key(sample_public_key) + + print_info(f"Sample address string: {sample_address_string}") + print_info(f"Address string length: {len(sample_address_string)} characters") + + sample_encoded = address_type.encode(sample_address_string) + print_info(f"Encoded bytes: {format_bytes(sample_encoded, 16)}") + print_info(f"Encoded as hex: {format_hex(sample_encoded)}") + print_info(f"Encoded length: {len(sample_encoded)} bytes") + + # Step 4: Encode from raw 32-byte public key (bytes) + print_step(4, "Encode from Raw 32-Byte Public Key") + + # AddressType can also encode directly from bytes + raw_public_key = bytes( + [ + 0xAB, + 0xCD, + 0xEF, + 0x01, + 0x23, + 0x45, + 0x67, + 0x89, + 0xAB, + 0xCD, + 0xEF, + 0x01, + 0x23, + 0x45, + 0x67, + 0x89, + 0xAB, + 0xCD, + 0xEF, + 0x01, + 0x23, + 0x45, + 0x67, + 0x89, + 0xAB, + 0xCD, + 0xEF, + 0x01, + 0x23, + 0x45, + 0x67, + 0x89, + ] + ) + + print_info(f"Raw public key: {format_hex(raw_public_key)}") + + encoded_from_raw = address_type.encode(raw_public_key) + print_info(f"Encoded from raw: {format_hex(encoded_from_raw)}") + + # Verify encoding from raw bytes returns the same bytes + raw_bytes_match = encoded_from_raw == raw_public_key + print_info(f"Raw bytes match encoded: {raw_bytes_match}") + + # Step 5: Decode bytes back to address string + print_step(5, "Decode Bytes Back to Address String") + + # Decode the sample encoded bytes back to address string + decoded_sample_address = address_type.decode(sample_encoded) + print_info(f"Original address: {sample_address_string}") + print_info(f"Decoded address: {decoded_sample_address}") + print_info(f"Round-trip verified: {decoded_sample_address == sample_address_string}") + + # Decode zero address + decoded_zero_address = address_type.decode(zero_encoded) + print_info(f"\nOriginal zero address: {zero_address_string}") + print_info(f"Decoded zero address: {decoded_zero_address}") + print_info(f"Round-trip verified: {decoded_zero_address == zero_address_string}") + + # Decode the raw public key + decoded_from_raw_address = address_type.decode(encoded_from_raw) + print_info(f"\nRaw public key as address: {decoded_from_raw_address}") + + # Step 6: Relationship between Algorand address and public key bytes + print_step(6, "Address vs Public Key Relationship") + + print_info("Algorand address format:") + print_info(" - Base32 encoded string") + print_info(" - 58 characters long") + print_info(" - Contains: 32-byte public key + 4-byte checksum") + + print_info("\nABI address encoding:") + print_info(" - Just the raw 32-byte public key") + print_info(" - No checksum included") + print_info(" - No length prefix (unlike ABI string type)") + print_info(" - Fixed size, not dynamic") + + # Demonstrate using public_key_from_address directly + print_info("\nUsing public_key_from_address:") + public_key = public_key_from_address(sample_address_string) + print_info(f" public_key_from_address('{sample_address_string[:20]}...')") + print_info(f" public_key: {format_bytes(public_key, 8)}") + print_info(f" address_from_public_key(): {address_from_public_key(public_key)}") + + # Show that AddressType encoding equals public_key_from_address + public_key_matches = public_key == sample_encoded + print_info(f"\nABI encoding equals public_key_from_address: {public_key_matches}") + + # Step 7: Encoding bytes directly + print_step(7, "Encode Raw Bytes Directly") + + # AddressType can accept raw bytes (32 bytes) + address_from_bytes = address_type.encode(raw_public_key) + + print_info(f"Raw public key: {format_hex(raw_public_key)}") + print_info(f"Encoded from bytes: {format_hex(address_from_bytes)}") + + bytes_match = address_from_bytes == raw_public_key + print_info(f"Encoding matches raw public key: {bytes_match}") + + # Step 8: Summary - all encoding methods produce 32 bytes + print_step(8, "Summary - All Encoding Methods") + + print_info("AddressType accepts:") + print_info(" 1. Address string (base32 format, 58 chars) -> extracts public key") + print_info(" 2. bytes (32 bytes) -> uses directly") + + print_info("\nAll methods produce exactly 32 bytes (no length prefix):") + print_info(f" From string: {len(address_type.encode(sample_address_string))} bytes") + print_info(f" From bytes: {len(address_type.encode(raw_public_key))} bytes") + + print_info("\nDecode always returns base32 address string (58 chars)") + + print_success("ABI Address Type example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/abi/04_string_type.py b/examples/abi/04_string_type.py new file mode 100644 index 00000000..8013a668 --- /dev/null +++ b/examples/abi/04_string_type.py @@ -0,0 +1,156 @@ +# ruff: noqa: N999, PLR0915 +""" +Example: ABI String Type + +This example demonstrates how to encode and decode dynamic strings using StringType: +- StringType encodes strings with a 2-byte length prefix followed by UTF-8 content +- Shows encoding of empty strings, ASCII text, and Unicode characters +- Demonstrates that strings are dynamic types (variable length) +- Displays byte breakdown: length prefix vs content bytes + +No LocalNet required - pure ABI encoding/decoding +""" + +from shared import format_hex, print_header, print_info, print_step, print_success + +from algokit_abi import abi + + +def main() -> None: + print_header("ABI String Type Example") + + # Step 1: StringType basics + print_step(1, "StringType - Basic Properties") + + string_type = abi.StringType() + + print_info(f"type: {string_type}") + print_info(f"is_dynamic: {string_type.is_dynamic()}") + print_info("Note: Strings are dynamic types - their encoded length varies with content") + + # Step 2: Encoding an empty string + print_step(2, "Encoding Empty String") + + empty_string = "" + empty_encoded = string_type.encode(empty_string) + empty_decoded = string_type.decode(empty_encoded) + + print_info('string value: "" (empty)') + print_info(f" encoded: {format_hex(empty_encoded)}") + print_info(f" total bytes: {len(empty_encoded)}") + length_prefix = (empty_encoded[0] << 8) | empty_encoded[1] + print_info(f" length prefix (2 bytes): {format_hex(empty_encoded[:2])} = {length_prefix}") + print_info(f" content bytes: {len(empty_encoded) - 2}") + print_info(f' decoded: "{empty_decoded}"') + print_info(f" round-trip verified: {empty_decoded == empty_string}") + + # Step 3: Encoding a short ASCII string + print_step(3, "Encoding Short ASCII String") + + hello_string = "Hello" + hello_encoded = string_type.encode(hello_string) + hello_decoded = string_type.decode(hello_encoded) + + print_info(f'string value: "{hello_string}"') + print_info(f" encoded: {format_hex(hello_encoded)}") + print_info(f" total bytes: {len(hello_encoded)}") + length_prefix = (hello_encoded[0] << 8) | hello_encoded[1] + print_info(f" length prefix (2 bytes): {format_hex(hello_encoded[:2])} = {length_prefix}") + print_info(f" content bytes: {len(hello_encoded) - 2}") + + # Show individual character encoding + print_info("\n Byte breakdown:") + print_info(f" [0-1] Length prefix: {format_hex(hello_encoded[:2])} ({len(hello_string)})") + for i, char in enumerate(hello_string): + char_byte = hello_encoded[i + 2] + print_info(f" [{i + 2}] '{char}' -> 0x{char_byte:02x} ({char_byte})") + + print_info(f'\n decoded: "{hello_decoded}"') + print_info(f" round-trip verified: {hello_decoded == hello_string}") + + # Step 4: Encoding a longer ASCII string + print_step(4, "Encoding Longer ASCII String") + + lorem_string = "The quick brown fox jumps over the lazy dog." + lorem_encoded = string_type.encode(lorem_string) + lorem_decoded = string_type.decode(lorem_encoded) + + print_info(f'string value: "{lorem_string}"') + print_info(f" encoded: {format_hex(lorem_encoded)}") + print_info(f" total bytes: {len(lorem_encoded)}") + length_prefix = (lorem_encoded[0] << 8) | lorem_encoded[1] + print_info(f" length prefix (2 bytes): {format_hex(lorem_encoded[:2])} = {length_prefix}") + print_info(f" content bytes: {len(lorem_encoded) - 2}") + print_info(f' decoded: "{lorem_decoded}"') + print_info(f" round-trip verified: {lorem_decoded == lorem_string}") + + # Step 5: Encoding Unicode characters + print_step(5, "Encoding Unicode Characters") + + unicode_string = "Hello, 世界! 🌍" + unicode_encoded = string_type.encode(unicode_string) + unicode_decoded = string_type.decode(unicode_encoded) + + print_info(f'string value: "{unicode_string}"') + print_info(f" encoded: {format_hex(unicode_encoded)}") + print_info(f" total bytes: {len(unicode_encoded)}") + length_prefix = (unicode_encoded[0] << 8) | unicode_encoded[1] + print_info(f" length prefix (2 bytes): {format_hex(unicode_encoded[:2])} = {length_prefix}") + print_info(f" content bytes: {len(unicode_encoded) - 2}") + print_info(f" Python string length: {len(unicode_string)} (characters)") + print_info(f" UTF-8 byte length: {len(unicode_encoded) - 2} (bytes)") + print_info(" Note: Unicode characters may use multiple bytes in UTF-8 encoding") + print_info(f' decoded: "{unicode_decoded}"') + print_info(f" round-trip verified: {unicode_decoded == unicode_string}") + + # Step 6: Encoding emoji-only string + print_step(6, "Encoding Emoji String") + + emoji_string = "🚀🎉💻" + emoji_encoded = string_type.encode(emoji_string) + emoji_decoded = string_type.decode(emoji_encoded) + + print_info(f'string value: "{emoji_string}"') + print_info(f" encoded: {format_hex(emoji_encoded)}") + print_info(f" total bytes: {len(emoji_encoded)}") + length_prefix = (emoji_encoded[0] << 8) | emoji_encoded[1] + print_info(f" length prefix (2 bytes): {format_hex(emoji_encoded[:2])} = {length_prefix}") + print_info(f" content bytes: {len(emoji_encoded) - 2}") + print_info(f" Python string length: {len(emoji_string)} (characters)") + print_info(f" UTF-8 byte length: {len(emoji_encoded) - 2} (bytes, emojis use 4 bytes each)") + print_info(f' decoded: "{emoji_decoded}"') + print_info(f" round-trip verified: {emoji_decoded == emoji_string}") + + # Step 7: Maximum length demonstration + print_step(7, "String Length Limits") + + print_info("String encoding uses a 2-byte (uint16) length prefix:") + print_info(" Maximum string length: 65535 bytes (2^16 - 1)") + print_info(" Length prefix is big-endian encoded") + + # Demonstrate a string that would have a length > 255 (requiring both bytes) + long_string = "A" * 300 + long_encoded = string_type.encode(long_string) + + print_info("\nExample with 300-character string:") + print_info(f" length prefix: {format_hex(long_encoded[:2])}") + print_info(f" high byte: 0x{long_encoded[0]:02x} = {long_encoded[0]}") + print_info(f" low byte: 0x{long_encoded[1]:02x} = {long_encoded[1]}") + decoded_length = (long_encoded[0] << 8) | long_encoded[1] + print_info(f" decoded length: ({long_encoded[0]} << 8) | {long_encoded[1]} = {decoded_length}") + + # Step 8: Summary + print_step(8, "Summary - Dynamic Type Behavior") + + print_info("Key points about StringType:") + print_info(" - Strings are dynamic types (is_dynamic() returns True)") + print_info(" - Encoding format: 2-byte length prefix + UTF-8 content") + print_info(" - Length prefix is big-endian (most significant byte first)") + print_info(" - UTF-8 encoding means characters may use 1-4 bytes") + print_info(" - Maximum string length: 65535 bytes") + + print_success("ABI String Type example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/abi/05_static_array.py b/examples/abi/05_static_array.py new file mode 100644 index 00000000..69554c73 --- /dev/null +++ b/examples/abi/05_static_array.py @@ -0,0 +1,269 @@ +# ruff: noqa: N999, C901, PLR0915 +""" +Example: ABI Static Array Type + +This example demonstrates how to encode and decode fixed-length arrays using StaticArrayType: +- byte[32]: Fixed 32 bytes, common for hashes and cryptographic data +- uint64[3]: Fixed array of 3 unsigned 64-bit integers +- address[2]: Fixed array of 2 Algorand addresses + +Key characteristics of static arrays: +- Fixed length known at compile time +- No length prefix in encoding (unlike dynamic arrays) +- Elements are encoded consecutively +- Encoded length = elementSize * arrayLength + +No LocalNet required - pure ABI encoding/decoding +""" + +from shared import format_bytes, format_hex, print_header, print_info, print_step, print_success + +from algokit_abi import abi +from algokit_common import address_from_public_key + + +def main() -> None: + print_header("ABI Static Array Type Example") + + # Step 1: Create StaticArrayType and inspect properties + print_step(1, "StaticArrayType Properties") + + byte32_type = abi.ABIType.from_string("byte[32]") + uint64x3_type = abi.ABIType.from_string("uint64[3]") + address2_type = abi.ABIType.from_string("address[2]") + + print_info("byte[32]:") + print_info(f" str(): {byte32_type}") + if isinstance(byte32_type, abi.StaticArrayType): + print_info(f" element: {byte32_type.element}") + print_info(f" size: {byte32_type.size}") + print_info(f" byte_len(): {byte32_type.byte_len()}") + print_info(f" is_dynamic(): {byte32_type.is_dynamic()}") + + print_info("\nuint64[3]:") + print_info(f" str(): {uint64x3_type}") + if isinstance(uint64x3_type, abi.StaticArrayType): + print_info(f" element: {uint64x3_type.element}") + print_info(f" size: {uint64x3_type.size}") + print_info(f" byte_len(): {uint64x3_type.byte_len()}") + print_info(f" is_dynamic(): {uint64x3_type.is_dynamic()}") + + print_info("\naddress[2]:") + print_info(f" str(): {address2_type}") + if isinstance(address2_type, abi.StaticArrayType): + print_info(f" element: {address2_type.element}") + print_info(f" size: {address2_type.size}") + print_info(f" byte_len(): {address2_type.byte_len()}") + print_info(f" is_dynamic(): {address2_type.is_dynamic()}") + + # Step 2: byte[32] encoding - common for hashes + print_step(2, "byte[32] Encoding - Common for Hashes") + + # Simulate a SHA-256 hash (32 bytes) + hash_bytes = bytes(i * 8 for i in range(32)) # 0x00, 0x08, 0x10, 0x18, ... + + # Encode as array of individual byte values + hash_values = list(hash_bytes) + + if isinstance(byte32_type, abi.StaticArrayType): + hash_encoded = byte32_type.encode(hash_values) + print_info("Input: array of 32 byte values") + print_info(f" Values: [{', '.join(str(v) for v in hash_values[:8])}, ...]") + print_info(f"Encoded: {format_hex(hash_encoded)}") + print_info(f"Encoded length: {len(hash_encoded)} bytes") + + # Verify encoded length = elementSize * arrayLength + byte_size = abi.ByteType().byte_len() + expected_byte32_len = byte_size * 32 + print_info(f"Expected length (1 byte * 32): {expected_byte32_len} bytes") + print_info(f"Length matches: {len(hash_encoded) == expected_byte32_len}") + + # Decode back + hash_decoded = byte32_type.decode(hash_encoded) + print_info(f"Decoded: {format_bytes(hash_decoded, 8)}") + print_info(f"Round-trip verified: {hash_decoded == hash_bytes}") + + # Step 3: uint64[3] encoding - fixed array of integers + print_step(3, "uint64[3] Encoding - Fixed Array of Integers") + + uint64_values = [1000, 2000, 3000] + + if isinstance(uint64x3_type, abi.StaticArrayType): + uint64x3_encoded = uint64x3_type.encode(uint64_values) + print_info(f"Input: {uint64_values}") + print_info(f"Encoded: {format_hex(uint64x3_encoded)}") + print_info(f"Encoded length: {len(uint64x3_encoded)} bytes") + + # Verify encoded length = elementSize * arrayLength + uint64_size = abi.UintType(64).byte_len() + expected_uint64x3_len = uint64_size * 3 + print_info(f"Expected length (8 bytes * 3): {expected_uint64x3_len} bytes") + print_info(f"Length matches: {len(uint64x3_encoded) == expected_uint64x3_len}") + + # Decode back + uint64_decoded = uint64x3_type.decode(uint64x3_encoded) + print_info(f"Decoded: {list(uint64_decoded)}") + print_info(f"Round-trip verified: {list(uint64_decoded) == uint64_values}") + + # Step 4: address[2] encoding - fixed array of addresses + print_step(4, "address[2] Encoding - Fixed Array of Addresses") + + # Create two sample addresses from public keys + pub_key1 = bytes([0xAA] * 32) + pub_key2 = bytes([0xBB] * 32) + + addr1 = address_from_public_key(pub_key1) + addr2 = address_from_public_key(pub_key2) + + address_values = [addr1, addr2] + + if isinstance(address2_type, abi.StaticArrayType): + address2_encoded = address2_type.encode(address_values) + print_info("Input addresses:") + print_info(f" [0]: {address_values[0]}") + print_info(f" [1]: {address_values[1]}") + print_info(f"Encoded: {format_bytes(address2_encoded, 16)}") + print_info(f"Encoded length: {len(address2_encoded)} bytes") + + # Verify encoded length = elementSize * arrayLength + address_size = abi.AddressType().byte_len() + expected_address2_len = address_size * 2 + print_info(f"Expected length (32 bytes * 2): {expected_address2_len} bytes") + print_info(f"Length matches: {len(address2_encoded) == expected_address2_len}") + + # Decode back + address_decoded = address2_type.decode(address2_encoded) + print_info("Decoded:") + print_info(f" [0]: {address_decoded[0]}") + print_info(f" [1]: {address_decoded[1]}") + print_info(f"Round-trip verified: {list(address_decoded) == address_values}") + + # Step 5: Demonstrate no length prefix + print_step(5, "Static Arrays Have No Length Prefix") + + print_info("Static arrays encode directly WITHOUT a length prefix:") + print_info(" - The length is known from the type definition") + print_info(" - All bytes are element data, none for length") + + # Show contrast with what a dynamic array would look like + single_uint64 = abi.UintType(64) + value1000 = single_uint64.encode(1000) + value2000 = single_uint64.encode(2000) + value3000 = single_uint64.encode(3000) + + print_info("\nCompare single uint64 encodings:") + print_info(f" 1000: {format_hex(value1000)} (8 bytes)") + print_info(f" 2000: {format_hex(value2000)} (8 bytes)") + print_info(f" 3000: {format_hex(value3000)} (8 bytes)") + + if isinstance(uint64x3_type, abi.StaticArrayType): + print_info("\nuint64[3] encoding is just these concatenated (no prefix):") + print_info(f" {format_hex(uint64x3_encoded)} (24 bytes)") + + # Verify the encoding is just concatenated elements + concatenated = value1000 + value2000 + value3000 + matches_concatenated = uint64x3_encoded == concatenated + print_info(f"Matches concatenation: {matches_concatenated}") + + # Step 6: Elements encoded consecutively + print_step(6, "Elements Are Encoded Consecutively") + + if isinstance(uint64x3_type, abi.StaticArrayType): + print_info("Each element occupies a fixed position:") + print_info(f" Element 0: bytes 0-7 ({format_hex(uint64x3_encoded[0:8])})") + print_info(f" Element 1: bytes 8-15 ({format_hex(uint64x3_encoded[8:16])})") + print_info(f" Element 2: bytes 16-23 ({format_hex(uint64x3_encoded[16:24])})") + + if isinstance(address2_type, abi.StaticArrayType): + print_info("\nFor address[2]:") + print_info(" Element 0: bytes 0-31 (first 32 bytes = address 1)") + print_info(" Element 1: bytes 32-63 (next 32 bytes = address 2)") + + # Extract individual elements from the encoded address array + extracted_addr1 = abi.AddressType().decode(address2_encoded[0:32]) + extracted_addr2 = abi.AddressType().decode(address2_encoded[32:64]) + + print_info("\nExtracted from encoded bytes:") + print_info(f" bytes[0:32] decoded: {extracted_addr1}") + print_info(f" bytes[32:64] decoded: {extracted_addr2}") + print_info( + f" Matches originals: {extracted_addr1 == address_values[0] and extracted_addr2 == address_values[1]}" + ) + + # Step 7: Verify encoded length formula + print_step(7, "Encoded Length Formula: elementSize * arrayLength") + + # Note: bool arrays have special packing - 8 bools fit in 1 byte + # So we exclude bool from the simple formula test + test_cases = [ + ("byte[16]", 1, 16), + ("byte[32]", 1, 32), + ("byte[64]", 1, 64), + ("uint8[10]", 1, 10), + ("uint16[5]", 2, 5), + ("uint32[4]", 4, 4), + ("uint64[3]", 8, 3), + ("uint128[2]", 16, 2), + ("uint256[2]", 32, 2), + ("address[3]", 32, 3), + ] + + print_info("Type | Element Size | Array Length | Expected | Actual") + print_info("--------------|--------------|--------------|----------|-------") + + for type_str, element_size, array_length in test_cases: + parsed_type = abi.ABIType.from_string(type_str) + expected_len = element_size * array_length + actual_len = parsed_type.byte_len() + match = "OK" if expected_len == actual_len else "MISMATCH" + + print_info( + f"{type_str:<13} | {element_size:<12} | {array_length:<12} | {expected_len:<8} | {actual_len} {match}" + ) + + # Step 8: Creating StaticArrayType programmatically + print_step(8, "Creating StaticArrayType Programmatically") + + # You can also create static array types directly with the constructor + custom_array_type = abi.StaticArrayType(abi.UintType(32), 5) + + print_info("Created with: StaticArrayType(UintType(32), 5)") + print_info(f" str(): {custom_array_type}") + print_info(f" element: {custom_array_type.element}") + print_info(f" size: {custom_array_type.size}") + print_info(f" byte_len(): {custom_array_type.byte_len()}") + + # Encode and decode with custom type + custom_values = [100, 200, 300, 400, 500] + custom_encoded = custom_array_type.encode(custom_values) + custom_decoded = custom_array_type.decode(custom_encoded) + + print_info(f"\nEncode {custom_values}:") + print_info(f" Encoded: {format_hex(custom_encoded)}") + print_info(f" Decoded: {list(custom_decoded)}") + print_info(f" Round-trip verified: {list(custom_decoded) == custom_values}") + + # Step 9: Summary + print_step(9, "Summary") + + print_info("StaticArrayType key properties:") + print_info(" - element: The type of each element") + print_info(" - size: Fixed number of elements") + print_info(" - byte_len(): Returns elementSize * size") + print_info(" - is_dynamic(): Always returns False") + + print_info("\nStatic array encoding characteristics:") + print_info(" - No length prefix (length is in the type)") + print_info(" - Elements encoded consecutively") + print_info(" - Fixed encoded size = elementSize * arrayLength") + print_info(" - Common uses: byte[32] for hashes, address[N] for multi-sig") + + print_info("\nCreating static array types:") + print_info(' - ABIType.from_string("byte[32]") - parse from string') + print_info(" - StaticArrayType(element, size) - programmatic") + + print_success("ABI Static Array Type example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/abi/06_dynamic_array.py b/examples/abi/06_dynamic_array.py new file mode 100644 index 00000000..f1806d6f --- /dev/null +++ b/examples/abi/06_dynamic_array.py @@ -0,0 +1,310 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: ABI Dynamic Array Type + +This example demonstrates how to encode and decode variable-length arrays using DynamicArrayType: +- uint64[]: Dynamic array of unsigned 64-bit integers +- string[]: Dynamic array of strings (nested dynamic types) +- address[]: Dynamic array of Algorand addresses + +Key characteristics of dynamic arrays: +- Variable length determined at runtime +- 2-byte (uint16) length prefix indicating number of elements +- For static element types: elements encoded consecutively after length +- For dynamic element types: head/tail encoding pattern is used + +Head/Tail encoding (for arrays containing dynamic elements): +- Length prefix: 2 bytes indicating number of elements +- Head section: Contains offsets (2 bytes each) pointing to where each element starts in tail +- Tail section: Contains the actual encoded elements + +No LocalNet required - pure ABI encoding/decoding +""" + +from shared import format_bytes, format_hex, print_header, print_info, print_step, print_success + +from algokit_abi import abi +from algokit_common import address_from_public_key + + +def main() -> None: + print_header("ABI Dynamic Array Type Example") + + # Step 1: DynamicArrayType properties + print_step(1, "DynamicArrayType Properties") + + uint64_array_type = abi.ABIType.from_string("uint64[]") + string_array_type = abi.ABIType.from_string("string[]") + address_array_type = abi.ABIType.from_string("address[]") + + print_info("uint64[]:") + print_info(f" str(): {uint64_array_type}") + if isinstance(uint64_array_type, abi.DynamicArrayType): + print_info(f" element: {uint64_array_type.element}") + print_info(f" is_dynamic(): {uint64_array_type.is_dynamic()}") + print_info(f" element.is_dynamic(): {uint64_array_type.element.is_dynamic()}") + + print_info("\nstring[]:") + print_info(f" str(): {string_array_type}") + if isinstance(string_array_type, abi.DynamicArrayType): + print_info(f" element: {string_array_type.element}") + print_info(f" is_dynamic(): {string_array_type.is_dynamic()}") + print_info(f" element.is_dynamic(): {string_array_type.element.is_dynamic()}") + + print_info("\naddress[]:") + print_info(f" str(): {address_array_type}") + if isinstance(address_array_type, abi.DynamicArrayType): + print_info(f" element: {address_array_type.element}") + print_info(f" is_dynamic(): {address_array_type.is_dynamic()}") + print_info(f" element.is_dynamic(): {address_array_type.element.is_dynamic()}") + + # Step 2: uint64[] encoding with static elements + print_step(2, "uint64[] Encoding - Static Element Type") + + uint64_values = [1000, 2000, 3000] + + if isinstance(uint64_array_type, abi.DynamicArrayType): + uint64_encoded = uint64_array_type.encode(uint64_values) + uint64_decoded = list(uint64_array_type.decode(uint64_encoded)) + + print_info(f"Input: {uint64_values}") + print_info(f"Encoded: {format_hex(uint64_encoded)}") + print_info(f"Total bytes: {len(uint64_encoded)}") + + # Break down the encoding + uint64_length_prefix = uint64_encoded[0:2] + uint64_element_data = uint64_encoded[2:] + + print_info("\nByte layout:") + length_value = (uint64_length_prefix[0] << 8) | uint64_length_prefix[1] + print_info(f" [0-1] Length prefix: {format_hex(uint64_length_prefix)} = {length_value} elements") + print_info(f" [2-25] Element data: {format_hex(uint64_element_data)}") + + # Show individual elements + print_info("\nElement breakdown (8 bytes each):") + for i, val in enumerate(uint64_values): + start = 2 + i * 8 + element_bytes = uint64_encoded[start : start + 8] + print_info(f" [{start}-{start + 7}] Element {i}: {format_hex(element_bytes)} = {val}") + + print_info(f"\nDecoded: {uint64_decoded}") + print_info(f"Round-trip verified: {uint64_decoded == uint64_values}") + + # Step 3: Demonstrate 2-byte length prefix + print_step(3, "Length Prefix - 2 Bytes (uint16 Big-Endian)") + + print_info("The length prefix encodes the NUMBER of elements (not byte size)") + print_info("Format: uint16 big-endian (high byte first)") + + # Show different array lengths + test_lengths = [0, 1, 3, 256, 1000] + + if isinstance(uint64_array_type, abi.DynamicArrayType): + for length in test_lengths: + test_array = list(range(length)) + encoded = uint64_array_type.encode(test_array) + prefix = encoded[0:2] + decoded_length = (prefix[0] << 8) | prefix[1] + hex_prefix = format_hex(prefix) + formula = f"({prefix[0]} << 8) | {prefix[1]}" + print_info(f" {length} elements: prefix = {hex_prefix} = {formula} = {decoded_length}") + + # Step 4: string[] encoding - demonstrates head/tail encoding + print_step(4, "string[] Encoding - Head/Tail Pattern") + + string_values = ["Hello", "World", "ABI"] + + if isinstance(string_array_type, abi.DynamicArrayType): + string_encoded = string_array_type.encode(string_values) + string_decoded = list(string_array_type.decode(string_encoded)) + + print_info(f"Input: {string_values}") + print_info(f"Encoded: {format_hex(string_encoded)}") + print_info(f"Total bytes: {len(string_encoded)}") + + # Break down the encoding + string_length_prefix = string_encoded[0:2] + num_elements = (string_length_prefix[0] << 8) | string_length_prefix[1] + + print_info("\nByte layout with head/tail encoding:") + print_info(f" [0-1] Length prefix: {format_hex(string_length_prefix)} = {num_elements} elements") + + # Head section: contains offsets for each element + # Each offset is 2 bytes, offsets are relative to start of array data (after length prefix) + print_info("\n HEAD SECTION (offsets to each element):") + head_start = 2 + head_size = num_elements * 2 # 2 bytes per offset + + for i in range(num_elements): + offset_pos = head_start + i * 2 + offset_bytes = string_encoded[offset_pos : offset_pos + 2] + offset = (offset_bytes[0] << 8) | offset_bytes[1] + target_byte = head_start + offset + hex_offset = format_hex(offset_bytes) + pos_range = f"[{offset_pos}-{offset_pos + 1}]" + print_info(f" {pos_range} Offset {i}: {hex_offset} = {offset} (points to byte {target_byte})") + + # Tail section: contains actual string data + print_info("\n TAIL SECTION (actual string data):") + tail_start = head_start + head_size + + current_pos = tail_start + for i in range(num_elements): + # Read string length prefix (2 bytes) + str_len_bytes = string_encoded[current_pos : current_pos + 2] + str_len = (str_len_bytes[0] << 8) | str_len_bytes[1] + + # Read string content + str_content = string_encoded[current_pos + 2 : current_pos + 2 + str_len] + str_end = current_pos + 2 + str_len - 1 + + print_info(f' [{current_pos}-{str_end}] String {i}: "{string_values[i]}"') + print_info(f" Length prefix: {format_hex(str_len_bytes)} = {str_len} bytes") + print_info(f" Content: {format_hex(str_content)}") + + current_pos += 2 + str_len + + print_info(f"\nDecoded: {string_decoded}") + print_info(f"Round-trip verified: {string_decoded == string_values}") + + # Step 5: Compare encoding of arrays with different lengths + print_step(5, "Dynamic Sizing - Arrays of Different Lengths") + + array_lengths = [0, 1, 3, 5] + + if isinstance(uint64_array_type, abi.DynamicArrayType): + print_info("uint64[] arrays of different lengths:") + for length in array_lengths: + arr = list(range(1, length + 1)) + encoded = uint64_array_type.encode(arr) + expected_bytes = 2 + length * 8 # 2 byte prefix + 8 bytes per element + print_info(f" {length} elements: {len(encoded)} bytes (expected: 2 + {length}*8 = {expected_bytes})") + + if isinstance(string_array_type, abi.DynamicArrayType): + print_info("\nstring[] arrays of different lengths:") + str_arrays: list[list[str]] = [ + [], + ["A"], + ["Hello", "World"], + ["One", "Two", "Three"], + ] + + for arr in str_arrays: + encoded = string_array_type.encode(arr) + # For string[], bytes = 2 (array length) + 2*n (offsets) + sum of (2 + strlen) for each string + offsets_size = len(arr) * 2 + strings_size = sum(2 + len(s.encode("utf-8")) for s in arr) + expected_bytes = 2 + offsets_size + strings_size + print_info(f" {len(arr)} strings {arr}: {len(encoded)} bytes (expected: {expected_bytes})") + + # Step 6: address[] encoding - static element type + print_step(6, "address[] Encoding - Static Element Type") + + # Create sample addresses + pub_key1 = bytes([0x11] * 32) + pub_key2 = bytes([0x22] * 32) + addr1 = address_from_public_key(pub_key1) + addr2 = address_from_public_key(pub_key2) + + address_values = [addr1, addr2] + + if isinstance(address_array_type, abi.DynamicArrayType): + address_encoded = address_array_type.encode(address_values) + address_decoded = list(address_array_type.decode(address_encoded)) + + print_info(f"Input: {len(address_values)} addresses") + print_info(f" [0]: {addr1}") + print_info(f" [1]: {addr2}") + print_info(f"Encoded: {format_bytes(address_encoded, 16)}") + print_info(f"Total bytes: {len(address_encoded)}") + + # Break down encoding + addr_length_prefix = address_encoded[0:2] + print_info("\nByte layout:") + addr_num_elements = (addr_length_prefix[0] << 8) | addr_length_prefix[1] + print_info(f" [0-1] Length prefix: {format_hex(addr_length_prefix)} = {addr_num_elements} elements") + print_info(" [2-33] Address 0: 32 bytes") + print_info(" [34-65] Address 1: 32 bytes") + print_info(f" Expected: 2 + 2*32 = {2 + 2 * 32} bytes") + + print_info("\nDecoded:") + print_info(f" [0]: {address_decoded[0]}") + print_info(f" [1]: {address_decoded[1]}") + print_info(f"Round-trip verified: {address_decoded == address_values}") + + # Step 7: Creating DynamicArrayType programmatically + print_step(7, "Creating DynamicArrayType Programmatically") + + custom_array_type = abi.DynamicArrayType(abi.UintType(32)) + + print_info("Created with: DynamicArrayType(UintType(32))") + print_info(f" str(): {custom_array_type}") + print_info(f" element: {custom_array_type.element}") + print_info(f" is_dynamic(): {custom_array_type.is_dynamic()}") + + custom_values = [100, 200, 300, 400] + custom_encoded = custom_array_type.encode(custom_values) + custom_decoded = list(custom_array_type.decode(custom_encoded)) + + print_info(f"\nEncode {custom_values}:") + print_info(f" Encoded: {format_hex(custom_encoded)}") + print_info(f" Total bytes: {len(custom_encoded)} (2 prefix + 4*4 elements)") + print_info(f" Decoded: {custom_decoded}") + print_info(f" Round-trip verified: {custom_decoded == custom_values}") + + # Step 8: Empty arrays + print_step(8, "Empty Dynamic Arrays") + + if ( + isinstance(uint64_array_type, abi.DynamicArrayType) + and isinstance(string_array_type, abi.DynamicArrayType) + and isinstance(address_array_type, abi.DynamicArrayType) + ): + empty_uint64 = uint64_array_type.encode([]) + empty_string = string_array_type.encode([]) + empty_address = address_array_type.encode([]) + + print_info("Empty arrays encode to just the length prefix (0):") + print_info(f" uint64[]: {format_hex(empty_uint64)} ({len(empty_uint64)} bytes)") + print_info(f" string[]: {format_hex(empty_string)} ({len(empty_string)} bytes)") + print_info(f" address[]: {format_hex(empty_address)} ({len(empty_address)} bytes)") + + # Verify decoding + decoded_empty_uint64 = list(uint64_array_type.decode(empty_uint64)) + decoded_empty_string = list(string_array_type.decode(empty_string)) + + print_info("\nDecoding empty arrays:") + print_info(f" uint64[]: length = {len(decoded_empty_uint64)}") + print_info(f" string[]: length = {len(decoded_empty_string)}") + + # Step 9: Summary + print_step(9, "Summary") + + print_info("DynamicArrayType key properties:") + print_info(" - element: The type of each element") + print_info(" - is_dynamic(): Always returns True") + print_info(' - No "size" property (unlike StaticArrayType)') + + print_info("\nDynamic array encoding format:") + print_info(" - 2-byte length prefix (number of elements, big-endian)") + print_info(" - For static element types: elements encoded consecutively") + print_info(" - For dynamic element types: head/tail encoding") + + print_info("\nHead/Tail encoding (for dynamic elements like string[]):") + print_info(" - Head: array of 2-byte offsets (one per element)") + print_info(" - Tail: actual encoded elements") + print_info(" - Offsets are relative to start of data (after length prefix)") + + print_info("\nEncoded size:") + print_info(" - Static elements: 2 + (elementSize * numElements)") + print_info(" - Dynamic elements: 2 + (2 * numElements) + sum(elementSizes)") + + print_info("\nCreating dynamic array types:") + print_info(' - ABIType.from_string("uint64[]") - parse from string') + print_info(" - DynamicArrayType(element) - programmatic") + + print_success("ABI Dynamic Array Type example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/abi/07_tuple_type.py b/examples/abi/07_tuple_type.py new file mode 100644 index 00000000..b11ce54c --- /dev/null +++ b/examples/abi/07_tuple_type.py @@ -0,0 +1,340 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: ABI Tuple Type + +This example demonstrates how to encode and decode tuples using TupleType: +- Tuples with mixed static types: (uint64,bool,address) +- Tuples with dynamic types: (uint64,string,bool) +- Nested tuples: ((uint64,bool),string) + +Key characteristics of tuple encoding: +- Static-only tuples: all elements encoded consecutively, fixed size +- Tuples with dynamic elements: head/tail encoding pattern + - Head: static values inline + offsets for dynamic values + - Tail: actual data for dynamic elements +- Nested tuples: inner tuples are encoded first, then treated as their component + +ARC-4 specification: Tuples are sequences of types enclosed in parentheses. + +No LocalNet required - pure ABI encoding/decoding +""" + +from shared import format_hex, print_header, print_info, print_step, print_success + +from algokit_abi import abi +from algokit_common import address_from_public_key + + +def main() -> None: + print_header("ABI Tuple Type Example") + + # Step 1: TupleType properties + print_step(1, "TupleType Properties") + + static_tuple_type = abi.ABIType.from_string("(uint64,bool,address)") + dynamic_tuple_type = abi.ABIType.from_string("(uint64,string,bool)") + nested_tuple_type = abi.ABIType.from_string("((uint64,bool),string)") + + print_info("(uint64,bool,address) - all static types:") + print_info(f" str(): {static_tuple_type}") + if isinstance(static_tuple_type, abi.TupleType): + print_info(f" elements length: {len(static_tuple_type.elements)}") + for i, child in enumerate(static_tuple_type.elements): + print_info(f" [{i}]: {child} (is_dynamic: {child.is_dynamic()})") + print_info(f" is_dynamic(): {static_tuple_type.is_dynamic()}") + print_info(f" byte_len(): {static_tuple_type.byte_len()}") + + print_info("\n(uint64,string,bool) - contains dynamic type:") + print_info(f" str(): {dynamic_tuple_type}") + if isinstance(dynamic_tuple_type, abi.TupleType): + print_info(f" elements length: {len(dynamic_tuple_type.elements)}") + for i, child in enumerate(dynamic_tuple_type.elements): + print_info(f" [{i}]: {child} (is_dynamic: {child.is_dynamic()})") + print_info(f" is_dynamic(): {dynamic_tuple_type.is_dynamic()} (because string is dynamic)") + + print_info("\n((uint64,bool),string) - nested tuple with dynamic:") + print_info(f" str(): {nested_tuple_type}") + if isinstance(nested_tuple_type, abi.TupleType): + print_info(f" elements length: {len(nested_tuple_type.elements)}") + for i, child in enumerate(nested_tuple_type.elements): + print_info(f" [{i}]: {child} (is_dynamic: {child.is_dynamic()})") + print_info(f" is_dynamic(): {nested_tuple_type.is_dynamic()}") + + # Step 2: Static tuple encoding - (uint64,bool,address) + print_step(2, "Static Tuple Encoding - (uint64,bool,address)") + + # Create a sample address + pub_key = bytes([0xAB] * 32) + sample_address = address_from_public_key(pub_key) + + static_value = [1000, True, sample_address] + + if isinstance(static_tuple_type, abi.TupleType): + static_encoded = static_tuple_type.encode(static_value) + static_decoded = static_tuple_type.decode(static_encoded) + + print_info(f"Input: [{static_value[0]}, {static_value[1]}, {str(static_value[2])[:10]}...]") + print_info(f"Encoded: {format_hex(static_encoded)}") + print_info(f"Total bytes: {len(static_encoded)}") + + # Break down the encoding + print_info("\nByte layout (all static, no head/tail separation):") + print_info(f" [0-7] uint64: {format_hex(static_encoded[0:8])} = {static_value[0]}") + print_info(f" [8] bool: {format_hex(static_encoded[8:9])} = {static_value[1]} (0x80=true, 0x00=false)") + print_info(f" [9-40] address: {format_hex(static_encoded[9:41])}") + print_info(" Expected size: 8 + 1 + 32 = 41 bytes") + + print_info(f"\nDecoded: [{static_decoded[0]}, {static_decoded[1]}, {str(static_decoded[2])[:10]}...]") + verified = ( + static_decoded[0] == static_value[0] + and static_decoded[1] == static_value[1] + and static_decoded[2] == static_value[2] + ) + print_info(f"Round-trip verified: {verified}") + + # Step 3: Dynamic tuple encoding - (uint64,string,bool) + print_step(3, "Dynamic Tuple Encoding - (uint64,string,bool)") + + dynamic_value = [42, "Hello ABI", False] + + if isinstance(dynamic_tuple_type, abi.TupleType): + dynamic_encoded = dynamic_tuple_type.encode(dynamic_value) + dynamic_decoded = dynamic_tuple_type.decode(dynamic_encoded) + + print_info(f'Input: [{dynamic_value[0]}, "{dynamic_value[1]}", {dynamic_value[2]}]') + print_info(f"Encoded: {format_hex(dynamic_encoded)}") + print_info(f"Total bytes: {len(dynamic_encoded)}") + + print_info("\nHead/Tail encoding pattern:") + print_info("HEAD SECTION (static values + offset for dynamic):") + + # uint64 is static - 8 bytes + print_info(f" [0-7] uint64 (static): {format_hex(dynamic_encoded[0:8])} = {dynamic_value[0]}") + + # string is dynamic - 2-byte offset pointing to tail + string_offset = (dynamic_encoded[8] << 8) | dynamic_encoded[9] + print_info(f" [8-9] string offset: {format_hex(dynamic_encoded[8:10])} = {string_offset} (points to tail)") + + # bool is static - 1 byte + print_info(f" [10] bool (static): {format_hex(dynamic_encoded[10:11])} = {dynamic_value[2]}") + + print_info("\nTAIL SECTION (dynamic value data):") + + # String data starts at the offset + string_len_bytes = dynamic_encoded[string_offset : string_offset + 2] + string_len = (string_len_bytes[0] << 8) | string_len_bytes[1] + string_content_bytes = dynamic_encoded[string_offset + 2 : string_offset + 2 + string_len] + + len_start = string_offset + len_end = string_offset + 1 + content_start = string_offset + 2 + content_end = string_offset + 1 + string_len + hex_len = format_hex(string_len_bytes) + hex_content = format_hex(string_content_bytes) + print_info(f" [{len_start}-{len_end}] string length: {hex_len} = {string_len} bytes") + print_info(f' [{content_start}-{content_end}] string content: {hex_content} = "{dynamic_value[1]}"') + + print_info(f'\nDecoded: [{dynamic_decoded[0]}, "{dynamic_decoded[1]}", {dynamic_decoded[2]}]') + verified = ( + dynamic_decoded[0] == dynamic_value[0] + and dynamic_decoded[1] == dynamic_value[1] + and dynamic_decoded[2] == dynamic_value[2] + ) + print_info(f"Round-trip verified: {verified}") + + # Step 4: Nested tuple encoding - ((uint64,bool),string) + print_step(4, "Nested Tuple Encoding - ((uint64,bool),string)") + + nested_value = [[999, True], "Nested!"] + + if isinstance(nested_tuple_type, abi.TupleType): + nested_encoded = nested_tuple_type.encode(nested_value) + nested_decoded = nested_tuple_type.decode(nested_encoded) + + print_info(f'Input: [[{nested_value[0][0]}, {nested_value[0][1]}], "{nested_value[1]}"]') + print_info(f"Encoded: {format_hex(nested_encoded)}") + print_info(f"Total bytes: {len(nested_encoded)}") + + print_info("\nNested tuple encoding:") + print_info(" Inner tuple (uint64,bool) is static - encoded inline in head") + print_info(" String is dynamic - offset in head, data in tail") + + print_info("\nHEAD SECTION:") + # Inner tuple is static: 8 bytes (uint64) + 1 byte (bool) = 9 bytes + print_info(f" [0-7] inner.uint64: {format_hex(nested_encoded[0:8])} = {nested_value[0][0]}") + print_info(f" [8] inner.bool: {format_hex(nested_encoded[8:9])} = {nested_value[0][1]}") + + # String offset + nested_string_offset = (nested_encoded[9] << 8) | nested_encoded[10] + print_info(f" [9-10] string offset: {format_hex(nested_encoded[9:11])} = {nested_string_offset}") + + print_info("\nTAIL SECTION:") + nested_str_len_bytes = nested_encoded[nested_string_offset : nested_string_offset + 2] + nested_str_len = (nested_str_len_bytes[0] << 8) | nested_str_len_bytes[1] + nested_str_content = nested_encoded[nested_string_offset + 2 : nested_string_offset + 2 + nested_str_len] + + len_start = nested_string_offset + len_end = nested_string_offset + 1 + content_start = nested_string_offset + 2 + content_end = nested_string_offset + 1 + nested_str_len + hex_len = format_hex(nested_str_len_bytes) + hex_content = format_hex(nested_str_content) + print_info(f" [{len_start}-{len_end}] string length: {hex_len} = {nested_str_len} bytes") + print_info(f' [{content_start}-{content_end}] string content: {hex_content} = "{nested_value[1]}"') + + print_info(f'\nDecoded: [[{nested_decoded[0][0]}, {nested_decoded[0][1]}], "{nested_decoded[1]}"]') + verified = ( + nested_decoded[0][0] == nested_value[0][0] + and nested_decoded[0][1] == nested_value[0][1] + and nested_decoded[1] == nested_value[1] + ) + print_info(f"Round-trip verified: {verified}") + + # Step 5: Accessing tuple elements after decoding + print_step(5, "Accessing Tuple Elements After Decoding") + + print_info("Decoded values are returned as tuples/lists, access by index:") + + mixed_tuple = abi.ABIType.from_string("(uint64,bool,string,address)") + mixed_value = [123, False, "test", sample_address] + + if isinstance(mixed_tuple, abi.TupleType): + mixed_encoded = mixed_tuple.encode(mixed_value) + mixed_decoded = mixed_tuple.decode(mixed_encoded) + + print_info("\nDecoded tuple (uint64,bool,string,address):") + print_info(f" element[0] (uint64): {mixed_decoded[0]} (type: {type(mixed_decoded[0]).__name__})") + print_info(f" element[1] (bool): {mixed_decoded[1]} (type: {type(mixed_decoded[1]).__name__})") + print_info(f' element[2] (string): "{mixed_decoded[2]}" (type: {type(mixed_decoded[2]).__name__})') + print_info(f" element[3] (address): {str(mixed_decoded[3])[:10]}... (type: {type(mixed_decoded[3]).__name__})") + + # Nested tuple element access + if isinstance(nested_tuple_type, abi.TupleType): + print_info("\nAccessing nested tuple elements:") + print_info(" nested_decoded[0]: inner tuple as tuple/list") + print_info(f" nested_decoded[0][0]: {nested_decoded[0][0]} (inner uint64)") + print_info(f" nested_decoded[0][1]: {nested_decoded[0][1]} (inner bool)") + print_info(f' nested_decoded[1]: "{nested_decoded[1]}" (outer string)') + + # Step 6: Byte layout comparison - static vs dynamic tuples + print_step(6, "Byte Layout Comparison") + + if isinstance(static_tuple_type, abi.TupleType): + print_info("STATIC TUPLE (uint64,bool,address):") + print_info(" Layout: [uint64:8 bytes][bool:1 byte][address:32 bytes]") + print_info(f" Total: {static_tuple_type.byte_len()} bytes (fixed size)") + print_info(" No head/tail separation - all data inline") + + if isinstance(dynamic_tuple_type, abi.TupleType): + print_info("\nDYNAMIC TUPLE (uint64,string,bool):") + print_info(" Layout: HEAD + TAIL") + print_info(" HEAD: [uint64:8][string_offset:2][bool:1] = 11 bytes") + print_info(" TAIL: [string_len:2][string_data:N]") + print_info(" Total: 11 + 2 + string_length bytes") + print_info(f' Example with "Hello ABI" (9 bytes): {len(dynamic_encoded)} bytes') + + # Show how different string lengths affect total size + print_info("\nSize varies with dynamic content:") + test_strings = ["", "Hi", "Hello World", "A longer string for testing"] + + for test_str in test_strings: + test_val = [1, test_str, True] + test_encoded = dynamic_tuple_type.encode(test_val) + expected_size = 11 + 2 + len(test_str.encode("utf-8")) + print_info(f' "{test_str}" ({len(test_str)} chars): {len(test_encoded)} bytes (expected: {expected_size})') + + # Step 7: Creating TupleType programmatically + print_step(7, "Creating TupleType Programmatically") + + custom_tuple_type = abi.TupleType([abi.UintType(32), abi.BoolType(), abi.StringType()]) + + print_info("Created with: TupleType([UintType(32), BoolType(), StringType()])") + print_info(f" str(): {custom_tuple_type}") + print_info(f" elements length: {len(custom_tuple_type.elements)}") + print_info(f" is_dynamic(): {custom_tuple_type.is_dynamic()}") + + custom_value = [500, True, "Custom"] + custom_encoded = custom_tuple_type.encode(custom_value) + custom_decoded = custom_tuple_type.decode(custom_encoded) + + print_info(f'\nEncode [{custom_value[0]}, {custom_value[1]}, "{custom_value[2]}"]:') + print_info(f" Encoded: {format_hex(custom_encoded)}") + print_info(f" Total bytes: {len(custom_encoded)}") + print_info(f' Decoded: [{custom_decoded[0]}, {custom_decoded[1]}, "{custom_decoded[2]}"]') + + # Step 8: Multiple dynamic elements in a tuple + print_step(8, "Multiple Dynamic Elements") + + multi_dynamic_type = abi.ABIType.from_string("(string,uint64,string)") + + if isinstance(multi_dynamic_type, abi.TupleType): + multi_dynamic_value = ["First", 42, "Second"] + multi_dynamic_encoded = multi_dynamic_type.encode(multi_dynamic_value) + multi_dynamic_decoded = multi_dynamic_type.decode(multi_dynamic_encoded) + + print_info(f'Input: ["{multi_dynamic_value[0]}", {multi_dynamic_value[1]}, "{multi_dynamic_value[2]}"]') + print_info(f"Encoded: {format_hex(multi_dynamic_encoded)}") + print_info(f"Total bytes: {len(multi_dynamic_encoded)}") + + print_info("\nHead/Tail layout with multiple dynamic elements:") + print_info("HEAD: [string1_offset:2][uint64:8][string2_offset:2] = 12 bytes") + + str1_offset = (multi_dynamic_encoded[0] << 8) | multi_dynamic_encoded[1] + str2_offset = (multi_dynamic_encoded[10] << 8) | multi_dynamic_encoded[11] + + print_info(f" [0-1] string1 offset: {format_hex(multi_dynamic_encoded[0:2])} = {str1_offset}") + print_info(f" [2-9] uint64: {format_hex(multi_dynamic_encoded[2:10])} = {multi_dynamic_value[1]}") + print_info(f" [10-11] string2 offset: {format_hex(multi_dynamic_encoded[10:12])} = {str2_offset}") + + print_info("\nTAIL: [string1_data][string2_data]") + print_info(f' String 1 at offset {str1_offset}: "{multi_dynamic_value[0]}"') + print_info(f' String 2 at offset {str2_offset}: "{multi_dynamic_value[2]}"') + + print_info( + f'\nDecoded: ["{multi_dynamic_decoded[0]}", {multi_dynamic_decoded[1]}, "{multi_dynamic_decoded[2]}"]' + ) + verified = ( + multi_dynamic_decoded[0] == multi_dynamic_value[0] + and multi_dynamic_decoded[1] == multi_dynamic_value[1] + and multi_dynamic_decoded[2] == multi_dynamic_value[2] + ) + print_info(f"Round-trip verified: {verified}") + + # Step 9: Summary + print_step(9, "Summary") + + print_info("TupleType key properties:") + print_info(" - elements: list of types for each element") + print_info(" - is_dynamic(): True if ANY child is dynamic") + print_info(" - byte_len(): only valid for static tuples") + + print_info("\nTuple encoding patterns:") + print_info(" Static tuples (all elements static):") + print_info(" - Elements encoded consecutively") + print_info(" - Fixed total size = sum of element sizes") + print_info(" - No offsets needed") + + print_info("\n Dynamic tuples (at least one dynamic element):") + print_info(" - HEAD: static values inline + 2-byte offsets for dynamic") + print_info(" - TAIL: actual data for dynamic elements") + print_info(" - Offsets are relative to start of tuple encoding") + + print_info("\nNested tuples:") + print_info(" - Inner tuples encoded as single units") + print_info(" - Static inner tuples: inline in head") + print_info(" - Dynamic inner tuples: offset in head, data in tail") + + print_info("\nDecoded values:") + print_info(" - Returned as tuples/lists") + print_info(" - Access elements by index: decoded[0], decoded[1], etc.") + print_info(" - Nested tuples: decoded[0][0] for inner elements") + + print_info("\nCreating tuple types:") + print_info(' - ABIType.from_string("(uint64,bool)") - parse from string') + print_info(" - TupleType([child1, child2, ...]) - programmatic") + + print_success("ABI Tuple Type example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/abi/08_struct_type.py b/examples/abi/08_struct_type.py new file mode 100644 index 00000000..adc56a58 --- /dev/null +++ b/examples/abi/08_struct_type.py @@ -0,0 +1,323 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: ABI Struct Type + +This example demonstrates how to encode and decode named structs using StructType: +- Creating StructType with named fields +- Encoding struct values as objects with named keys +- Comparing struct encoding to equivalent tuple encoding +- Accessing struct field names and types +- Decoding back to struct values with named fields + +Key characteristics of struct encoding: +- Structs are named tuples - the encoding is identical to the equivalent tuple +- Field names provide semantic meaning but don't affect the binary encoding +- Decoded values are objects with named properties (not arrays like tuples) + +ARC-4 specification: Structs are tuples with named fields for improved readability. + +No LocalNet required - pure ABI encoding/decoding +""" + +from shared import format_hex, print_header, print_info, print_step, print_success + +from algokit_abi import abi + + +def main() -> None: + print_header("ABI Struct Type Example") + + # Step 1: Creating StructType with named fields + print_step(1, "Creating StructType with Named Fields") + + # Create a struct: { name: string, age: uint64, active: bool } + user_struct = abi.StructType( + struct_name="User", + fields={ + "name": abi.StringType(), + "age": abi.UintType(64), + "active": abi.BoolType(), + }, + ) + + print_info("Created struct using StructType():") + print_info(f" Struct name: {user_struct.struct_name}") + print_info(f" Display name: {user_struct.display_name}") + print_info(f" ABI type name: {user_struct.name}") + print_info(f" Number of fields: {len(user_struct.fields)}") + print_info(f" is_dynamic(): {user_struct.is_dynamic()} (because string is dynamic)") + + print_info("\nStruct fields:") + for i, (field_name, field_type) in enumerate(user_struct.fields.items()): + print_info(f" [{i}] {field_name}: {field_type}") + + # Step 2: Encoding struct values as objects with named keys + print_step(2, "Encoding Struct Values as Objects") + + user_value = { + "name": "Alice", + "age": 30, + "active": True, + } + + user_encoded = user_struct.encode(user_value) + + print_info( + f'Input object: {{ name: "{user_value["name"]}", age: {user_value["age"]}, active: {user_value["active"]} }}' + ) + print_info(f"Encoded: {format_hex(user_encoded)}") + print_info(f"Total bytes: {len(user_encoded)}") + + # Break down the encoding + print_info("\nByte layout (head/tail encoding because string is dynamic):") + print_info("HEAD SECTION:") + + # string is dynamic - 2-byte offset + name_offset = (user_encoded[0] << 8) | user_encoded[1] + print_info(f" [0-1] name offset: {format_hex(user_encoded[0:2])} = {name_offset} (points to tail)") + + # uint64 is static - 8 bytes + print_info(f" [2-9] age (uint64): {format_hex(user_encoded[2:10])} = {user_value['age']}") + + # bool is static - 1 byte + print_info(f" [10] active (bool): {format_hex(user_encoded[10:11])} = {user_value['active']}") + + print_info("\nTAIL SECTION:") + name_len_bytes = user_encoded[name_offset : name_offset + 2] + name_len = (name_len_bytes[0] << 8) | name_len_bytes[1] + name_content = user_encoded[name_offset + 2 : name_offset + 2 + name_len] + len_start = name_offset + len_end = name_offset + 1 + content_start = name_offset + 2 + content_end = name_offset + 1 + name_len + hex_len = format_hex(name_len_bytes) + hex_content = format_hex(name_content) + print_info(f" [{len_start}-{len_end}] string length: {hex_len} = {name_len} bytes") + print_info(f' [{content_start}-{content_end}] string content: {hex_content} = "{user_value["name"]}"') + + # Step 3: Struct encoding is identical to equivalent tuple encoding + print_step(3, "Struct Encoding vs Tuple Encoding") + + # Create equivalent tuple type + equivalent_tuple = abi.TupleType([abi.StringType(), abi.UintType(64), abi.BoolType()]) + tuple_value = ("Alice", 30, True) + tuple_encoded = equivalent_tuple.encode(tuple_value) + + print_info(f"Struct type: {user_struct.name}") + print_info(f"Tuple type: {equivalent_tuple.name}") + + print_info("\nStruct encoded:") + print_info(f" {format_hex(user_encoded)}") + + print_info("\nTuple encoded (same values):") + print_info(f" {format_hex(tuple_encoded)}") + + # Compare byte by byte + encodings_match = user_encoded == tuple_encoded + + print_info(f"\nEncodings are identical: {encodings_match}") + print_info("This confirms structs are just named tuples with the same binary encoding.") + + # Step 4: Accessing struct field names and types via the type object + print_step(4, "Accessing Struct Field Names and Types") + + print_info("Field information from fields property:") + for i, (field_name, field_type) in enumerate(user_struct.fields.items()): + print_info(f"\n Field {i}:") + print_info(f" Name: {field_name}") + print_info(f" Type: {field_type}") + print_info(f" is_dynamic: {field_type.is_dynamic()}") + byte_len = field_type.byte_len() + if byte_len is not None: + print_info(f" byte_len: {byte_len}") + + print_info("\nConverting struct to tuple type:") + tuple_from_struct = user_struct._tuple_type # noqa: SLF001 + print_info(f" _tuple_type: {tuple_from_struct}") + print_info(f" elements length: {len(tuple_from_struct.elements)}") + + # Step 5: Decoding back to struct value with named fields + print_step(5, "Decoding to Struct with Named Fields") + + user_decoded = user_struct.decode(user_encoded) + + print_info("Decoded struct value (dict with named keys):") + print_info(f" typeof decoded: {type(user_decoded).__name__}") + print_info(f' decoded["name"]: "{user_decoded["name"]}"') + print_info(f' decoded["age"]: {user_decoded["age"]}') + print_info(f' decoded["active"]: {user_decoded["active"]}') + + # Compare with tuple decoding + tuple_decoded = equivalent_tuple.decode(user_encoded) + print_info("\nCompare with tuple decoding (tuple with index access):") + print_info(f" typeof decoded: {type(tuple_decoded).__name__}") + print_info(f' decoded[0]: "{tuple_decoded[0]}"') + print_info(f" decoded[1]: {tuple_decoded[1]}") + print_info(f" decoded[2]: {tuple_decoded[2]}") + + print_info("\nKey difference:") + print_info(" Struct decode() returns a DICT with named properties") + print_info(" Tuple decode() returns a TUPLE with indexed elements") + + # Step 6: Static struct example + print_step(6, "Static Struct Example") + + # Create a struct with all static fields + point_struct = abi.StructType( + struct_name="Point", + fields={ + "x": abi.UintType(32), + "y": abi.UintType(32), + }, + ) + + print_info("Static struct (all fields are static types):") + print_info(f" Struct name: {point_struct.struct_name}") + print_info(f" ABI type: {point_struct.name}") + print_info(f" is_dynamic(): {point_struct.is_dynamic()}") + print_info(f" byte_len(): {point_struct.byte_len()} (4 + 4 = 8 bytes)") + + point_value = {"x": 100, "y": 200} + point_encoded = point_struct.encode(point_value) + point_decoded = point_struct.decode(point_encoded) + + print_info(f"\nEncode {{ x: {point_value['x']}, y: {point_value['y']} }}:") + print_info(f" Encoded: {format_hex(point_encoded)}") + print_info(f" Total bytes: {len(point_encoded)}") + + print_info("\nByte layout (all static, no offsets):") + print_info(f" [0-3] x (uint32): {format_hex(point_encoded[0:4])} = {point_value['x']}") + print_info(f" [4-7] y (uint32): {format_hex(point_encoded[4:8])} = {point_value['y']}") + + print_info(f"\nDecoded: {{ x: {point_decoded['x']}, y: {point_decoded['y']} }}") + + # Step 7: Encoding struct as tuple (tuple-style) + print_step(7, "Encoding Struct as Tuple (Tuple-style)") + + print_info("StructType.encode() accepts both dicts and tuples:") + + # Encode as dict + obj_encoded = user_struct.encode({"name": "Bob", "age": 25, "active": False}) + + # Encode as tuple (tuple-style) + arr_encoded = user_struct.encode(("Bob", 25, False)) + + print_info('\nEncoded as dict { name: "Bob", age: 25, active: False }:') + print_info(f" {format_hex(obj_encoded)}") + + print_info('\nEncoded as tuple ("Bob", 25, False):') + print_info(f" {format_hex(arr_encoded)}") + + array_obj_match = obj_encoded == arr_encoded + + print_info(f"\nEncodings are identical: {array_obj_match}") + print_info("Both input formats produce the same encoded bytes.") + + # Step 8: Nested struct example + print_step(8, "Nested Struct Example") + + # Create nested structs: Person containing Address + address_struct = abi.StructType( + struct_name="Address", + fields={ + "street": abi.StringType(), + "city": abi.StringType(), + }, + ) + + person_struct = abi.StructType( + struct_name="Person", + fields={ + "name": abi.StringType(), + "age": abi.UintType(8), + "address": address_struct, + }, + ) + + print_info("Nested struct Person containing Address:") + print_info(f" Person ABI type: {person_struct.name}") + + person_value = { + "name": "Charlie", + "age": 28, + "address": { + "street": "123 Main St", + "city": "Boston", + }, + } + + person_encoded = person_struct.encode(person_value) + person_decoded = person_struct.decode(person_encoded) + + print_info(f'\nInput: {{ name: "{person_value["name"]}", age: {person_value["age"]}, address: {{...}} }}') + print_info(f"Encoded: {format_hex(person_encoded)}") + print_info(f"Total bytes: {len(person_encoded)}") + + print_info("\nDecoded nested struct:") + print_info(f' decoded["name"]: "{person_decoded["name"]}"') + print_info(f' decoded["age"]: {person_decoded["age"]}') + print_info(f' decoded["address"]["street"]: "{person_decoded["address"]["street"]}"') + print_info(f' decoded["address"]["city"]: "{person_decoded["address"]["city"]}"') + + # Step 9: Creating StructType programmatically + print_step(9, "Creating StructType Programmatically") + + # Create struct type using constructor directly + custom_struct = abi.StructType( + struct_name="Score", + fields={ + "playerId": abi.UintType(64), + "score": abi.UintType(32), + "isHighScore": abi.BoolType(), + }, + ) + + print_info('Created with: StructType(struct_name="Score", fields={...})') + print_info(f" Struct name: {custom_struct.struct_name}") + print_info(f" ABI type: {custom_struct.name}") + print_info(f" is_dynamic(): {custom_struct.is_dynamic()}") + print_info(f" byte_len(): {custom_struct.byte_len()} (8 + 4 + 1 = 13 bytes)") + + score_value = {"playerId": 12345, "score": 9999, "isHighScore": True} + score_encoded = custom_struct.encode(score_value) + score_decoded = custom_struct.decode(score_encoded) + + player_id = score_value["playerId"] + score = score_value["score"] + is_high = score_value["isHighScore"] + print_info(f"\nEncode: {{ playerId: {player_id}, score: {score}, isHighScore: {is_high} }}") + print_info(f" Encoded: {format_hex(score_encoded)}") + dec_player_id = score_decoded["playerId"] + dec_score = score_decoded["score"] + dec_is_high = score_decoded["isHighScore"] + print_info(f" Decoded: {{ playerId: {dec_player_id}, score: {dec_score}, isHighScore: {dec_is_high} }}") + + # Step 10: Summary + print_step(10, "Summary") + + print_info("StructType key properties:") + print_info(" - struct_name: The name of the struct") + print_info(" - fields: Dict of { name: type } field definitions") + print_info(" - _tuple_type: Internal tuple type representation") + print_info(" - is_dynamic(): True if ANY field is dynamic") + print_info(" - byte_len(): only valid for static structs") + + print_info("\nStruct vs Tuple:") + print_info(" - Structs are named tuples with identical binary encoding") + print_info(" - Field names provide semantic meaning, not encoding differences") + print_info(" - encode() accepts dicts OR tuples") + print_info(" - decode() returns dicts with named properties (not tuples)") + + print_info("\nCreating struct types:") + print_info(" - StructType(struct_name=name, fields={...}) - programmatic with ABIType instances") + + print_info("\nNested structs:") + print_info(" - Structs can contain other structs") + print_info(" - Pass struct types directly in fields") + print_info(" - Nested struct values are dicts within dicts") + + print_success("ABI Struct Type example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/abi/09_struct_tuple_conversion.py b/examples/abi/09_struct_tuple_conversion.py new file mode 100644 index 00000000..da338109 --- /dev/null +++ b/examples/abi/09_struct_tuple_conversion.py @@ -0,0 +1,382 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: ABI Struct and Tuple Conversion + +This example demonstrates how to convert between struct values (named) and tuple values (positional): +- get_tuple_from_struct(): Convert struct dict to tuple +- get_struct_from_tuple(): Convert tuple back to struct dict +- Simple struct { name: 'Alice', age: 30n } <-> tuple ('Alice', 30) +- Nested structs with complex types +- Verify that struct and tuple encodings produce identical bytes + +Key concept: Structs and tuples have identical binary encoding in ARC-4. +The conversion functions allow you to work with the same data in either format: +- Struct format: dict with named properties (more readable) +- Tuple format: tuple with positional elements (matches ABI encoding) + +No LocalNet required - pure ABI encoding/decoding +""" + +from typing import Any + +from shared import format_hex, print_header, print_info, print_step, print_success + +from algokit_abi import abi + + +def get_tuple_from_struct(struct_type: abi.StructType, struct_value: dict[str, Any]) -> tuple: + """Convert struct dict value to tuple value. + + Args: + struct_type: The StructType defining the struct fields + struct_value: Dict with named field values + + Returns: + Tuple with positional values in field order + """ + result = [] + for field_name, field_type in struct_type.fields.items(): + field_value = struct_value[field_name] + if isinstance(field_type, abi.StructType): + # Recursively convert nested structs + field_value = get_tuple_from_struct(field_type, field_value) + result.append(field_value) + return tuple(result) + + +def get_struct_from_tuple(struct_type: abi.StructType, tuple_value: tuple | list) -> dict[str, Any]: + """Convert tuple value to struct dict value. + + Args: + struct_type: The StructType defining the struct fields + tuple_value: Tuple/list with positional values + + Returns: + Dict with named field values + """ + result: dict[str, Any] = {} + for i, (field_name, field_type) in enumerate(struct_type.fields.items()): + field_value = tuple_value[i] + if isinstance(field_type, abi.StructType): + # Recursively convert nested tuples to structs + field_value = get_struct_from_tuple(field_type, field_value) + result[field_name] = field_value + return result + + +def main() -> None: + print_header("ABI Struct and Tuple Conversion Example") + + # Step 1: Simple struct to tuple conversion + print_step(1, "Simple Struct to Tuple Conversion") + + # Create a struct type: { name: string, age: uint64 } + person_struct = abi.StructType( + struct_name="Person", + fields={ + "name": abi.StringType(), + "age": abi.UintType(64), + }, + ) + + print_info(f"Struct type: {person_struct.struct_name}") + print_info(f"ABI representation: {person_struct.name}") + + # Define a struct value + struct_value = {"name": "Alice", "age": 30} + print_info(f'\nStruct value: {{ name: "{struct_value["name"]}", age: {struct_value["age"]} }}') + + # Convert struct to tuple using get_tuple_from_struct() + tuple_value = get_tuple_from_struct(person_struct, struct_value) + + print_info("\nConverted to tuple using get_tuple_from_struct():") + print_info(f' Result: ("{tuple_value[0]}", {tuple_value[1]})') + print_info(f' tuple_value[0]: "{tuple_value[0]}" (name)') + print_info(f" tuple_value[1]: {tuple_value[1]} (age)") + + # Step 2: Tuple to struct conversion + print_step(2, "Tuple to Struct Conversion") + + # Start with a tuple value + input_tuple = ("Bob", 25) + print_info(f'Tuple value: ("{input_tuple[0]}", {input_tuple[1]})') + + # Convert tuple to struct using get_struct_from_tuple() + converted_struct = get_struct_from_tuple(person_struct, input_tuple) + + print_info("\nConverted to struct using get_struct_from_tuple():") + print_info(f' Result: {{ name: "{converted_struct["name"]}", age: {converted_struct["age"]} }}') + print_info(f' converted_struct["name"]: "{converted_struct["name"]}"') + print_info(f' converted_struct["age"]: {converted_struct["age"]}') + + # Step 3: Round-trip conversion + print_step(3, "Round-trip Conversion") + + original = {"name": "Charlie", "age": 42} + print_info(f'Original struct: {{ name: "{original["name"]}", age: {original["age"]} }}') + + # Struct -> Tuple -> Struct + as_tuple = get_tuple_from_struct(person_struct, original) + print_info(f'After struct -> tuple: ("{as_tuple[0]}", {as_tuple[1]})') + + back_to_struct = get_struct_from_tuple(person_struct, as_tuple) + print_info(f'After tuple -> struct: {{ name: "{back_to_struct["name"]}", age: {back_to_struct["age"]} }}') + + round_trip_match = original["name"] == back_to_struct["name"] and original["age"] == back_to_struct["age"] + print_info(f"\nRound-trip preserved values: {round_trip_match}") + + # Step 4: Verify identical encoding + print_step(4, "Verify Identical Encoding") + + print_info("Both struct and tuple values should encode to identical bytes:") + + # Encode using struct type + struct_encoded = person_struct.encode(struct_value) + print_info(f"\nStruct encoded: {format_hex(struct_encoded)}") + + # Create equivalent tuple type and encode the tuple value + tuple_type = abi.TupleType([abi.StringType(), abi.UintType(64)]) + tuple_encoded = tuple_type.encode(tuple_value) + print_info(f"Tuple encoded: {format_hex(tuple_encoded)}") + + # Compare encodings + encodings_match = struct_encoded == tuple_encoded + print_info(f"\nEncodings are identical: {encodings_match}") + print_info(f"Total bytes: {len(struct_encoded)}") + + # Step 5: Complex struct with more fields + print_step(5, "Complex Struct with More Fields") + + # Create a more complex struct + user_struct = abi.StructType( + struct_name="User", + fields={ + "id": abi.UintType(64), + "username": abi.StringType(), + "active": abi.BoolType(), + "balance": abi.UintType(256), + }, + ) + + user_value = { + "id": 12345, + "username": "alice_wonder", + "active": True, + "balance": 1000000000000000000, # 1 ETH in wei + } + + print_info(f"Struct type: {user_struct.struct_name}") + print_info("Fields: id (uint64), username (string), active (bool), balance (uint256)") + print_info("\nStruct value:") + print_info(f" id: {user_value['id']}") + print_info(f' username: "{user_value["username"]}"') + print_info(f" active: {user_value['active']}") + print_info(f" balance: {user_value['balance']}") + + # Convert to tuple + user_tuple = get_tuple_from_struct(user_struct, user_value) + + print_info("\nConverted to tuple:") + print_info(f' ({user_tuple[0]}, "{user_tuple[1]}", {user_tuple[2]}, {user_tuple[3]})') + + # Convert back + user_back = get_struct_from_tuple(user_struct, user_tuple) + + print_info("\nConverted back to struct:") + print_info(f" id: {user_back['id']}") + print_info(f' username: "{user_back["username"]}"') + print_info(f" active: {user_back['active']}") + print_info(f" balance: {user_back['balance']}") + + # Verify encoding + user_struct_encoded = user_struct.encode(user_value) + user_tuple_type = abi.TupleType([abi.UintType(64), abi.StringType(), abi.BoolType(), abi.UintType(256)]) + user_tuple_encoded = user_tuple_type.encode(user_tuple) + + user_encodings_match = user_struct_encoded == user_tuple_encoded + print_info(f"\nStruct and tuple encodings identical: {user_encodings_match}") + + # Step 6: Nested struct conversion + print_step(6, "Nested Struct Conversion") + + # Create nested struct types + item_struct = abi.StructType( + struct_name="Item", + fields={ + "name": abi.StringType(), + "price": abi.UintType(64), + }, + ) + + order_struct = abi.StructType( + struct_name="Order", + fields={ + "orderId": abi.UintType(64), + "item": item_struct, + "quantity": abi.UintType(32), + }, + ) + + order_value = { + "orderId": 1001, + "item": { + "name": "Widget", + "price": 2500, + }, + "quantity": 5, + } + + print_info("Nested struct type: Order containing Item") + print_info(" Order: { orderId: uint64, item: Item, quantity: uint32 }") + print_info(" Item: { name: string, price: uint64 }") + + print_info("\nNested struct value:") + print_info(f" orderId: {order_value['orderId']}") + print_info(f' item: {{ name: "{order_value["item"]["name"]}", price: {order_value["item"]["price"]} }}') + print_info(f" quantity: {order_value['quantity']}") + + # Convert nested struct to tuple + order_tuple = get_tuple_from_struct(order_struct, order_value) + + print_info("\nConverted to nested tuple using get_tuple_from_struct():") + print_info(" Result structure: (orderId, (name, price), quantity)") + print_info(f" order_tuple[0]: {order_tuple[0]} (orderId)") + print_info(f' order_tuple[1]: ("{order_tuple[1][0]}", {order_tuple[1][1]}) (item)') + print_info(f" order_tuple[2]: {order_tuple[2]} (quantity)") + + # Convert back to struct + order_back = get_struct_from_tuple(order_struct, order_tuple) + + print_info("\nConverted back to struct using get_struct_from_tuple():") + print_info(f" orderId: {order_back['orderId']}") + print_info(f' item["name"]: "{order_back["item"]["name"]}"') + print_info(f' item["price"]: {order_back["item"]["price"]}') + print_info(f" quantity: {order_back['quantity']}") + + # Verify nested encoding + order_struct_encoded = order_struct.encode(order_value) + order_tuple_type = abi.TupleType( + [abi.UintType(64), abi.TupleType([abi.StringType(), abi.UintType(64)]), abi.UintType(32)] + ) + order_tuple_encoded = order_tuple_type.encode(order_tuple) + + order_encodings_match = order_struct_encoded == order_tuple_encoded + print_info(f"\nNested struct and tuple encodings identical: {order_encodings_match}") + print_info(f"Total bytes: {len(order_struct_encoded)}") + + # Step 7: Deeply nested struct + print_step(7, "Deeply Nested Struct") + + # Create deeply nested struct + contact_struct = abi.StructType( + struct_name="Contact", + fields={ + "email": abi.StringType(), + "phone": abi.StringType(), + }, + ) + + employee_struct = abi.StructType( + struct_name="Employee", + fields={ + "name": abi.StringType(), + "contact": contact_struct, + }, + ) + + company_struct = abi.StructType( + struct_name="Company", + fields={ + "name": abi.StringType(), + "ceo": employee_struct, + }, + ) + + company_value = { + "name": "TechCorp", + "ceo": { + "name": "Jane Doe", + "contact": { + "email": "jane@techcorp.com", + "phone": "+1-555-0100", + }, + }, + } + + print_info("Deeply nested struct: Company -> Employee -> Contact") + print_info("\nCompany value:") + print_info(f' name: "{company_value["name"]}"') + print_info(f' ceo["name"]: "{company_value["ceo"]["name"]}"') + print_info(f' ceo["contact"]["email"]: "{company_value["ceo"]["contact"]["email"]}"') + print_info(f' ceo["contact"]["phone"]: "{company_value["ceo"]["contact"]["phone"]}"') + + # Convert to deeply nested tuple + company_tuple = get_tuple_from_struct(company_struct, company_value) + + print_info("\nConverted to deeply nested tuple:") + print_info(" Structure: (name, (employeeName, (email, phone)))") + ceo_tuple = company_tuple[1] + contact_tuple = ceo_tuple[1] + print_info(f' company_tuple[0]: "{company_tuple[0]}"') + print_info(f' company_tuple[1][0]: "{ceo_tuple[0]}"') + print_info(f' company_tuple[1][1][0]: "{contact_tuple[0]}"') + print_info(f' company_tuple[1][1][1]: "{contact_tuple[1]}"') + + # Convert back + company_back = get_struct_from_tuple(company_struct, company_tuple) + + print_info("\nConverted back to struct:") + print_info(f' name: "{company_back["name"]}"') + print_info(f' ceo["name"]: "{company_back["ceo"]["name"]}"') + print_info(f' ceo["contact"]["email"]: "{company_back["ceo"]["contact"]["email"]}"') + print_info(f' ceo["contact"]["phone"]: "{company_back["ceo"]["contact"]["phone"]}"') + + # Verify deep nesting encoding + company_struct_encoded = company_struct.encode(company_value) + company_tuple_type = abi.TupleType( + [abi.StringType(), abi.TupleType([abi.StringType(), abi.TupleType([abi.StringType(), abi.StringType()])])] + ) + company_tuple_encoded = company_tuple_type.encode(company_tuple) + + company_encodings_match = company_struct_encoded == company_tuple_encoded + print_info(f"\nDeeply nested struct and tuple encodings identical: {company_encodings_match}") + + # Step 8: Use cases for conversion functions + print_step(8, "Use Cases for Conversion Functions") + + print_info("When to use get_tuple_from_struct():") + print_info(" - Converting struct data to pass to tuple-expecting ABI methods") + print_info(" - Serializing struct data in a position-based format") + print_info(" - Working with libraries that expect tuple format") + print_info(" - Building raw transaction arguments") + + print_info("\nWhen to use get_struct_from_tuple():") + print_info(" - Converting decoded tuple results to readable struct format") + print_info(" - Adding field names to positional data for debugging") + print_info(" - Working with APIs that return tuple arrays") + print_info(" - Making code more maintainable with named fields") + + # Step 9: Summary + print_step(9, "Summary") + + print_info("Conversion functions:") + print_info(" - get_tuple_from_struct(struct_type, struct_value) -> tuple") + print_info(" - get_struct_from_tuple(struct_type, tuple_value) -> dict") + + print_info("\nKey points:") + print_info(" - Structs and tuples are interchangeable at the binary level") + print_info(" - Conversion is lossless - round-trip preserves all values") + print_info(" - Nested structs convert to nested tuples and vice versa") + print_info(" - Field names provide semantic meaning without affecting encoding") + print_info(" - Use struct format for readability, tuple format for ABI compatibility") + + print_info("\nBinary equivalence verified:") + print_info(" - Simple struct { name, age } = tuple (string, uint64)") + print_info(" - Complex struct { id, username, active, balance } = tuple (uint64, string, bool, uint256)") + print_info(" - Nested struct Order { Item { ... } } = nested tuple (...)") + + print_success("ABI Struct and Tuple Conversion example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/abi/10_bool_packing.py b/examples/abi/10_bool_packing.py new file mode 100644 index 00000000..5427bf74 --- /dev/null +++ b/examples/abi/10_bool_packing.py @@ -0,0 +1,323 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: ABI Bool Array Packing + +This example demonstrates how bool arrays are packed efficiently in ARC-4: +- 8 booleans fit in 1 byte (1 bit per boolean) +- bool[8] encodes to exactly 1 byte +- bool[16] encodes to 2 bytes +- Partial byte arrays (e.g., bool[5]) still use full bytes + +Key characteristics of bool array packing: +- Each bool is stored as a single bit, not a full byte +- Bools are packed left-to-right starting from the MSB (most significant bit) +- Array length is rounded up to the next full byte +- This is much more space-efficient than storing each bool as uint8 + +No LocalNet required - pure ABI encoding/decoding +""" + +import math + +from shared import format_hex, print_header, print_info, print_step, print_success + +from algokit_abi import abi + + +def format_binary(byte: int) -> str: + """Format a byte as a binary string showing all 8 bits.""" + return bin(byte)[2:].zfill(8) + + +def format_binary_bytes(data: bytes) -> str: + """Format a byte array as binary showing the bit layout.""" + return " ".join(format_binary(b) for b in data) + + +def main() -> None: + print_header("ABI Bool Array Packing Example") + + # Step 1: Introduction to bool array packing + print_step(1, "Introduction to Bool Array Packing") + + print_info("In ARC-4 ABI encoding, boolean arrays use bit-packing:") + print_info(" - Each bool takes 1 bit (not 1 byte)") + print_info(" - 8 bools fit in 1 byte") + print_info(" - Bools are packed from MSB (bit 7) to LSB (bit 0)") + print_info(" - true = 1, false = 0") + + # Step 2: bool[8] - exactly 1 byte + print_step(2, "bool[8] Encoding - Exactly 1 Byte") + + bool8_type = abi.ABIType.from_string("bool[8]") + + print_info(f"Type: {bool8_type}") + if isinstance(bool8_type, abi.StaticArrayType): + print_info(f"element: {bool8_type.element}") + print_info(f"size: {bool8_type.size}") + print_info(f"byte_len(): {bool8_type.byte_len()}") + print_info(f"is_dynamic(): {bool8_type.is_dynamic()}") + + # All true - should be 0b11111111 = 0xFF + all_true8 = [True, True, True, True, True, True, True, True] + all_true8_encoded = bool8_type.encode(all_true8) + + print_info(f"\nAll true: {all_true8}") + print_info(f" Encoded: {format_hex(all_true8_encoded)}") + print_info(f" Binary: {format_binary_bytes(all_true8_encoded)}") + print_info(f" Length: {len(all_true8_encoded)} byte") + + # All false - should be 0b00000000 = 0x00 + all_false8 = [False, False, False, False, False, False, False, False] + all_false8_encoded = bool8_type.encode(all_false8) + + print_info(f"\nAll false: {all_false8}") + print_info(f" Encoded: {format_hex(all_false8_encoded)}") + print_info(f" Binary: {format_binary_bytes(all_false8_encoded)}") + print_info(f" Length: {len(all_false8_encoded)} byte") + + # Alternating pattern - should be 0b10101010 = 0xAA + alternating8 = [True, False, True, False, True, False, True, False] + alternating8_encoded = bool8_type.encode(alternating8) + + print_info(f"\nAlternating: {alternating8}") + print_info(f" Encoded: {format_hex(alternating8_encoded)}") + print_info(f" Binary: {format_binary_bytes(alternating8_encoded)}") + print_info(" Expected: 10101010 = 0xAA") + expected_alternating = 0xAA # 10101010 binary + print_info(f" Matches: {alternating8_encoded[0] == expected_alternating}") + + # Step 3: Bit position mapping + print_step(3, "Bit Position Mapping") + + print_info("Bools map to bit positions (MSB first):") + print_info(" Array index: [0] [1] [2] [3] [4] [5] [6] [7]") + print_info(" Bit position: b7 b6 b5 b4 b3 b2 b1 b0") + print_info(" Bit value: 128 64 32 16 8 4 2 1") + + # Single true at each position + print_info("\nSingle true at each position:") + + if isinstance(bool8_type, abi.StaticArrayType): + for i in range(8): + bools = [False] * 8 + bools[i] = True + encoded = bool8_type.encode(bools) + expected_byte = 1 << (7 - i) # MSB first + print_info( + f" Index {i}: {format_binary(encoded[0])} = 0x{encoded[0]:02x} (expected: 0x{expected_byte:02x})" + ) + + # Step 4: bool[16] - 2 bytes + print_step(4, "bool[16] Encoding - 2 Bytes") + + bool16_type = abi.ABIType.from_string("bool[16]") + + print_info(f"Type: {bool16_type}") + if isinstance(bool16_type, abi.StaticArrayType): + print_info(f"byte_len(): {bool16_type.byte_len()}") + + # First 8 true, rest false + first_half16 = [True] * 8 + [False] * 8 + first_half16_encoded = bool16_type.encode(first_half16) + + print_info("\nFirst 8 true, rest false:") + print_info(f" Encoded: {format_hex(first_half16_encoded)}") + print_info(f" Binary: {format_binary_bytes(first_half16_encoded)}") + print_info(f" Byte 0: {format_binary(first_half16_encoded[0])} (positions 0-7)") + print_info(f" Byte 1: {format_binary(first_half16_encoded[1])} (positions 8-15)") + + # All true 16 + all_true16 = [True] * 16 + all_true16_encoded = bool16_type.encode(all_true16) + + print_info("\nAll 16 true:") + print_info(f" Encoded: {format_hex(all_true16_encoded)}") + print_info(f" Binary: {format_binary_bytes(all_true16_encoded)}") + print_info(f" Length: {len(all_true16_encoded)} bytes") + + # Step 5: Partial byte arrays (bool[5]) + print_step(5, "Partial Byte Arrays - bool[5]") + + bool5_type = abi.ABIType.from_string("bool[5]") + + print_info(f"Type: {bool5_type}") + if isinstance(bool5_type, abi.StaticArrayType): + print_info(f"byte_len(): {bool5_type.byte_len()}") + print_info("Note: 5 bools still require 1 full byte (bits 0-4 used, bits 5-7 are padding zeros)") + + bool5_values = [True, True, True, True, True] + bool5_encoded = bool5_type.encode(bool5_values) + + print_info(f"\nAll 5 true: {bool5_values}") + print_info(f" Encoded: {format_hex(bool5_encoded)}") + print_info(f" Binary: {format_binary_bytes(bool5_encoded)}") + print_info(" Expected: 11111000 (5 ones + 3 padding zeros)") + expected_5_true = 0xF8 # 11111000 binary + print_info(f" Expected value: 0xF8 = {expected_5_true}") + print_info(f" Matches: {bool5_encoded[0] == expected_5_true}") + + # Different bool[5] patterns + bool5_pattern = [True, False, True, False, True] + bool5_pattern_encoded = bool5_type.encode(bool5_pattern) + + print_info(f"\nPattern {bool5_pattern}:") + print_info(f" Encoded: {format_hex(bool5_pattern_encoded)}") + print_info(f" Binary: {format_binary_bytes(bool5_pattern_encoded)}") + print_info(" Expected: 10101000 (pattern + 3 padding zeros)") + + # Step 6: Various partial byte sizes + print_step(6, "Byte Length Formula for Bool Arrays") + + print_info("Formula: byte_len = ceil(arrayLength / 8)") + print_info("") + print_info("Length | Bytes | Formula") + print_info("-------|-------|--------") + + bool_sizes = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 16, 17, 24, 32] + + for size in bool_sizes: + parsed_type = abi.ABIType.from_string(f"bool[{size}]") + expected_bytes = math.ceil(size / 8) + if isinstance(parsed_type, abi.StaticArrayType): + actual_bytes = parsed_type.byte_len() + print_info(f"{size:6} | {actual_bytes:5} | ceil({size}/8) = {expected_bytes}") + + # Step 7: Compare bool[] vs uint8[] encoding size + print_step(7, "Size Comparison: bool[] vs uint8[]") + + print_info("Comparison of encoded sizes for same element count:") + print_info("") + print_info("Count | bool[N] bytes | uint8[N] bytes | Savings") + print_info("------|---------------|----------------|--------") + + counts = [8, 16, 32, 64, 100, 256] + + for count in counts: + bool_type = abi.ABIType.from_string(f"bool[{count}]") + uint8_type = abi.ABIType.from_string(f"uint8[{count}]") + + if isinstance(bool_type, abi.StaticArrayType) and isinstance(uint8_type, abi.StaticArrayType): + bool_bytes = bool_type.byte_len() + uint8_bytes = uint8_type.byte_len() + if bool_bytes is not None and uint8_bytes is not None: + savings = (1 - bool_bytes / uint8_bytes) * 100 + print_info(f"{count:5} | {bool_bytes:13} | {uint8_bytes:14} | {savings:.1f}%") + + print_info("\nBool arrays use 8x less space than uint8 arrays for boolean data!") + + # Step 8: Dynamic bool arrays + print_step(8, "Dynamic Bool Arrays") + + bool_dynamic_type = abi.ABIType.from_string("bool[]") + + print_info(f"Type: {bool_dynamic_type}") + if isinstance(bool_dynamic_type, abi.DynamicArrayType): + print_info(f"element: {bool_dynamic_type.element}") + print_info(f"is_dynamic(): {bool_dynamic_type.is_dynamic()}") + + # Encode a dynamic bool array + dynamic_bools = [True, True, False, True, True, False, False, True, True, False] + dynamic_encoded = bool_dynamic_type.encode(dynamic_bools) + + print_info(f"\nDynamic array: {dynamic_bools} ({len(dynamic_bools)} elements)") + print_info(f" Encoded: {format_hex(dynamic_encoded)}") + print_info(f" Length: {len(dynamic_encoded)} bytes") + + # Break down the encoding + length_prefix = (dynamic_encoded[0] << 8) | dynamic_encoded[1] + data_bytes = dynamic_encoded[2:] + + print_info("\nEncoding breakdown:") + print_info(f" Length prefix: {format_hex(bytes(dynamic_encoded[0:2]))} = {length_prefix} elements") + print_info(f" Data bytes: {format_hex(data_bytes)}") + print_info(f" Data binary: {format_binary_bytes(data_bytes)}") + + # Step 9: Decoding packed bool arrays + print_step(9, "Decoding Packed Bool Arrays") + + if isinstance(bool8_type, abi.StaticArrayType): + # Static array decode + encode_values = [True, False, True, True, False, False, True, False] + encoded = bool8_type.encode(encode_values) + decoded = list(bool8_type.decode(encoded)) + + print_info(f"Original: {encode_values}") + print_info(f"Encoded: {format_hex(encoded)} = {format_binary_bytes(encoded)}") + print_info(f"Decoded: {decoded}") + print_info(f"Round-trip: {decoded == encode_values}") + + if isinstance(bool_dynamic_type, abi.DynamicArrayType): + # Dynamic array decode + dynamic_decoded = list(bool_dynamic_type.decode(dynamic_encoded)) + + print_info(f"\nDynamic original: {dynamic_bools}") + print_info(f"Dynamic decoded: {dynamic_decoded}") + print_info(f"Round-trip: {dynamic_decoded == dynamic_bools}") + + # Step 10: Bit-level view visualization + print_step(10, "Bit-Level View Visualization") + + print_info("Detailed bit-level view of bool[8] encoding:") + print_info("") + + if isinstance(bool8_type, abi.StaticArrayType): + visual_bools = [True, False, True, True, False, True, False, True] + visual_encoded = bool8_type.encode(visual_bools) + + print_info(f"Values: {visual_bools}") + print_info(f"Byte: {format_hex(visual_encoded)} = {format_binary(visual_encoded[0])}") + print_info("") + print_info("Position | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |") + print_info("---------|-----|-----|-----|-----|-----|-----|-----|-----|") + print_info(f"Value | {' | '.join('T' if b else 'F' for b in visual_bools)} |") + print_info(f"Bit | {' | '.join(format_binary(visual_encoded[0]))} |") + print_info("Weight | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |") + + # Calculate the byte value step by step + byte_value = 0 + contributions: list[str] = [] + + for i in range(8): + if visual_bools[i]: + bit_value = 1 << (7 - i) + byte_value += bit_value + contributions.append(str(bit_value)) + + print_info("") + print_info(f"Byte value = {' + '.join(contributions)} = {byte_value} = 0x{byte_value:02x}") + + # Step 11: Summary + print_step(11, "Summary") + + print_info("Bool array packing in ARC-4:") + print_info("") + print_info("Packing rules:") + print_info(" - Each bool = 1 bit") + print_info(" - 8 bools pack into 1 byte") + print_info(" - Bit order: MSB first (index 0 = bit 7)") + print_info(" - Padding: zeros added to complete the last byte") + print_info("") + print_info("Size formula:") + print_info(" - Static: byte_len = ceil(arrayLength / 8)") + print_info(" - Dynamic: 2 (length prefix) + ceil(arrayLength / 8)") + print_info("") + print_info("Space efficiency:") + print_info(" - 8x more efficient than storing bools as uint8") + print_info(" - bool[256] = 32 bytes vs uint8[256] = 256 bytes") + print_info("") + print_info("Bit values by position:") + print_info(" Position 0 (MSB): 0x80 = 128") + print_info(" Position 1: 0x40 = 64") + print_info(" Position 2: 0x20 = 32") + print_info(" Position 3: 0x10 = 16") + print_info(" Position 4: 0x08 = 8") + print_info(" Position 5: 0x04 = 4") + print_info(" Position 6: 0x02 = 2") + print_info(" Position 7 (LSB): 0x01 = 1") + + print_success("ABI Bool Array Packing example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/abi/11_abi_method.py b/examples/abi/11_abi_method.py new file mode 100644 index 00000000..24a907ae --- /dev/null +++ b/examples/abi/11_abi_method.py @@ -0,0 +1,326 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: ABI Method + +This example demonstrates how to work with ABI methods: +- Parsing method signatures with Method.from_signature() +- Accessing method name, args, and return type +- Generating 4-byte method selectors with get_selector() +- Understanding the relationship: selector = first 4 bytes of SHA-512/256(signature) + +ABI method signatures follow the pattern: name(arg1Type,arg2Type,...)returnType +Examples: 'transfer(address,uint64)uint64', 'hello(string)string' + +No LocalNet required - pure ABI encoding/decoding +""" + +import hashlib + +from shared import format_hex, print_header, print_info, print_step, print_success + +from algokit_abi.arc56 import Method, ReferenceType, TransactionType + + +def main() -> None: + print_header("ABI Method Example") + + # Step 1: Introduction to ABI Methods + print_step(1, "Introduction to ABI Methods") + + print_info("ABI methods define the interface for smart contract functions.") + print_info("Method signatures follow the pattern: name(argTypes...)returnType") + print_info("") + print_info("Key components:") + print_info(' - name: The method name (e.g., "transfer")') + print_info(" - args: Sequence of argument types (e.g., [address, uint64])") + print_info(" - returns: The return type (e.g., uint64)") + print_info(" - selector: 4-byte identifier = SHA-512/256(signature)[0:4]") + + # Step 2: Parse a basic method signature + print_step(2, "Parsing Method Signatures") + + transfer_method = Method.from_signature("transfer(address,uint64)uint64") + + print_info("Signature: transfer(address,uint64)uint64") + print_info(f" name: {transfer_method.name}") + print_info(f" args count: {len(transfer_method.args)}") + + for i, arg in enumerate(transfer_method.args): + print_info(f" args[{i}].type: {arg.type}") + + print_info(f" returns.type: {transfer_method.returns.type}") + + # Step 3: Parse various method signatures + print_step(3, "Various Method Signatures") + + hello_method = Method.from_signature("hello(string)string") + print_info("hello(string)string:") + print_info(f" name: {hello_method.name}") + print_info(f" args: [{', '.join(str(a.type) for a in hello_method.args)}]") + print_info(f" returns: {hello_method.returns.type}") + + add_method = Method.from_signature("add(uint64,uint64)uint64") + print_info("\nadd(uint64,uint64)uint64:") + print_info(f" name: {add_method.name}") + print_info(f" args: [{', '.join(str(a.type) for a in add_method.args)}]") + print_info(f" returns: {add_method.returns.type}") + + swap_method = Method.from_signature("swap(address,address,uint64,uint64)bool") + print_info("\nswap(address,address,uint64,uint64)bool:") + print_info(f" name: {swap_method.name}") + print_info(f" args: [{', '.join(str(a.type) for a in swap_method.args)}]") + print_info(f" returns: {swap_method.returns.type}") + + # Step 4: Method with no args + print_step(4, "Method with No Arguments") + + get_method = Method.from_signature("get()uint64") + + print_info("Signature: get()uint64") + print_info(f" name: {get_method.name}") + print_info(f" args count: {len(get_method.args)}") + print_info(" args: []") + print_info(f" returns.type: {get_method.returns.type}") + + get_counter_method = Method.from_signature("getCounter()uint256") + + print_info("\nSignature: getCounter()uint256") + print_info(f" name: {get_counter_method.name}") + print_info(" args: []") + print_info(f" returns: {get_counter_method.returns.type}") + + # Step 5: Method with void return + print_step(5, "Method with Void Return") + + set_method = Method.from_signature("set(uint64)void") + + print_info("Signature: set(uint64)void") + print_info(f" name: {set_method.name}") + print_info(f" args: [{', '.join(str(a.type) for a in set_method.args)}]") + print_info(f" returns.type: {set_method.returns.type}") + + initialize_method = Method.from_signature("initialize(address,string,uint64)void") + + print_info("\nSignature: initialize(address,string,uint64)void") + print_info(f" name: {initialize_method.name}") + print_info(f" args: [{', '.join(str(a.type) for a in initialize_method.args)}]") + print_info(f" returns: {initialize_method.returns.type}") + + # Step 6: Method selectors + print_step(6, "Method Selectors (get_selector)") + + print_info("The method selector is a 4-byte identifier used in ABI calls.") + print_info("It is computed as the first 4 bytes of SHA-512/256(signature).") + print_info("") + + methods = [ + Method.from_signature("transfer(address,uint64)uint64"), + Method.from_signature("hello(string)string"), + Method.from_signature("get()uint64"), + Method.from_signature("set(uint64)void"), + ] + + for method in methods: + selector = method.get_selector() + print_info(f"{method.get_signature()}") + print_info(f" selector: {format_hex(selector)}") + + # Step 7: Demonstrate selector computation + print_step(7, "Selector Computation Deep Dive") + + demo_method = Method.from_signature("transfer(address,uint64)uint64") + signature = demo_method.get_signature() + + print_info(f"Signature: {signature}") + print_info("") + print_info("Computing selector:") + print_info(" 1. Take the method signature string") + print_info(" 2. Compute SHA-512/256 hash of the signature") + print_info(" 3. Take the first 4 bytes as the selector") + print_info("") + + # Compute the hash manually to show the relationship + hash_obj = hashlib.new("sha512_256") + hash_obj.update(signature.encode("utf-8")) + full_hash = hash_obj.digest() + first_4_bytes = full_hash[:4] + + print_info(f' SHA-512/256("{signature}"):') + print_info(f" Full hash: {format_hex(full_hash)}") + print_info(f" First 4 bytes: {format_hex(first_4_bytes)}") + print_info("") + print_info(f" get_selector(): {format_hex(demo_method.get_selector())}") + print_info(f" Match: {first_4_bytes == demo_method.get_selector()}") + + # Step 8: Methods with tuple arguments + print_step(8, "Methods with Tuple Arguments") + + tuple_arg_method = Method.from_signature("processOrder((uint64,address,uint64),bool)uint64") + + print_info("Signature: processOrder((uint64,address,uint64),bool)uint64") + print_info(f" name: {tuple_arg_method.name}") + print_info(f" args count: {len(tuple_arg_method.args)}") + print_info(f" args[0].type: {tuple_arg_method.args[0].type} (tuple)") + print_info(f" args[1].type: {tuple_arg_method.args[1].type}") + print_info(f" returns: {tuple_arg_method.returns.type}") + print_info(f" selector: {format_hex(tuple_arg_method.get_selector())}") + + nested_tuple_method = Method.from_signature("nested(((uint64,bool),string))void") + + print_info("\nSignature: nested(((uint64,bool),string))void") + print_info(f" name: {nested_tuple_method.name}") + print_info(f" args[0].type: {nested_tuple_method.args[0].type}") + print_info(f" returns: {nested_tuple_method.returns.type}") + print_info(f" selector: {format_hex(nested_tuple_method.get_selector())}") + + # Step 9: Methods with tuple returns + print_step(9, "Methods with Tuple Returns") + + tuple_return_method = Method.from_signature("getInfo(address)(uint64,string,bool)") + + print_info("Signature: getInfo(address)(uint64,string,bool)") + print_info(f" name: {tuple_return_method.name}") + print_info(f" args: [{', '.join(str(a.type) for a in tuple_return_method.args)}]") + print_info(f" returns.type: {tuple_return_method.returns.type} (tuple)") + print_info(f" selector: {format_hex(tuple_return_method.get_selector())}") + + complex_return_method = Method.from_signature("swap(uint64,uint64)(uint64,uint64,address)") + + print_info("\nSignature: swap(uint64,uint64)(uint64,uint64,address)") + print_info(f" name: {complex_return_method.name}") + print_info(f" args: [{', '.join(str(a.type) for a in complex_return_method.args)}]") + print_info(f" returns: {complex_return_method.returns.type}") + print_info(f" selector: {format_hex(complex_return_method.get_selector())}") + + # Step 10: Methods with array arguments + print_step(10, "Methods with Array Arguments") + + array_arg_method = Method.from_signature("batchTransfer(address[],uint64[])bool") + + print_info("Signature: batchTransfer(address[],uint64[])bool") + print_info(f" name: {array_arg_method.name}") + print_info(f" args: [{', '.join(str(a.type) for a in array_arg_method.args)}]") + print_info(f" returns: {array_arg_method.returns.type}") + print_info(f" selector: {format_hex(array_arg_method.get_selector())}") + + static_array_method = Method.from_signature("setVotes(uint64[5])void") + + print_info("\nSignature: setVotes(uint64[5])void") + print_info(f" name: {static_array_method.name}") + print_info(f" args: [{', '.join(str(a.type) for a in static_array_method.args)}]") + print_info(f" returns: {static_array_method.returns.type}") + print_info(f" selector: {format_hex(static_array_method.get_selector())}") + + # Step 11: get_signature() method + print_step(11, "Reconstructing Signature with get_signature()") + + print_info("The get_signature() method returns the canonical signature string.") + print_info("") + + test_methods = [ + Method.from_signature("transfer(address,uint64)uint64"), + Method.from_signature("get()uint64"), + Method.from_signature("set(uint64)void"), + Method.from_signature("process((uint64,bool),string)void"), + ] + + for method in test_methods: + print_info(f" get_signature(): {method.get_signature()}") + + # Step 12: Selector uniqueness + print_step(12, "Selector Uniqueness") + + print_info("Each method signature produces a unique 4-byte selector.") + print_info("Different signatures = different selectors.") + print_info("") + + different_methods = [ + Method.from_signature("get()uint64"), + Method.from_signature("get()string"), + Method.from_signature("get(uint64)uint64"), + Method.from_signature("fetch()uint64"), + ] + + print_info("Method | Selector") + print_info("------------------------|----------") + + for method in different_methods: + sig = method.get_signature().ljust(22) + sel = format_hex(method.get_selector()) + print_info(f"{sig} | {sel}") + + # Step 13: Methods with transaction and reference types + print_step(13, "Methods with Transaction and Reference Types") + + print_info("ABI methods can also include transaction and reference types:") + print_info("") + + # Transaction types + print_info("Transaction types (for group transaction arguments):") + for tx_type in TransactionType: + print_info(f" {tx_type.name}: '{tx_type.value}'") + + print_info("") + + # Reference types + print_info("Reference types (for foreign references):") + for ref_type in ReferenceType: + print_info(f" {ref_type.name}: '{ref_type.value}'") + + print_info("") + + # Parse a method with transaction type + swap_with_payment = Method.from_signature("swap(asset,asset,pay,uint64)uint64") + print_info("Method: swap(asset,asset,pay,uint64)uint64") + print_info(f" name: {swap_with_payment.name}") + print_info(f" args count: {len(swap_with_payment.args)}") + + for i, arg in enumerate(swap_with_payment.args): + arg_type = arg.type + type_category = ( + "transaction" + if isinstance(arg_type, TransactionType) + else ("reference" if isinstance(arg_type, ReferenceType) else "ABI") + ) + print_info(f" args[{i}]: {arg_type} ({type_category})") + + print_info(f" transaction arg count: {swap_with_payment.get_txn_calls()}") + + # Step 14: Summary + print_step(14, "Summary") + + print_info("Method provides tools for working with ABI method signatures:") + print_info("") + print_info("Parsing:") + print_info(" Method.from_signature(sig) - Parse a method signature string") + print_info("") + print_info("Properties:") + print_info(" method.name - Method name (string)") + print_info(" method.args - Sequence of argument descriptors") + print_info(" method.args[i].type - ABIType, TransactionType, or ReferenceType") + print_info(" method.returns.type - ABIType of return value (or 'void')") + print_info(" method.signature - Canonical signature string") + print_info(" method.selector - 4-byte selector (bytes)") + print_info("") + print_info("Methods:") + print_info(" get_signature() - Get canonical signature string") + print_info(" get_selector() - Get 4-byte selector (bytes)") + print_info(" get_txn_calls() - Count transaction-type arguments") + print_info("") + print_info("Selector computation:") + print_info(" selector = SHA-512/256(signature)[0:4]") + print_info("") + print_info("Supported signatures:") + print_info(" - Simple: name(type1,type2)returnType") + print_info(" - No args: name()returnType") + print_info(" - Void: name(type1)void") + print_info(" - Tuples: name((t1,t2),t3)(r1,r2)") + print_info(" - Arrays: name(type[],type[N])type") + print_info(" - References: name(asset,account,application)type") + print_info(" - Transactions: name(txn,pay,axfer)type") + + print_success("ABI Method example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/abi/12_avm_types.py b/examples/abi/12_avm_types.py new file mode 100644 index 00000000..16079cee --- /dev/null +++ b/examples/abi/12_avm_types.py @@ -0,0 +1,374 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: AVM Type Encoding + +This example demonstrates how to work with AVM-specific types: +- AVMBytes: Raw byte arrays (no length prefix, unlike ABI string/bytes) +- AVMString: UTF-8 strings (no length prefix, unlike ABI string) +- AVMUint64: 64-bit unsigned integers (8 bytes, big-endian) + +AVM types represent how data is stored natively on the AVM stack, +while ABI types follow the ARC-4 encoding specification with length prefixes. + +The Python SDK provides the AVMType enum in algokit_abi.arc56 +with values: AVMType.BYTES, AVMType.STRING, AVMType.UINT64 + +No LocalNet required - pure ABI encoding/decoding +""" + +from shared import format_hex, print_header, print_info, print_step, print_success + +from algokit_abi import abi +from algokit_abi.arc56 import AVMType + + +def is_avm_type(type_str: str) -> bool: + """Check if a type string is an AVM type.""" + return type_str in (AVMType.BYTES.value, AVMType.STRING.value, AVMType.UINT64.value) + + +def encode_avm_value_raw(avm_type: AVMType, value: str | bytes | int) -> bytes: + """ + Encode a value to raw AVM representation (as conceptualized in ARC-56). + + ARC-56 defines AVM types as having NO length prefixes: + - AVMString: Raw UTF-8 bytes (no 2-byte length prefix) + - AVMBytes: Raw bytes as-is + - AVMUint64: 8-byte big-endian encoding + + Args: + avm_type: The AVM type to encode as + value: The value to encode + + Returns: + Encoded bytes + """ + if avm_type == AVMType.STRING: + # Raw UTF-8 bytes - no length prefix + if isinstance(value, str): + return value.encode("utf-8") + return bytes(value) if isinstance(value, bytes) else str(value).encode("utf-8") + + if avm_type == AVMType.BYTES: + # Raw bytes as-is + if isinstance(value, str): + return value.encode("utf-8") + if isinstance(value, bytes): + return value + return bytes(value) + + if avm_type == AVMType.UINT64: + # 8-byte big-endian encoding + int_value = value if isinstance(value, int) else int(value) + return int_value.to_bytes(8, "big") + + raise ValueError(f"Unknown AVM type: {avm_type}") + + +def decode_avm_value(avm_type: AVMType, data: bytes) -> str | bytes | int: + """ + Decode raw AVM bytes to a value. + + Args: + avm_type: The AVM type to decode as + data: The bytes to decode + + Returns: + Decoded value (string, bytes, or int) + """ + if avm_type == AVMType.STRING: + return data.decode("utf-8") + + if avm_type == AVMType.BYTES: + return data + + if avm_type == AVMType.UINT64: + return int.from_bytes(data, "big") + + raise ValueError(f"Unknown AVM type: {avm_type}") + + +def main() -> None: + print_header("AVM Type Encoding Example") + + # Step 1: Introduction to AVM Types + print_step(1, "Introduction to AVM Types") + + print_info("AVM types represent native Algorand Virtual Machine stack values.") + print_info("") + print_info("Three AVM types:") + print_info(" AVMBytes - Raw byte array (no length prefix)") + print_info(" AVMString - UTF-8 string (no length prefix)") + print_info(" AVMUint64 - 64-bit unsigned integer (8 bytes, big-endian)") + print_info("") + print_info("Key difference from ABI types:") + print_info(" ABI string/bytes: 2-byte length prefix + data") + print_info(" AVM string/bytes: Raw data only (no prefix)") + + # Step 2: AVMBytes type + print_step(2, "AVMBytes - Raw Byte Arrays") + + avm_bytes_type = AVMType.BYTES + print_info(f"Type: {avm_bytes_type.value}") + print_info(f'is_avm_type("AVMBytes"): {is_avm_type("AVMBytes")}') + print_info("") + + # Encode raw bytes + raw_bytes = bytes([0x48, 0x65, 0x6C, 0x6C, 0x6F]) # "Hello" in ASCII + avm_bytes_encoded = encode_avm_value_raw(AVMType.BYTES, raw_bytes) + + print_info('Encoding raw bytes [0x48, 0x65, 0x6c, 0x6c, 0x6f] ("Hello"):') + print_info(f" Input bytes: {format_hex(raw_bytes)}") + print_info(f" Encoded: {format_hex(avm_bytes_encoded)}") + print_info(f" Length: {len(avm_bytes_encoded)} bytes") + print_info("") + + # Decode back + avm_bytes_decoded = decode_avm_value(AVMType.BYTES, avm_bytes_encoded) + print_info("Decoding AVMBytes:") + print_info(f" Result type: {type(avm_bytes_decoded).__name__}") + print_info(f" Result: {format_hex(avm_bytes_decoded)}") + + # Step 3: AVMString type + print_step(3, "AVMString - UTF-8 Strings (No Length Prefix)") + + avm_string_type = AVMType.STRING + print_info(f"Type: {avm_string_type.value}") + print_info(f'is_avm_type("AVMString"): {is_avm_type("AVMString")}') + print_info("") + + # Encode various strings + test_strings = ["Hello", "World!", "Algorand"] + + for s in test_strings: + encoded = encode_avm_value_raw(AVMType.STRING, s) + print_info(f'"{s}":') + print_info(f" Encoded: {format_hex(encoded)}") + print_info(f" Length: {len(encoded)} bytes") + + print_info("") + + # Decode back + encoded_hello = encode_avm_value_raw(AVMType.STRING, "Hello") + decoded_hello = decode_avm_value(AVMType.STRING, encoded_hello) + print_info("Decoding AVMString:") + print_info(f" Input: {format_hex(encoded_hello)}") + print_info(f' Result: "{decoded_hello}"') + print_info(f" Result type: {type(decoded_hello).__name__}") + + # Step 4: AVMUint64 type + print_step(4, "AVMUint64 - 64-bit Unsigned Integers") + + avm_uint64_type = AVMType.UINT64 + print_info(f"Type: {avm_uint64_type.value}") + print_info(f'is_avm_type("AVMUint64"): {is_avm_type("AVMUint64")}') + print_info("") + + # Encode various uint64 values + test_numbers = [0, 1, 255, 1000, 1000000, 2**32 - 1, 2**64 - 1] + + print_info("Encoding uint64 values (8-byte big-endian):") + for num in test_numbers: + encoded = encode_avm_value_raw(AVMType.UINT64, num) + print_info(f" {str(num).rjust(20)}: {format_hex(encoded)}") + + print_info("") + + # Decode back + encoded_1000 = encode_avm_value_raw(AVMType.UINT64, 1000) + decoded_1000 = decode_avm_value(AVMType.UINT64, encoded_1000) + print_info("Decoding AVMUint64:") + print_info(f" Input: {format_hex(encoded_1000)}") + print_info(f" Result: {decoded_1000}") + print_info(f" Result type: {type(decoded_1000).__name__}") + + # Step 5: Compare AVM encoding vs ABI encoding + print_step(5, "AVM Encoding vs ABI Encoding Comparison") + + print_info("Comparing how the same values encode differently:") + print_info("") + + # String comparison + test_string = "Hello" + avm_string_encoded = encode_avm_value_raw(AVMType.STRING, test_string) + abi_string_type = abi.ABIType.from_string("string") + abi_string_encoded = abi_string_type.encode(test_string) + + print_info(f'String: "{test_string}"') + print_info(f" AVM encoding: {format_hex(avm_string_encoded)}") + print_info(f" Length: {len(avm_string_encoded)} bytes (raw UTF-8 only)") + print_info(f" ABI encoding: {format_hex(abi_string_encoded)}") + print_info(f" Length: {len(abi_string_encoded)} bytes (2-byte prefix + UTF-8)") + length_value = (abi_string_encoded[0] << 8) | abi_string_encoded[1] + print_info(f" First 2 bytes: {format_hex(abi_string_encoded[:2])} = {length_value} (length)") + print_info("") + + # Bytes comparison + test_bytes_array = bytes([0xDE, 0xAD, 0xBE, 0xEF]) + avm_bytes_encoded_cmp = encode_avm_value_raw(AVMType.BYTES, test_bytes_array) + # ABI has no "bytes" type - closest is byte[] or string; we'll use static byte[4] + abi_byte4_type = abi.ABIType.from_string("byte[4]") + abi_byte4_encoded = abi_byte4_type.encode(list(test_bytes_array)) + + print_info("Bytes: [0xde, 0xad, 0xbe, 0xef]") + print_info(f" AVMBytes encoding: {format_hex(avm_bytes_encoded_cmp)}") + print_info(f" Length: {len(avm_bytes_encoded_cmp)} bytes (raw bytes only)") + print_info(f" ABI byte[4] encoding: {format_hex(abi_byte4_encoded)}") + print_info(f" Length: {len(abi_byte4_encoded)} bytes (static array, no prefix)") + print_info("") + + # Uint64 comparison + test_uint64 = 1000 + avm_uint64_encoded = encode_avm_value_raw(AVMType.UINT64, test_uint64) + abi_uint64_type = abi.ABIType.from_string("uint64") + abi_uint64_encoded = abi_uint64_type.encode(test_uint64) + + print_info(f"Uint64: {test_uint64}") + print_info(f" AVM encoding: {format_hex(avm_uint64_encoded)}") + print_info(f" Length: {len(avm_uint64_encoded)} bytes") + print_info(f" ABI encoding: {format_hex(abi_uint64_encoded)}") + print_info(f" Length: {len(abi_uint64_encoded)} bytes") + print_info(f" Match: {avm_uint64_encoded == abi_uint64_encoded}") + print_info(" (uint64 encoding is identical - both are 8 bytes big-endian)") + + # Step 6: is_avm_type helper function + print_step(6, "is_avm_type Helper Function") + + print_info("Use is_avm_type() to check if a type string is an AVM type:") + print_info("") + + type_checks = [ + "AVMBytes", + "AVMString", + "AVMUint64", + "uint64", + "string", + "address", + "byte[]", + "(uint64,bool)", + ] + + for type_str in type_checks: + is_avm = is_avm_type(type_str) + print_info(f' is_avm_type("{type_str}"): {is_avm}') + + # Step 7: AVMType enum values + print_step(7, "AVMType Enum Values") + + print_info("The AVMType enum provides type-safe AVM type constants:") + print_info("") + + print_info(f" AVMType.BYTES: value = '{AVMType.BYTES.value}'") + print_info(f" AVMType.STRING: value = '{AVMType.STRING.value}'") + print_info(f" AVMType.UINT64: value = '{AVMType.UINT64.value}'") + print_info("") + print_info("Access via enum member or string value:") + avm_bytes_match = AVMType("AVMBytes") == AVMType.BYTES + print_info(f" AVMType.BYTES == AVMType('AVMBytes'): {avm_bytes_match}") + + # Step 8: When to use AVM types vs ABI types + print_step(8, "When to Use AVM Types vs ABI Types") + + print_info("Use AVM types when:") + print_info(" - Working with raw AVM stack values (global/local state, box storage)") + print_info(" - Reading/writing app state where values have no length prefix") + print_info(" - The ARC-56 spec specifies AVMBytes, AVMString, or AVMUint64") + print_info("") + print_info("Use ABI types when:") + print_info(" - Encoding method arguments for ARC-4 ABI method calls") + print_info(" - Encoding method return values following ARC-4 specification") + print_info(' - The type is an ARC-4 type like "uint64", "string", "address"') + print_info("") + print_info("Example scenarios:") + print_info(" - App global state value stored as uint64 -> AVMUint64") + print_info(" - App global state key stored as string -> AVMString") + print_info(" - Box content stored as raw bytes -> AVMBytes") + print_info(' - ABI method arg of type "string" -> ABIStringType (with length prefix)') + print_info(' - ABI method return of type "uint64" -> ABIUintType (same encoding)') + + # Step 9: Practical example - Encoding for app state + print_step(9, "Practical Example - Encoding for App State") + + print_info("Simulating app state encoding (as seen in ARC-56 contracts):") + print_info("") + + # Simulate a key-value pair in global state + state_key = "counter" + state_value = 42 + + # Keys are typically AVMString (no length prefix in state key) + encoded_key = encode_avm_value_raw(AVMType.STRING, state_key) + # Values can be AVMUint64 for integer values + encoded_value = encode_avm_value_raw(AVMType.UINT64, state_value) + + print_info("Global state entry:") + print_info(f' Key: "{state_key}"') + print_info(f" Key encoded (AVMString): {format_hex(encoded_key)}") + print_info(f" Value: {state_value}") + print_info(f" Value encoded (AVMUint64): {format_hex(encoded_value)}") + print_info("") + + # Decode back + decoded_key = decode_avm_value(AVMType.STRING, encoded_key) + decoded_value = decode_avm_value(AVMType.UINT64, encoded_value) + + print_info("Decoding back:") + print_info(f' Key: "{decoded_key}"') + print_info(f" Value: {decoded_value}") + + # Step 10: Round-trip verification + print_step(10, "Round-Trip Verification") + + print_info("Verifying encode/decode round-trips preserve values:") + print_info("") + + # AVMString round-trip + original_string = "AlgorandFoundation" + enc_string = encode_avm_value_raw(AVMType.STRING, original_string) + dec_string = decode_avm_value(AVMType.STRING, enc_string) + match_string = original_string == dec_string + print_info(f'AVMString "{original_string}": {"PASS" if match_string else "FAIL"}') + + # AVMBytes round-trip + original_bytes = bytes([1, 2, 3, 4, 5, 6, 7, 8]) + enc_bytes = encode_avm_value_raw(AVMType.BYTES, original_bytes) + dec_bytes = decode_avm_value(AVMType.BYTES, enc_bytes) + match_bytes = original_bytes == dec_bytes + print_info(f"AVMBytes [1,2,3,4,5,6,7,8]: {'PASS' if match_bytes else 'FAIL'}") + + # AVMUint64 round-trip + original_uint64 = 9007199254740991 # Max safe integer + enc_uint64 = encode_avm_value_raw(AVMType.UINT64, original_uint64) + dec_uint64 = decode_avm_value(AVMType.UINT64, enc_uint64) + match_uint64 = original_uint64 == dec_uint64 + print_info(f"AVMUint64 {original_uint64}: {'PASS' if match_uint64 else 'FAIL'}") + + # Step 11: Summary + print_step(11, "Summary") + + print_info("AVM Type Summary:") + print_info("") + print_info("Types:") + print_info(" AVMBytes - Raw bytes, no length prefix") + print_info(" AVMString - UTF-8 string, no length prefix") + print_info(" AVMUint64 - 8-byte big-endian unsigned integer") + print_info("") + print_info("AVMType Enum:") + print_info(" AVMType.BYTES - 'AVMBytes'") + print_info(" AVMType.STRING - 'AVMString'") + print_info(" AVMType.UINT64 - 'AVMUint64'") + print_info("") + print_info("Key Differences from ABI:") + print_info(" - AVMString has no 2-byte length prefix (ABI string does)") + print_info(" - AVMBytes is raw (ABI uses length-prefixed byte arrays)") + print_info(" - AVMUint64 encoding is identical to ABI uint64") + print_info("") + print_info("Use Cases:") + print_info(" - AVM types: App state, box storage, raw stack values") + print_info(" - ABI types: Method calls, ARC-4 encoded arguments/returns") + + print_success("AVM Type Encoding example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/abi/13_type_guards.py b/examples/abi/13_type_guards.py new file mode 100644 index 00000000..b2c8189e --- /dev/null +++ b/examples/abi/13_type_guards.py @@ -0,0 +1,323 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Type Guards + +This example demonstrates how to check argument and type categories in the ABI system: + +- TransactionType: Check if type is a transaction type (txn, pay, keyreg, acfg, axfer, afrz, appl) +- ReferenceType: Check if type is a reference type (account, asset, application) +- ABIType: Standard ABI types (not transaction or reference) +- AVMType: AVM-specific types (AVMBytes, AVMString, AVMUint64) + +In Python, use isinstance() checks with TransactionType and ReferenceType enums, +and the abi.ABIType base class to determine type categories. + +These checks are essential for: +- Method argument handling and routing +- Type narrowing for safer code +- Determining how to encode/decode values based on type category + +No LocalNet required - pure ABI encoding/decoding +""" + +from shared import print_header, print_info, print_step, print_success + +from algokit_abi import abi +from algokit_abi.arc56 import AVMType, Method, ReferenceType, TransactionType + + +def is_transaction_type(arg_type: abi.ABIType | ReferenceType | TransactionType) -> bool: + """Check if the argument type is a transaction type.""" + return isinstance(arg_type, TransactionType) + + +def is_reference_type(arg_type: abi.ABIType | ReferenceType | TransactionType) -> bool: + """Check if the argument type is a reference type.""" + return isinstance(arg_type, ReferenceType) + + +def is_abi_type(arg_type: abi.ABIType | ReferenceType | TransactionType) -> bool: + """Check if the argument type is a standard ABI type (not transaction or reference).""" + return isinstance(arg_type, abi.ABIType) + + +def is_avm_type(type_str: str) -> bool: + """Check if a type string is an AVM-specific type.""" + return type_str in (AVMType.BYTES.value, AVMType.STRING.value, AVMType.UINT64.value) + + +def main() -> None: + print_header("Type Guards Example") + + # Step 1: Introduction to type categories + print_step(1, "Introduction to Type Categories") + + print_info("In ABI method calls, arguments can be categorized into:") + print_info("") + print_info("1. Transaction types: Represent transaction arguments") + print_info(" txn, pay, keyreg, acfg, axfer, afrz, appl") + print_info("") + print_info("2. Reference types: Represent references to on-chain entities") + print_info(" account, asset, application") + print_info("") + print_info("3. ABI types: Standard ARC-4 encoded types") + print_info(" uint64, string, address, (tuple), arrays, etc.") + print_info("") + print_info("4. AVM types: Native AVM stack value types") + print_info(" AVMBytes, AVMString, AVMUint64") + + # Step 2: Transaction type checking + print_step(2, "TransactionType - Check for Transaction Types") + + print_info("Transaction types identify arguments that must be transactions:") + print_info("") + + print_info("TransactionType enum values:") + for tx_type in TransactionType: + print_info(f" TransactionType.{tx_type.name}: '{tx_type.value}'") + + print_info("") + + # Test with method arguments + print_info("Testing isinstance(arg_type, TransactionType):") + test_types = [ + ("TransactionType.ANY", TransactionType.ANY), + ("TransactionType.PAY", TransactionType.PAY), + ("TransactionType.KEYREG", TransactionType.KEYREG), + ("TransactionType.ACFG", TransactionType.ACFG), + ("TransactionType.AXFER", TransactionType.AXFER), + ("TransactionType.AFRZ", TransactionType.AFRZ), + ("TransactionType.APPL", TransactionType.APPL), + ] + + for name, tx_type in test_types: + result = is_transaction_type(tx_type) + print_info(f" is_transaction_type({name}): {result}") + + # Step 3: Reference type checking + print_step(3, "ReferenceType - Check for Reference Types") + + print_info("Reference types identify foreign references in method calls:") + print_info("") + + print_info("ReferenceType enum values:") + for ref_type in ReferenceType: + print_info(f" ReferenceType.{ref_type.name}: '{ref_type.value}'") + + print_info("") + + print_info("Testing isinstance(arg_type, ReferenceType):") + ref_test_types = [ + ("ReferenceType.ACCOUNT", ReferenceType.ACCOUNT), + ("ReferenceType.ASSET", ReferenceType.ASSET), + ("ReferenceType.APPLICATION", ReferenceType.APPLICATION), + ] + + for name, ref_type in ref_test_types: + result = is_reference_type(ref_type) + print_info(f" is_reference_type({name}): {result}") + + # Step 4: ABI type checking + print_step(4, "ABIType - Check for Standard ABI Types") + + print_info("ABI types are standard ARC-4 encoded types (not txn or reference):") + print_info("") + + # Create various ABI types + abi_types = [ + ("uint64", abi.ABIType.from_string("uint64")), + ("string", abi.ABIType.from_string("string")), + ("address", abi.ABIType.from_string("address")), + ("bool", abi.ABIType.from_string("bool")), + ("byte", abi.ABIType.from_string("byte")), + ("byte[32]", abi.ABIType.from_string("byte[32]")), + ("uint64[]", abi.ABIType.from_string("uint64[]")), + ("(uint64,bool)", abi.ABIType.from_string("(uint64,bool)")), + ] + + print_info("Testing isinstance(arg_type, abi.ABIType):") + for name, abi_type in abi_types: + result = is_abi_type(abi_type) + print_info(f' is_abi_type(ABIType.from_string("{name}")): {result}') + + print_info("") + print_info("Transaction and reference types are NOT ABITypes:") + print_info(f" is_abi_type(TransactionType.PAY): {is_abi_type(TransactionType.PAY)}") + print_info(f" is_abi_type(ReferenceType.ASSET): {is_abi_type(ReferenceType.ASSET)}") + + # Step 5: AVMType checking + print_step(5, "AVMType - Check for AVM-Specific Types") + + print_info("AVM types represent native Algorand Virtual Machine stack values:") + print_info("") + + avm_types = ["AVMBytes", "AVMString", "AVMUint64"] + + print_info("Testing is_avm_type():") + for avm_type in avm_types: + result = is_avm_type(avm_type) + print_info(f' is_avm_type("{avm_type}"): {result}') + + print_info("") + print_info("Non-AVM types:") + non_avm_types = ["uint64", "string", "address", "bytes", "txn", "account"] + for type_str in non_avm_types: + result = is_avm_type(type_str) + print_info(f' is_avm_type("{type_str}"): {result}') + + # Step 6: Type narrowing with type guards + print_step(6, "Type Narrowing with Type Guards") + + print_info("Type guards enable type narrowing for safer code:") + print_info("") + + def demonstrate_type_narrowing(arg_type: abi.ABIType | ReferenceType | TransactionType) -> str: + """Demonstrate type narrowing with different argument types.""" + if is_transaction_type(arg_type): + # We know arg_type is TransactionType here + return f"Transaction type detected: {arg_type.value}" # type: ignore[union-attr] + if is_reference_type(arg_type): + # We know arg_type is ReferenceType here + return f"Reference type detected: {arg_type.value}" # type: ignore[union-attr] + # Must be ABIType + return f"ABI type detected: {arg_type}" + + print_info('Testing type narrowing with TransactionType.PAY ("pay"):') + print_info(f" {demonstrate_type_narrowing(TransactionType.PAY)}") + + print_info("") + print_info('Testing type narrowing with ReferenceType.ASSET ("asset"):') + print_info(f" {demonstrate_type_narrowing(ReferenceType.ASSET)}") + + print_info("") + print_info('Testing type narrowing with ABIType.from_string("uint64"):') + print_info(f" {demonstrate_type_narrowing(abi.ABIType.from_string('uint64'))}") + + # Step 7: Practical example - Method argument handling + print_step(7, "Practical Example - Method Argument Handling") + + print_info('Consider a method: "swap(asset,asset,pay,uint64)uint64"') + print_info("") + + # Parse the method + swap_method = Method.from_signature("swap(asset,asset,pay,uint64)uint64") + + print_info(f"Method name: {swap_method.name}") + print_info(f"Number of args: {len(swap_method.args)}") + print_info("") + + # Analyze each argument + for i, arg in enumerate(swap_method.args): + arg_type = arg.type + + if is_transaction_type(arg_type): + category = "Transaction" + handling = "Pass a transaction object" + elif is_reference_type(arg_type): + category = "Reference" + handling = "Will be added to foreign arrays, arg receives index" + else: + category = "ABI" + handling = "Will be ARC-4 encoded" + + print_info(f' Arg {i}: type="{arg_type}"') + print_info(f" Category: {category}") + print_info(f" Handling: {handling}") + print_info("") + + # Step 8: All type strings test matrix + print_step(8, "Complete Type String Test Matrix") + + print_info("Testing all type guard combinations:") + print_info("") + + # Build test cases with actual type objects + test_cases: list[tuple[str, abi.ABIType | ReferenceType | TransactionType, str]] = [ + ("txn", TransactionType.ANY, "txn"), + ("pay", TransactionType.PAY, "pay"), + ("keyreg", TransactionType.KEYREG, "keyreg"), + ("acfg", TransactionType.ACFG, "acfg"), + ("axfer", TransactionType.AXFER, "axfer"), + ("afrz", TransactionType.AFRZ, "afrz"), + ("appl", TransactionType.APPL, "appl"), + ("account", ReferenceType.ACCOUNT, "account"), + ("asset", ReferenceType.ASSET, "asset"), + ("application", ReferenceType.APPLICATION, "application"), + ("uint64", abi.ABIType.from_string("uint64"), "uint64"), + ("string", abi.ABIType.from_string("string"), "string"), + ("address", abi.ABIType.from_string("address"), "address"), + ("bool", abi.ABIType.from_string("bool"), "bool"), + ] + + # Also check AVM types as strings + avm_string_tests = ["AVMBytes", "AVMString", "AVMUint64"] + + print_info(" Type | isTxn | isRef | isAbi | isAVM") + print_info(" ----------------+-------+-------+-------+------") + + for name, type_obj, _ in test_cases: + is_txn = is_transaction_type(type_obj) + is_ref = is_reference_type(type_obj) + is_abi = is_abi_type(type_obj) + is_avm = is_avm_type(name) + + pad_type = name.ljust(16) + pad_txn = str(is_txn).ljust(5) + pad_ref = str(is_ref).ljust(5) + pad_abi = str(is_abi).ljust(5) + + print_info(f" {pad_type}| {pad_txn} | {pad_ref} | {pad_abi} | {is_avm}") + + for avm_str in avm_string_tests: + pad_type = avm_str.ljust(16) + # AVM types are string identifiers, not actual type objects + print_info(f" {pad_type}| False | False | False | True") + + # Step 9: Enum values demonstration + print_step(9, "Using TransactionType and ReferenceType Enums") + + print_info("The library provides enums for type safety:") + print_info("") + + print_info("TransactionType enum:") + print_info(f' ANY: "{TransactionType.ANY.value}"') + print_info(f' PAY: "{TransactionType.PAY.value}"') + print_info(f' KEYREG: "{TransactionType.KEYREG.value}"') + print_info(f' ACFG: "{TransactionType.ACFG.value}"') + print_info(f' AXFER: "{TransactionType.AXFER.value}"') + print_info(f' AFRZ: "{TransactionType.AFRZ.value}"') + print_info(f' APPL: "{TransactionType.APPL.value}"') + print_info("") + + print_info("ReferenceType enum:") + print_info(f' ACCOUNT: "{ReferenceType.ACCOUNT.value}"') + print_info(f' ASSET: "{ReferenceType.ASSET.value}"') + print_info(f' APPLICATION: "{ReferenceType.APPLICATION.value}"') + + # Step 10: Summary + print_step(10, "Summary") + + print_info("Type Guard Summary:") + print_info("") + print_info("Functions (using isinstance):") + print_info(" isinstance(arg_type, TransactionType) - True for txn, pay, keyreg, etc.") + print_info(" isinstance(arg_type, ReferenceType) - True for account, asset, application") + print_info(" isinstance(arg_type, abi.ABIType) - True for standard ABI types") + print_info(" is_avm_type(type_str) - True for AVMBytes, AVMString, AVMUint64") + print_info("") + print_info("Use Cases:") + print_info(" - Routing method arguments to appropriate handling logic") + print_info(" - Type narrowing for safe property access") + print_info(" - Determining encoding/decoding strategy based on type category") + print_info(" - Validating method signatures and argument types") + print_info("") + print_info("Key Insight:") + print_info(" The three arg type categories are mutually exclusive:") + print_info(" - Every method arg type is exactly one of: Transaction, Reference, or ABI type") + print_info(" - AVMType is orthogonal - it checks for AVM-specific storage types (strings)") + + print_success("Type Guards example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/abi/14_complex_nested.py b/examples/abi/14_complex_nested.py new file mode 100644 index 00000000..75485342 --- /dev/null +++ b/examples/abi/14_complex_nested.py @@ -0,0 +1,471 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: ABI Complex Nested Types + +This example demonstrates how to work with deeply nested ABI types combining +arrays, tuples, and structs: +- Array of tuples: (uint64,string)[] +- Tuple containing arrays: (uint64[],string[]) +- Nested structs with arrays +- Deeply nested type: ((uint64,bool)[],string,(address,uint256))[] + +Key concepts: +- Dynamic types (strings, dynamic arrays) always use head/tail encoding +- Offsets in head section point to data positions in tail section +- Nesting depth affects encoding complexity but follows consistent rules +- Round-trip encoding/decoding preserves all nested values + +No LocalNet required - pure ABI encoding/decoding +""" + +from shared import format_bytes, format_hex, print_header, print_info, print_step, print_success + +from algokit_abi import abi +from algokit_common import address_from_public_key + + +def main() -> None: + print_header("ABI Complex Nested Types Example") + + # Step 1: Array of tuples - (uint64,string)[] + print_step(1, "Array of Tuples - (uint64,string)[]") + + array_of_tuples_type = abi.ABIType.from_string("(uint64,string)[]") + + print_info("Type: (uint64,string)[]") + print_info(f" str(): {array_of_tuples_type}") + if isinstance(array_of_tuples_type, abi.DynamicArrayType): + print_info(f" is_dynamic(): {array_of_tuples_type.is_dynamic()}") + print_info(f" element: {array_of_tuples_type.element}") + print_info(f" element.is_dynamic(): {array_of_tuples_type.element.is_dynamic()} (because string is dynamic)") + + tuple_array_value = [ + [100, "First"], + [200, "Second"], + [300, "Third"], + ] + + if isinstance(array_of_tuples_type, abi.DynamicArrayType): + tuple_array_encoded = array_of_tuples_type.encode(tuple_array_value) + + print_info('\nInput: [[100, "First"], [200, "Second"], [300, "Third"]]') + print_info(f"Encoded: {format_hex(tuple_array_encoded)}") + print_info(f"Total bytes: {len(tuple_array_encoded)}") + + print_info("\nByte layout (dynamic array of dynamic tuples):") + print_info(" [0-1] Array length prefix") + + num_tuples = (tuple_array_encoded[0] << 8) | tuple_array_encoded[1] + print_info(f" {format_hex(tuple_array_encoded[0:2])} = {num_tuples} elements") + + print_info("\n HEAD SECTION (offsets to each tuple):") + for i in range(num_tuples): + offset_pos = 2 + i * 2 + offset = (tuple_array_encoded[offset_pos] << 8) | tuple_array_encoded[offset_pos + 1] + print_info( + f" [{offset_pos}-{offset_pos + 1}] Tuple {i} offset: " + f"{format_hex(tuple_array_encoded[offset_pos : offset_pos + 2])} = {offset}" + ) + + print_info("\n TAIL SECTION (tuple data):") + head_end = 2 + num_tuples * 2 + print_info(f" Starts at byte {head_end}") + print_info(" Each tuple has: [uint64:8 bytes][string_offset:2 bytes][string_len:2][string_data:N]") + + # Decode and verify + tuple_array_decoded = list(array_of_tuples_type.decode(tuple_array_encoded)) + + print_info("\nDecoded:") + for i, tup in enumerate(tuple_array_decoded): + print_info(f' [{i}]: [{tup[0]}, "{tup[1]}"]') + + tuple_array_match = all( + tuple_array_decoded[i][0] == tuple_array_value[i][0] + and tuple_array_decoded[i][1] == tuple_array_value[i][1] + for i in range(len(tuple_array_value)) + ) + print_info(f"Round-trip verified: {tuple_array_match}") + + # Step 2: Tuple containing arrays - (uint64[],string[]) + print_step(2, "Tuple Containing Arrays - (uint64[],string[])") + + tuple_with_arrays_type = abi.ABIType.from_string("(uint64[],string[])") + + print_info("Type: (uint64[],string[])") + print_info(f" str(): {tuple_with_arrays_type}") + if isinstance(tuple_with_arrays_type, abi.TupleType): + print_info(f" is_dynamic(): {tuple_with_arrays_type.is_dynamic()}") + print_info(f" elements: {len(tuple_with_arrays_type.elements)} elements") + for i, child in enumerate(tuple_with_arrays_type.elements): + print_info(f" [{i}]: {child} (is_dynamic: {child.is_dynamic()})") + + tuple_with_arrays_value = [ + [10, 20, 30], + ["Apple", "Banana", "Cherry"], + ] + + if isinstance(tuple_with_arrays_type, abi.TupleType): + tuple_with_arrays_encoded = tuple_with_arrays_type.encode(tuple_with_arrays_value) + + print_info('\nInput: [[10, 20, 30], ["Apple", "Banana", "Cherry"]]') + print_info(f"Encoded: {format_bytes(tuple_with_arrays_encoded, 16)}") + print_info(f"Total bytes: {len(tuple_with_arrays_encoded)}") + + print_info("\nByte layout (tuple with 2 dynamic children):") + print_info(" HEAD SECTION (2 offsets):") + + arr1_offset = (tuple_with_arrays_encoded[0] << 8) | tuple_with_arrays_encoded[1] + arr2_offset = (tuple_with_arrays_encoded[2] << 8) | tuple_with_arrays_encoded[3] + + print_info(f" [0-1] uint64[] offset: {format_hex(tuple_with_arrays_encoded[0:2])} = {arr1_offset}") + print_info(f" [2-3] string[] offset: {format_hex(tuple_with_arrays_encoded[2:4])} = {arr2_offset}") + + print_info("\n TAIL SECTION:") + print_info(f" uint64[] at offset {arr1_offset}: [len:2][elem1:8][elem2:8][elem3:8]") + print_info(f" string[] at offset {arr2_offset}: [len:2][offsets...][string data...]") + + # Decode and verify + tuple_with_arrays_decoded = tuple_with_arrays_type.decode(tuple_with_arrays_encoded) + + print_info("\nDecoded:") + print_info(f" uint64[]: [{', '.join(str(v) for v in tuple_with_arrays_decoded[0])}]") + str_list = ", ".join(f'"{s}"' for s in tuple_with_arrays_decoded[1]) + print_info(f" string[]: [{str_list}]") + + tuple_with_arrays_match = ( + list(tuple_with_arrays_decoded[0]) == tuple_with_arrays_value[0] + and list(tuple_with_arrays_decoded[1]) == tuple_with_arrays_value[1] + ) + print_info(f"Round-trip verified: {tuple_with_arrays_match}") + + # Step 3: Nested structs with arrays + print_step(3, "Nested Structs with Arrays") + + # Create struct definition + order_struct = abi.StructType( + struct_name="Order", + fields={ + "orderId": abi.UintType(64), + "items": abi.DynamicArrayType(abi.StringType()), + "quantities": abi.DynamicArrayType(abi.UintType(32)), + }, + ) + + print_info("Order struct: { orderId: uint64, items: string[], quantities: uint32[] }") + print_info(f" ABI type: {order_struct}") + print_info(f" is_dynamic(): {order_struct.is_dynamic()}") + + order_value = { + "orderId": 12345, + "items": ["Widget", "Gadget", "Gizmo"], + "quantities": [2, 5, 1], + } + + order_encoded = order_struct.encode(order_value) + + print_info('\nInput: { orderId: 12345, items: ["Widget", "Gadget", "Gizmo"], quantities: [2, 5, 1] }') + print_info(f"Encoded: {format_bytes(order_encoded, 20)}") + print_info(f"Total bytes: {len(order_encoded)}") + + print_info("\nByte layout (struct with static + dynamic fields):") + print_info(" HEAD SECTION:") + print_info(f" [0-7] orderId (uint64): {format_hex(order_encoded[0:8])} = {order_value['orderId']}") + + items_offset = (order_encoded[8] << 8) | order_encoded[9] + quantities_offset = (order_encoded[10] << 8) | order_encoded[11] + + print_info(f" [8-9] items offset: {format_hex(order_encoded[8:10])} = {items_offset}") + print_info(f" [10-11] quantities offset: {format_hex(order_encoded[10:12])} = {quantities_offset}") + + print_info("\n TAIL SECTION:") + print_info(f" items (string[]) at offset {items_offset}") + print_info(f" quantities (uint32[]) at offset {quantities_offset}") + + # Decode and verify + order_decoded = order_struct.decode(order_encoded) + + print_info("\nDecoded:") + print_info(f" orderId: {order_decoded['orderId']}") + items_str = ", ".join(f'"{s}"' for s in order_decoded["items"]) + print_info(f" items: [{items_str}]") + print_info(f" quantities: [{', '.join(str(q) for q in order_decoded['quantities'])}]") + + order_match = ( + order_decoded["orderId"] == order_value["orderId"] + and list(order_decoded["items"]) == order_value["items"] + and [int(q) for q in order_decoded["quantities"]] == order_value["quantities"] + ) + print_info(f"Round-trip verified: {order_match}") + + # Step 4: Deeply nested type - ((uint64,bool)[],string,(address,uint256))[] + print_step(4, "Deeply Nested Type - ((uint64,bool)[],string,(address,uint256))[]") + + deeply_nested_type = abi.ABIType.from_string("((uint64,bool)[],string,(address,uint256))[]") + + print_info("Type: ((uint64,bool)[],string,(address,uint256))[]") + print_info(f" str(): {deeply_nested_type}") + if isinstance(deeply_nested_type, abi.DynamicArrayType): + print_info(f" is_dynamic(): {deeply_nested_type.is_dynamic()}") + + inner_tuple_type = deeply_nested_type.element + print_info(f"\n Child tuple type: {inner_tuple_type}") + print_info(" Child tuple elements:") + if isinstance(inner_tuple_type, abi.TupleType): + for i, child in enumerate(inner_tuple_type.elements): + print_info(f" [{i}]: {child} (is_dynamic: {child.is_dynamic()})") + + # Create sample addresses + pub_key1 = bytes([0xAA] * 32) + pub_key2 = bytes([0xBB] * 32) + addr1 = address_from_public_key(pub_key1) + addr2 = address_from_public_key(pub_key2) + + # Create deeply nested value + deeply_nested_value = [ + [ + [[1, True], [2, False]], # (uint64,bool)[] + "First Entry", # string + [addr1, 10**18], # (address,uint256) + ], + [ + [[10, False], [20, True], [30, True]], # (uint64,bool)[] + "Second Entry", # string + [addr2, 2 * 10**18], # (address,uint256) + ], + ] + + if isinstance(deeply_nested_type, abi.DynamicArrayType): + deeply_nested_encoded = deeply_nested_type.encode(deeply_nested_value) + + print_info("\nInput:") + print_info(" [") + print_info(' [[[1, True], [2, False]], "First Entry", [addr1, 1e18]],') + print_info(' [[[10, False], [20, True], [30, True]], "Second Entry", [addr2, 2e18]]') + print_info(" ]") + print_info(f"\nEncoded: {format_bytes(deeply_nested_encoded, 24)}") + print_info(f"Total bytes: {len(deeply_nested_encoded)}") + + print_info("\nEncoding structure (simplified):") + print_info(" OUTER ARRAY:") + print_info(" [0-1] Array length prefix (2 elements)") + print_info(" [2-3] Offset to element 0") + print_info(" [4-5] Offset to element 1") + print_info(" [6+] Element data (each element is a complex tuple)") + + print_info("\n EACH INNER TUPLE ((uint64,bool)[],string,(address,uint256)):") + print_info(" HEAD: [arr_offset:2][string_offset:2][addr:32][uint256:32]") + print_info(" TAIL: [(uint64,bool)[] data][string data]") + + print_info("\n INNERMOST (uint64,bool)[]:") + print_info(" [len:2][elem0:9][elem1:9]... (each tuple is 8+1=9 bytes)") + + # Decode and verify + deeply_nested_decoded = list(deeply_nested_type.decode(deeply_nested_encoded)) + + print_info("\nDecoded:") + for i, entry in enumerate(deeply_nested_decoded): + print_info(f" Entry {i}:") + inner_pairs = entry[0] + pair_strs = [f"[{t[0]}, {t[1]}]" for t in inner_pairs] + print_info(f" (uint64,bool)[]: [{', '.join(pair_strs)}]") + print_info(f' string: "{entry[1]}"') + print_info(f" (address,uint256): [{str(entry[2][0])[:10]}..., {entry[2][1]}]") + + # Verify round-trip + deep_match = len(deeply_nested_decoded) == len(deeply_nested_value) + for i in range(len(deeply_nested_value)): + orig = deeply_nested_value[i] + dec = deeply_nested_decoded[i] + # Check (uint64,bool)[] + deep_match = deep_match and len(orig[0]) == len(dec[0]) + for j in range(len(orig[0])): + deep_match = deep_match and orig[0][j][0] == dec[0][j][0] and orig[0][j][1] == dec[0][j][1] + # Check string + deep_match = deep_match and orig[1] == dec[1] + # Check (address,uint256) + deep_match = deep_match and orig[2][0] == dec[2][0] and orig[2][1] == dec[2][1] + print_info(f"Round-trip verified: {deep_match}") + + # Step 5: Encoding size analysis + print_step(5, "Encoding Size Analysis") + + print_info("Comparing encoding sizes for different nesting levels:") + + # Simple static tuple + simple_type = abi.ABIType.from_string("(uint64,bool)") + simple_encoded = simple_type.encode([1, True]) + print_info("\n (uint64,bool) = [1, True]:") + print_info(f" Size: {len(simple_encoded)} bytes (8 + 1 = 9, all static)") + + # Array of static tuples + static_array_type = abi.ABIType.from_string("(uint64,bool)[]") + static_array_encoded = static_array_type.encode([[1, True], [2, False]]) + print_info("\n (uint64,bool)[] = [[1, True], [2, False]]:") + print_info(f" Size: {len(static_array_encoded)} bytes (2 length + 2*9 elements = 20)") + + # Tuple with dynamic element + dynamic_tuple_type = abi.ABIType.from_string("(uint64,string)") + dynamic_tuple_encoded = dynamic_tuple_type.encode([1, "Hello"]) + print_info('\n (uint64,string) = [1, "Hello"]:') + print_info(f" Size: {len(dynamic_tuple_encoded)} bytes (8 + 2 offset + 2 len + 5 content = 17)") + + # Array of tuples with dynamic element + dynamic_array_type = abi.ABIType.from_string("(uint64,string)[]") + dynamic_array_encoded = dynamic_array_type.encode([[1, "Hi"], [2, "Bye"]]) + print_info('\n (uint64,string)[] = [[1, "Hi"], [2, "Bye"]]:') + print_info(f" Size: {len(dynamic_array_encoded)} bytes") + print_info(" Breakdown: 2 array_len + 2*2 offsets + 2*(8+2+2+N) per tuple") + + # Deep nesting size + print_info("\n ((uint64,bool)[],string,(address,uint256))[] with 2 complex elements:") + print_info(f" Size: {len(deeply_nested_encoded)} bytes") + print_info(" Each element has: array of tuples + string + (address,uint256) tuple") + + # Step 6: Static vs dynamic arrays inside tuples + print_step(6, "Static vs Dynamic Arrays Inside Tuples") + + # Tuple with static array + tuple_with_static_array_type = abi.ABIType.from_string("(uint64[3],bool)") + tuple_with_static_array_value = [[1, 2, 3], True] + if isinstance(tuple_with_static_array_type, abi.TupleType): + tuple_with_static_array_encoded = tuple_with_static_array_type.encode(tuple_with_static_array_value) + + print_info("Tuple with static array: (uint64[3],bool)") + print_info(" Input: [[1, 2, 3], True]") + print_info(f" Encoded: {format_hex(tuple_with_static_array_encoded)}") + print_info(f" Size: {len(tuple_with_static_array_encoded)} bytes (24 + 1 = 25, no offsets needed)") + is_dyn = tuple_with_static_array_type.is_dynamic() + print_info(f" is_dynamic(): {is_dyn} (static array doesnt make tuple dynamic)") + + # Tuple with dynamic array + tuple_with_dynamic_array_type = abi.ABIType.from_string("(uint64[],bool)") + tuple_with_dynamic_array_value = [[1, 2, 3], True] + if isinstance(tuple_with_dynamic_array_type, abi.TupleType): + tuple_with_dynamic_array_encoded = tuple_with_dynamic_array_type.encode(tuple_with_dynamic_array_value) + + print_info("\nTuple with dynamic array: (uint64[],bool)") + print_info(" Input: [[1, 2, 3], True]") + print_info(f" Encoded: {format_hex(tuple_with_dynamic_array_encoded)}") + print_info(f" Size: {len(tuple_with_dynamic_array_encoded)} bytes (2 offset + 1 bool + 2 len + 24 data = 29)") + print_info(f" is_dynamic(): {tuple_with_dynamic_array_type.is_dynamic()}") + + print_info("\nByte layout comparison:") + print_info(" Static (uint64[3],bool):") + print_info(f" [0-7] uint64[0]: {format_hex(tuple_with_static_array_encoded[0:8])}") + print_info(f" [8-15] uint64[1]: {format_hex(tuple_with_static_array_encoded[8:16])}") + print_info(f" [16-23] uint64[2]: {format_hex(tuple_with_static_array_encoded[16:24])}") + print_info(f" [24] bool: {format_hex(tuple_with_static_array_encoded[24:25])}") + + print_info("\n Dynamic (uint64[],bool):") + dyn_array_offset = (tuple_with_dynamic_array_encoded[0] << 8) | tuple_with_dynamic_array_encoded[1] + print_info( + f" [0-1] array offset: {format_hex(tuple_with_dynamic_array_encoded[0:2])} = {dyn_array_offset}" + ) + print_info(f" [2] bool: {format_hex(tuple_with_dynamic_array_encoded[2:3])}") + print_info(f" [3-4] array length: {format_hex(tuple_with_dynamic_array_encoded[3:5])}") + print_info(f" [5-28] array data: {format_hex(tuple_with_dynamic_array_encoded[5:])}") + + # Decode and verify both + static_array_decoded = tuple_with_static_array_type.decode(tuple_with_static_array_encoded) + dynamic_array_decoded = tuple_with_dynamic_array_type.decode(tuple_with_dynamic_array_encoded) + + print_info("\nRound-trip verification:") + static_match = list(static_array_decoded[0]) == [1, 2, 3] and static_array_decoded[1] == True # noqa: E712 + print_info(f" Static array tuple: {static_match}") + dynamic_match = ( + list(dynamic_array_decoded[0]) == [1, 2, 3] and dynamic_array_decoded[1] == True # noqa: E712 + ) + print_info(f" Dynamic array tuple: {dynamic_match}") + + # Step 7: Triple nesting verification + print_step(7, "Triple Nesting Verification") + + # Type: ((uint64,bool)[])[] is an array of single-element tuples where each tuple contains (uint64,bool)[] + triple_nested_type = abi.ABIType.from_string("((uint64,bool)[])[]") + + print_info("Type: ((uint64,bool)[])[]") + print_info(" This is: array of 1-element tuples, where each tuple contains (uint64,bool)[]") + if isinstance(triple_nested_type, abi.DynamicArrayType): + print_info(f" str(): {triple_nested_type}") + print_info(f" is_dynamic(): {triple_nested_type.is_dynamic()}") + + triple_inner_tuple_type = triple_nested_type.element + print_info(f"\n element: {triple_inner_tuple_type} (a 1-element tuple)") + if isinstance(triple_inner_tuple_type, abi.TupleType): + print_info(f" elements[0]: {triple_inner_tuple_type.elements[0]}") + + # Each element is a 1-element tuple containing an array of (uint64,bool) tuples + triple_nested_value = [ + [[[1, True], [2, False]]], # 1-element tuple containing [(1,true), (2,false)] + [[[10, False]]], # 1-element tuple containing [(10,false)] + [[[100, True], [200, True], [300, False]]], # 1-element tuple containing 3 tuples + ] + + if isinstance(triple_nested_type, abi.DynamicArrayType): + triple_nested_encoded = triple_nested_type.encode(triple_nested_value) + + print_info("\nInput (each element is a tuple containing an array):") + print_info(" [") + print_info(" [[ [1, True], [2, False] ]], // tuple wrapping array of 2 tuples") + print_info(" [[ [10, False] ]], // tuple wrapping array of 1 tuple") + print_info(" [[ [100, True], [200, True], [300, False] ]] // tuple wrapping array of 3") + print_info(" ]") + print_info(f"\nEncoded: {format_bytes(triple_nested_encoded, 20)}") + print_info(f"Total bytes: {len(triple_nested_encoded)}") + + # Decode and verify + triple_nested_decoded = list(triple_nested_type.decode(triple_nested_encoded)) + + print_info("\nDecoded:") + for i, outer in enumerate(triple_nested_decoded): + inner_array = outer[0] # First (only) element of the tuple + pair_strs = [f"[{t[0]}, {t[1]}]" for t in inner_array] + print_info(f" [{i}]: [[ {', '.join(pair_strs)} ]]") + + triple_match = len(triple_nested_decoded) == len(triple_nested_value) + for i in range(len(triple_nested_value)): + orig_inner = triple_nested_value[i][0] + dec_inner = triple_nested_decoded[i][0] + triple_match = triple_match and len(orig_inner) == len(dec_inner) + for j in range(len(orig_inner)): + vals_match = orig_inner[j][0] == dec_inner[j][0] and orig_inner[j][1] == dec_inner[j][1] + triple_match = triple_match and vals_match + print_info(f"Round-trip verified: {triple_match}") + + # Step 8: Summary + print_step(8, "Summary") + + print_info("Complex nested types follow consistent encoding rules:") + + print_info("\nArray of tuples (T)[]:") + print_info(" - 2-byte length prefix (element count)") + print_info(" - If T is dynamic: head section with offsets, tail section with data") + print_info(" - If T is static: elements encoded consecutively after length") + + print_info("\nTuple containing arrays (T1[],T2[]):") + print_info(" - Head section: offsets for each dynamic child") + print_info(" - Tail section: array data in order") + print_info(" - Static arrays (T[N]) encode inline, dynamic arrays (T[]) use offsets") + + print_info("\nNested structs with arrays:") + print_info(" - Struct encoding identical to equivalent tuple") + print_info(" - Static fields inline, dynamic fields via offsets") + print_info(" - Nested arrays and strings all end up in tail section") + + print_info("\nDeeply nested types like ((uint64,bool)[],string,(address,uint256))[]:") + print_info(" - Outer array: 2-byte count + offsets to each inner tuple") + print_info(" - Each inner tuple: offsets for dynamic parts, inline for static") + print_info(" - Innermost arrays: 2-byte count + element data") + print_info(" - Round-trip encoding/decoding preserves all values at every nesting level") + + print_info("\nKey observations:") + print_info(" - Static types never need offsets (fixed position)") + print_info(" - Dynamic types always use 2-byte offsets relative to container start") + print_info(" - Nesting depth doesnt change rules, just adds layers") + print_info(" - All encoded bytes are deterministic for same input values") + + print_success("ABI Complex Nested Types example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/abi/15_arc56_storage.py b/examples/abi/15_arc56_storage.py new file mode 100644 index 00000000..ad88354d --- /dev/null +++ b/examples/abi/15_arc56_storage.py @@ -0,0 +1,358 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: ARC-56 Storage Helpers + +This example demonstrates how to use ARC-56 storage helpers to inspect +contract state key definitions and maps from an ARC-56 contract specification: + +Storage Key Properties (StorageKey): +- key: Base64-encoded key bytes +- key_type: The type of the key (ABIType or AVMType) +- value_type: The type of the value (ABIType or AVMType) +- desc: Optional description + +Storage Map Properties (StorageMap): +- key_type: The type of keys in the map +- value_type: The type of values in the map +- desc: Optional description +- prefix: Base64-encoded prefix for map keys + +In the Python SDK, access storage definitions via: +- contract.state.keys.global_state - Global state keys +- contract.state.keys.local_state - Local state keys +- contract.state.keys.box - Box storage keys +- contract.state.maps.global_state - Global state maps +- contract.state.maps.local_state - Local state maps +- contract.state.maps.box - Box storage maps + +No LocalNet required - demonstrates ARC-56 spec parsing +""" + +import base64 +from pathlib import Path + +from shared import format_hex, print_header, print_info, print_step, print_success + +from algokit_abi import abi +from algokit_abi.arc56 import Arc56Contract, AVMType, StorageKey, StorageMap + + +def format_key_or_value_type(type_val: abi.ABIType | AVMType) -> str: + """Formats a storage key type for display (either ABI type or AVM type).""" + if isinstance(type_val, AVMType): + return type_val.value # AVM type (e.g., "AVMUint64", "AVMString", "AVMBytes") + return str(type_val) # ABI type + + +def display_storage_key(name: str, storage_key: StorageKey) -> None: + """Displays StorageKey properties.""" + print_info(f" {name}:") + print_info(f" key (base64): {storage_key.key}") + try: + decoded_key = base64.b64decode(storage_key.key).decode("utf-8") + print_info(f' key (decoded): "{decoded_key}"') + except (UnicodeDecodeError, ValueError): + decoded_bytes = base64.b64decode(storage_key.key) + print_info(f" key (decoded): {format_hex(decoded_bytes)}") + print_info(f" key_type: {format_key_or_value_type(storage_key.key_type)}") + print_info(f" value_type: {format_key_or_value_type(storage_key.value_type)}") + if storage_key.desc: + print_info(f" desc: {storage_key.desc}") + + +def display_storage_map(name: str, storage_map: StorageMap) -> None: + """Displays StorageMap properties.""" + print_info(f" {name}:") + print_info(f" key_type: {format_key_or_value_type(storage_map.key_type)}") + print_info(f" value_type: {format_key_or_value_type(storage_map.value_type)}") + if storage_map.desc: + print_info(f" desc: {storage_map.desc}") + if storage_map.prefix is not None: + print_info(f' prefix (base64): "{storage_map.prefix}"') + if storage_map.prefix: + try: + decoded_prefix = base64.b64decode(storage_map.prefix).decode("utf-8") + print_info(f' prefix (decoded): "{decoded_prefix}"') + except (UnicodeDecodeError, ValueError): + decoded_bytes = base64.b64decode(storage_map.prefix) + print_info(f" prefix (decoded): {format_hex(decoded_bytes)}") + + +def main() -> None: + print_header("ARC-56 Storage Helpers Example") + + # Step 1: Load ARC-56 contract specification + print_step(1, "Load ARC-56 Contract Specification") + + # Load the State.arc56.json from test artifacts + arc56_path = Path(__file__).parent.parent.parent / "tests" / "artifacts" / "state_contract" / "State.arc56.json" + arc56_content = arc56_path.read_text() + app_spec = Arc56Contract.from_json(arc56_content) + + print_info(f"Loaded contract: {app_spec.name}") + print_info(f"ARC standards supported: {', '.join(str(arc) for arc in app_spec.arcs)}") + print_info("") + print_info("State schema:") + print_info( + f" Global: {app_spec.state.schema.global_state.ints} ints, {app_spec.state.schema.global_state.bytes} bytes" + ) + print_info( + f" Local: {app_spec.state.schema.local_state.ints} ints, {app_spec.state.schema.local_state.bytes} bytes" + ) + + # Step 2: Demonstrate accessing global state keys + print_step(2, "Get Global State Key Definitions") + + print_info("Accessing contract.state.keys.global_state to get all global state keys:") + print_info("") + + global_keys = app_spec.state.keys.global_state + global_key_names = list(global_keys.keys()) + + print_info(f"Found {len(global_key_names)} global state keys:") + print_info("") + + for name in global_key_names: + display_storage_key(name, global_keys[name]) + print_info("") + + # Step 3: Demonstrate accessing local state keys + print_step(3, "Get Local State Key Definitions") + + print_info("Accessing contract.state.keys.local_state to get all local state keys:") + print_info("") + + local_keys = app_spec.state.keys.local_state + local_key_names = list(local_keys.keys()) + + print_info(f"Found {len(local_key_names)} local state keys:") + print_info("") + + for name in local_key_names: + display_storage_key(name, local_keys[name]) + print_info("") + + # Step 4: Demonstrate accessing box keys + print_step(4, "Get Box Key Definitions") + + print_info("Accessing contract.state.keys.box to get all box storage keys:") + print_info("") + + box_keys = app_spec.state.keys.box + box_key_names = list(box_keys.keys()) + + if box_key_names: + print_info(f"Found {len(box_key_names)} box storage keys:") + print_info("") + for name in box_key_names: + display_storage_key(name, box_keys[name]) + print_info("") + else: + print_info("No box storage keys defined in this contract.") + + # Step 5: Demonstrate accessing box maps + print_step(5, "Get Box Map Definitions") + + print_info("Accessing contract.state.maps.box to get box map definitions:") + print_info("") + + box_maps = app_spec.state.maps.box + box_map_names = list(box_maps.keys()) + + if box_map_names: + print_info(f"Found {len(box_map_names)} box maps:") + print_info("") + for name in box_map_names: + display_storage_map(name, box_maps[name]) + print_info("") + else: + print_info("No box maps defined in this contract.") + + # Step 6: Demonstrate decoding storage keys + print_step(6, "Decoding Storage Key Names") + + print_info("Storage keys are stored as base64-encoded bytes.") + print_info("Decode them to see the actual key names used in the contract:") + print_info("") + + print_info("Global state keys decoded:") + for name in global_key_names: + key_base64 = global_keys[name].key + try: + key_decoded = base64.b64decode(key_base64).decode("utf-8") + print_info(f" {name}: '{key_decoded}'") + except UnicodeDecodeError: + key_bytes = base64.b64decode(key_base64) + print_info(f" {name}: {format_hex(key_bytes)} (binary)") + + print_info("") + print_info("Local state keys decoded:") + for name in local_key_names: + key_base64 = local_keys[name].key + try: + key_decoded = base64.b64decode(key_base64).decode("utf-8") + print_info(f" {name}: '{key_decoded}'") + except UnicodeDecodeError: + key_bytes = base64.b64decode(key_base64) + print_info(f" {name}: {format_hex(key_bytes)} (binary)") + + # Step 7: Understanding type categories in storage + print_step(7, "Understanding Type Categories in Storage") + + print_info("Storage keys can have AVM types or ABI types for keys and values:") + print_info("") + print_info("AVM Types (native stack values, no length prefix):") + print_info(" - AVMBytes: Raw bytes") + print_info(" - AVMString: UTF-8 string") + print_info(" - AVMUint64: 64-bit unsigned integer") + print_info("") + print_info("ABI Types (ARC-4 encoded with potential length prefixes):") + print_info(" - string: 2-byte length prefix + UTF-8") + print_info(" - uint64: 8 bytes big-endian") + print_info(" - (tuple): Head/tail encoding") + print_info(" - etc.") + print_info("") + + # Analyze types used in this contract + print_info("Types used in this contract's storage:") + print_info("") + + avm_count = 0 + abi_count = 0 + + for key in global_keys.values(): + key_is_avm = isinstance(key.key_type, AVMType) + val_is_avm = isinstance(key.value_type, AVMType) + if key_is_avm: + avm_count += 1 + else: + abi_count += 1 + if val_is_avm: + avm_count += 1 + else: + abi_count += 1 + + for key in local_keys.values(): + key_is_avm = isinstance(key.key_type, AVMType) + val_is_avm = isinstance(key.value_type, AVMType) + if key_is_avm: + avm_count += 1 + else: + abi_count += 1 + if val_is_avm: + avm_count += 1 + else: + abi_count += 1 + + print_info(f" AVM type usages: {avm_count}") + print_info(f" ABI type usages: {abi_count}") + + # Step 8: Creating a synthetic example with maps + print_step(8, "Working with Storage Maps") + + print_info("Storage maps define key-value relationships with typed keys and values.") + print_info("") + + # Create a synthetic example showing what a box map would look like + synthetic_spec = { + "name": "ExampleWithMaps", + "arcs": [4, 56], + "methods": [], + "state": { + "schema": {"global": {"ints": 0, "bytes": 0}, "local": {"ints": 0, "bytes": 0}}, + "keys": {"global": {}, "local": {}, "box": {}}, + "maps": { + "global": {}, + "local": {}, + "box": { + "userBalances": { + "keyType": "address", + "valueType": "uint64", + "prefix": "dXNlcl8=", # base64("user_") + "desc": "Maps user addresses to their balances", + }, + "orderData": { + "keyType": "uint64", + "valueType": "(address,uint64,string)", + "desc": "Maps order IDs to order tuples", + }, + }, + }, + }, + } + + example_spec = Arc56Contract.from_dict(synthetic_spec) + + print_info(f"Synthetic contract: {example_spec.name}") + print_info("") + print_info("Box maps defined:") + print_info("") + + for name, storage_map in example_spec.state.maps.box.items(): + display_storage_map(name, storage_map) + print_info("") + + # Step 9: Practical use cases + print_step(9, "Practical Use Cases") + + print_info("ARC-56 storage inspection enables:") + print_info("") + print_info("1. Contract State Discovery") + print_info(" - List all state keys without reading contract source") + print_info(" - Understand data types for proper encoding/decoding") + print_info("") + print_info("2. Generic Contract Explorers") + print_info(" - Build tools that can inspect any ARC-56 contract") + print_info(" - Automatically decode state values using type info") + print_info("") + print_info("3. Runtime Type Validation") + print_info(" - Validate state key/value types before transactions") + print_info(" - Ensure proper encoding based on AVM vs ABI type") + print_info("") + print_info("4. Documentation Generation") + print_info(" - Auto-generate state documentation from spec") + print_info(" - Include type information and descriptions") + + # Step 10: Summary + print_step(10, "Summary") + + print_info("ARC-56 Storage Classes:") + print_info("") + print_info("State (contract.state):") + print_info(" keys: Keys - Container for storage key definitions") + print_info(" maps: Maps - Container for storage map definitions") + print_info(" schema: Schema - State schema (ints/bytes counts)") + print_info("") + print_info("Keys (contract.state.keys):") + print_info(" global_state: dict[str, StorageKey] - Global state keys") + print_info(" local_state: dict[str, StorageKey] - Local state keys") + print_info(" box: dict[str, StorageKey] - Box storage keys") + print_info("") + print_info("Maps (contract.state.maps):") + print_info(" global_state: dict[str, StorageMap] - Global state maps") + print_info(" local_state: dict[str, StorageMap] - Local state maps") + print_info(" box: dict[str, StorageMap] - Box storage maps") + print_info("") + print_info("StorageKey Properties:") + print_info(" key - Base64-encoded key bytes") + print_info(" key_type - Type of the key (ABIType or AVMType)") + print_info(" value_type - Type of the value (ABIType or AVMType)") + print_info(" desc - Optional description") + print_info("") + print_info("StorageMap Properties:") + print_info(" key_type - Type of keys in the map") + print_info(" value_type - Type of values in the map") + print_info(" desc - Optional description") + print_info(" prefix - Base64-encoded prefix for map keys") + print_info("") + print_info("Use Cases:") + print_info(" - Inspect contract state schema from ARC-56 spec") + print_info(" - Decode raw state bytes using typed definitions") + print_info(" - Build generic contract explorers/tools") + print_info(" - Validate state key/value types at runtime") + + print_success("ARC-56 Storage Helpers example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/abi/verify-all.sh b/examples/abi/verify-all.sh new file mode 100755 index 00000000..2f76d20d --- /dev/null +++ b/examples/abi/verify-all.sh @@ -0,0 +1,87 @@ +#!/bin/bash + +# verify-all.sh - Run all abi examples and verify they work +# Exit with non-zero code if any example fails + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +cd "$SCRIPT_DIR" + +# Array of example files in order +EXAMPLES=( + "01_type_parsing.py" + "02_primitive_types.py" + "03_address_type.py" + "04_string_type.py" + "05_static_array.py" + "06_dynamic_array.py" + "07_tuple_type.py" + "08_struct_type.py" + "09_struct_tuple_conversion.py" + "10_bool_packing.py" + "11_abi_method.py" + "12_avm_types.py" + "13_type_guards.py" + "14_complex_nested.py" + "15_arc56_storage.py" +) + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +NC='\033[0m' # No Color + +echo "========================================" +echo "ABI Examples Verification Script" +echo "========================================" +echo "" + +if [ ${#EXAMPLES[@]} -eq 0 ]; then + echo "No examples to run yet." + echo "" + echo -e "${GREEN}ABI examples suite passed (no examples)${NC}" + exit 0 +fi + +PASSED=0 +FAILED=0 +FAILED_EXAMPLES=() + +for example in "${EXAMPLES[@]}"; do + echo -n "Running $example... " + + if [ ! -f "$example" ]; then + echo -e "${RED}FAILED${NC} (file not found)" + FAILED=$((FAILED + 1)) + FAILED_EXAMPLES+=("$example") + continue + fi + + # Run the example and capture output/exit code + if OUTPUT=$(uv run python "$example" 2>&1); then + echo -e "${GREEN}PASSED${NC}" + PASSED=$((PASSED + 1)) + else + echo -e "${RED}FAILED${NC}" + echo "$OUTPUT" + FAILED=$((FAILED + 1)) + FAILED_EXAMPLES+=("$example") + fi +done + +echo "" +echo "========================================" +echo "Results: ${PASSED} passed, ${FAILED} failed" +echo "========================================" + +if [ $FAILED -gt 0 ]; then + echo "" + echo -e "${RED}Failed examples:${NC}" + for failed in "${FAILED_EXAMPLES[@]}"; do + echo " - $failed" + done + exit 1 +fi + +echo "" +echo -e "${GREEN}All ABI examples passed!${NC}" +exit 0 diff --git a/examples/algo25/01_mnemonic_from_seed.py b/examples/algo25/01_mnemonic_from_seed.py new file mode 100644 index 00000000..ddd76134 --- /dev/null +++ b/examples/algo25/01_mnemonic_from_seed.py @@ -0,0 +1,120 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Mnemonic from Seed + +This example demonstrates how to use mnemonic_from_seed() to convert a 32-byte +seed into a 25-word Algorand mnemonic. The mnemonic uses BIP39-style word +encoding where each word represents 11 bits of data. + +Key concepts: +- A 32-byte (256-bit) seed produces 24 data words (256 / 11 = ~23.3, rounded up) +- A 25th checksum word is computed from the SHA-512/256 hash of the seed +- The mnemonic is deterministic: same seed always produces same mnemonic + +No LocalNet required - pure utility function +""" + +import secrets + +from shared import format_bytes, format_hex, print_header, print_info, print_step, print_success + +from algokit_algo25 import mnemonic_from_seed + + +def main() -> None: + print_header("Mnemonic from Seed Example") + + # Step 1: Generate a random 32-byte seed + print_step(1, "Generate a Random 32-byte Seed") + + seed = secrets.token_bytes(32) + + print_info(f"Seed length: {len(seed)} bytes (256 bits)") + print_info(f"Seed bytes: {format_bytes(seed, 16)}") + print_info(f"Seed hex: {format_hex(seed)}") + + # Step 2: Convert seed to mnemonic + print_step(2, "Convert Seed to 25-Word Mnemonic") + + mnemonic = mnemonic_from_seed(seed) + words = mnemonic.split(" ") + + print_info(f"Total words: {len(words)}") + print_info("Data words: 24 (encoding 256 bits of seed data)") + print_info("Checksum word: 1 (derived from SHA-512/256 hash of seed)") + + # Step 3: Display the 25 words + print_step(3, "Display the Mnemonic Words") + + print_info("Mnemonic words:") + # Display words in rows of 5 for readability + for i in range(0, len(words), 5): + row = words[i : i + 5] + numbered = " ".join(f"{i + j + 1:2}. {w:<10}" for j, w in enumerate(row)) + print_info(f" {numbered}") + + # Step 4: Explain the 11-bit encoding scheme + print_step(4, "Explain the 11-bit Encoding Scheme") + + print_info("How seed bits map to mnemonic words:") + print_info(" - Seed: 32 bytes = 256 bits") + print_info(" - Each word encodes 11 bits (2^11 = 2048 possible words)") + print_info(" - 256 bits / 11 bits per word = 23.27 words") + print_info(" - This rounds up to 24 words (with 8 padding bits)") + print_info(" - 24 words x 11 bits = 264 bits total") + print_info(" - Extra 8 bits are zero-padded") + print_info("") + print_info("Checksum word calculation:") + print_info(" - Compute SHA-512/256 hash of the 32-byte seed") + print_info(" - Take the first 11 bits of the hash") + print_info(" - Map those 11 bits to a word from the wordlist") + print_info(" - This becomes the 25th (checksum) word") + + # Step 5: Verify determinism + print_step(5, "Verify Determinism - Same Seed Produces Same Mnemonic") + + mnemonic1 = mnemonic_from_seed(seed) + mnemonic2 = mnemonic_from_seed(seed) + + print_info("First call result:") + print_info(f' "{" ".join(mnemonic1.split(" ")[:5])}..."') + print_info("Second call result:") + print_info(f' "{" ".join(mnemonic2.split(" ")[:5])}..."') + + is_identical = mnemonic1 == mnemonic2 + print_info(f"Mnemonics identical: {'Yes' if is_identical else 'No'}") + + if is_identical: + print_success("Determinism verified: same seed always produces same mnemonic") + + # Step 6: Show a second random seed for comparison + print_step(6, "Different Seed Produces Different Mnemonic") + + seed2 = secrets.token_bytes(32) + mnemonic3 = mnemonic_from_seed(seed2) + + print_info(f"Seed 1 (first 8 bytes): {format_hex(seed[:8])}...") + print_info(f"Seed 2 (first 8 bytes): {format_hex(seed2[:8])}...") + print_info("") + print_info(f"Mnemonic 1 (first 3 words): {' '.join(mnemonic1.split(' ')[:3])}...") + print_info(f"Mnemonic 2 (first 3 words): {' '.join(mnemonic3.split(' ')[:3])}...") + + is_different = mnemonic1 != mnemonic3 + print_info(f"Mnemonics different: {'Yes' if is_different else 'No'}") + + # Summary + print_step(7, "Summary") + + print_info("mnemonic_from_seed() converts a 32-byte seed to a 25-word mnemonic:") + print_info(" - Input: 32-byte bytes object (cryptographically random seed)") + print_info(" - Output: Space-separated string of 25 words") + print_info(" - Words 1-24: Encode the 256-bit seed (11 bits per word)") + print_info(" - Word 25: Checksum derived from SHA-512/256 hash") + print_info(" - Deterministic: reproducible from the same seed") + print_info(" - BIP39-compatible wordlist: 2048 English words") + + print_success("Mnemonic from Seed example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/algo25/02_seed_from_mnemonic.py b/examples/algo25/02_seed_from_mnemonic.py new file mode 100644 index 00000000..c2a8f430 --- /dev/null +++ b/examples/algo25/02_seed_from_mnemonic.py @@ -0,0 +1,137 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Seed from Mnemonic + +This example demonstrates how to use seed_from_mnemonic() to convert a 25-word +Algorand mnemonic back to its original 32-byte seed. This is the reverse +operation of mnemonic_from_seed(). + +Key concepts: +- seed_from_mnemonic() reverses the mnemonic encoding process +- The checksum word is verified to ensure mnemonic integrity +- Round-trip conversion: seed -> mnemonic -> seed produces identical bytes + +No LocalNet required - pure utility function +""" + +import secrets + +from shared import format_hex, print_error, print_header, print_info, print_step, print_success + +from algokit_algo25 import mnemonic_from_seed, seed_from_mnemonic + + +def main() -> None: + print_header("Seed from Mnemonic Example") + + # Step 1: Generate a random 32-byte seed + print_step(1, "Generate a Random 32-byte Seed") + + original_seed = secrets.token_bytes(32) + + print_info(f"Original seed length: {len(original_seed)} bytes (256 bits)") + print_info(f"Original seed hex: {format_hex(original_seed)}") + + # Step 2: Convert seed to mnemonic + print_step(2, "Convert Seed to 25-Word Mnemonic") + + mnemonic = mnemonic_from_seed(original_seed) + words = mnemonic.split(" ") + + print_info(f"Mnemonic has {len(words)} words") + print_info("Mnemonic words:") + # Display words in rows of 5 for readability + for i in range(0, len(words), 5): + row = words[i : i + 5] + numbered = " ".join(f"{i + j + 1:2}. {w:<10}" for j, w in enumerate(row)) + print_info(f" {numbered}") + + # Step 3: Recover seed from mnemonic + print_step(3, "Recover Seed from Mnemonic using seed_from_mnemonic()") + + recovered_seed = seed_from_mnemonic(mnemonic) + + print_info(f"Recovered seed length: {len(recovered_seed)} bytes") + print_info(f"Recovered seed hex: {format_hex(recovered_seed)}") + + # Step 4: Compare original and recovered seeds + print_step(4, "Compare Original and Recovered Seeds") + + print_info("Original seed:") + print_info(f" {format_hex(original_seed)}") + print_info("Recovered seed:") + print_info(f" {format_hex(recovered_seed)}") + + seeds_match = original_seed == recovered_seed + print_info(f"Seeds are identical: {'Yes' if seeds_match else 'No'}") + + if seeds_match: + print_success("Round-trip verification passed: seed_from_mnemonic(mnemonic_from_seed(seed)) == seed") + else: + print_error("Round-trip verification failed!") + return + + # Step 5: Byte-by-byte comparison + print_step(5, "Byte-by-Byte Verification") + + print_info("Comparing first 8 bytes:") + for i in range(8): + orig_byte = f"{original_seed[i]:02x}" + rec_byte = f"{recovered_seed[i]:02x}" + match = "✓" if original_seed[i] == recovered_seed[i] else "✗" + print_info(f" Byte {i}: original=0x{orig_byte}, recovered=0x{rec_byte} {match}") + print_info(" ... (all 32 bytes verified)") + + # Step 6: Explain how seed_from_mnemonic works + print_step(6, "How seed_from_mnemonic() Works") + + print_info("The recovery process:") + print_info(" 1. Split the mnemonic into 25 words") + print_info(" 2. Separate the first 24 words (data) from the 25th word (checksum)") + print_info(" 3. Look up each data word in the BIP39 wordlist to get its 11-bit index") + print_info(" 4. Combine the 24 x 11 = 264 bits back into bytes") + print_info(" 5. Remove the last byte (8 padding bits) to get the 32-byte seed") + print_info(" 6. Recompute the checksum from the recovered seed") + print_info(" 7. Verify the computed checksum matches the 25th word") + print_info(" 8. Return the 32-byte seed if checksum is valid") + + # Step 7: Demonstrate checksum validation + print_step(7, "Checksum Validation Protects Against Errors") + + print_info(f'Checksum word (25th word): "{words[24]}"') + print_info("The checksum is computed from SHA-512/256 hash of the seed.") + print_info("If any word is changed, the checksum will not match.") + + # Create an invalid mnemonic by changing one word + tampered_words = words.copy() + tampered_words[0] = "about" if tampered_words[0] == "abandon" else "abandon" + tampered_mnemonic = " ".join(tampered_words) + + print_info("") + print_info("Attempting to decode a tampered mnemonic...") + print_info(f' Changed word 1 from "{words[0]}" to "{tampered_words[0]}"') + + try: + seed_from_mnemonic(tampered_mnemonic) + print_error("Unexpectedly succeeded with tampered mnemonic!") + except Exception as error: + print_success(f'Checksum validation caught the error: "{error}"') + + # Step 8: Summary + print_step(8, "Summary") + + print_info("seed_from_mnemonic() converts a 25-word mnemonic back to a 32-byte seed:") + print_info(" - Input: Space-separated string of 25 words") + print_info(" - Output: 32-byte bytes object (the original seed)") + print_info(" - Validates the checksum to ensure integrity") + print_info(" - Raises an error if:") + print_info(" - Any word is not in the BIP39 wordlist") + print_info(" - The checksum word does not match") + print_info(" - Enables round-trip: seed -> mnemonic -> seed") + print_info(" - Use case: Recover a seed from a backed-up mnemonic phrase") + + print_success("Seed from Mnemonic example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/algo25/03_secret_key_to_mnemonic.py b/examples/algo25/03_secret_key_to_mnemonic.py new file mode 100644 index 00000000..2fc5d5d1 --- /dev/null +++ b/examples/algo25/03_secret_key_to_mnemonic.py @@ -0,0 +1,153 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Secret Key to Mnemonic + +This example demonstrates how to use secret_key_to_mnemonic() to convert a +64-byte Algorand secret key to a 25-word mnemonic. + +Key concepts: +- Algorand secret keys are 64 bytes: bytes 0-31 are the seed, bytes 32-63 are the public key +- secret_key_to_mnemonic() extracts the first 32 bytes (seed portion) and converts to mnemonic +- This produces the same result as calling mnemonic_from_seed() on the seed directly + +No LocalNet required - pure utility function +""" + +import secrets + +from shared import format_hex, print_header, print_info, print_step, print_success + +from algokit_algo25 import mnemonic_from_seed, secret_key_to_mnemonic + + +def main() -> None: + print_header("Secret Key to Mnemonic Example") + + # Step 1: Create a 64-byte secret key (simulating what Algorand uses) + print_step(1, "Create a 64-byte Algorand Secret Key") + + # In Algorand, the secret key is 64 bytes: + # - Bytes 0-31: The seed (private key material) + # - Bytes 32-63: The public key (derived from the seed) + secret_key = secrets.token_bytes(64) + + print_info(f"Secret key length: {len(secret_key)} bytes") + print_info("Structure:") + print_info(f" Bytes 0-31 (seed): {format_hex(secret_key[:32])}") + print_info(f" Bytes 32-63 (public key): {format_hex(secret_key[32:64])}") + + # Step 2: Display the secret key structure + print_step(2, "Understand the Secret Key Structure") + + print_info("Algorand secret keys are 64 bytes (512 bits):") + print_info("") + print_info(" +--------------------------------+--------------------------------+") + print_info(" | Seed (32 bytes) | Public Key (32 bytes) |") + print_info(" | Bytes 0-31 | Bytes 32-63 |") + print_info(" | (Private key material) | (Derived from seed) |") + print_info(" +--------------------------------+--------------------------------+") + print_info("") + print_info("The seed is the actual secret; the public key is appended for convenience.") + print_info("When converting to mnemonic, only the seed portion is needed.") + + # Step 3: Convert secret key to mnemonic using secret_key_to_mnemonic + print_step(3, "Convert Secret Key to Mnemonic using secret_key_to_mnemonic()") + + mnemonic_from_secret_key = secret_key_to_mnemonic(secret_key) + words = mnemonic_from_secret_key.split(" ") + + print_info(f"Mnemonic has {len(words)} words") + print_info("Mnemonic words:") + # Display words in rows of 5 for readability + for i in range(0, len(words), 5): + row = words[i : i + 5] + numbered = " ".join(f"{i + j + 1:2}. {w:<10}" for j, w in enumerate(row)) + print_info(f" {numbered}") + + # Step 4: Explain what secret_key_to_mnemonic does internally + print_step(4, "What secret_key_to_mnemonic() Does Internally") + + print_info("secret_key_to_mnemonic(secret_key) performs these steps:") + print_info(" 1. Extract the seed: secret_key[:32]") + print_info(" 2. Call mnemonic_from_seed(seed) on the extracted 32 bytes") + print_info(" 3. Return the resulting 25-word mnemonic") + print_info("") + print_info("This is equivalent to:") + print_info(" seed = secret_key[:32]") + print_info(" mnemonic = mnemonic_from_seed(seed)") + + # Step 5: Compare with calling mnemonic_from_seed directly + print_step(5, "Compare with mnemonic_from_seed() on First 32 Bytes") + + seed = secret_key[:32] + mnemonic_from_seed_direct = mnemonic_from_seed(seed) + + print_info("Method 1: secret_key_to_mnemonic(64-byte secret_key)") + print_info(f' Result: "{" ".join(mnemonic_from_secret_key.split(" ")[:5])}..."') + print_info("") + print_info("Method 2: mnemonic_from_seed(secret_key[:32])") + print_info(f' Result: "{" ".join(mnemonic_from_seed_direct.split(" ")[:5])}..."') + + mnemonics_match = mnemonic_from_secret_key == mnemonic_from_seed_direct + print_info("") + print_info(f"Mnemonics identical: {'Yes' if mnemonics_match else 'No'}") + + if mnemonics_match: + print_success("Both methods produce identical mnemonics!") + + # Step 6: Demonstrate that only the seed portion matters + print_step(6, "Only the Seed Portion Affects the Mnemonic") + + # Create a second secret key with the same seed but different "public key" bytes + secret_key2 = bytearray(64) + secret_key2[:32] = seed # Same seed + secret_key2[32:] = secrets.token_bytes(32) # Different public key portion + secret_key2 = bytes(secret_key2) + + mnemonic1 = secret_key_to_mnemonic(secret_key) + mnemonic2 = secret_key_to_mnemonic(secret_key2) + + print_info("Secret Key 1 (first 8 bytes of public key):") + print_info(f" {format_hex(secret_key[32:40])}...") + print_info("Secret Key 2 (first 8 bytes of public key):") + print_info(f" {format_hex(secret_key2[32:40])}...") + print_info("") + print_info("Same seed, different public key bytes...") + print_info(f'Mnemonic 1: "{" ".join(mnemonic1.split(" ")[:3])}..."') + print_info(f'Mnemonic 2: "{" ".join(mnemonic2.split(" ")[:3])}..."') + print_info(f"Mnemonics identical: {'Yes' if mnemonic1 == mnemonic2 else 'No'}") + + if mnemonic1 == mnemonic2: + print_success("The public key portion (bytes 32-63) does not affect the mnemonic.") + + # Step 7: Use cases for secret_key_to_mnemonic + print_step(7, "When to Use secret_key_to_mnemonic()") + + print_info("Use secret_key_to_mnemonic() when you have a 64-byte Algorand secret key") + print_info("and need to convert it to a mnemonic for backup or display.") + print_info("") + print_info("Common scenarios:") + print_info(" - Exporting an account from a wallet") + print_info(" - Displaying the recovery phrase after key generation") + print_info(" - Converting keys from ed25519 libraries that output 64-byte keys") + print_info("") + print_info("Use mnemonic_from_seed() directly when you only have the 32-byte seed.") + + # Step 8: Summary + print_step(8, "Summary") + + print_info("secret_key_to_mnemonic() converts a 64-byte secret key to a 25-word mnemonic:") + print_info(" - Input: 64-byte bytes object (Algorand secret key format)") + print_info(" - Output: Space-separated string of 25 words") + print_info(" - Internally extracts bytes 0-31 (the seed portion)") + print_info(" - Produces identical result to mnemonic_from_seed(seed)") + print_info(" - Bytes 32-63 (public key portion) are ignored") + print_info("") + print_info("Relationship between functions:") + print_info(" secret_key_to_mnemonic(sk) == mnemonic_from_seed(sk[:32])") + + print_success("Secret Key to Mnemonic example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/algo25/04_master_derivation_key.py b/examples/algo25/04_master_derivation_key.py new file mode 100644 index 00000000..af4a77d9 --- /dev/null +++ b/examples/algo25/04_master_derivation_key.py @@ -0,0 +1,164 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Master Derivation Key Functions + +This example demonstrates the master derivation key (MDK) alias functions +and shows their equivalence to the core seed/mnemonic functions. + +Key concepts: +- master_derivation_key_to_mnemonic() is an alias for mnemonic_from_seed() +- mnemonic_to_master_derivation_key() is an alias for seed_from_mnemonic() +- These aliases exist for wallet derivation workflows where the terminology + "master derivation key" is more familiar than "seed" + +No LocalNet required - pure utility functions (aliases) +""" + +import secrets + +from shared import format_hex, print_header, print_info, print_step, print_success + +from algokit_algo25 import ( + master_derivation_key_to_mnemonic, + mnemonic_from_seed, + mnemonic_to_master_derivation_key, + seed_from_mnemonic, +) + + +def main() -> None: + print_header("Master Derivation Key Functions Example") + + # Step 1: Generate a random 32-byte master derivation key (MDK) + print_step(1, "Generate a Random 32-byte Master Derivation Key") + + mdk = secrets.token_bytes(32) + + print_info(f"Master Derivation Key (MDK): {len(mdk)} bytes") + print_info(f"Hex: {format_hex(mdk)}") + print_info("") + print_info("A master derivation key is simply a 32-byte seed.") + print_info('The term "MDK" is used in wallet derivation contexts.') + + # Step 2: Convert MDK to mnemonic using master_derivation_key_to_mnemonic + print_step(2, "Convert MDK to Mnemonic using master_derivation_key_to_mnemonic()") + + mnemonic_from_mdk = master_derivation_key_to_mnemonic(mdk) + words = mnemonic_from_mdk.split(" ") + + print_info(f"Mnemonic has {len(words)} words") + print_info("Mnemonic words:") + for i in range(0, len(words), 5): + row = words[i : i + 5] + numbered = " ".join(f"{i + j + 1:2}. {w:<10}" for j, w in enumerate(row)) + print_info(f" {numbered}") + + # Step 3: Convert mnemonic back to MDK using mnemonic_to_master_derivation_key + print_step(3, "Convert Mnemonic Back to MDK using mnemonic_to_master_derivation_key()") + + recovered_mdk = mnemonic_to_master_derivation_key(mnemonic_from_mdk) + + print_info(f"Recovered MDK: {len(recovered_mdk)} bytes") + print_info(f"Hex: {format_hex(recovered_mdk)}") + + mdk_match = mdk == recovered_mdk + print_info("") + print_info(f"Original MDK matches recovered MDK: {'Yes' if mdk_match else 'No'}") + + if mdk_match: + print_success("Round-trip conversion successful!") + + # Step 4: Show equivalence: master_derivation_key_to_mnemonic === mnemonic_from_seed + print_step(4, "Demonstrate Equivalence: master_derivation_key_to_mnemonic == mnemonic_from_seed") + + mnemonic_via_mdk = master_derivation_key_to_mnemonic(mdk) + mnemonic_via_seed = mnemonic_from_seed(mdk) + + print_info("Using master_derivation_key_to_mnemonic(mdk):") + print_info(f' "{" ".join(mnemonic_via_mdk.split(" ")[:5])}..."') + print_info("") + print_info("Using mnemonic_from_seed(mdk):") + print_info(f' "{" ".join(mnemonic_via_seed.split(" ")[:5])}..."') + print_info("") + + mnemonics_equal = mnemonic_via_mdk == mnemonic_via_seed + print_info(f"Results identical: {'Yes' if mnemonics_equal else 'No'}") + + if mnemonics_equal: + print_success("master_derivation_key_to_mnemonic(mdk) == mnemonic_from_seed(mdk)") + + # Step 5: Show equivalence: mnemonic_to_master_derivation_key === seed_from_mnemonic + print_step(5, "Demonstrate Equivalence: mnemonic_to_master_derivation_key == seed_from_mnemonic") + + mdk_from_alias = mnemonic_to_master_derivation_key(mnemonic_from_mdk) + seed_from_core = seed_from_mnemonic(mnemonic_from_mdk) + + print_info("Using mnemonic_to_master_derivation_key(mnemonic):") + print_info(f" {format_hex(mdk_from_alias)}") + print_info("") + print_info("Using seed_from_mnemonic(mnemonic):") + print_info(f" {format_hex(seed_from_core)}") + print_info("") + + seeds_equal = mdk_from_alias == seed_from_core + print_info(f"Results identical: {'Yes' if seeds_equal else 'No'}") + + if seeds_equal: + print_success("mnemonic_to_master_derivation_key(mn) equals seed_from_mnemonic(mn)") + + # Step 6: Explain why these aliases exist + print_step(6, "Why These Convenience Aliases Exist") + + print_info("The MDK alias functions exist for wallet derivation workflows:") + print_info("") + print_info("Terminology mapping:") + print_info(" +--------------------------------+--------------------------------+") + print_info(" | Wallet Context | Cryptographic Context |") + print_info(" +--------------------------------+--------------------------------+") + print_info(" | Master Derivation Key (MDK) | Seed |") + print_info(" | master_derivation_key_to_mnemonic | mnemonic_from_seed |") + print_info(" | mnemonic_to_master_derivation_key | seed_from_mnemonic |") + print_info(" +--------------------------------+--------------------------------+") + print_info("") + print_info("In hierarchical deterministic (HD) wallet implementations,") + print_info('the "master derivation key" is used to derive child keys.') + print_info("This is the same 32-byte value as the seed, just with") + print_info("terminology that matches wallet derivation standards.") + + # Step 7: Practical usage examples + print_step(7, "When to Use MDK vs Seed Functions") + + print_info("Use MDK functions when:") + print_info(" - Working with KMD (Key Management Daemon)") + print_info(" - Implementing HD wallet derivation") + print_info(" - Following wallet-specific documentation that uses MDK terminology") + print_info("") + print_info("Use seed functions when:") + print_info(" - Working with general cryptographic operations") + print_info(" - Following Algorand core documentation") + print_info(" - The context is account creation rather than wallet derivation") + print_info("") + print_info("Both function pairs are interchangeable - choose based on context.") + + # Step 8: Summary + print_step(8, "Summary") + + print_info("Master Derivation Key functions are convenience aliases:") + print_info("") + print_info(" master_derivation_key_to_mnemonic(mdk)") + print_info(" - Alias for: mnemonic_from_seed(mdk)") + print_info(" - Input: 32-byte bytes object") + print_info(" - Output: 25-word mnemonic string") + print_info("") + print_info(" mnemonic_to_master_derivation_key(mn)") + print_info(" - Alias for: seed_from_mnemonic(mn)") + print_info(" - Input: 25-word mnemonic string") + print_info(" - Output: 32-byte bytes object") + print_info("") + print_info("The aliases exist to provide familiar terminology for wallet workflows.") + + print_success("Master Derivation Key Functions example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/algo25/05_error_handling.py b/examples/algo25/05_error_handling.py new file mode 100644 index 00000000..448576ea --- /dev/null +++ b/examples/algo25/05_error_handling.py @@ -0,0 +1,239 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Error Handling for Mnemonic Functions + +This example demonstrates how to properly handle errors when working with +mnemonic functions, including invalid words, bad checksums, and wrong seed lengths. + +Key concepts: +- NOT_IN_WORDS_LIST_ERROR_MSG: Thrown when a mnemonic contains an invalid word +- FAIL_TO_DECODE_MNEMONIC_ERROR_MSG: Thrown when checksum validation fails +- InvalidSeedLengthError: Thrown when seed length is not 32 bytes + +No LocalNet required - demonstrates error conditions +""" + +import secrets + +from shared import print_error, print_header, print_info, print_step, print_success + +from algokit_algo25 import ( + FAIL_TO_DECODE_MNEMONIC_ERROR_MSG, + NOT_IN_WORDS_LIST_ERROR_MSG, + InvalidMnemonicError, + InvalidSeedLengthError, + WordNotFoundError, + mnemonic_from_seed, + seed_from_mnemonic, +) + + +def main() -> None: + print_header("Error Handling for Mnemonic Functions") + + # Step 1: Display the error constants + print_step(1, "Error Constants and Their Values") + + print_info("The algokit_algo25 package exports two error message constants:") + print_info("") + print_info(" NOT_IN_WORDS_LIST_ERROR_MSG:") + print_info(f' Value: "{NOT_IN_WORDS_LIST_ERROR_MSG}"') + print_info(" When: A word in the mnemonic is not in the BIP39 wordlist") + print_info("") + print_info(" FAIL_TO_DECODE_MNEMONIC_ERROR_MSG:") + print_info(f' Value: "{FAIL_TO_DECODE_MNEMONIC_ERROR_MSG}"') + print_info(" When: Checksum validation fails or mnemonic structure is invalid") + print_info("") + print_info("Additionally, mnemonic_from_seed() throws InvalidSeedLengthError for wrong seed length.") + + # Step 2: Demonstrate NOT_IN_WORDS_LIST_ERROR_MSG error + print_step(2, "Error: Invalid Word Not in Wordlist") + + # Create a mnemonic with an invalid word (25 words total) + invalid_word_mnemonic = ( + "invalidword abandon abandon abandon abandon abandon abandon abandon " + "abandon abandon abandon abandon abandon abandon abandon abandon " + "abandon abandon abandon abandon abandon abandon abandon abandon abandon" + ) + + print_info("Attempting to decode a mnemonic with an invalid word...") + print_info(' First word: "invalidword" (not in BIP39 wordlist)') + print_info("") + + try: + seed_from_mnemonic(invalid_word_mnemonic) + print_error("Unexpectedly succeeded - this should have thrown an error!") + except WordNotFoundError as error: + error_message = str(error) + + print_info(f'Caught WordNotFoundError: "{error_message}"') + print_info("") + + # Demonstrate programmatic error checking + if NOT_IN_WORDS_LIST_ERROR_MSG in error_message: + print_success("Error message contains NOT_IN_WORDS_LIST_ERROR_MSG constant") + print_info("") + print_info("Programmatic handling pattern:") + print_info(" try:") + print_info(" seed_from_mnemonic(mnemonic)") + print_info(" except WordNotFoundError:") + print_info(" # Handle invalid word error") + print_info(" # e.g., prompt user to check their mnemonic spelling") + + # Step 3: Demonstrate FAIL_TO_DECODE_MNEMONIC_ERROR_MSG error + print_step(3, "Error: Invalid Checksum") + + # Create a mnemonic with valid words but invalid checksum + # Using all "abandon" words creates a valid structure but wrong checksum + invalid_checksum_mnemonic = ( + "abandon abandon abandon abandon abandon abandon abandon abandon " + "abandon abandon abandon abandon abandon abandon abandon abandon " + "abandon abandon abandon abandon abandon abandon abandon abandon wrong" + ) + + print_info("Attempting to decode a mnemonic with valid words but invalid checksum...") + print_info(' All 24 data words: "abandon" (valid BIP39 word)') + print_info(' Checksum word: "wrong" (valid word, but incorrect checksum)') + print_info("") + + try: + seed_from_mnemonic(invalid_checksum_mnemonic) + print_error("Unexpectedly succeeded - this should have thrown an error!") + except InvalidMnemonicError as error: + error_message = str(error) + + print_info(f'Caught InvalidMnemonicError: "{error_message}"') + print_info("") + + # Demonstrate programmatic error checking + if FAIL_TO_DECODE_MNEMONIC_ERROR_MSG in error_message: + print_success("Error message contains FAIL_TO_DECODE_MNEMONIC_ERROR_MSG constant") + print_info("") + print_info("Programmatic handling pattern:") + print_info(" try:") + print_info(" seed_from_mnemonic(mnemonic)") + print_info(" except InvalidMnemonicError:") + print_info(" # Handle checksum validation error") + print_info(" # e.g., prompt user to verify their mnemonic phrase") + + # Step 4: Demonstrate InvalidSeedLengthError for wrong seed length + print_step(4, "Error: Wrong Seed Length") + + # Create seeds with wrong lengths + short_seed = bytes(16) # Too short (16 bytes instead of 32) + long_seed = bytes(64) # Too long (64 bytes instead of 32) + + print_info("mnemonic_from_seed() requires exactly 32 bytes.") + print_info("Attempting with incorrect seed lengths...") + print_info("") + + # Test with short seed + print_info("Test 1: 16-byte seed (too short)") + try: + mnemonic_from_seed(short_seed) + print_error("Unexpectedly succeeded - this should have thrown an error!") + except InvalidSeedLengthError as error: + error_message = str(error) + print_info(f' Caught InvalidSeedLengthError: "{error_message}"') + print_success(" Correctly threw InvalidSeedLengthError for wrong seed length") + + print_info("") + + # Test with long seed + print_info("Test 2: 64-byte seed (too long)") + try: + mnemonic_from_seed(long_seed) + print_error("Unexpectedly succeeded - this should have thrown an error!") + except InvalidSeedLengthError as error: + error_message = str(error) + print_info(f' Caught InvalidSeedLengthError: "{error_message}"') + print_success(" Correctly threw InvalidSeedLengthError for wrong seed length") + + print_info("") + print_info("Programmatic handling pattern:") + print_info(" try:") + print_info(" mnemonic_from_seed(seed)") + print_info(" except InvalidSeedLengthError:") + print_info(" # Handle wrong seed length error") + print_info(" # e.g., validate input data before calling mnemonic_from_seed()") + + # Step 5: Comprehensive try/catch pattern + print_step(5, "Comprehensive Error Handling Pattern") + + print_info("Here is a complete try/except pattern for mnemonic functions:") + print_info("") + print_info(" from algokit_algo25 import (") + print_info(" FAIL_TO_DECODE_MNEMONIC_ERROR_MSG,") + print_info(" NOT_IN_WORDS_LIST_ERROR_MSG,") + print_info(" InvalidMnemonicError,") + print_info(" InvalidSeedLengthError,") + print_info(" WordNotFoundError,") + print_info(" seed_from_mnemonic,") + print_info(" )") + print_info("") + print_info(" try:") + print_info(" seed = seed_from_mnemonic(user_input)") + print_info(" # Success - use the seed") + print_info(" except WordNotFoundError:") + print_info(" # One or more words are not in the BIP39 wordlist") + print_info(" # Action: Check spelling, ensure words are lowercase") + print_info(" except InvalidMnemonicError:") + print_info(" # Checksum validation failed or wrong word count") + print_info(" # Action: Verify the complete mnemonic phrase") + print_info(" except InvalidSeedLengthError:") + print_info(" # Wrong seed length (for mnemonic_from_seed)") + print_info(" # Action: Ensure seed is exactly 32 bytes") + print_info(" except Exception as e:") + print_info(" # Unexpected error") + print_info(" # Action: Log and report") + + # Step 6: Demonstrate a successful operation for comparison + print_step(6, "Successful Operation for Comparison") + + valid_seed = secrets.token_bytes(32) + + print_info("Creating a valid mnemonic from a 32-byte seed...") + + try: + valid_mnemonic = mnemonic_from_seed(valid_seed) + words = valid_mnemonic.split(" ") + print_success(f"Generated valid mnemonic with {len(words)} words") + print_info(f' First 3 words: "{" ".join(words[:3])}..."') + + # Round-trip to verify + recovered_seed = seed_from_mnemonic(valid_mnemonic) + print_success("Successfully recovered seed from mnemonic (no errors)") + print_info(f" Recovered seed length: {len(recovered_seed)} bytes") + except Exception as error: + print_error(f"Unexpected error: {error}") + + # Step 7: Summary + print_step(7, "Summary") + + print_info("Error handling best practices for mnemonic functions:") + print_info("") + print_info(" 1. Import error types and constants for programmatic checking:") + print_info(" from algokit_algo25 import (") + print_info(" FAIL_TO_DECODE_MNEMONIC_ERROR_MSG,") + print_info(" NOT_IN_WORDS_LIST_ERROR_MSG,") + print_info(" InvalidMnemonicError,") + print_info(" InvalidSeedLengthError,") + print_info(" WordNotFoundError,") + print_info(" )") + print_info("") + print_info(" 2. Three exception types to handle:") + print_info(" - WordNotFoundError: Invalid word in mnemonic") + print_info(" - InvalidMnemonicError: Checksum validation failed") + print_info(" - InvalidSeedLengthError: Seed is not exactly 32 bytes") + print_info("") + print_info(" 3. Always use try/except when processing user-provided mnemonics") + print_info("") + print_info(" 4. Use isinstance() checks for specific exception handling") + print_info("") + print_info(" 5. Check error message contents against constants if needed") + + print_success("Error Handling example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/algo25/verify-all.sh b/examples/algo25/verify-all.sh new file mode 100755 index 00000000..206dafca --- /dev/null +++ b/examples/algo25/verify-all.sh @@ -0,0 +1,77 @@ +#!/bin/bash + +# verify-all.sh - Run all algo25 examples and verify they work +# Exit with non-zero code if any example fails + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +cd "$SCRIPT_DIR" + +# Array of example files in order +EXAMPLES=( + "01_mnemonic_from_seed.py" + "02_seed_from_mnemonic.py" + "03_secret_key_to_mnemonic.py" + "04_master_derivation_key.py" + "05_error_handling.py" +) + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +NC='\033[0m' # No Color + +echo "========================================" +echo "Algo25 Examples Verification Script" +echo "========================================" +echo "" + +if [ ${#EXAMPLES[@]} -eq 0 ]; then + echo "No examples to run yet." + echo "" + echo -e "${GREEN}Algo25 examples suite passed (no examples)${NC}" + exit 0 +fi + +PASSED=0 +FAILED=0 +FAILED_EXAMPLES=() + +for example in "${EXAMPLES[@]}"; do + echo -n "Running $example... " + + if [ ! -f "$example" ]; then + echo -e "${RED}FAILED${NC} (file not found)" + FAILED=$((FAILED + 1)) + FAILED_EXAMPLES+=("$example") + continue + fi + + # Run the example and capture output/exit code + if OUTPUT=$(uv run python "$example" 2>&1); then + echo -e "${GREEN}PASSED${NC}" + PASSED=$((PASSED + 1)) + else + echo -e "${RED}FAILED${NC}" + echo "$OUTPUT" + FAILED=$((FAILED + 1)) + FAILED_EXAMPLES+=("$example") + fi +done + +echo "" +echo "========================================" +echo "Results: ${PASSED} passed, ${FAILED} failed" +echo "========================================" + +if [ $FAILED -gt 0 ]; then + echo "" + echo -e "${RED}Failed examples:${NC}" + for failed in "${FAILED_EXAMPLES[@]}"; do + echo " - $failed" + done + exit 1 +fi + +echo "" +echo -e "${GREEN}All Algo25 examples passed!${NC}" +exit 0 diff --git a/examples/algod_client/01_node_health_status.py b/examples/algod_client/01_node_health_status.py new file mode 100644 index 00000000..c9ef76e5 --- /dev/null +++ b/examples/algod_client/01_node_health_status.py @@ -0,0 +1,144 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Node Health and Status + +This example demonstrates how to check node health and status using +the AlgodClient methods: health_check(), ready(), status(), and status_after_block(). + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from shared import ( + create_algod_client, + print_error, + print_header, + print_info, + print_step, + print_success, +) + + +def format_nanoseconds(ns: int) -> str: + """Format a nanoseconds value to a human-readable string.""" + ms = ns / 1_000_000 + if ms < 1000: + return f"{ms:.2f} ms" + seconds = ms / 1000 + if seconds < 60: + return f"{seconds:.2f} seconds" + minutes = seconds / 60 + return f"{minutes:.2f} minutes" + + +def main() -> None: + print_header("Node Health and Status Example") + + # Create an Algod client connected to LocalNet + algod = create_algod_client() + + # ========================================================================= + # Step 1: Health Check + # ========================================================================= + print_step(1, "Checking node health with health_check()") + + try: + # health_check() returns void if successful, throws an error if unhealthy + algod.health_check() + print_success("Node is healthy!") + print_info("health_check() returns None when the node is healthy") + print_info("If the node is unhealthy, it raises an exception") + except Exception as e: + print_error(f"Node health check failed: {e}") + + # ========================================================================= + # Step 2: Ready Check + # ========================================================================= + print_step(2, "Checking if node is ready with ready()") + + try: + # ready() returns void if the node is ready to accept transactions + algod.ready() + print_success("Node is ready to accept transactions!") + print_info("ready() returns None when the node is ready") + print_info("If the node is not ready (e.g., catching up), it raises an exception") + except Exception as e: + print_error(f"Node ready check failed: {e}") + + # ========================================================================= + # Step 3: Get Node Status + # ========================================================================= + print_step(3, "Getting current node status with status()") + + try: + node_status = algod.status() + + print_success("Node status retrieved successfully!") + print_info("") + print_info("Key status fields:") + print_info(f" - last-round: {node_status['last-round']}") + print_info(f" - catchup-time: {format_nanoseconds(node_status['catchup-time'])}") + print_info(f" - time-since-last-round: {format_nanoseconds(node_status['time-since-last-round'])}") + print_info(f" - last-version: {node_status['last-version']}") + print_info(f" - stopped-at-unsupported-round: {node_status['stopped-at-unsupported-round']}") + + # Check if node has synced since startup (catchup-time === 0 means synced) + has_synced_since_startup = node_status["catchup-time"] == 0 + print_info(f" - hasSyncedSinceStartup: {has_synced_since_startup}") + + if "last-catchpoint" in node_status: + print_info(f" - last-catchpoint: {node_status['last-catchpoint']}") + except Exception as e: + print_error(f"Failed to get node status: {e}") + + # ========================================================================= + # Step 4: Wait for Block After Round + # ========================================================================= + print_step(4, "Waiting for next block with status_after_block(round)") + + try: + import time + + # First, get the current round + current_status = algod.status() + current_round = current_status["last-round"] + + print_info(f"Current round: {current_round}") + print_info(f"Waiting for block after round {current_round}...") + + # Wait for a block after the current round + # Note: On LocalNet in dev mode, blocks are produced on-demand, + # so this may timeout if no transactions are submitted + start_time = time.time() + new_status = algod.status_after_block(current_round) + elapsed_time = (time.time() - start_time) * 1000 + + print_success("New block received!") + print_info(f" - New round: {new_status['last-round']}") + print_info(f" - Wait time: {elapsed_time:.0f} ms") + print_info(f" - time-since-last-round: {format_nanoseconds(new_status['time-since-last-round'])}") + except Exception as e: + # status_after_block has a 1 minute timeout by default + print_error(f"Failed to wait for block: {e}") + print_info("Note: On LocalNet in dev mode, blocks are only produced when transactions are submitted") + print_info("Try submitting a transaction in another terminal to trigger a new block") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. health_check() - Checks if the node is healthy (returns None or raises)") + print_info(" 2. ready() - Checks if the node is ready to accept transactions") + print_info(" 3. status() - Gets current node status including last-round, catchup-time, etc.") + print_info(" 4. status_after_block(round) - Waits for a new block after the specified round") + print_info("") + print_info("Key status fields explained:") + print_info(" - last-round: The most recent block the node has seen") + print_info(" - catchup-time: Time spent catching up (0 = fully synced)") + print_info(" - time-since-last-round: Time elapsed since the last block") + print_info(" - stopped-at-unsupported-round: True if node stopped due to unsupported consensus") + + +if __name__ == "__main__": + main() diff --git a/examples/algod_client/02_version_genesis.py b/examples/algod_client/02_version_genesis.py new file mode 100644 index 00000000..a8486213 --- /dev/null +++ b/examples/algod_client/02_version_genesis.py @@ -0,0 +1,161 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Version and Genesis Information + +This example demonstrates how to retrieve node version information and +genesis configuration using the AlgodClient methods: versions() and genesis(). + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import base64 +from datetime import UTC, datetime + +from shared import ( + create_algod_client, + print_error, + print_header, + print_info, + print_step, + print_success, +) + + +def main() -> None: + print_header("Version and Genesis Information Example") + + # Create an Algod client connected to LocalNet + algod = create_algod_client() + + # ========================================================================= + # Step 1: Get Version Information + # ========================================================================= + print_step(1, "Getting algod version information with versions()") + + try: + version_info = algod.versions() + + print_success("Version information retrieved successfully!") + print_info("") + print_info("Build information:") + print_info(f" - major: {version_info['build']['major']}") + print_info(f" - minor: {version_info['build']['minor']}") + print_info(f" - build_number: {version_info['build']['build_number']}") + print_info(f" - commit_hash: {version_info['build']['commit_hash']}") + print_info(f" - branch: {version_info['build']['branch']}") + print_info(f" - channel: {version_info['build']['channel']}") + + print_info("") + print_info("Network information:") + print_info(f" - genesis_id: {version_info['genesis_id']}") + + # The genesis_hash_b64 is already a base64 string + genesis_hash_b64 = version_info["genesis_hash_b64"] + print_info(f" - genesis_hash (base64): {genesis_hash_b64}") + + print_info("") + print_info("Supported API versions:") + for v in version_info["versions"]: + print_info(f" - {v}") + except Exception as e: + print_error(f"Failed to get version information: {e}") + + # ========================================================================= + # Step 2: Get Genesis Configuration + # ========================================================================= + print_step(2, "Getting genesis configuration with genesis()") + + try: + genesis_config = algod.genesis() + + print_success("Genesis configuration retrieved successfully!") + print_info("") + print_info("Genesis fields:") + print_info(f" - network: {genesis_config['network']}") + print_info(f" - id: {genesis_config['id']}") + print_info(f" - proto (protocol version): {genesis_config['proto']}") + print_info(f" - fees (fee sink address): {genesis_config['fees']}") + print_info(f" - rwd (rewards pool address): {genesis_config['rwd']}") + + if "timestamp" in genesis_config: + timestamp = genesis_config["timestamp"] + timestamp_date = datetime.fromtimestamp(timestamp, tz=UTC) + print_info(f" - timestamp: {timestamp} ({timestamp_date.isoformat()})") + + if "devmode" in genesis_config: + print_info(f" - devmode: {genesis_config['devmode']}") + + if "comment" in genesis_config: + print_info(f" - comment: {genesis_config['comment']}") + + # Display allocation (genesis accounts) information + print_info("") + alloc = genesis_config.get("alloc", []) + print_info(f"Genesis allocations ({len(alloc)} accounts):") + + # Show first few accounts as examples + accounts_to_show = min(3, len(alloc)) + for i in range(accounts_to_show): + account = alloc[i] + algo_amount = account["state"]["algo"] / 1_000_000 + print_info(f" Account {i + 1}:") + print_info(f" - addr: {account['addr']}") + print_info(f" - comment: {account.get('comment', '')}") + print_info(f" - algo: {algo_amount:,.0f} ALGO ({account['state']['algo']} microALGO)") + print_info(f" - onl (online status): {account['state'].get('onl', 0)}") + + if len(alloc) > accounts_to_show: + print_info(f" ... and {len(alloc) - accounts_to_show} more accounts") + except Exception as e: + print_error(f"Failed to get genesis configuration: {e}") + + # ========================================================================= + # Step 3: Decode and Verify Genesis Hash + # ========================================================================= + print_step(3, "Demonstrating genesis hash decoding") + + try: + version_info = algod.versions() + + # The genesis_hash_b64 is a base64-encoded string + genesis_hash_b64 = version_info["genesis_hash_b64"] + hash_bytes = base64.b64decode(genesis_hash_b64) + + print_success("Genesis hash decoded successfully!") + print_info("") + print_info("Genesis hash representations:") + print_info(f" - Raw bytes length: {len(hash_bytes)} bytes") + print_info(f" - Base64 encoded: {genesis_hash_b64}") + print_info(f" - Hex encoded: {hash_bytes.hex()}") + + print_info("The genesis hash is a SHA512/256 hash (32 bytes) that uniquely identifies the network") + print_info("It is used in transaction signing to ensure transactions are bound to a specific network") + except Exception as e: + print_error(f"Failed to decode genesis hash: {e}") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. versions() - Retrieves algod version and build information") + print_info(" 2. genesis() - Retrieves the full genesis configuration") + print_info(" 3. Decoding the base64 genesis hash") + print_info("") + print_info("Key version fields:") + print_info(" - build.major/minor/build_number: Software version numbers") + print_info(" - build.commit_hash: Git commit that built the node") + print_info(' - genesis_id: Human-readable network identifier (e.g., "devnet-v1")') + print_info(" - genesis_hash: Cryptographic hash uniquely identifying the network") + print_info("") + print_info("Key genesis fields:") + print_info(" - network: The network name") + print_info(" - proto: Initial consensus protocol version") + print_info(" - alloc: Pre-allocated accounts at network genesis") + print_info(" - fees: Address of the fee sink account") + print_info(" - rwd: Address of the rewards pool account") + + +if __name__ == "__main__": + main() diff --git a/examples/algod_client/03_ledger_supply.py b/examples/algod_client/03_ledger_supply.py new file mode 100644 index 00000000..4b2b871c --- /dev/null +++ b/examples/algod_client/03_ledger_supply.py @@ -0,0 +1,137 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Ledger Supply Information + +This example demonstrates how to retrieve ledger supply information using +the AlgodClient method: supply(). + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from shared import ( + create_algod_client, + print_error, + print_header, + print_info, + print_step, + print_success, +) + + +def format_amount(micro_algos: int) -> dict[str, str]: + """Format a microAlgos value to both microAlgo and Algo representations.""" + micro_algo_str = f"{micro_algos:,} uALGO" + algo_value = micro_algos / 1_000_000 + algo_str = f"{algo_value:,.6f} ALGO" + return { + "micro_algo": micro_algo_str, + "algo": algo_str, + } + + +def calculate_percentage(part: int, total: int, decimals: int = 2) -> str: + """Calculate percentage with specified decimal places.""" + if total == 0: + return "0%" + percentage = (part / total) * 100 + return f"{percentage:.{decimals}f}%" + + +def main() -> None: + print_header("Ledger Supply Information Example") + + # Create an Algod client connected to LocalNet + algod = create_algod_client() + + # ========================================================================= + # Step 1: Get Ledger Supply Information + # ========================================================================= + print_step(1, "Getting ledger supply information with supply()") + + try: + supply_info = algod.supply() + + print_success("Ledger supply information retrieved successfully!") + print_info("") + + # ===================================================================== + # Step 2: Display Total Money Supply + # ===================================================================== + print_step(2, "Displaying total_money (total Algos in the network)") + + total_formatted = format_amount(supply_info.total_money) + print_info("Total money supply in the network:") + print_info(f" - In microAlgos: {total_formatted['micro_algo']}") + print_info(f" - In Algos: {total_formatted['algo']}") + print_info("") + print_info("total_money represents the total amount of Algos in circulation") + + # ===================================================================== + # Step 3: Display Online Money + # ===================================================================== + print_step(3, "Displaying online_money (Algos in online accounts for consensus)") + + online_formatted = format_amount(supply_info.online_money) + print_info("Online money (participating in consensus):") + print_info(f" - In microAlgos: {online_formatted['micro_algo']}") + print_info(f" - In Algos: {online_formatted['algo']}") + print_info("") + print_info("online_money represents Algos held by accounts that are online and participating in consensus") + + # ===================================================================== + # Step 4: Calculate and Display Online Percentage + # ===================================================================== + print_step(4, "Calculating percentage of Algos that are online") + + total_money = supply_info.total_money + online_money = supply_info.online_money + + online_percentage = calculate_percentage(online_money, total_money) + offline_money = total_money - online_money + offline_formatted = format_amount(offline_money) + offline_percentage = calculate_percentage(offline_money, total_money) + + print_info("Supply distribution:") + print_info(f" - Online: {online_percentage} ({online_formatted['algo']})") + print_info(f" - Offline: {offline_percentage} ({offline_formatted['algo']})") + print_info("") + + print_info("A higher online percentage indicates more stake participating in consensus") + print_info("This metric is important for network security and decentralization") + + # ===================================================================== + # Step 5: Display Current Round + # ===================================================================== + print_step(5, "Displaying the current round") + + print_info(f"Current round: {supply_info.current_round:,}") + print_info("") + print_info("The supply information is accurate as of this round") + except Exception as e: + print_error(f"Failed to get ledger supply information: {e}") + raise SystemExit(1) from e + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. supply() - Retrieves the ledger supply information") + print_info(" 2. Displaying total_money in both microAlgos and Algos") + print_info(" 3. Displaying online_money in both microAlgos and Algos") + print_info(" 4. Calculating the percentage of Algos participating in consensus") + print_info("") + print_info("Key supply fields:") + print_info(" - total_money: Total Algos in circulation on the network") + print_info(" - online_money: Algos in accounts online for consensus") + print_info(" - current_round: The round at which this supply info was calculated") + print_info("") + print_info("Use cases:") + print_info(" - Monitor network participation rate") + print_info(" - Track total supply for economic analysis") + print_info(" - Verify consensus security metrics") + + +if __name__ == "__main__": + main() diff --git a/examples/algod_client/04_account_info.py b/examples/algod_client/04_account_info.py new file mode 100644 index 00000000..1d565429 --- /dev/null +++ b/examples/algod_client/04_account_info.py @@ -0,0 +1,309 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Account Information + +This example demonstrates how to retrieve comprehensive account information using +the AlgodClient methods: account_information(), account_application_information(), and +account_asset_information(). + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from shared import ( + create_algod_client, + create_algorand_client, + get_funded_account, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + + +def format_amount(micro_algos: int) -> dict[str, str]: + """Format a bigint microAlgos value to both microAlgo and Algo representations.""" + micro_algo_str = f"{micro_algos:,} uALGO" + algo_value = micro_algos / 1_000_000 + algo_str = f"{algo_value:,.6f} ALGO" + return { + "micro_algo": micro_algo_str, + "algo": algo_str, + } + + +def main() -> None: + print_header("Account Information Example") + + # Create an Algod client connected to LocalNet + algod = create_algod_client() + + # Create an AlgorandClient to get a funded account + algorand = create_algorand_client() + + # ========================================================================= + # Step 1: Get a Funded Account from LocalNet + # ========================================================================= + print_step(1, "Getting a funded account from LocalNet") + + account_address: str + try: + funded_account = get_funded_account(algorand) + account_address = str(funded_account.addr) + print_success(f"Got funded account: {account_address}") + except Exception as e: + print_error(f"Failed to get funded account: {e}") + print_info("Make sure LocalNet is running with `algokit localnet start`") + print_info("If issues persist, try `algokit localnet reset`") + raise SystemExit(1) from e + + # ========================================================================= + # Step 2: Get Full Account Information + # ========================================================================= + print_step(2, "Getting full account information with account_information()") + + try: + account_info = algod.account_information(account_address) + + print_success("Account information retrieved successfully!") + print_info("") + + # Display core account fields + print_info("Core Account Information:") + print_info(f" Address: {account_info.address}") + print_info(f" Short: {shorten_address(str(account_info.address))}") + + balance = format_amount(account_info.amount) + print_info(f" Balance: {balance['algo']} ({balance['micro_algo']})") + + min_balance = format_amount(account_info.min_balance) + print_info(f" Min Balance: {min_balance['algo']} ({min_balance['micro_algo']})") + + print_info(f" Status: {account_info.status}") + print_info(f" Round: {account_info.round_:,}") + print_info("") + + # ===================================================================== + # Step 3: Display Additional Account Fields + # ===================================================================== + print_step(3, "Displaying additional account fields") + + pending_rewards = format_amount(account_info.pending_rewards or 0) + total_rewards = format_amount(account_info.rewards or 0) + amount_without_rewards = format_amount(account_info.amount_without_pending_rewards or 0) + + print_info("Rewards Information:") + print_info(f" Pending Rewards: {pending_rewards['algo']}") + print_info(f" Total Rewards: {total_rewards['algo']}") + print_info(f" Amount Without Rewards: {amount_without_rewards['algo']}") + print_info("") + + # ===================================================================== + # Step 4: Display Asset Holdings + # ===================================================================== + print_step(4, "Displaying assets held by the account (assets)") + + print_info("Asset Holdings:") + print_info(f" Total Assets Opted In: {account_info.total_assets_opted_in or 0}") + + assets = account_info.assets or [] + if assets: + print_info(" Asset Holdings:") + for asset in assets: + print_info(f" - Asset ID: {asset.asset_id}") + print_info(f" Amount: {asset.amount:,}") + print_info(f" Frozen: {asset.is_frozen or False}") + else: + print_info(" No assets held by this account") + print_info("On LocalNet, dispenser accounts typically do not hold any ASAs") + print_info("") + + # ===================================================================== + # Step 5: Display Created Applications + # ===================================================================== + print_step(5, "Displaying applications created by the account (created-apps)") + + print_info("Created Applications:") + print_info(f" Total Created Apps: {account_info.total_created_apps or 0}") + + created_apps = account_info.created_apps or [] + if created_apps: + print_info(" Created Applications:") + for app in created_apps: + print_info(f" - App ID: {app.id}") + if app.params and app.params.creator: + print_info(f" Creator: {shorten_address(str(app.params.creator))}") + else: + print_info(" No applications created by this account") + print_info("This account has not deployed any smart contracts") + print_info("") + + # ===================================================================== + # Step 6: Display Opted-In Applications + # ===================================================================== + print_step(6, "Displaying applications the account has opted into (apps-local-state)") + + print_info("Opted-In Applications (Local State):") + print_info(f" Total Apps Opted In: {account_info.total_apps_opted_in or 0}") + + apps_local_state = account_info.apps_local_state or [] + if apps_local_state: + print_info(" Local State Entries:") + for local_state in apps_local_state: + print_info(f" - App ID: {local_state.id}") + schema = local_state.schema + num_uint = schema.num_uint if schema else 0 + num_byte = schema.num_byte_slice if schema else 0 + print_info(f" Schema: {num_uint} uints, {num_byte} byte slices") + key_value = local_state.key_value or [] + if key_value: + print_info(f" Key-Value Pairs: {len(key_value)}") + else: + print_info(" No applications opted into") + print_info("This account has not opted into any applications") + print_info("") + + # ===================================================================== + # Step 7: Display Created Assets + # ===================================================================== + print_step(7, "Displaying assets created by the account (created-assets)") + + print_info("Created Assets:") + print_info(f" Total Created Assets: {account_info.total_created_assets or 0}") + + created_assets = account_info.created_assets or [] + if created_assets: + print_info(" Created Assets:") + for asset in created_assets: + print_info(f" - Asset ID: {asset.index}") + params = asset.params + if params and params.name: + print_info(f" Name: {params.name}") + if params and params.unit_name: + print_info(f" Unit: {params.unit_name}") + print_info(f" Total: {(params.total if params else 0):,}") + print_info(f" Decimals: {params.decimals if params else 0}") + else: + print_info(" No assets created by this account") + print_info("") + + # ===================================================================== + # Step 8: Demonstrate account_application_information() (if apps exist) + # ===================================================================== + print_step(8, "Demonstrating account_application_information(address, app_id)") + + if apps_local_state: + app_id = apps_local_state[0].id + print_info(f"Querying specific application info for App ID: {app_id}") + + app_info = algod.account_application_information(account_address, app_id) + print_success("Application-specific information retrieved!") + print_info(f" Round: {app_info.round_:,}") + if app_info.app_local_state: + print_info(" Has Local State: Yes") + local_schema = app_info.app_local_state.schema + num_uint = local_schema.num_uint if local_schema else 0 + num_byte = local_schema.num_byte_slice if local_schema else 0 + print_info(f" Schema: {num_uint} uints, {num_byte} byte slices") + if app_info.created_app: + print_info(" Is Creator: Yes") + elif created_apps: + app_id = created_apps[0].id + print_info(f"Querying specific application info for App ID: {app_id}") + + app_info = algod.account_application_information(account_address, app_id) + print_success("Application-specific information retrieved!") + print_info(f" Round: {app_info.round_:,}") + if app_info.created_app: + print_info(" Is Creator: Yes") + created_app = app_info.created_app + approval_size = len(created_app.approval_program or b"") + clear_size = len(created_app.clear_state_program or b"") + print_info(f" Approval Program Size: {approval_size} bytes") + print_info(f" Clear Program Size: {clear_size} bytes") + else: + print_info("No applications to query.") + print_info("account_application_information() requires an app ID that the account has interacted with.") + print_info("It returns both local state (if opted in) and global state (if creator).") + print_info("") + + # ===================================================================== + # Step 9: Demonstrate account_asset_information() (if assets exist) + # ===================================================================== + print_step(9, "Demonstrating account_asset_information(address, asset_id)") + + if assets: + asset_id = assets[0].asset_id + print_info(f"Querying specific asset info for Asset ID: {asset_id}") + + asset_info = algod.account_asset_information(account_address, asset_id) + print_success("Asset-specific information retrieved!") + print_info(f" Round: {asset_info.round_:,}") + if asset_info.asset_holding: + holding = asset_info.asset_holding + print_info(f" Holding Amount: {holding.amount:,}") + print_info(f" Is Frozen: {holding.is_frozen or False}") + if asset_info.created_asset: + print_info(" Is Creator: Yes") + created = asset_info.created_asset + print_info(f" Total Supply: {created.total or 0:,}") + elif created_assets: + asset_id = created_assets[0].index + print_info(f"Querying specific asset info for Asset ID: {asset_id}") + + asset_info = algod.account_asset_information(account_address, asset_id) + print_success("Asset-specific information retrieved!") + print_info(f" Round: {asset_info.round_:,}") + if asset_info.asset_holding: + holding = asset_info.asset_holding + print_info(f" Holding Amount: {holding.amount:,}") + if asset_info.created_asset: + print_info(" Is Creator: Yes") + created = asset_info.created_asset + print_info(f" Total Supply: {created.total or 0:,}") + print_info(f" Decimals: {created.decimals or 0}") + else: + print_info("No assets to query.") + print_info("account_asset_information() requires an asset ID that the account has interacted with.") + print_info("It returns both the holding info and asset params (if creator).") + except Exception as e: + print_error(f"Failed to get account information: {e}") + raise SystemExit(1) from e + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. account_information(address) - Get full account details") + print_info(" 2. Key fields: address, amount, min-balance, status, round") + print_info(" 3. Asset holdings (assets array)") + print_info(" 4. Created applications (created-apps array)") + print_info(" 5. Opted-in applications (apps-local-state array)") + print_info(" 6. Created assets (created-assets array)") + print_info(" 7. account_application_information(address, app_id) - Get specific app info") + print_info(" 8. account_asset_information(address, asset_id) - Get specific asset info") + print_info("") + print_info("Key Account fields:") + print_info(" - address: The account public key") + print_info(" - amount: Total MicroAlgos in the account") + print_info(" - min-balance: Minimum balance required based on usage") + print_info(' - status: "Offline", "Online", or "NotParticipating"') + print_info(" - round: The round this information is valid for") + print_info(" - assets: Array of AssetHolding (asset-id, amount, is-frozen)") + print_info(" - apps-local-state: Array of ApplicationLocalState (opted-in apps)") + print_info(" - created-apps: Array of Application (apps created by this account)") + print_info(" - created-assets: Array of Asset (ASAs created by this account)") + print_info("") + print_info("Use cases:") + print_info(" - Check account balance before transactions") + print_info(" - Verify minimum balance requirements") + print_info(" - Enumerate assets held or created by an account") + print_info(" - Check application opt-in status") + print_info(" - Query specific asset or app details for an account") + + +if __name__ == "__main__": + main() diff --git a/examples/algod_client/05_transaction_params.py b/examples/algod_client/05_transaction_params.py new file mode 100644 index 00000000..a01272fd --- /dev/null +++ b/examples/algod_client/05_transaction_params.py @@ -0,0 +1,225 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Transaction Parameters + +This example demonstrates how to get suggested transaction parameters using +suggested_params(). These parameters are essential for constructing valid +transactions on the Algorand network. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import base64 + +from shared import ( + create_algod_client, + print_error, + print_header, + print_info, + print_step, + print_success, +) + + +def format_as_base64(data: bytes | str) -> str: + """Format bytes or base64 string for display.""" + if isinstance(data, bytes): + return base64.b64encode(data).decode("utf-8") + return data + + +def format_fee(micro_algos: int) -> str: + """Format a fee as microAlgos and Algos.""" + algo_value = micro_algos / 1_000_000 + return f"{micro_algos:,} uALGO ({algo_value:.6f} ALGO)" + + +def main() -> None: + print_header("Transaction Parameters Example") + + # Create an Algod client connected to LocalNet + algod = create_algod_client() + + # ========================================================================= + # Step 1: Get Suggested Parameters using suggested_params() + # ========================================================================= + print_step(1, "Getting suggested transaction parameters with suggested_params()") + + try: + suggested_params = algod.suggested_params() + + print_success("Suggested parameters retrieved successfully!") + print_info("") + + # ===================================================================== + # Step 2: Display Core Parameters + # ===================================================================== + print_step(2, "Displaying suggested transaction parameters") + + print_info("Core Transaction Parameters:") + print_info(f" fee: {format_fee(suggested_params.fee)}") + print_info(f" min_fee: {format_fee(suggested_params.min_fee)}") + print_info(f" flat_fee: {suggested_params.flat_fee}") + print_info("") + + # ===================================================================== + # Step 3: Display Validity Window Parameters + # ===================================================================== + print_step(3, "Displaying validity window parameters (first_valid, last_valid)") + + print_info("Validity Window:") + print_info(f" first_valid: {suggested_params.first_valid:,}") + print_info(f" last_valid: {suggested_params.last_valid:,}") + print_info("") + + validity_window = suggested_params.last_valid - suggested_params.first_valid + print_info(f" Validity Window: {validity_window:,} rounds") + print_info("The default validity window is 1000 rounds (~1 hour on MainNet)") + print_info("A transaction is only valid between first_valid and last_valid rounds") + print_info("") + + # ===================================================================== + # Step 4: Display Network Identification Parameters + # ===================================================================== + print_step(4, "Displaying network identification parameters") + + print_info("Network Identification:") + print_info(f" genesis_id: {suggested_params.genesis_id}") + print_info(f" genesis_hash: {format_as_base64(suggested_params.genesis_hash)}") + print_info(f" consensus_version: {suggested_params.consensus_version}") + print_info("") + + print_info("genesis_id and genesis_hash uniquely identify the network") + print_info("Transactions are rejected if sent to the wrong network") + print_info("") + + # ===================================================================== + # Step 5: Explain Each Parameter's Purpose + # ===================================================================== + print_step(5, "Explaining each parameter's purpose") + + print_info("Parameter Purposes:") + print_info("") + print_info(" fee:") + print_info(" The suggested fee per byte for the transaction.") + print_info(" During network congestion, this value may increase.") + print_info("") + print_info(" min_fee:") + print_info(" The minimum fee required regardless of transaction size.") + print_info(" Currently 1000 uALGO (0.001 ALGO) on all Algorand networks.") + print_info("") + print_info(" flat_fee:") + print_info(" When false, fee is calculated as: fee * transactionSize") + print_info(" When true, fee is used directly as the total fee.") + print_info("") + print_info(" first_valid:") + print_info(" The first round this transaction is valid for.") + print_info(" Usually set to the current round from the node.") + print_info("") + print_info(" last_valid:") + print_info(" The last round this transaction is valid for.") + print_info(" Transaction will fail if not confirmed by this round.") + print_info("") + print_info(" genesis_id:") + print_info(' A human-readable network identifier (e.g., "mainnet-v1.0").') + print_info(" Prevents replaying transactions across networks.") + print_info("") + print_info(" genesis_hash:") + print_info(" The SHA256 hash of the genesis block, uniquely identifying the network.") + print_info(" Cryptographically ensures transaction is for the correct chain.") + print_info("") + print_info(" consensus_version:") + print_info(" The consensus protocol version at the current round.") + print_info(" Indicates which features and rules are active.") + print_info("") + + # ===================================================================== + # Step 6: Demonstrate Customizing Parameters + # ===================================================================== + print_step(6, "Demonstrating how to customize transaction parameters") + + print_info("Customizing Parameters:") + print_info("") + + # Example 1: Setting a specific flat fee + custom_fee_value = 2000 # Set a fixed 2000 uALGO fee + + print_info(" Example 1: Setting a flat fee") + print_info(f" Original fee: {format_fee(suggested_params.fee)}") + print_info(f" Original flat_fee: {suggested_params.flat_fee}") + print_info(f" Custom fee: {format_fee(custom_fee_value)}") + print_info(" Custom flat_fee: True") + print_info("Set flat_fee=True to use a fixed fee instead of per-byte") + print_info("") + + # Example 2: Extending the validity window + first_valid = suggested_params.first_valid + last_valid = suggested_params.last_valid + extended_window = 2000 # 2000 rounds instead of default 1000 + extended_last_valid = first_valid + extended_window + + print_info(" Example 2: Extending the validity window") + print_info(f" Original last_valid: {last_valid:,}") + print_info(f" Extended last_valid: {extended_last_valid:,}") + print_info(f" Original window: {validity_window:,} rounds") + print_info(f" Extended window: {extended_window:,} rounds") + print_info("Extend validity window for offline signing or delayed submission") + print_info("") + + # Example 3: Shortening the validity window + short_window = 100 # Only 100 rounds validity + short_last_valid = first_valid + short_window + + print_info(" Example 3: Shortening the validity window") + print_info(f" Original last_valid: {last_valid:,}") + print_info(f" Shortened last_valid: {short_last_valid:,}") + print_info(f" Shortened window: {short_window:,} rounds") + print_info("Shorter windows provide better replay protection") + print_info("") + + # Example 4: Setting a specific first_valid for delayed execution + future_round = first_valid + 10 # Valid starting 10 rounds from now + future_last_valid = future_round + 1000 + + print_info(" Example 4: Delayed execution (future first_valid)") + print_info(f" Original first_valid: {first_valid:,}") + print_info(f" Delayed first_valid: {future_round:,}") + print_info(f" Delayed last_valid: {future_last_valid:,}") + print_info("Set future first_valid to prevent immediate execution") + + except Exception as e: + print_error(f"Failed to get transaction parameters: {e}") + print_info("Make sure LocalNet is running with `algokit localnet start`") + raise SystemExit(1) from e + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. suggested_params() - Get parameters for building transactions") + print_info(" 2. Parameter fields: fee, min_fee, flat_fee, first_valid, last_valid") + print_info(" 3. Network identification: genesis_id, genesis_hash, consensus_version") + print_info(" 4. How first_valid and last_valid define the validity window") + print_info(" 5. Customizing parameters: fees and validity windows") + print_info("") + print_info("Key suggested_params fields:") + print_info(" - fee: Suggested fee per byte (int)") + print_info(" - min_fee: Minimum transaction fee (int)") + print_info(" - flat_fee: Whether fee is flat or per-byte (bool)") + print_info(" - first_valid: First valid round (int)") + print_info(" - last_valid: Last valid round (int)") + print_info(" - genesis_id: Network identifier string") + print_info(" - genesis_hash: Genesis block hash (base64 string)") + print_info(" - consensus_version: Protocol version string") + print_info("") + print_info("Use cases:") + print_info(" - Building transactions with correct fees") + print_info(" - Setting appropriate validity windows") + print_info(" - Ensuring network compatibility") + print_info(" - Offline transaction signing with extended windows") + + +if __name__ == "__main__": + main() diff --git a/examples/algod_client/06_send_transaction.py b/examples/algod_client/06_send_transaction.py new file mode 100644 index 00000000..127581af --- /dev/null +++ b/examples/algod_client/06_send_transaction.py @@ -0,0 +1,352 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, ANN401 +""" +Example: Send and Confirm Transaction + +This example demonstrates how to send transactions and wait for confirmation +using send_raw_transaction() and pending_transaction_information(). It shows +the complete lifecycle of submitting a transaction to the Algorand network. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from typing import Any + +from shared import ( + create_algod_client, + create_algorand_client, + format_micro_algo, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_utils import AlgoAmount, PaymentParams + + +def format_fee(micro_algos: int) -> str: + """Format a fee as microAlgos and Algos.""" + algo_value = micro_algos / 1_000_000 + return f"{micro_algos:,} uALGO ({algo_value:.6f} ALGO)" + + +def wait_for_confirmation( + algod: Any, + tx_id: str, + max_rounds: int = 10, +) -> Any: + """ + Wait for a transaction to be confirmed using pending_transaction_information. + This implements a polling loop to check transaction status. + + Args: + algod: The AlgodClient instance + tx_id: The transaction ID to wait for + max_rounds: Maximum number of rounds to wait (default: 10) + + Returns: + The PendingTransactionResponse when confirmed + """ + # Get the current status to know what round we're on + status = algod.status() + current_round = status.last_round + end_round = current_round + max_rounds + + print_info(f" Starting at round: {current_round:,}") + print_info(f" Will wait until round: {end_round:,}") + print_info("") + + while current_round < end_round: + # Check the transaction status + pending_info = algod.pending_transaction_information(tx_id) + + # Case 1: Transaction is confirmed (confirmed-round > 0) + confirmed_round = pending_info.confirmed_round or 0 + if confirmed_round > 0: + print_info(f" Transaction confirmed in round {confirmed_round:,}") + return pending_info + + # Case 2: Transaction was rejected (pool-error is not empty) + pool_error = pending_info.pool_error or "" + if pool_error: + raise Exception(f"Transaction rejected: {pool_error}") + + # Case 3: Transaction is still pending (confirmed-round = 0, pool-error = "") + print_info(f" Round {current_round:,}: Transaction still pending...") + + # Wait for the next block + algod.status_after_block(current_round) + current_round += 1 + + raise Exception(f"Transaction {tx_id} not confirmed after {max_rounds} rounds") + + +def main() -> None: + print_header("Send and Confirm Transaction Example") + + # Create clients + algod = create_algod_client() + algorand = create_algorand_client() + + # ========================================================================= + # Step 1: Get a funded account and create a receiver + # ========================================================================= + print_step(1, "Setting up sender and receiver accounts") + + # Get a funded account from LocalNet (the dispenser) + sender = algorand.account.localnet_dispenser() + print_info(f"Sender address: {shorten_address(str(sender.addr))}") + + # Get sender balance + sender_info = algod.account_information(str(sender.addr)) + print_info(f"Sender balance: {format_micro_algo(sender_info.amount)}") + + # Create a new random account as receiver + receiver = algorand.account.random() + print_info(f"Receiver address: {shorten_address(str(receiver.addr))}") + print_info("Receiver is a new unfunded account") + print_info("") + + # ========================================================================= + # Step 2: Get suggested transaction parameters + # ========================================================================= + print_step(2, "Getting suggested transaction parameters") + + suggested_params = algod.suggested_params() + print_info(f"Last round: {suggested_params.last_valid:,}") + print_info(f"Min fee: {format_fee(suggested_params.min_fee)}") + print_info(f"Genesis ID: {suggested_params.genesis_id}") + print_info("") + + # ========================================================================= + # Step 3: Create a payment transaction using algokit + # ========================================================================= + print_step(3, "Creating a payment transaction") + + payment_amount = AlgoAmount.from_algo(1) # 1 ALGO + print_info(f"Payment amount: {payment_amount.algo} ALGO ({payment_amount.micro_algo:,} uALGO)") + print_info(f"Sender: {shorten_address(str(sender.addr))}") + print_info(f"Receiver: {shorten_address(str(receiver.addr))}") + print_info("") + + # Build the transaction using AlgorandClient.create_transaction + # This creates an unsigned Transaction object + payment_txn = algorand.create_transaction.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=payment_amount, + ) + ) + + # Get the transaction ID before sending + tx_id = payment_txn.tx_id() + print_info(f"Transaction ID: {tx_id}") + + # Sign the transaction using the sender's signer + signed_txn = sender.signer([payment_txn], [0]) + print_success("Transaction signed successfully!") + print_info("") + + # ========================================================================= + # Step 4: Submit the transaction using send_raw_transaction() + # ========================================================================= + print_step(4, "Submitting transaction with send_raw_transaction()") + + try: + submit_response = algod.send_raw_transaction(signed_txn) + print_success("Transaction submitted successfully!") + print_info(f"Transaction ID from response: {submit_response}") + print_info("") + + print_info("send_raw_transaction() accepts:") + print_info(" - A single signed transaction (bytes)") + print_info(" - An array of signed transactions (list[bytes])") + print_info("Returns PostTransactionsResponse with txId field") + print_info("") + + except Exception as e: + print_error(f"Failed to submit transaction: {e}") + print_info("Common errors:") + print_info(' - "txn dead" - Transaction validity window has passed') + print_info(' - "overspend" - Sender has insufficient funds') + print_info(' - "fee too small" - Transaction fee is below minimum') + raise + + # ========================================================================= + # Step 5: Check transaction status with pending_transaction_information() + # ========================================================================= + print_step(5, "Checking transaction status with pending_transaction_information()") + + # First, let's check the initial status (may already be confirmed on LocalNet) + initial_status = algod.pending_transaction_information(tx_id) + confirmed_round_value = initial_status.confirmed_round + print_info("Initial transaction status:") + if confirmed_round_value: + print_info(f" confirmed-round: {confirmed_round_value}") + else: + print_info(" confirmed-round: undefined (not yet confirmed)") + pool_error_value = initial_status.pool_error or "" + error_note = "(ERROR!)" if pool_error_value else "(empty = no error)" + print_info(f' pool-error: "{pool_error_value}" {error_note}') + print_info("") + + print_info("pending_transaction_information() returns PendingTransactionResponse with:") + print_info(" - confirmed-round: The round the txn was confirmed (0 or None if pending)") + print_info(" - pool-error: Error message if txn was rejected (empty if OK)") + print_info(" - txn: The signed transaction object") + print_info(" - And other fields like rewards, inner transactions, etc.") + print_info("") + + # ========================================================================= + # Step 6: Wait for confirmation using a polling loop + # ========================================================================= + print_step(6, "Implementing waitForConfirmation loop") + + print_info("The waitForConfirmation pattern:") + print_info(" 1. Call pending_transaction_information(tx_id)") + print_info(" 2. If confirmed-round > 0: Transaction confirmed!") + print_info(" 3. If pool-error is not empty: Transaction rejected!") + print_info(" 4. Otherwise: Wait for next block with status_after_block(round)") + print_info(" 5. Repeat until confirmed, rejected, or timeout") + print_info("") + + confirmed_info: Any + + # On LocalNet in dev mode, the transaction may already be confirmed + initial_confirmed = initial_status.confirmed_round or 0 + if initial_confirmed > 0: + print_info("Transaction was already confirmed (LocalNet dev mode)") + confirmed_info = initial_status + else: + print_info("Waiting for confirmation...") + print_info("") + confirmed_info = wait_for_confirmation(algod, tx_id, 10) + + print_success("Transaction confirmed!") + print_info("") + + # ========================================================================= + # Step 7: Display confirmed transaction details + # ========================================================================= + print_step(7, "Displaying confirmed transaction details") + + print_info("Confirmed Transaction Details:") + print_info(f" confirmed-round: {confirmed_info.confirmed_round or 0:,}") + print_info("") + + # Display the transaction object details + print_info("Transaction Object (txn):") + # confirmed_info.txn is a SignedTransaction, and .txn is the inner Transaction + signed_txn_obj = confirmed_info.txn + txn = signed_txn_obj.txn if signed_txn_obj else None + if txn: + print_info(f" type: {txn.transaction_type}") + print_info(f" sender: {shorten_address(str(txn.sender))}") + print_info(f" fee: {format_fee(txn.fee)}") + print_info(f" first-valid: {txn.first_valid:,}") + print_info(f" last-valid: {txn.last_valid:,}") + print_info(f" genesis-id: {txn.genesis_id}") + + # Payment-specific fields + if txn.payment: + print_info("") + print_info("Payment Fields:") + print_info(f" receiver: {shorten_address(str(txn.payment.receiver))}") + print_info(f" amount: {format_micro_algo(txn.payment.amount)}") + else: + print_info(" (Transaction details not available)") + print_info("") + + # Display rewards (if any) + sender_rewards = confirmed_info.sender_rewards + if sender_rewards is not None: + print_info("Rewards:") + print_info(f" sender-rewards: {format_micro_algo(sender_rewards)}") + receiver_rewards = confirmed_info.receiver_rewards + if receiver_rewards is not None: + print_info(f" receiver-rewards: {format_micro_algo(receiver_rewards)}") + print_info("") + + # ========================================================================= + # Step 8: Handle and display transaction errors + # ========================================================================= + print_step(8, "Demonstrating error handling (pool-error)") + + print_info("The pool-error field in PendingTransactionResponse indicates why a") + print_info("transaction was rejected from the transaction pool.") + print_info("") + + print_info("Common pool-error values:") + print_info(' "" (empty string) - Transaction is valid and in pool/confirmed') + print_info(' "transaction already in ledger" - Duplicate transaction') + print_info(' "txn dead" - Transaction validity window expired') + print_info(' "overspend" - Sender has insufficient funds') + print_info(' "fee too small" - Fee is below network minimum') + print_info(' "asset frozen" - Asset is frozen for the account') + print_info(' "logic eval error" - Smart contract evaluation failed') + print_info("") + + print_info("Best practice: Always check pool-error before assuming success") + print_info("") + + # Example of checking pool-error + print_info("Example error handling pattern:") + print_info("```") + print_info("pending_info = algod.pending_transaction_information(tx_id)") + print_info("if pending_info.get('pool-error'):") + print_info(" raise Exception(f\"Transaction rejected: {pending_info['pool-error']}\")") + print_info("if pending_info.get('confirmed-round', 0) > 0:") + print_info(" print('Transaction confirmed!')") + print_info("```") + print_info("") + + # ========================================================================= + # Step 9: Verify the payment was received + # ========================================================================= + print_step(9, "Verifying the receiver got the funds") + + receiver_info = algod.account_information(str(receiver.addr)) + print_info(f"Receiver balance: {format_micro_algo(receiver_info.amount)}") + + if receiver_info.amount == payment_amount.micro_algo: + print_success(f"Payment of {payment_amount.algo} ALGO received successfully!") + else: + print_error(f"Expected {payment_amount.micro_algo} uALGO but got {receiver_info.amount} uALGO") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. send_raw_transaction(signed_txn) - Submit a signed transaction") + print_info(" 2. pending_transaction_information(tx_id) - Check transaction status") + print_info(" 3. waitForConfirmation loop - Poll until confirmed or rejected") + print_info(" 4. Confirmed transaction details: confirmed-round, txn, fee") + print_info(" 5. Error handling with pool-error field") + print_info("") + print_info("Key PendingTransactionResponse fields:") + print_info(" - confirmed-round: Round when confirmed (int, None if pending)") + print_info(" - pool-error: Error message if rejected (string, empty if OK)") + print_info(" - txn: The SignedTransaction object") + print_info(" - sender-rewards: Rewards applied to sender (int)") + print_info(" - receiver-rewards: Rewards applied to receiver (int)") + print_info(" - closing-amount: Amount sent to close-to address (int)") + print_info("") + print_info("Transaction Status Cases:") + print_info(" - confirmed-round > 0: Transaction committed to ledger") + print_info(' - confirmed-round = 0, pool-error = "": Still pending in pool') + print_info(' - confirmed-round = 0, pool-error != "": Rejected from pool') + print_info("") + print_info("Best practices:") + print_info(" - Always wait for confirmation before considering a transaction final") + print_info(" - Check pool-error for rejection reasons") + print_info(" - Use appropriate timeout (validity window is typically 1000 rounds)") + print_info(" - On LocalNet dev mode, transactions confirm immediately") + + +if __name__ == "__main__": + main() diff --git a/examples/algod_client/07_pending_transactions.py b/examples/algod_client/07_pending_transactions.py new file mode 100644 index 00000000..29915985 --- /dev/null +++ b/examples/algod_client/07_pending_transactions.py @@ -0,0 +1,272 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, ANN401 +""" +Example: Pending Transactions + +This example demonstrates how to query pending transactions in the transaction +pool using pending_transactions() and pending_transactions_by_address(). Pending +transactions are those that have been submitted but not yet confirmed in a block. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from typing import Any + +from shared import ( + create_algod_client, + create_algorand_client, + format_micro_algo, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_utils import AlgoAmount, PaymentParams + + +def display_pending_transaction(signed_txn: Any, index: int) -> None: + """Display details of a signed transaction from the pending pool.""" + print_info(f" Transaction {index + 1}:") + if signed_txn.txn: + inner = signed_txn.txn + print_info(f" Type: {inner.transaction_type.value}") + print_info(f" Sender: {shorten_address(str(inner.sender))}") + if inner.fee: + print_info(f" Fee: {format_micro_algo(inner.fee)}") + print_info(f" First Valid: {inner.first_valid:,}") + print_info(f" Last Valid: {inner.last_valid:,}") + + # Payment-specific fields + if inner.payment: + print_info(f" Receiver: {shorten_address(str(inner.payment.receiver))}") + print_info(f" Amount: {format_micro_algo(inner.payment.amount)}") + print_info("") + + +def main() -> None: + print_header("Pending Transactions Example") + + # Create clients + algod = create_algod_client() + algorand = create_algorand_client() + + # ========================================================================= + # Step 1: Query all pending transactions in the pool + # ========================================================================= + print_step(1, "Querying all pending transactions with pending_transactions()") + + print_info("pending_transactions() returns all transactions in the pending pool") + print_info("sorted by priority (fee per byte) in decreasing order.") + print_info("") + + all_pending = algod.pending_transactions() + + top_transactions = all_pending.top_transactions or [] + print_info("PendingTransactionsResponse structure:") + print_info(f" total_transactions: {all_pending.total_transactions} (total txns in pool)") + print_info(" top_transactions: SignedTransaction[] (array of pending txns)") + print_info(f" top_transactions.length: {len(top_transactions)}") + print_info("") + + if all_pending.total_transactions == 0: + print_info("No pending transactions in the pool (normal for LocalNet in dev mode)") + print_info("On LocalNet dev mode, transactions are confirmed immediately when submitted.") + else: + print_info(f"Found {all_pending.total_transactions} pending transaction(s)") + for i, pending_txn in enumerate(top_transactions): + display_pending_transaction(pending_txn, i) + print_info("") + + # ========================================================================= + # Step 2: Query pending transactions for a specific address + # ========================================================================= + print_step(2, "Querying pending transactions by address with pending_transactions_by_address()") + + # Get the dispenser account address for testing + dispenser = algorand.account.localnet_dispenser() + dispenser_address = str(dispenser.addr) + + print_info(f"Checking pending transactions for: {shorten_address(dispenser_address)}") + print_info("") + + address_pending = algod.pending_transactions_by_address(dispenser_address) + + addr_top_transactions = address_pending.top_transactions or [] + print_info("PendingTransactionsResponse for address:") + print_info(f" total_transactions: {address_pending.total_transactions}") + print_info(f" top_transactions.length: {len(addr_top_transactions)}") + print_info("") + + if address_pending.total_transactions == 0: + print_info("No pending transactions for this address") + else: + print_info(f"Found {address_pending.total_transactions} pending transaction(s) for this address") + for i, pending_txn in enumerate(addr_top_transactions): + display_pending_transaction(pending_txn, i) + print_info("") + + # ========================================================================= + # Step 3: Using the max parameter to limit results + # ========================================================================= + print_step(3, "Using the max parameter to limit results") + + print_info("Both methods accept an optional max_ parameter") + print_info("When max_ = 0 (or not specified), all pending transactions are returned") + print_info("When max_ > 0, results are truncated to that many transactions") + print_info("") + + # Query with max = 5 + limited_pending = algod.pending_transactions(max_=5) + limited_top = limited_pending.top_transactions or [] + print_info("pending_transactions(max_=5):") + print_info(f" total_transactions: {limited_pending.total_transactions} (total in pool)") + print_info(f" top_transactions.length: {len(limited_top)} (returned, max 5)") + print_info("") + + # Query by address with max = 3 + limited_by_address = algod.pending_transactions_by_address(dispenser_address, max_=3) + limited_addr_top = limited_by_address.top_transactions or [] + print_info("pending_transactions_by_address(address, max_=3):") + print_info(f" total_transactions: {limited_by_address.total_transactions}") + print_info(f" top_transactions.length: {len(limited_addr_top)}") + print_info("") + + # ========================================================================= + # Step 4: Submit a transaction and immediately query the pending pool + # ========================================================================= + print_step(4, "Submitting a transaction and immediately querying pending pool") + + print_info("On LocalNet in dev mode, transactions are confirmed immediately,") + print_info("so they may not appear in the pending pool. On MainNet/TestNet,") + print_info("there is a window where the transaction is pending before confirmation.") + print_info("") + + # Create a receiver account + receiver = algorand.account.random() + print_info(f"Sender: {shorten_address(str(dispenser.addr))}") + print_info(f"Receiver: {shorten_address(str(receiver.addr))}") + print_info("") + + # Create and sign a payment transaction + payment_amount = AlgoAmount.from_algo(0.1) + payment_txn = algorand.create_transaction.payment( + PaymentParams( + sender=dispenser.addr, + receiver=receiver.addr, + amount=payment_amount, + ) + ) + + tx_id = payment_txn.tx_id() + print_info(f"Transaction ID: {tx_id}") + + # Sign the transaction + signed_txn = dispenser.signer([payment_txn], [0]) + + # Submit the transaction + print_info("Submitting transaction...") + algod.send_raw_transaction(signed_txn) + print_success("Transaction submitted!") + print_info("") + + # Immediately query pending transactions + # Note: On LocalNet dev mode, this will likely show the transaction as already confirmed + pending_after_submit = algod.pending_transactions() + submit_top = pending_after_submit.top_transactions or [] + print_info("Pending pool immediately after submission:") + print_info(f" total_transactions: {pending_after_submit.total_transactions}") + + if pending_after_submit.total_transactions == 0: + print_info("Transaction already confirmed (LocalNet dev mode behavior)") + else: + print_info("Transaction found in pending pool:") + for pending_txn in submit_top: + if pending_txn.txn: + display_pending_transaction(pending_txn, 0) + print_info("") + + # Also check by sender address + sender_pending = algod.pending_transactions_by_address(str(dispenser.addr)) + print_info(f"Pending for sender address: {sender_pending.total_transactions} transaction(s)") + print_info("") + + # Verify the transaction was confirmed + pending_info = algod.pending_transaction_information(tx_id) + confirmed_round = pending_info.confirmed_round or 0 + if confirmed_round > 0: + print_success(f"Transaction confirmed in round {confirmed_round:,}") + elif pending_info.pool_error: + print_error(f"Transaction rejected: {pending_info.pool_error}") + else: + print_info("Transaction is still pending...") + print_info("") + + # ========================================================================= + # Step 5: Understanding the SignedTransaction structure + # ========================================================================= + print_step(5, "Understanding the SignedTransaction structure in pending pool") + + print_info("Each transaction in top-transactions is a SignedTransaction with:") + print_info(" txn: Transaction - The unsigned transaction details") + print_info(" sig?: bytes - Signature bytes (for single-sig)") + print_info(" msig?: Multisig - Multisig details (if multisig)") + print_info(" lsig?: LogicSig - Logic signature (if using smart sig)") + print_info(" sgnr?: Address - The actual signer (if rekeyed)") + print_info("") + + print_info("The Transaction (txn) object contains:") + print_info(" type: string - Transaction type (pay, axfer, appl, etc.)") + print_info(" snd: Address - The sender address") + print_info(" fee?: int - Transaction fee in microAlgos") + print_info(" fv: int - First valid round") + print_info(" lv: int - Last valid round") + print_info(" gen?: string - Genesis ID (network identifier)") + print_info(" gh?: bytes - Genesis hash") + print_info(" note?: bytes - Transaction note") + print_info(" lx?: bytes - Transaction lease") + print_info(" rekey?: Address - Rekey-to address") + print_info(" grp?: bytes - Group ID (if in atomic group)") + print_info("") + + print_info("Type-specific fields (on the Transaction object):") + print_info(" pay (payment): rcv, amt, close") + print_info(" axfer (asset transfer): xaid, arcv, aamt, asnd, aclose") + print_info(" appl (application call): apid, apan, apat, apaa, ...") + print_info(" acfg (asset config): caid, apar") + print_info(" afrz (asset freeze): fadd, faid, afrz") + print_info(" keyreg (key registration): ...") + print_info("") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. pending_transactions() - Get all pending transactions in the pool") + print_info(" 2. pending_transactions_by_address(address) - Get pending txns for an address") + print_info(" 3. Using max_ parameter to limit results") + print_info(" 4. Submitting and immediately querying for pending transactions") + print_info(" 5. Understanding the SignedTransaction and Transaction structure") + print_info("") + print_info("Key PendingTransactionsResponse fields:") + print_info(" - total_transactions: Total number of transactions in the pool") + print_info(" - top_transactions: Array of SignedTransaction objects") + print_info("") + print_info("Use cases for pending transactions:") + print_info(" - Monitor your own pending transactions") + print_info(" - Check transaction pool congestion") + print_info(" - Verify a transaction was submitted before confirmation") + print_info(" - Build fee estimation based on current pool") + print_info("") + print_info("Notes:") + print_info(" - On LocalNet dev mode, transactions confirm immediately") + print_info(" - On MainNet/TestNet, pending pool shows unconfirmed transactions") + print_info(" - Transactions are sorted by priority (fee per byte)") + print_info(" - Use max_ parameter to avoid fetching large numbers of transactions") + + +if __name__ == "__main__": + main() diff --git a/examples/algod_client/08_block_data.py b/examples/algod_client/08_block_data.py new file mode 100644 index 00000000..6616b9dd --- /dev/null +++ b/examples/algod_client/08_block_data.py @@ -0,0 +1,295 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Block Data + +This example demonstrates how to retrieve block information using +the AlgodClient methods: block(), block_hash(), and block_tx_ids(). + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from datetime import datetime, timezone + +from shared import ( + create_algod_client, + create_algorand_client, + format_micro_algo, + get_funded_account, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_transact import TransactionType +from algokit_utils import AlgoAmount + + +def format_timestamp(timestamp: int) -> str: + """Format a Unix timestamp to a human-readable date string.""" + dt = datetime.fromtimestamp(timestamp, tz=timezone.utc) + return dt.isoformat() + + +def bytes_to_hex(data: bytes) -> str: + """Format bytes as a hex string.""" + return data.hex() + + +def main() -> None: + print_header("Block Data Example") + + # Create an Algod client connected to LocalNet + algod = create_algod_client() + algorand = create_algorand_client() + + # ========================================================================= + # Step 1: Get the latest round from status() + # ========================================================================= + print_step(1, "Getting current node status to find the latest round") + + node_status = algod.status() + latest_round = node_status.last_round + + print_success("Current node status retrieved") + print_info(f" - Latest round: {latest_round}") + + # On LocalNet dev mode, lastRound may be 0 if no transactions have been submitted + # Let's submit a transaction to create a block with transactions + if latest_round == 0: + print_info("Round is 0 (LocalNet dev mode). Submitting a transaction to create a block...") + + sender = get_funded_account(algorand) + receiver = algorand.account.random() + + algorand.send.payment( + sender=sender.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_algo(1), # 1 ALGO + ) + + # Get updated status + updated_status = algod.status() + latest_round = updated_status.last_round + print_success(f"Transaction submitted. New latest round: {latest_round}") + + # ========================================================================= + # Step 2: Get full block data with block(round) + # ========================================================================= + print_step(2, f"Getting full block data for round {latest_round} with block()") + + block_response = algod.block(latest_round) + block = block_response.block + + print_success("Block data retrieved successfully!") + print_info("") + print_info("Block Header Fields:") + print_info(f" - Round: {block.header.round}") + print_info(f" - Timestamp: {format_timestamp(block.header.timestamp)} ({block.header.timestamp})") + + if block.header.previous_block_hash: + print_info(f" - Previous Block Hash: {bytes_to_hex(block.header.previous_block_hash)[:16]}...") + + if block.header.seed: + print_info(f" - Seed: {bytes_to_hex(block.header.seed)[:16]}...") + + print_info(f" - Genesis ID: {block.header.genesis_id}") + + if block.header.genesis_hash: + print_info(f" - Genesis Hash: {bytes_to_hex(block.header.genesis_hash)[:16]}...") + + if block.header.proposer: + print_info(f" - Proposer: {shorten_address(block.header.proposer)}") + + if block.header.fees_collected is not None: + print_info(f" - Fees Collected: {format_micro_algo(block.header.fees_collected)}") + + if block.header.txn_counter is not None: + print_info(f" - Transaction Counter: {block.header.txn_counter}") + + # Display transaction commitment hashes + print_info("") + print_info("Transaction Commitments:") + if block.header.txn_commitments.native_sha512_256_commitment: + print_info(f" - SHA512/256: {bytes_to_hex(block.header.txn_commitments.native_sha512_256_commitment)[:32]}...") + + if block.header.txn_commitments.sha256_commitment: + print_info(f" - SHA256: {bytes_to_hex(block.header.txn_commitments.sha256_commitment)[:32]}...") + + # Display reward state + print_info("") + print_info("Reward State:") + if block.header.reward_state.fee_sink: + print_info(f" - Fee Sink: {shorten_address(block.header.reward_state.fee_sink)}") + if block.header.reward_state.rewards_pool: + print_info(f" - Rewards Pool: {shorten_address(block.header.reward_state.rewards_pool)}") + print_info(f" - Rewards Level: {block.header.reward_state.rewards_level}") + print_info(f" - Rewards Rate: {block.header.reward_state.rewards_rate}") + + # Display upgrade state + print_info("") + print_info("Upgrade State:") + if block.header.upgrade_state.current_protocol: + print_info(f" - Current Protocol: {block.header.upgrade_state.current_protocol}") + if block.header.upgrade_state.next_protocol: + print_info(f" - Next Protocol: {block.header.upgrade_state.next_protocol}") + + # ========================================================================= + # Step 3: Explore transactions in the block (payset) + # ========================================================================= + print_step(3, "Exploring transactions in the block (payset)") + + transactions = block.payset or [] + print_info(f"Number of transactions in block: {len(transactions)}") + + if transactions: + print_info("") + print_info("Transaction Details:") + + for i, txn_in_block in enumerate(transactions[:5]): + # Navigate the nested structure: SignedTxnInBlock -> SignedTxnWithAD -> SignedTransaction -> Transaction + signed_txn = txn_in_block.signed_transaction.signed_transaction + txn = signed_txn.txn + + print_info("") + print_info(f" Transaction {i + 1}:") + print_info(f" - Type: {txn.transaction_type.value}") + print_info(f" - Sender: {shorten_address(str(txn.sender))}") + print_info(f" - Fee: {format_micro_algo(txn.fee or 0)}") + print_info(f" - First Valid: {txn.first_valid}") + print_info(f" - Last Valid: {txn.last_valid}") + + # Show payment-specific fields + if txn.transaction_type == TransactionType.Payment and txn.payment: + print_info(f" - Receiver: {shorten_address(str(txn.payment.receiver))}") + print_info(f" - Amount: {format_micro_algo(txn.payment.amount)}") + + # Show apply data if available + apply_data = txn_in_block.signed_transaction.apply_data + if apply_data: + if apply_data.sender_rewards and apply_data.sender_rewards > 0: + print_info(f" - Sender Rewards: {format_micro_algo(apply_data.sender_rewards)}") + if apply_data.receiver_rewards and apply_data.receiver_rewards > 0: + print_info(f" - Receiver Rewards: {format_micro_algo(apply_data.receiver_rewards)}") + + # Show hasGenesisId and hasGenesisHash flags + has_gen_id = txn_in_block.has_genesis_id if txn_in_block.has_genesis_id is not None else "not set" + has_gen_hash = txn_in_block.has_genesis_hash if txn_in_block.has_genesis_hash is not None else "not set" + print_info(f" - Has Genesis ID: {has_gen_id}") + print_info(f" - Has Genesis Hash: {has_gen_hash}") + + if len(transactions) > 5: + print_info(f" ... and {len(transactions) - 5} more transactions") + else: + print_info("This block contains no transactions.") + print_info("On LocalNet in dev mode, blocks are only created when transactions are submitted.") + + # ========================================================================= + # Step 4: Get block hash with block_hash(round) + # ========================================================================= + print_step(4, f"Getting block hash for round {latest_round} with block_hash()") + + block_hash_response = algod.block_hash(latest_round) + + print_success("Block hash retrieved successfully!") + print_info(f" - Block Hash: {block_hash_response.block_hash}") + print_info("The block hash is a base64-encoded SHA256 hash of the block header.") + print_info("It uniquely identifies this block and is used for cryptographic verification.") + + # ========================================================================= + # Step 5: Get transaction IDs in block with block_tx_ids(round) + # ========================================================================= + print_step(5, f"Getting transaction IDs for round {latest_round} with block_tx_ids()") + + block_tx_ids_response = algod.block_tx_ids(latest_round) + tx_ids = block_tx_ids_response.block_tx_ids or [] + + print_success("Transaction IDs retrieved successfully!") + print_info(f" - Number of transactions: {len(tx_ids)}") + + if tx_ids: + print_info("") + print_info("Transaction IDs:") + for i, tx_id in enumerate(tx_ids[:5]): + print_info(f" {i + 1}. {tx_id}") + if len(tx_ids) > 5: + print_info(f" ... and {len(tx_ids) - 5} more") + print_info("Transaction IDs can be used with pending_transaction_information() to get details.") + else: + print_info("This block contains no transactions.") + + # ========================================================================= + # Step 6: Demonstrate header-only mode + # ========================================================================= + print_step(6, "Getting block header only (without transactions)") + + # Python SDK supports header_only parameter + header_only_response = algod.block(latest_round, header_only=True) + header_only_block = header_only_response.block + + print_success("Block header retrieved (header-only mode)!") + print_info(f" - Round: {header_only_block.header.round}") + print_info(f" - Timestamp: {format_timestamp(header_only_block.header.timestamp)}") + payset_count = len(header_only_block.payset or []) + print_info(f" - Transactions in payset: {payset_count}") + print_info("With header_only=True, the payset is empty, reducing response size.") + print_info("Use this when you only need block metadata, not transaction details.") + + # ========================================================================= + # Step 7: Compare blocks across rounds (if multiple rounds exist) + # ========================================================================= + if latest_round > 1: + print_step(7, "Comparing blocks across multiple rounds") + + previous_round = latest_round - 1 + previous_block_response = algod.block(previous_round) + previous_block = previous_block_response.block + + print_info("Comparing consecutive blocks:") + print_info("") + print_info(f" Round {previous_round}:") + print_info(f" - Timestamp: {format_timestamp(previous_block.header.timestamp)}") + print_info(f" - Transactions: {len(previous_block.payset or [])}") + if previous_block.header.txn_commitments.native_sha512_256_commitment: + prev_hash = bytes_to_hex(previous_block.header.txn_commitments.native_sha512_256_commitment) + print_info(f" - Block Hash: {prev_hash[:16]}...") + print_info("") + print_info(f" Round {latest_round}:") + print_info(f" - Timestamp: {format_timestamp(block.header.timestamp)}") + print_info(f" - Transactions: {len(block.payset or [])}") + if block.header.previous_block_hash: + print_info(f" - Previous Block Hash: {bytes_to_hex(block.header.previous_block_hash)[:16]}...") + + print_info("Each block contains the hash of the previous block, forming a chain.") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. status() - Get the latest round number") + print_info(" 2. block(round) - Get full block data including header and transactions") + print_info(" 3. block_hash(round) - Get just the block hash for verification") + print_info(" 4. block_tx_ids(round) - Get transaction IDs without full transaction data") + print_info(" 5. block(round, header_only=True) - Get header without transactions") + print_info("") + print_info("Key block structure:") + print_info(" - BlockResponse.block.header - Block metadata (round, timestamp, hashes, etc.)") + print_info(" - BlockResponse.block.payset - List of SignedTxnInBlock") + print_info(" - BlockHashResponse.block_hash - Base64-encoded block hash") + print_info(" - BlockTxidsResponse.block_tx_ids - List of transaction IDs") + print_info("") + print_info("Important header fields:") + print_info(" - header.round: Block number") + print_info(" - header.timestamp: Unix timestamp (seconds since epoch)") + print_info(" - header.previous_block_hash: Links to prior block (chain integrity)") + print_info(" - header.seed: VRF seed for sortition") + print_info(" - header.txn_commitments: Merkle root of transactions") + print_info(" - header.reward_state: Fee sink, rewards pool, and reward rates") + print_info(" - header.upgrade_state: Current and pending protocol versions") + + +if __name__ == "__main__": + main() diff --git a/examples/algod_client/09_asset_info.py b/examples/algod_client/09_asset_info.py new file mode 100644 index 00000000..169fed05 --- /dev/null +++ b/examples/algod_client/09_asset_info.py @@ -0,0 +1,259 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Asset Information + +This example demonstrates how to retrieve asset information using +the AlgodClient method: asset_by_id() + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from shared import ( + create_algod_client, + create_algorand_client, + get_funded_account, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_utils import AssetCreateParams + + +def main() -> None: + print_header("Asset Information Example") + + # Create an Algod client connected to LocalNet + algod = create_algod_client() + + # Create an AlgorandClient for asset creation + algorand = create_algorand_client() + + # ========================================================================= + # Step 1: Get a Funded Account from LocalNet + # ========================================================================= + print_step(1, "Getting a funded account from LocalNet") + + try: + creator = get_funded_account(algorand) + print_success(f"Got funded account: {shorten_address(str(creator.addr))}") + except Exception as e: + print_error(f"Failed to get funded account: {e}") + print_info("Make sure LocalNet is running with `algokit localnet start`") + print_info("If issues persist, try `algokit localnet reset`") + raise SystemExit(1) from e + + # ========================================================================= + # Step 2: Create a Test Asset using AlgorandClient + # ========================================================================= + print_step(2, "Creating a test asset using AlgorandClient") + + asset_total = 1_000_000_000_000 # 1 million units with 6 decimals + asset_decimals = 6 + asset_name = "Test Asset" + asset_unit_name = "TEST" + asset_url = "https://example.com/test-asset" + metadata_hash = bytes([0xAB] * 32) # 32-byte metadata hash + + try: + print_info(f"Creating asset: {asset_name} ({asset_unit_name})") + print_info(f"Total supply: {asset_total:,} base units") + print_info(f"Decimals: {asset_decimals}") + + result = algorand.send.asset_create( + AssetCreateParams( + sender=str(creator.addr), + total=asset_total, + decimals=asset_decimals, + asset_name=asset_name, + unit_name=asset_unit_name, + url=asset_url, + metadata_hash=metadata_hash, + default_frozen=False, + manager=str(creator.addr), + reserve=str(creator.addr), + freeze=str(creator.addr), + clawback=str(creator.addr), + ) + ) + + asset_id = result.asset_id + print_success(f"Asset created with ID: {asset_id}") + print_info("") + + # ========================================================================= + # Step 3: Get Asset Information using asset_by_id() + # ========================================================================= + print_step(3, "Getting asset information with asset_by_id()") + + asset = algod.asset_by_id(asset_id) + + print_success("Asset information retrieved successfully!") + print_info("") + + # ========================================================================= + # Step 4: Display Asset Params + # ========================================================================= + print_step(4, "Displaying asset parameters") + + print_info("Asset Identification:") + print_info(f" Asset ID: {asset.id_}") + print_info("") + + print_info("Asset Parameters:") + print_info(f" Creator: {asset.params.creator}") + print_info(f" {shorten_address(asset.params.creator)} (shortened)") + print_info(f" Total: {asset.params.total:,} base units") + + # Calculate human-readable total + decimals = asset.params.decimals + human_readable_total = asset.params.total / (10**decimals) if decimals > 0 else asset.params.total + unit_name_display = asset.params.unit_name or "units" + print_info(f" {human_readable_total:,.{decimals}f} {unit_name_display}") + print_info(f" Decimals: {decimals}") + print_info(f" Unit Name: {asset.params.unit_name or '(not set)'}") + print_info(f" Asset Name: {asset.params.name or '(not set)'}") + print_info(f" URL: {asset.params.url or '(not set)'}") + + # Display metadata hash if present + if asset.params.metadata_hash: + hash_hex = asset.params.metadata_hash.hex() + print_info(f" Metadata Hash: {hash_hex[:16]}...{hash_hex[-16:]} ({len(asset.params.metadata_hash)} bytes)") + else: + print_info(" Metadata Hash: (not set)") + + print_info(f" Default Frozen: {asset.params.default_frozen or False}") + print_info("") + + # ========================================================================= + # Step 5: Display Asset Addresses (Manager, Reserve, Freeze, Clawback) + # ========================================================================= + print_step(5, "Displaying asset management addresses") + + print_info("Asset Management Addresses:") + print_info(f" Manager: {asset.params.manager or '(immutable - not set)'}") + if asset.params.manager: + print_info(f" {shorten_address(asset.params.manager)} (shortened)") + print_info("Manager can modify manager, reserve, freeze, and clawback addresses") + + print_info(f" Reserve: {asset.params.reserve or '(not set)'}") + if asset.params.reserve: + print_info(f" {shorten_address(asset.params.reserve)} (shortened)") + print_info("Reserve holds non-minted/non-circulating units") + + print_info(f" Freeze: {asset.params.freeze or '(not set - freezing disabled)'}") + if asset.params.freeze: + print_info(f" {shorten_address(asset.params.freeze)} (shortened)") + print_info("Freeze address can freeze/unfreeze asset holdings") + + print_info(f" Clawback: {asset.params.clawback or '(not set - clawback disabled)'}") + if asset.params.clawback: + print_info(f" {shorten_address(asset.params.clawback)} (shortened)") + print_info("Clawback address can revoke assets from any account") + print_info("") + + # ========================================================================= + # Step 6: Note about Round Information + # ========================================================================= + print_step(6, "Note about data validity") + + print_info("The asset_by_id() method returns the current asset state.") + print_info("Unlike some other endpoints, it does not include a round field.") + print_info("To get the current round, use status() or other round-aware methods.") + + # Get current round for reference + status = algod.status() + print_info(f" Current network round: {status.last_round:,}") + print_info("") + + # ========================================================================= + # Step 7: Handle Asset Not Found + # ========================================================================= + print_step(7, "Demonstrating error handling for non-existent asset") + + non_existent_asset_id = 999999999 + try: + print_info(f"Querying non-existent asset ID: {non_existent_asset_id}") + algod.asset_by_id(non_existent_asset_id) + print_error("Expected an error but none was thrown") + except Exception as e: + print_success("Correctly caught error for non-existent asset") + print_info(f" Error message: {e}") + print_info("Always handle the case where an asset may not exist or has been destroyed") + print_info("") + + # ========================================================================= + # Step 8: Create Asset with Minimal Parameters (for comparison) + # ========================================================================= + print_step(8, "Creating a minimal asset (no optional addresses)") + + minimal_result = algorand.send.asset_create( + AssetCreateParams( + sender=str(creator.addr), + total=1000, + decimals=0, + asset_name="Minimal Asset", + unit_name="MIN", + # Note: No manager, reserve, freeze, or clawback addresses set + ) + ) + + minimal_asset = algod.asset_by_id(minimal_result.asset_id) + + print_info("Minimal Asset Configuration:") + print_info(f" Asset ID: {minimal_asset.id_}") + print_info(f" Creator: {shorten_address(minimal_asset.params.creator)}") + print_info(f" Total: {minimal_asset.params.total}") + print_info(f" Manager: {minimal_asset.params.manager or '(not set - asset is immutable)'}") + print_info(f" Reserve: {minimal_asset.params.reserve or '(not set)'}") + print_info(f" Freeze: {minimal_asset.params.freeze or '(not set - freezing disabled)'}") + print_info(f" Clawback: {minimal_asset.params.clawback or '(not set - clawback disabled)'}") + print_info("Without a manager address, asset parameters cannot be changed") + print_info("") + except Exception as e: + print_error(f"Failed to create or query asset: {e}") + print_info("If LocalNet errors occur, try `algokit localnet reset`") + raise SystemExit(1) from e + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. Creating a test asset using AlgorandClient.send.asset_create()") + print_info(" 2. asset_by_id(asset_id) - Get complete asset information") + print_info(" 3. Asset params: creator, total, decimals, unit_name, name, url, metadata_hash") + print_info(" 4. Asset addresses: manager, reserve, freeze, clawback") + print_info(" 5. Error handling for non-existent assets") + print_info(" 6. Minimal asset creation (without optional addresses)") + print_info("") + print_info("Key Asset fields:") + print_info(" - id_: Unique asset identifier (int)") + print_info(" - params.creator: Address that created the asset") + print_info(" - params.total: Total supply in base units (int)") + print_info(" - params.decimals: Number of decimal places (0-19)") + print_info(" - params.unit_name: Short name for asset unit (e.g., 'ALGO')") + print_info(" - params.name: Full asset name") + print_info(" - params.url: URL with more information") + print_info(" - params.metadata_hash: 32-byte commitment to metadata") + print_info(" - params.default_frozen: Whether new holdings are frozen by default") + print_info("") + print_info("Management addresses (optional):") + print_info(" - manager: Can reconfigure or destroy the asset") + print_info(" - reserve: Holds non-circulating units") + print_info(" - freeze: Can freeze/unfreeze holdings") + print_info(" - clawback: Can revoke assets from any account") + print_info("") + print_info("Use cases:") + print_info(" - Verify asset parameters before opt-in") + print_info(" - Check management addresses for trust evaluation") + print_info(" - Display asset information in wallets/explorers") + print_info(" - Validate asset metadata for compliance") + + +if __name__ == "__main__": + main() diff --git a/examples/algod_client/10_application_info.py b/examples/algod_client/10_application_info.py new file mode 100644 index 00000000..388cbad8 --- /dev/null +++ b/examples/algod_client/10_application_info.py @@ -0,0 +1,319 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Application Information + +This example demonstrates how to retrieve application information using +the AlgodClient method: application_by_id() + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import base64 + +from shared import ( + create_algod_client, + create_algorand_client, + get_funded_account, + load_teal_source, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_algod_client.models import TealValue +from algokit_utils import AppCallParams, AppCreateParams + + +def decode_teal_value(value: TealValue) -> str: + """Decode a TEAL value for display.""" + if value.type_ == 2: + # uint + return f"{value.uint} (uint)" + elif value.type_ == 1: + # bytes + if value.bytes_: + try: + # Check if it's a printable string + text = value.bytes_.decode("utf-8") + if all(32 <= ord(c) <= 126 for c in text) and len(text) > 0: + return f'"{text}" (bytes)' + except (ValueError, UnicodeDecodeError): + pass + # Fall back to hex + return f"0x{value.bytes_.hex()} (bytes)" + return "(empty bytes)" + return "(unknown type)" + + +def main() -> None: + print_header("Application Information Example") + + # Create an Algod client connected to LocalNet + algod = create_algod_client() + + # Create an AlgorandClient for application deployment + algorand = create_algorand_client() + + # ========================================================================= + # Step 1: Get a Funded Account from LocalNet + # ========================================================================= + print_step(1, "Getting a funded account from LocalNet") + + try: + creator = get_funded_account(algorand) + print_success(f"Got funded account: {shorten_address(str(creator.addr))}") + except Exception as e: + print_error(f"Failed to get funded account: {e}") + print_info("Make sure LocalNet is running with `algokit localnet start`") + print_info("If issues persist, try `algokit localnet reset`") + raise SystemExit(1) from e + + # ========================================================================= + # Step 2: Deploy a Test Application using AlgorandClient + # ========================================================================= + print_step(2, "Deploying a test application") + + # Load approval program from shared artifacts + # - Accepts all ApplicationCall transactions + # - Stores a counter in global state on each call + # - Has one global uint and one global bytes slot + approval_source = load_teal_source("approval-counter-message.teal") + + # Load clear state program from shared artifacts + clear_source = load_teal_source("clear-state-approve.teal") + + try: + print_info("Compiling TEAL programs...") + approval_compiled = algod.teal_compile(approval_source.encode()) + clear_compiled = algod.teal_compile(clear_source.encode()) + print_success(f"Approval program hash: {approval_compiled.hash_}") + print_success(f"Clear program hash: {clear_compiled.hash_}") + + print_info("Deploying application...") + result = algorand.send.app_create( + AppCreateParams( + sender=str(creator.addr), + approval_program=base64.b64decode(approval_compiled.result), + clear_state_program=base64.b64decode(clear_compiled.result), + schema={ + "global_ints": 1, + "global_byte_slices": 1, + "local_ints": 0, + "local_byte_slices": 0, + }, + ) + ) + + app_id = result.app_id + print_success(f"Application deployed with ID: {app_id}") + print_info("") + + # ========================================================================= + # Step 3: Get Application Information using application_by_id() + # ========================================================================= + print_step(3, "Getting application information with application_by_id()") + + app = algod.application_by_id(app_id) + + print_success("Application information retrieved successfully!") + print_info("") + + # ========================================================================= + # Step 4: Display Application Params + # ========================================================================= + print_step(4, "Displaying application parameters") + + print_info("Application Identification:") + print_info(f" Application ID: {app.id_}") + print_info("") + + params = app.params + print_info("Application Parameters:") + print_info(f" Creator: {params.creator}") + print_info(f" {shorten_address(params.creator)} (shortened)") + print_info("") + + # Display approval program info + print_info("Approval Program:") + if params.approval_program: + print_info(f" Size: {len(params.approval_program)} bytes") + approval_preview = params.approval_program[:20].hex() + print_info(f" Preview: {approval_preview}... (first 20 bytes, hex)") + print_info("The approval program runs when the app is called") + print_info("") + + # Display clear state program info + print_info("Clear State Program:") + if params.clear_state_program: + print_info(f" Size: {len(params.clear_state_program)} bytes") + clear_preview = params.clear_state_program[:20].hex() + print_info(f" Preview: {clear_preview}... (first 20 bytes, hex)") + print_info("The clear state program runs when an account clears its local state") + print_info("") + + # Display extra program pages if any + if params.extra_program_pages and params.extra_program_pages > 0: + print_info(f" Extra Pages: {params.extra_program_pages}") + print_info("Extra program pages allow for larger smart contracts") + + # Display version if available + if params.version is not None: + print_info(f" Version: {params.version}") + print_info("Version tracks number of program updates") + + print_info("") + + # ========================================================================= + # Step 5: Display State Schema + # ========================================================================= + print_step(5, "Displaying state schema") + + print_info("Global State Schema:") + global_state_schema = params.global_state_schema + if global_state_schema: + print_info(f" Uint Slots: {global_state_schema.num_uints}") + print_info(f" Byte Slice Slots: {global_state_schema.num_byte_slices}") + print_info("Global state is shared across all accounts") + else: + print_info(" (no global state schema)") + print_info("") + + print_info("Local State Schema:") + local_state_schema = params.local_state_schema + if local_state_schema: + print_info(f" Uint Slots: {local_state_schema.num_uints}") + print_info(f" Byte Slice Slots: {local_state_schema.num_byte_slices}") + print_info("Local state is per-account and requires opt-in") + else: + print_info(" (no local state schema)") + print_info("") + + # ========================================================================= + # Step 6: Display Global State + # ========================================================================= + print_step(6, "Displaying global state") + + global_state = params.global_state or [] + if global_state: + print_info("Global State Values:") + for kv in global_state: + # Decode the key (it's bytes) + try: + key_str = kv.key.decode("utf-8") + except Exception: + key_str = kv.key.hex() + value_str = decode_teal_value(kv.value) + print_info(f' "{key_str}": {value_str}') + print_info("") + print_info("Global state is stored on-chain and costs MBR") + else: + print_info(" (no global state values)") + print_info("This application has no global state set") + print_info("") + + # ========================================================================= + # Step 7: Call the Application to Update Global State + # ========================================================================= + print_step(7, "Calling application to update global state") + + print_info("Calling the application to increment the counter...") + algorand.send.app_call( + AppCallParams( + sender=str(creator.addr), + app_id=app_id, + ) + ) + + # Fetch updated application info + updated_app = algod.application_by_id(app_id) + + print_info("Updated Global State:") + updated_global_state = updated_app.params.global_state or [] + if updated_global_state: + for kv in updated_global_state: + try: + key_str = kv.key.decode("utf-8") + except Exception: + key_str = kv.key.hex() + value_str = decode_teal_value(kv.value) + print_info(f' "{key_str}": {value_str}') + print_success("Counter was incremented from 0 to 1") + print_info("") + + # ========================================================================= + # Step 8: Handle Application Not Found + # ========================================================================= + print_step(8, "Demonstrating error handling for non-existent application") + + non_existent_app_id = 999999999 + try: + print_info(f"Querying non-existent application ID: {non_existent_app_id}") + algod.application_by_id(non_existent_app_id) + print_error("Expected an error but none was thrown") + except Exception as e: + print_success("Correctly caught error for non-existent application") + print_info(f" Error message: {e}") + print_info("Always handle the case where an application may not exist or has been deleted") + print_info("") + + # ========================================================================= + # Step 9: Note about Round Information + # ========================================================================= + print_step(9, "Note about data validity") + + print_info("The application_by_id() method returns the current application state.") + print_info("Unlike some other endpoints, it does not include a round field.") + print_info("To get the current round, use status() or other round-aware methods.") + + # Get current round for reference + status = algod.status() + print_info(f" Current network round: {status.last_round:,}") + print_info("") + except Exception as e: + print_error(f"Failed to deploy or query application: {e}") + print_info("If LocalNet errors occur, try `algokit localnet reset`") + raise SystemExit(1) from e + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. Deploying a test application using AlgorandClient.send.app_create()") + print_info(" 2. application_by_id(app_id) - Get complete application information") + print_info(" 3. Application params: creator, approval_program, clear_state_program") + print_info(" 4. State schema: global_state_schema, local_state_schema") + print_info(" 5. Displaying global state values with TEAL key-value decoding") + print_info(" 6. Calling the application and observing state changes") + print_info(" 7. Error handling for non-existent applications") + print_info("") + print_info("Key Application fields:") + print_info(" - id_: Unique application identifier (int)") + print_info(" - params.creator: Address that deployed the application") + print_info(" - params.approval_program: Bytecode for app calls (bytes)") + print_info(" - params.clear_state_program: Bytecode for clear state (bytes)") + print_info(" - params.global_state_schema: { num_uints, num_byte_slices }") + print_info(" - params.local_state_schema: { num_uints, num_byte_slices }") + print_info(" - params.global_state: list[TealKeyValue] (current global state)") + print_info(" - params.extra_program_pages: Additional program space (optional)") + print_info(" - params.version: Number of updates to the program (optional)") + print_info("") + print_info("Global State (TealKeyValue) structure:") + print_info(" - key: bytes (state key, often UTF-8 string)") + print_info(" - value.type_: 1 = bytes, 2 = uint") + print_info(" - value.bytes_: bytes (for bytes type)") + print_info(" - value.uint: int (for uint type)") + print_info("") + print_info("Use cases:") + print_info(" - Verify application creator and code before interaction") + print_info(" - Read current global state values") + print_info(" - Check state schema to understand storage limits") + print_info(" - Display application information in explorers/wallets") + + +if __name__ == "__main__": + main() diff --git a/examples/algod_client/11_application_boxes.py b/examples/algod_client/11_application_boxes.py new file mode 100644 index 00000000..e2c1de96 --- /dev/null +++ b/examples/algod_client/11_application_boxes.py @@ -0,0 +1,340 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Application Boxes + +This example demonstrates how to query application boxes using +the AlgodClient methods: application_boxes() and application_box_by_name() + +API Patterns: +- application_boxes(app_id) returns BoxesResponse with .boxes attribute (list of BoxDescriptor) +- application_box_by_name(app_id, box_name_bytes) returns Box with .name, .value, .round_ attributes +- BoxDescriptor.name is bytes (not base64) +- Box.name and Box.value are bytes (not base64) +- Box.round_ uses underscore to avoid Python reserved keyword + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import base64 + +from shared import ( + create_algod_client, + create_algorand_client, + get_funded_account, + load_teal_source, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_common import get_application_address +from algokit_utils import AlgoAmount, AppCallParams, AppCreateParams, BoxReference, PaymentParams + + +def main() -> None: + print_header("Application Boxes Example") + + # Create an Algod client connected to LocalNet + algod = create_algod_client() + + # Create an AlgorandClient for application deployment + algorand = create_algorand_client() + + # ========================================================================= + # Step 1: Get a Funded Account from LocalNet + # ========================================================================= + print_step(1, "Getting a funded account from LocalNet") + + try: + creator = get_funded_account(algorand) + print_success(f"Got funded account: {shorten_address(str(creator.addr))}") + except Exception as e: + print_error(f"Failed to get funded account: {e}") + print_info("Make sure LocalNet is running with `algokit localnet start`") + print_info("If issues persist, try `algokit localnet reset`") + raise SystemExit(1) from e + + # ========================================================================= + # Step 2: Deploy an Application that Uses Box Storage + # ========================================================================= + print_step(2, "Deploying an application that uses box storage") + + # Load approval program from shared artifacts that supports box operations: + # - On create: does nothing (just succeeds) + # - On call with arg "create_box": creates a box with name from arg[1] and value from arg[2] + # - On call with arg "delete_box": deletes a box with name from arg[1] + # Box operations require the box to be referenced in the transaction + approval_source = load_teal_source("approval-box-ops.teal") + + # Load clear state program from shared artifacts + clear_source = load_teal_source("clear-state-approve.teal") + + try: + print_info("Compiling TEAL programs...") + # teal_compile() takes bytes, returns CompileResponse with .hash_ and .result + approval_compiled = algod.teal_compile(approval_source.encode()) + clear_compiled = algod.teal_compile(clear_source.encode()) + print_success(f"Approval program hash: {approval_compiled.hash_}") + + print_info("Deploying application...") + # app_create() requires AppCreateParams wrapper + result = algorand.send.app_create( + AppCreateParams( + sender=str(creator.addr), + approval_program=base64.b64decode(approval_compiled.result), + clear_state_program=base64.b64decode(clear_compiled.result), + schema={ + "global_ints": 0, + "global_byte_slices": 0, + "local_ints": 0, + "local_byte_slices": 0, + }, + ) + ) + + app_id = result.app_id + print_success(f"Application deployed with ID: {app_id}") + print_info("") + + # ========================================================================= + # Step 3: Handle Case Where Application Has No Boxes + # ========================================================================= + print_step(3, "Querying boxes when application has no boxes") + + # application_boxes() returns BoxesResponse with .boxes attribute + # .boxes can be None when empty, use `or []` for safe access + empty_boxes = algod.application_boxes(app_id) + boxes_list = empty_boxes.boxes or [] + print_info("Boxes response for new application:") + print_info(f" Total boxes: {len(boxes_list)}") + + if len(boxes_list) == 0: + print_success("Correctly shows 0 boxes for new application") + print_info("Applications start with no boxes - boxes are created via app calls") + print_info("") + + # ========================================================================= + # Step 4: Create Several Boxes with Different Names and Values + # ========================================================================= + print_step(4, "Creating several boxes with different names and values") + + # Box names and values to create + box_data = [ + {"name": "user_count", "value": "counter:42"}, + {"name": "settings", "value": '{"theme":"dark","lang":"en"}'}, + {"name": "metadata", "value": "v1.0.0-production"}, + ] + + # Need to fund the app account for box storage MBR + print_info("Funding application account for box storage MBR...") + app_address = get_application_address(app_id) + # send.payment() requires PaymentParams wrapper + algorand.send.payment( + PaymentParams( + sender=str(creator.addr), + receiver=app_address, + amount=AlgoAmount.from_algo(1), # 1 ALGO should cover several boxes + ) + ) + print_success(f"Funded app account: {shorten_address(app_address)}") + + for box in box_data: + box_name = box["name"] + box_value = box["value"] + print_info(f'Creating box "{box_name}" with value "{box_value}"...') + + box_name_bytes = box_name.encode("utf-8") + box_value_bytes = box_value.encode("utf-8") + + # send.app_call() requires AppCallParams wrapper + # box_references requires BoxReference objects, not tuples + algorand.send.app_call( + AppCallParams( + sender=str(creator.addr), + app_id=app_id, + args=[b"create_box", box_name_bytes, box_value_bytes], + box_references=[BoxReference(app_id=app_id, name=box_name_bytes)], + ) + ) + + print_success(f'Created box "{box_name}"') + print_info("") + + # ========================================================================= + # Step 5: Demonstrate application_boxes() to List All Boxes + # ========================================================================= + print_step(5, "Listing all boxes with application_boxes(app_id)") + + # application_boxes() returns BoxesResponse with .boxes attribute + # .boxes can be None when empty, use `or []` for safe access + boxes_response = algod.application_boxes(app_id) + boxes_list = boxes_response.boxes or [] + + print_info("BoxesResponse structure:") + print_info(f" boxes: list[BoxDescriptor] (length: {len(boxes_list)})") + print_info("") + + print_info("All boxes for this application:") + for i, box_descriptor in enumerate(boxes_list): + # BoxDescriptor.name is bytes (not base64) + name_bytes = box_descriptor.name + try: + name_str = name_bytes.decode("utf-8") + except Exception: + name_str = repr(name_bytes) + name_hex = name_bytes.hex() + print_info(f' [{i}] Name: "{name_str}"') + print_info(f" Raw (hex): 0x{name_hex}") + print_info(f" Raw (bytes): {len(name_bytes)} bytes") + print_info("") + + print_info("application_boxes() returns BoxesResponse with list of BoxDescriptor") + print_info("To get the actual values, use application_box_by_name()") + print_info("") + + # ========================================================================= + # Step 6: Demonstrate application_box_by_name() to Get Specific Box + # ========================================================================= + print_step(6, "Getting specific box values with application_box_by_name()") + + for box in box_data: + box_name = box["name"] + box_name_bytes = box_name.encode("utf-8") + # application_box_by_name() takes bytes directly (not base64) + box_result = algod.application_box_by_name(app_id, box_name_bytes) + + # Box attributes: .name (bytes), .value (bytes), .round_ (int) + try: + result_name = box_result.name.decode("utf-8") + except Exception: + result_name = repr(box_result.name) + + try: + result_value = box_result.value.decode("utf-8") + except Exception: + result_value = repr(box_result.value) + + print_info(f'Box "{box_name}":') + print_info(f" Round: {box_result.round_}") + print_info(f' Name: "{result_name}"') + print_info(f' Value: "{result_value}"') + print_info(f" Size: {len(box_result.value)} bytes") + print_info("") + + # ========================================================================= + # Step 7: Show Box Structure and Decoding + # ========================================================================= + print_step(7, "Understanding Box structure and decoding") + + # application_box_by_name() takes bytes directly + example_box = algod.application_box_by_name(app_id, b"settings") + + # Box attributes: .name (bytes), .value (bytes), .round_ (int with underscore) + try: + example_value_str = example_box.value.decode("utf-8") + except Exception: + example_value_str = repr(example_box.value) + + print_info("Box type structure:") + print_info(" {") + print_info(f" round_: int = {example_box.round_}") + print_info(f" name: bytes = {len(example_box.name)!s} bytes") + print_info(f" value: bytes = {len(example_box.value)!s} bytes") + print_info(" }") + print_info("") + + print_info("Different decoding methods:") + print_info(f' As UTF-8 string: "{example_value_str}"') + print_info(f" As hex: 0x{example_box.value.hex()}") + print_info(f" As base64: {base64.b64encode(example_box.value).decode('ascii')}") + print_info("") + + # Parse JSON if it looks like JSON + if example_value_str.startswith("{"): + import json + + try: + parsed = json.loads(example_value_str) + print_info(" As parsed JSON:") + for key, val in parsed.items(): + print_info(f" {key}: {json.dumps(val)}") + except json.JSONDecodeError: + pass + print_info("") + + print_info("Box values are raw bytes - the encoding/format is application-defined") + print_info("") + + # ========================================================================= + # Step 8: Handle Box Not Found Error + # ========================================================================= + print_step(8, "Handling non-existent box") + + try: + # application_box_by_name() takes bytes directly + print_info('Querying non-existent box "does_not_exist"...') + algod.application_box_by_name(app_id, b"does_not_exist") + print_error("Expected an error but none was thrown") + except Exception as e: + print_success("Correctly caught error for non-existent box") + print_info(f" Error message: {e}") + print_info("Always handle the case where a box may not exist") + print_info("") + + # ========================================================================= + # Step 9: Box Costs and MBR + # ========================================================================= + print_step(9, "Understanding box storage costs") + + print_info("Box storage requires minimum balance (MBR) in the app account:") + print_info(" - Base cost per box: 2,500 microAlgo (0.0025 ALGO)") + print_info(" - Cost per byte: 400 microAlgo per byte") + print_info(" - Formula: 2500 + (400 * (box_name_length + box_value_length))") + print_info("") + + # Calculate MBR for our boxes + print_info("MBR for boxes we created:") + for box in box_data: + name_len = len(box["name"].encode("utf-8")) + value_len = len(box["value"].encode("utf-8")) + mbr = 2500 + 400 * (name_len + value_len) + print_info(f' "{box["name"]}": {mbr:,} uALGO (name: {name_len}B, value: {value_len}B)') + print_info("") + except Exception as e: + print_error(f"Failed to complete example: {e}") + print_info("If LocalNet errors occur, try `algokit localnet reset`") + raise SystemExit(1) from e + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. Deploying an application that uses box storage") + print_info(" 2. Creating boxes via app calls with box_references") + print_info(" 3. application_boxes(app_id) - List all box names for an app") + print_info(" 4. application_box_by_name(app_id, box_name) - Get specific box value") + print_info(" 5. Handling the case where application has no boxes") + print_info(" 6. Error handling for non-existent boxes") + print_info(" 7. Understanding box storage costs (MBR)") + print_info("") + print_info("Key types and methods:") + print_info(" - application_boxes(app_id) -> BoxesResponse with .boxes: list[BoxDescriptor]") + print_info(" - application_box_by_name(app_id, box_name_bytes) -> Box with .round_, .name, .value") + print_info(" - BoxDescriptor: .name (bytes)") + print_info(" - Box: .round_ (int), .name (bytes), .value (bytes)") + print_info("") + print_info("Box storage notes:") + print_info(" - Boxes must be referenced in transaction box_references to be accessed") + print_info(" - Box names can be any bytes (not just UTF-8 strings)") + print_info(" - Box values are raw bytes - format is application-defined") + print_info(" - App account must have sufficient MBR for box storage") + print_info(" - Max box name: 64 bytes, max box value: 32,768 bytes") + + +if __name__ == "__main__": + main() diff --git a/examples/algod_client/12_teal_compile.py b/examples/algod_client/12_teal_compile.py new file mode 100644 index 00000000..7e573f88 --- /dev/null +++ b/examples/algod_client/12_teal_compile.py @@ -0,0 +1,357 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: TEAL Compile and Disassemble + +This example demonstrates how to compile TEAL source code to bytecode and +disassemble bytecode back to TEAL using the AlgodClient methods: +- teal_compile(source_bytes, sourcemap?) - Compile TEAL source to bytecode +- teal_disassemble(bytecode) - Disassemble bytecode back to TEAL + +Note: Python SDK takes bytes for teal_compile (use .encode()), while TypeScript takes string. +CompileResponse uses attribute access with hash_ (underscore to avoid Python builtin). + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import base64 + +from shared import ( + create_algod_client, + load_teal_source, + print_error, + print_header, + print_info, + print_step, + print_success, +) + + +def main() -> None: + print_header("TEAL Compile and Disassemble Example") + + # Create an Algod client connected to LocalNet + algod = create_algod_client() + + # ========================================================================= + # Step 1: Compile a Simple Approval Program + # ========================================================================= + print_step(1, "Compiling a simple approval program") + + # A minimal approval program that always succeeds + simple_source = load_teal_source("simple-approve.teal") + + try: + # Python SDK requires bytes - encode the source string + compiled = algod.teal_compile(simple_source.encode()) + + print_success("Compilation successful!") + print_info("") + print_info("Compilation Result:") + print_info(f" Hash: {compiled.hash_}") + print_info(" (base32 SHA512/256 of program bytes, Address-style)") + print_info(f" Result: {compiled.result}") + print_info(" (base64 encoded bytecode)") + print_info("") + + # Decode bytecode to show the raw bytes + bytecode = base64.b64decode(compiled.result) + print_info("Bytecode Details:") + print_info(f" Size: {len(bytecode)} bytes") + print_info(f" Hex: {bytecode.hex()}") + print_info("") + print_info("The hash can be used as a Logic Signature address") + print_info("The bytecode (result) is what gets stored on-chain") + print_info("") + except Exception as e: + print_error(f"Compilation failed: {e}") + raise SystemExit(1) from e + + # ========================================================================= + # Step 2: Compile a More Complex Program + # ========================================================================= + print_step(2, "Compiling a more complex approval program") + + # A program that checks sender and approves specific transaction types + complex_source = load_teal_source("complex-approve.teal") + + try: + compiled = algod.teal_compile(complex_source.encode()) + + print_success("Complex program compiled successfully!") + print_info("") + print_info("Compilation Result:") + print_info(f" Hash: {compiled.hash_}") + print_info(f" Result: {compiled.result}") + print_info("") + + bytecode = base64.b64decode(compiled.result) + print_info("Bytecode Details:") + print_info(f" Size: {len(bytecode)} bytes") + print_info(f" Hex: {bytecode.hex()}") + print_info("") + print_info("Complex programs compile to larger bytecode") + print_info("") + except Exception as e: + print_error(f"Compilation failed: {e}") + raise SystemExit(1) from e + + # ========================================================================= + # Step 3: Compile with Sourcemap Option + # ========================================================================= + print_step(3, "Compiling with sourcemap option") + + # Program with multiple lines for meaningful sourcemap + sourcemap_source = load_teal_source("counter-init.teal") + + try: + # Python SDK uses sourcemap parameter (bool) + compiled = algod.teal_compile(sourcemap_source.encode(), sourcemap=True) + + print_success("Compilation with sourcemap successful!") + print_info("") + print_info("Compilation Result:") + print_info(f" Hash: {compiled.hash_}") + print_info(f" Result: {compiled.result}") + print_info("") + + if compiled.sourcemap: + sourcemap = compiled.sourcemap + print_info("Source Map:") + print_info(f" Version: {sourcemap.version}") + print_info(f" Sources: {sourcemap.sources}") + print_info(f" Names: {sourcemap.names}") + print_info(f" Mappings: {sourcemap.mappings}") + print_info("") + print_info("Sourcemaps enable debugging by mapping bytecode to source lines") + print_info("The mappings string uses VLQ (Variable Length Quantity) encoding") + else: + print_info("Sourcemap was not returned (may depend on node configuration)") + print_info("") + except Exception as e: + print_error(f"Compilation failed: {e}") + raise SystemExit(1) from e + + # ========================================================================= + # Step 4: Disassemble Bytecode Back to TEAL + # ========================================================================= + print_step(4, "Disassembling bytecode back to TEAL") + + try: + # First compile, then disassemble to show round-trip + compiled = algod.teal_compile(simple_source.encode()) + # Decode base64 result to get raw bytecode for disassembly + bytecode = base64.b64decode(compiled.result) + + print_info("Original Source:") + for line in simple_source.split("\n"): + print_info(f" {line}") + print_info("") + + # Python SDK takes raw bytes for disassembly, not base64 + disassembled = algod.teal_disassemble(bytecode) + + print_success("Disassembly successful!") + print_info("") + print_info("Disassembled Output:") + for line in disassembled.result.strip().split("\n"): + print_info(f" {line}") + print_info("") + print_info("Disassembled output may differ from original (comments removed, labels renamed)") + print_info("") + except Exception as e: + print_error(f"Disassembly failed: {e}") + raise SystemExit(1) from e + + # ========================================================================= + # Step 5: Compare Original Source with Disassembled Output + # ========================================================================= + print_step(5, "Comparing original source with disassembled output") + + try: + # Use the complex source for a more interesting comparison + compiled = algod.teal_compile(complex_source.encode()) + bytecode = base64.b64decode(compiled.result) + disassembled = algod.teal_disassemble(bytecode) + + print_info("Original Source:") + original_lines = complex_source.strip().split("\n") + for i, line in enumerate(original_lines): + print_info(f" {i + 1:2}: {line}") + print_info("") + + print_info("Disassembled Output:") + disassembled_lines = disassembled.result.strip().split("\n") + for i, line in enumerate(disassembled_lines): + print_info(f" {i + 1:2}: {line}") + print_info("") + + print_info("Key Differences:") + print_info(" - Comments are removed during compilation") + print_info(" - Labels are converted to numeric addresses") + print_info(" - The semantic meaning remains identical") + print_info("") + except Exception as e: + print_error(f"Comparison failed: {e}") + raise SystemExit(1) from e + + # ========================================================================= + # Step 6: Handle Compilation Errors + # ========================================================================= + print_step(6, "Handling compilation errors for invalid TEAL") + + # Invalid TEAL source - unknown opcode + invalid_source1 = """#pragma version 10 +invalid_opcode +int 1""" + + try: + print_info("Attempting to compile invalid TEAL (unknown opcode):") + for line in invalid_source1.split("\n"): + print_info(f" {line}") + print_info("") + algod.teal_compile(invalid_source1.encode()) + print_error("Expected compilation to fail but it succeeded") + except Exception as e: + print_success("Correctly caught compilation error!") + print_info(f" Error: {e}") + print_info("") + + # Invalid TEAL source - syntax error + invalid_source2 = """#pragma version 10 +int""" + + try: + print_info("Attempting to compile invalid TEAL (missing operand):") + for line in invalid_source2.split("\n"): + print_info(f" {line}") + print_info("") + algod.teal_compile(invalid_source2.encode()) + print_error("Expected compilation to fail but it succeeded") + except Exception as e: + print_success("Correctly caught syntax error!") + print_info(f" Error: {e}") + print_info("") + + # Invalid TEAL source - invalid version + invalid_source3 = """#pragma version 999 +int 1""" + + try: + print_info("Attempting to compile invalid TEAL (invalid version):") + for line in invalid_source3.split("\n"): + print_info(f" {line}") + print_info("") + algod.teal_compile(invalid_source3.encode()) + print_error("Expected compilation to fail but it succeeded") + except Exception as e: + print_success("Correctly caught version error!") + print_info(f" Error: {e}") + print_info("") + + print_info("Always validate TEAL source before deployment") + print_info("Compilation errors include line numbers and descriptions") + print_info("") + + # ========================================================================= + # Step 7: Understanding Disassembly Behavior + # ========================================================================= + print_step(7, "Understanding disassembly behavior with various bytecode") + + # The disassembler does best-effort interpretation of bytecode + # Even invalid patterns may produce some output + + # Example 1: Bytecode with invalid version (version 0) + # Python SDK takes raw bytes directly, not base64 + invalid_version_bytecode = bytes([0x00, 0x00, 0x00]) + print_info("Disassembling bytecode with version 0:") + print_info(f" Bytes: {invalid_version_bytecode.hex()}") + try: + result = algod.teal_disassemble(invalid_version_bytecode) + print_info(" Result:") + for line in result.result.strip().split("\n"): + print_info(f" {line}") + print_info("Version 0 is disassembled but is not a valid TEAL version") + print_info("") + except Exception as e: + print_error(f"Disassembly failed: {e}") + print_info("") + + # Example 2: Single byte (just version, no opcodes) + minimal_bytecode = bytes([0x0A]) # version 10 + print_info("Disassembling minimal bytecode (just version byte):") + print_info(f" Bytes: {minimal_bytecode.hex()}") + try: + result = algod.teal_disassemble(minimal_bytecode) + print_info(" Result:") + for line in result.result.strip().split("\n"): + print_info(f" {line}") + print_info("Minimal valid bytecode: version byte only") + print_info("") + except Exception as e: + print_error(f"Disassembly failed: {e}") + print_info("") + + print_info("The disassembler does best-effort interpretation") + print_info("Always verify disassembled output matches expected behavior") + print_info("") + + # ========================================================================= + # Step 8: Compile Different TEAL Versions + # ========================================================================= + print_step(8, "Compiling programs with different TEAL versions") + + versions = [6, 8, 10] + + for version in versions: + source = f"""#pragma version {version} +int 1""" + + try: + compiled = algod.teal_compile(source.encode()) + bytecode = base64.b64decode(compiled.result) + + print_info(f"TEAL Version {version}:") + print_info(f" Hash: {compiled.hash_}") + print_info(f" Size: {len(bytecode)} bytes") + print_info(f" Bytecode: {bytecode.hex()}") + print_info("") + except Exception as e: + print_error(f"Version {version} failed: {e}") + + print_info("Different TEAL versions may produce different bytecode") + print_info("Newer versions support more opcodes and features") + print_info("") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. teal_compile(source) - Compile TEAL source code to bytecode") + print_info(" 2. CompileResponse fields: hash (base32), result (base64 bytecode)") + print_info(" 3. teal_compile(source, source_map=True) - Get source map for debugging") + print_info(" 4. teal_disassemble(bytecode) - Convert bytecode back to TEAL") + print_info(" 5. Comparing original source with disassembled output") + print_info(" 6. Handling compilation errors for invalid TEAL") + print_info(" 7. Handling disassembly errors for invalid bytecode") + print_info(" 8. Compiling programs with different TEAL versions") + print_info("") + print_info("Key CompileResponse fields:") + print_info(" - hash: base32 SHA512/256 of program bytes (Address-style)") + print_info(" - result: base64 encoded bytecode") + print_info(" - sourcemap?: { version, sources, names, mappings } (optional)") + print_info("") + print_info("Key DisassembleResponse fields:") + print_info(" - result: Disassembled TEAL source code (string)") + print_info("") + print_info("Use cases:") + print_info(" - Compile TEAL before deploying smart contracts") + print_info(" - Get program hash for Logic Signature addresses") + print_info(" - Debug bytecode by disassembling to readable TEAL") + print_info(" - Validate TEAL syntax before deployment") + print_info(" - Generate sourcemaps for debugging tools") + + +if __name__ == "__main__": + main() diff --git a/examples/algod_client/13_simulation.py b/examples/algod_client/13_simulation.py new file mode 100644 index 00000000..67173fa6 --- /dev/null +++ b/examples/algod_client/13_simulation.py @@ -0,0 +1,463 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Transaction Simulation + +This example demonstrates how to simulate transactions before submitting them +to the Algorand network. Simulation allows you to: +- Preview transaction outcomes without committing to the blockchain +- Estimate transaction fees +- Detect potential errors before spending fees +- Debug smart contract execution + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from decimal import Decimal + +from shared import ( + create_algod_client, + create_algorand_client, + format_micro_algo, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_algod_client.models import SimulateRequest, SimulateRequestTransactionGroup +from algokit_transact import SignedTransaction, decode_signed_transaction +from algokit_utils import AlgoAmount, PaymentParams + + +def main() -> None: + print_header("Transaction Simulation Example") + + # Create clients + algod = create_algod_client() + algorand = create_algorand_client() + + # ========================================================================= + # Step 1: Set up accounts for simulation + # ========================================================================= + print_step(1, "Setting up accounts for simulation") + + # Get a funded account from LocalNet (the dispenser) + sender = algorand.account.localnet_dispenser() + print_info(f"Sender address: {shorten_address(str(sender.addr))}") + + # Get sender balance + sender_info = algod.account_information(str(sender.addr)) + print_info(f"Sender balance: {format_micro_algo(sender_info.amount)}") + + # Create a new random account as receiver + receiver = algorand.account.random() + print_info(f"Receiver address: {shorten_address(str(receiver.addr))}") + print_info("Receiver is a new unfunded account") + print_info("") + + # ========================================================================= + # Step 2: Create a payment transaction for simulation + # ========================================================================= + print_step(2, "Creating a payment transaction for simulation") + + payment_amount = AlgoAmount.from_algo(1) # 1 ALGO + print_info(f"Payment amount: {payment_amount.algo} ALGO") + + # Build the transaction using AlgorandClient.create_transaction + payment_txn = algorand.create_transaction.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=payment_amount, + ) + ) + + # Get the transaction ID + tx_id = payment_txn.tx_id() + print_info(f"Transaction ID: {tx_id}") + + # Sign the transaction + signed_txn_bytes = sender.signer([payment_txn], [0]) + print_success("Transaction signed successfully!") + print_info("") + + # ========================================================================= + # Step 3: Simulate using simulate_transactions() + # ========================================================================= + print_step(3, "Simulating with simulate_transactions(SimulateRequest)") + + print_info("simulate_transactions() accepts a SimulateRequest object that:") + print_info(" - Contains transaction groups to simulate") + print_info(" - Can include options like allow_empty_signatures, fix_signers") + print_info(" - Returns SimulateResponse with detailed results") + print_info("") + + # Create a SimulateRequest with the signed transaction + # Decode the signed transaction bytes to get a SignedTransaction object + signed_txn = decode_signed_transaction(signed_txn_bytes[0]) + sim_request = SimulateRequest(txn_groups=[SimulateRequestTransactionGroup(txns=[signed_txn])]) + + sim_result = algod.simulate_transactions(sim_request) + + print_success("Simulation completed!") + print_info("") + + # ========================================================================= + # Step 4: Display simulation results + # ========================================================================= + print_step(4, "Displaying simulation results") + + print_info("SimulateResponse structure:") + print_info(f" version: {sim_result.version}") + print_info(f" last_round: {sim_result.last_round:,}") + txn_groups = sim_result.txn_groups + print_info(f" txn_groups: {len(txn_groups)} group(s)") + print_info("") + + # Check if the transaction would succeed + if txn_groups: + txn_group = txn_groups[0] + failure_message = txn_group.failure_message + would_succeed = not failure_message + + print_info("Transaction Group Result:") + print_info(f" Would succeed: {'Yes' if would_succeed else 'No'}") + if failure_message: + print_info(f" Failure message: {failure_message}") + failed_at = txn_group.failed_at + if failed_at: + print_info(f" Failed at: {failed_at}") + print_info("") + + # Display budget information (for app calls) + app_budget_added = txn_group.app_budget_added + app_budget_consumed = txn_group.app_budget_consumed + if app_budget_added is not None or app_budget_consumed is not None: + print_info("App Budget:") + print_info(f" Budget added: {app_budget_added if app_budget_added else 'N/A'}") + print_info(f" Budget consumed: {app_budget_consumed if app_budget_consumed else 'N/A'}") + print_info("") + + # ========================================================================= + # Step 5: Display individual transaction results + # ========================================================================= + print_step(5, "Displaying individual transaction results") + + if txn_groups: + txn_results = txn_groups[0].txn_results + for i, txn_result in enumerate(txn_results): + print_info(f"Transaction {i + 1}:") + + # The txn_result contains a PendingTransactionResponse + pending_response = txn_result.txn_result + inner_txn = pending_response.txn.txn + print_info(f" Transaction type: {inner_txn.transaction_type.value}") + + # Display fixed_signer if present (indicates missing/wrong signature) + fixed_signer = txn_result.fixed_signer + if fixed_signer: + print_info(f" Fixed signer: {shorten_address(str(fixed_signer))}") + print_info(" ^ This indicates the correct signer when simulation used allow_empty_signatures") + else: + print_info(" Fixed signer: None (signature was correct)") + + # Display budget consumed (for app calls) + app_budget = txn_result.app_budget_consumed + if app_budget is not None: + print_info(f" App budget consumed: {app_budget}") + + logic_sig_budget = txn_result.logic_sig_budget_consumed + if logic_sig_budget is not None: + print_info(f" LogicSig budget consumed: {logic_sig_budget}") + print_info("") + + # ========================================================================= + # Step 6: Show transaction group details + # ========================================================================= + print_step(6, "Show transaction group details from simulation") + + print_info("Each SimulateTransactionResult contains txn_result (PendingTransactionResponse)") + print_info("which includes the transaction details as if it were confirmed.") + print_info("") + + if txn_groups and txn_groups[0].txn_results: + txn_details = txn_groups[0].txn_results[0].txn_result + inner_txn = txn_details.txn.txn + + print_info("Simulated Transaction Details:") + print_info(f" Type: {inner_txn.transaction_type.value}") + print_info(f" Sender: {shorten_address(str(inner_txn.sender))}") + print_info(f" Fee: {format_micro_algo(inner_txn.fee or 0)}") + print_info(f" First valid: {inner_txn.first_valid:,}") + print_info(f" Last valid: {inner_txn.last_valid:,}") + + if inner_txn.payment: + print_info("") + print_info(" Payment fields:") + print_info(f" Receiver: {shorten_address(str(inner_txn.payment.receiver))}") + print_info(f" Amount: {format_micro_algo(inner_txn.payment.amount)}") + print_info("") + + # ========================================================================= + # Step 7: Demonstrate simulation with extra budget options + # ========================================================================= + print_step(7, "Demonstrating simulation with extra budget options") + + print_info("simulate_transactions() accepts a SimulateRequest with various options:") + print_info(" - allow_empty_signatures: Simulate unsigned transactions") + print_info(" - allow_more_logging: Lift limits on log opcode usage") + print_info(" - allow_unnamed_resources: Access resources not in txn references") + print_info(" - extra_opcode_budget: Add extra opcode budget for app calls") + print_info(" - fix_signers: Auto-fix incorrect signers in simulation") + print_info("") + + # Demonstrate with allow_empty_signatures (useful for fee estimation without signing) + print_info("Simulating an UNSIGNED transaction with allow_empty_signatures=True:") + print_info("") + + # Create an unsigned transaction + unsigned_txn = algorand.create_transaction.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_algo(Decimal("0.5")), + ) + ) + + # Build a simulate request with allow_empty_signatures + unsigned_sim_request = SimulateRequest( + txn_groups=[ + SimulateRequestTransactionGroup( + txns=[SignedTransaction(txn=unsigned_txn)] # No signature + ) + ], + allow_empty_signatures=True, + fix_signers=True, + ) + + unsigned_sim_result = algod.simulate_transactions(unsigned_sim_request) + + unsigned_groups = unsigned_sim_result.txn_groups + print_info("Unsigned transaction simulation result:") + if unsigned_groups: + would_succeed = not unsigned_groups[0].failure_message + print_info(f" Would succeed: {'Yes' if would_succeed else 'No'}") + + # Check if fixed_signer shows the required signer + unsigned_results = unsigned_groups[0].txn_results + if unsigned_results: + fixed_signer = unsigned_results[0].fixed_signer + if fixed_signer: + print_info(f" Required signer: {shorten_address(str(fixed_signer))}") + print_info("") + + # Demonstrate with extra_opcode_budget + print_info("extra_opcode_budget is useful for complex app calls that need more compute:") + print_info("") + + extra_budget_request = SimulateRequest( + txn_groups=[ + SimulateRequestTransactionGroup( + txns=[SignedTransaction(txn=unsigned_txn)] # No signature + ) + ], + allow_empty_signatures=True, + extra_opcode_budget=10000, # Add 10,000 extra opcodes + ) + + extra_budget_result = algod.simulate_transactions(extra_budget_request) + extra_groups = extra_budget_result.txn_groups + print_info("Simulation with extra budget:") + if extra_groups: + would_succeed = not extra_groups[0].failure_message + print_info(f" Would succeed: {'Yes' if would_succeed else 'No'}") + print_info(" (extra_opcode_budget is mainly useful for app calls, not simple payments)") + print_info("") + + # ========================================================================= + # Step 8: Show how simulation can estimate fees and detect errors + # ========================================================================= + print_step(8, "Using simulation to estimate fees and detect errors") + + print_info("Simulation helps with fee estimation by:") + print_info(" 1. Determining minimum fee for transaction to succeed") + print_info(" 2. Checking if your fee is sufficient before sending") + print_info(" 3. Avoiding wasted fees on transactions that would fail") + print_info("") + + # Get current suggested params to show fee structure + params = algod.suggested_params() + print_info("Current fee structure:") + print_info(f" Min fee: {format_micro_algo(params.min_fee)}") + print_info(f" Suggested fee: {format_micro_algo(params.fee)}") + print_info("") + + print_info("Simulation can detect errors BEFORE spending fees:") + print_info("") + + # Error detection example - insufficient balance + print_info("Example: Detecting an overspend error") + + # Create a transaction that would overspend + poor_account = algorand.account.random() + overspend_txn = algorand.create_transaction.payment( + PaymentParams( + sender=poor_account.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_algo(1000000), # 1 million ALGO - way more than account has + ) + ) + + overspend_request = SimulateRequest( + txn_groups=[SimulateRequestTransactionGroup(txns=[SignedTransaction(txn=overspend_txn)])], + allow_empty_signatures=True, + ) + + overspend_result = algod.simulate_transactions(overspend_request) + overspend_groups = overspend_result.txn_groups + + print_info(" Overspend simulation result:") + if overspend_groups: + overspend_group = overspend_groups[0] + would_succeed = not overspend_group.failure_message + print_info(f" Would succeed: {'Yes' if would_succeed else 'No'}") + failure = overspend_group.failure_message + if failure: + print_info(f" Failure: {failure}") + print_info("") + + # ========================================================================= + # Step 9: Simulate a failing transaction and display the failure reason + # ========================================================================= + print_step(9, "Simulating failing transactions") + + print_info("Demonstrating various failure scenarios:") + print_info("") + + # Failure scenario 1: Insufficient funds (already shown above) + print_info("1. Insufficient funds:") + if overspend_groups: + failure = overspend_groups[0].failure_message or "N/A" + print_info(f" Error: {failure}") + print_info("") + + # Failure scenario 2: Sending to zero balance account and closing + print_info("2. Sending to zero balance account and closing:") + print_info(" Simulating a close-out transaction to demonstrate simulation details") + + # Create a transaction that closes out to a specific address + close_out_txn = algorand.create_transaction.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_algo(0), + close_remainder_to=receiver.addr, # Close account to receiver + ) + ) + + close_out_request = SimulateRequest( + txn_groups=[SimulateRequestTransactionGroup(txns=[SignedTransaction(txn=close_out_txn)])], + allow_empty_signatures=True, + ) + + close_out_result = algod.simulate_transactions(close_out_request) + close_out_groups = close_out_result.txn_groups + + if close_out_groups: + close_out_group = close_out_groups[0] + would_succeed = not close_out_group.failure_message + print_info(f" Would succeed: {'Yes' if would_succeed else 'No'}") + failure = close_out_group.failure_message + if failure: + print_info(f" Failure: {failure}") + else: + print_info(" This would succeed (sender can close to receiver)") + print_info("") + + # Failure scenario 3: Insufficient fee (below minimum) + print_info("3. Transaction with fee below minimum:") + print_info(" Note: Very low fees are rejected before simulation even runs") + + # Create a transaction with a fee set to 0 (below min fee of 1000) + low_fee_txn = algorand.create_transaction.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_algo(Decimal("0.1")), + static_fee=AlgoAmount.from_micro_algo(0), # 0 fee - below minimum + ) + ) + + low_fee_request = SimulateRequest( + txn_groups=[SimulateRequestTransactionGroup(txns=[SignedTransaction(txn=low_fee_txn)])], + allow_empty_signatures=True, + ) + + try: + low_fee_result = algod.simulate_transactions(low_fee_request) + low_fee_groups = low_fee_result.txn_groups + if low_fee_groups: + low_fee_group = low_fee_groups[0] + would_succeed = not low_fee_group.failure_message + print_info(f" Would succeed: {'Yes' if would_succeed else 'No'}") + failure = low_fee_group.failure_message + if failure: + print_info(f" Failure: {failure}") + except Exception as e: + # Fee too low errors are caught at the API level, not in simulation results + error_message = str(e) + if "less than the minimum" in error_message.lower() or "fee" in error_message.lower(): + print_info(" Rejected before simulation: Fee too low") + print_info(" Algod validates minimum fees before running simulation") + else: + print_info(f" Error: {error_message}") + print_info("") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + + print_info("This example demonstrated:") + print_info("") + print_info("1. simulate_transactions(SimulateRequest):") + print_info(" - Method for simulating transactions") + print_info(" - Accepts SimulateRequest with transaction groups") + print_info(" - Returns SimulateResponse with detailed results") + print_info("") + print_info("2. SimulateResponse structure:") + print_info(" - version: API version number") + print_info(" - last_round: Round at which simulation was performed") + print_info(" - txn_groups: List of SimulateTransactionGroupResult") + print_info("") + print_info("3. SimulateTransactionGroupResult:") + print_info(" - txn_results: List of individual transaction results") + print_info(" - failure_message: Error message if group would fail (None if OK)") + print_info(" - failed_at: Index path to failing transaction (None if OK)") + print_info(" - app_budget_added/consumed: App call budget tracking") + print_info("") + print_info("4. SimulateTransactionResult:") + print_info(" - txn_result: PendingTransactionResponse with full details") + print_info(" - fixed_signer: Address that should have signed (None if correct)") + print_info(" - app_budget_consumed: Budget used by this transaction") + print_info(" - logic_sig_budget_consumed: Budget used by logic signature") + print_info("") + print_info("5. SimulateRequest options:") + print_info(" - allow_empty_signatures: Simulate without signatures") + print_info(" - allow_more_logging: Lift log opcode limits") + print_info(" - allow_unnamed_resources: Access unref'd resources") + print_info(" - extra_opcode_budget: Add extra compute budget") + print_info(" - fix_signers: Auto-fix incorrect signers") + print_info("") + print_info("6. Use cases for simulation:") + print_info(" - Fee estimation without signing") + print_info(" - Error detection before spending fees") + print_info(" - Debugging smart contract execution") + print_info(" - Validating transaction groups") + print_info(" - Testing complex app interactions") + + +if __name__ == "__main__": + main() diff --git a/examples/algod_client/14_state_deltas.py b/examples/algod_client/14_state_deltas.py new file mode 100644 index 00000000..c3ff419a --- /dev/null +++ b/examples/algod_client/14_state_deltas.py @@ -0,0 +1,404 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Ledger State Deltas + +This example demonstrates how to retrieve ledger state deltas using: +- ledger_state_delta(round) - Get state changes for a specific round +- ledger_state_delta_for_transaction_group(tx_id) - Get deltas for a specific transaction group +- transaction_group_ledger_state_deltas_for_round(round) - Get all transaction group deltas in a round + +State deltas show what changed in the ledger (accounts, balances, apps, assets) between rounds. + +Note: These endpoints may require node configuration to enable (EnableDeveloperAPI=true). + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from shared import ( + create_algod_client, + create_algorand_client, + format_micro_algo, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_algod_client.models import ( + LedgerStateDelta, + TransactionGroupLedgerStateDeltasForRound, +) +from algokit_utils import AlgoAmount, PaymentParams + + +def get_account_status(status: int) -> str: + """Convert an account status number to a string.""" + if status == 0: + return "Offline" + if status == 1: + return "Online" + if status == 2: + return "NotParticipating" + return f"Unknown ({status})" + + +def display_state_delta(delta: LedgerStateDelta, source: str) -> None: + """Display details from a LedgerStateDelta. + + LedgerStateDelta uses attribute access with snake_case names: + - delta.block.header.round (block header information) + - delta.prev_timestamp (previous round timestamp) + - delta.accounts.accounts (list of LedgerBalanceRecord) + - delta.totals (LedgerAccountTotals) + - delta.kv_mods (dict[bytes, LedgerKvValueDelta] | None) + - delta.tx_ids (dict[bytes, LedgerIncludedTransactions] | None) + - delta.creatables (dict[int, LedgerModifiedCreatable] | None) + """ + print_info(f"State Delta from {source}:") + print_info("") + + # Block information (LedgerStateDelta.block is a Block object) + print_info(" Block Information:") + print_info(f" Round: {delta.block.header.round:,}") + print_info(f" Timestamp: {delta.block.header.timestamp}") + print_info(f" Previous timestamp: {delta.prev_timestamp:,}") + if delta.block.header.proposer: + print_info(f" Proposer: {shorten_address(str(delta.block.header.proposer))}") + print_info("") + + # Account changes (LedgerStateDelta.accounts is LedgerAccountDeltas) + print_info(" Account Changes (LedgerAccountDeltas):") + accounts = delta.accounts + + accounts_list = accounts.accounts or [] + if accounts_list: + print_info(f" Modified accounts: {len(accounts_list)}") + for record in accounts_list[:5]: # Show first 5 + # LedgerBalanceRecord has address, account_data (LedgerAccountData) + # LedgerAccountData has account_base_data (LedgerAccountBaseData) + base_data = record.account_data.account_base_data + print_info(f" - {shorten_address(str(record.address))}") + print_info(f" Balance: {format_micro_algo(base_data.micro_algos)}") + print_info(f" Status: {get_account_status(base_data.status)}") + if len(accounts_list) > 5: + print_info(f" ... and {len(accounts_list) - 5} more") + else: + print_info(" No account balance changes") + + app_resources = accounts.app_resources or [] + if app_resources: + print_info(f" App resources modified: {len(app_resources)}") + for app in app_resources[:3]: + # LedgerAppResourceRecord has app_id, params (LedgerAppParamsDelta) + is_deleted = app.params.deleted + print_info(f" - App {app.app_id}: {'DELETED' if is_deleted else 'MODIFIED'}") + + asset_resources = accounts.asset_resources or [] + if asset_resources: + print_info(f" Asset resources modified: {len(asset_resources)}") + for asset in asset_resources[:3]: + # LedgerAssetResourceRecord has asset_id, params (LedgerAssetParamsDelta) + is_deleted = asset.params.deleted + print_info(f" - Asset {asset.asset_id}: {'DELETED' if is_deleted else 'MODIFIED'}") + print_info("") + + # Totals (LedgerStateDelta.totals is LedgerAccountTotals) + print_info(" Account Totals (LedgerAccountTotals):") + # LedgerAccountTotals has online, offline, not_participating (LedgerAlgoCount) + print_info(f" Online money: {format_micro_algo(delta.totals.online.money)}") + print_info(f" Offline money: {format_micro_algo(delta.totals.offline.money)}") + print_info(f" Not participating: {format_micro_algo(delta.totals.not_participating.money)}") + print_info(f" Rewards level: {delta.totals.rewards_level:,}") + print_info("") + + # KV mods (dict[bytes, LedgerKvValueDelta] | None) + if delta.kv_mods: + print_info(f" KV Store Modifications: {len(delta.kv_mods)} keys changed") + + # Transaction IDs (dict[bytes, LedgerIncludedTransactions] | None) + if delta.tx_ids: + print_info(f" Transactions included: {len(delta.tx_ids)}") + + # Creatables (dict[int, LedgerModifiedCreatable] | None) + if delta.creatables: + print_info(f" Creatables modified: {len(delta.creatables)}") + for creatable_id, creatable in list(delta.creatables.items())[:5]: + # LedgerModifiedCreatable has creatable_type, created, creator + creatable_type = "Asset" if creatable.creatable_type == 0 else "Application" + action = "CREATED" if creatable.created else "DELETED" + print_info(f" - {creatable_type} {creatable_id}: {action} by {shorten_address(str(creatable.creator))}") + print_info("") + + +def display_round_deltas(response: TransactionGroupLedgerStateDeltasForRound) -> None: + """Display details from a TransactionGroupLedgerStateDeltasForRound. + + TransactionGroupLedgerStateDeltasForRound uses attribute access: + - response.deltas (list of LedgerStateDeltaForTransactionGroup) + - Each group has: delta (LedgerStateDelta), ids (list[str]) + """ + print_info("Transaction Group Deltas for Round:") + print_info(f" Total transaction groups: {len(response.deltas)}") + print_info("") + + for i, group_delta in enumerate(response.deltas): + print_info(f" Group {i + 1}:") + # LedgerStateDeltaForTransactionGroup has ids (list[str]) and delta (LedgerStateDelta) + print_info(f" Transaction IDs in group: {len(group_delta.ids)}") + + for tx_id in group_delta.ids: + print_info(f" - {tx_id}") + + # Summary of delta (LedgerStateDelta) + accounts = group_delta.delta.accounts + accounts_list = accounts.accounts or [] + app_resources = accounts.app_resources or [] + asset_resources = accounts.asset_resources or [] + + modified_count = len(accounts_list) + app_count = len(app_resources) + asset_count = len(asset_resources) + + print_info(" State changes:") + print_info(f" - Accounts modified: {modified_count}") + if app_count > 0: + print_info(f" - App resources: {app_count}") + if asset_count > 0: + print_info(f" - Asset resources: {asset_count}") + print_info("") + + +def main() -> None: + print_header("Ledger State Deltas Example") + + # Create clients + algod = create_algod_client() + algorand = create_algorand_client() + + # ========================================================================= + # Step 1: Set up accounts and submit a transaction to create state changes + # ========================================================================= + print_step(1, "Setting up accounts and submitting a payment transaction") + + # Get a funded account from LocalNet (the dispenser) + # AddressWithSigners uses .addr attribute (not .address) + sender = algorand.account.localnet_dispenser() + print_info(f"Sender address: {shorten_address(str(sender.addr))}") + + # Get sender initial balance + # account_information() returns Account object with attribute access + sender_info_before = algod.account_information(str(sender.addr)) + print_info(f"Sender initial balance: {format_micro_algo(sender_info_before.amount)}") + + # Create a new random account as receiver + receiver = algorand.account.random() + print_info(f"Receiver address: {shorten_address(str(receiver.addr))}") + + # Submit a payment transaction - this will create state changes (balance changes) + payment_amount = AlgoAmount.from_algo(5) + print_info(f"Sending {payment_amount.algo} ALGO to receiver...") + + # algorand.send.payment() requires PaymentParams wrapper (Python SDK) + result = algorand.send.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=payment_amount, + ) + ) + + tx_id = result.tx_ids[0] + # confirmed_round can be None if not confirmed, but we know it's confirmed + confirmed_round = result.confirmation.confirmed_round or 0 + + print_success("Transaction confirmed!") + print_info(f"Transaction ID: {tx_id}") + print_info(f"Confirmed in round: {confirmed_round:,}") + print_info("") + + # Get balances after transaction + # Account object uses attribute access (not dict) + sender_info_after = algod.account_information(str(sender.addr)) + receiver_info = algod.account_information(str(receiver.addr)) + + print_info(f"Sender balance after: {format_micro_algo(sender_info_after.amount)}") + print_info(f"Receiver balance after: {format_micro_algo(receiver_info.amount)}") + print_info("") + + # ========================================================================= + # Step 2: Demonstrate ledger_state_delta(round) + # ========================================================================= + print_step(2, "Getting ledger state delta for a round using ledger_state_delta(round)") + + print_info("ledger_state_delta(round) returns all state changes that occurred in a specific round.") + print_info("This includes account balance changes, app state changes, and more.") + print_info("") + + try: + # ledger_state_delta() returns LedgerStateDelta object + state_delta = algod.ledger_state_delta(confirmed_round) + print_success("Successfully retrieved state delta for the round!") + print_info("") + + display_state_delta(state_delta, "ledger_state_delta") + except Exception as e: + error_message = str(e) + if "not supported" in error_message or "not enabled" in error_message or "404" in error_message: + print_error("ledger_state_delta endpoint may not be enabled on this node.") + print_info("Node configuration may need EnableDeveloperAPI=true or specific delta tracking settings.") + else: + print_error(f"Error getting state delta: {error_message}") + print_info("") + + # ========================================================================= + # Step 3: Demonstrate ledger_state_delta_for_transaction_group(tx_id) + # ========================================================================= + print_step(3, "Getting state delta for a specific transaction group") + + print_info("ledger_state_delta_for_transaction_group(tx_id) returns the state changes") + print_info("caused by a specific transaction group, identified by any transaction ID in the group.") + print_info("") + + try: + # ledger_state_delta_for_transaction_group() returns LedgerStateDelta object + tx_group_delta = algod.ledger_state_delta_for_transaction_group(tx_id) + print_success("Successfully retrieved state delta for the transaction group!") + print_info("") + + display_state_delta(tx_group_delta, "ledger_state_delta_for_transaction_group") + except Exception as e: + error_message = str(e) + if "tracer" in error_message or "501" in error_message: + print_error("ledger_state_delta_for_transaction_group requires delta tracking to be enabled.") + print_info("This endpoint needs EnableDeveloperAPI=true AND EnableTxnEvalTracer=true in node config.") + print_info("On LocalNet, this may require custom configuration.") + elif "not supported" in error_message or "not enabled" in error_message or "404" in error_message: + print_error("ledger_state_delta_for_transaction_group endpoint may not be enabled on this node.") + else: + print_error(f"Error getting transaction group delta: {error_message}") + print_info("") + + # ========================================================================= + # Step 4: Demonstrate transaction_group_ledger_state_deltas_for_round(round) + # ========================================================================= + print_step(4, "Getting all transaction group deltas for a round") + + print_info("transaction_group_ledger_state_deltas_for_round(round) returns deltas for ALL") + print_info("transaction groups that were included in a specific round.") + print_info("Each entry includes the delta and the transaction IDs in that group.") + print_info("") + + try: + # transaction_group_ledger_state_deltas_for_round() returns TransactionGroupLedgerStateDeltasForRound + round_deltas = algod.transaction_group_ledger_state_deltas_for_round(confirmed_round) + print_success("Successfully retrieved all transaction group deltas for the round!") + print_info("") + + display_round_deltas(round_deltas) + except Exception as e: + error_message = str(e) + if "tracer" in error_message or "501" in error_message: + print_error("transaction_group_ledger_state_deltas_for_round requires delta tracking to be enabled.") + print_info("This endpoint needs EnableDeveloperAPI=true AND EnableTxnEvalTracer=true in node config.") + print_info("On LocalNet, this may require custom configuration.") + elif "not supported" in error_message or "not enabled" in error_message or "404" in error_message: + print_error("transaction_group_ledger_state_deltas_for_round endpoint may not be enabled on this node.") + else: + print_error(f"Error getting round deltas: {error_message}") + print_info("") + + # ========================================================================= + # Step 5: Submit more transactions to see different state changes + # ========================================================================= + print_step(5, "Submitting additional transactions to demonstrate more state changes") + + # Create another account and do a multi-transaction round + receiver2 = algorand.account.random() + print_info(f"Created second receiver: {shorten_address(str(receiver2.addr))}") + + # Send payments to create more activity + result2 = algorand.send.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver2.addr, + amount=AlgoAmount.from_algo(3), + ) + ) + + confirmed_round2 = result2.confirmation.confirmed_round or 0 + print_success(f"Second transaction confirmed in round {confirmed_round2:,}") + print_info("") + + # Try to get deltas for this new round + try: + # TransactionGroupLedgerStateDeltasForRound uses attribute access + round_deltas2 = algod.transaction_group_ledger_state_deltas_for_round(confirmed_round2) + print_success(f"Found {len(round_deltas2.deltas)} transaction group(s) in round {confirmed_round2:,}") + + for i, group_delta in enumerate(round_deltas2.deltas): + # LedgerStateDeltaForTransactionGroup has ids (list[str]) and delta (LedgerStateDelta) + print_info(f"\n Transaction Group {i + 1}:") + print_info(f" Transaction IDs: {len(group_delta.ids)}") + for txid in group_delta.ids: + print_info(f" - {txid}") + + # Show account changes summary + accounts = group_delta.delta.accounts + accounts_list = accounts.accounts or [] + if accounts_list: + print_info(f" Accounts modified: {len(accounts_list)}") + except Exception as e: + error_message = str(e) + if "tracer" in error_message or "501" in error_message: + print_info("(Skipped - requires EnableTxnEvalTracer node configuration)") + else: + print_error(f"Could not get deltas: {error_message}") + print_info("") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + + print_info("This example demonstrated three ways to get ledger state deltas:") + print_info("") + print_info("1. ledger_state_delta(round):") + print_info(" - Returns ALL state changes for a specific round") + print_info(" - Includes: account balances, app state, asset holdings") + print_info(" - LedgerStateDelta contains: accounts, block, totals, kvMods, txIds, creatables") + print_info("") + print_info("2. ledger_state_delta_for_transaction_group(tx_id):") + print_info(" - Returns state changes for a SPECIFIC transaction group") + print_info(" - Accepts any transaction ID from the group") + print_info(" - Useful for tracking changes from your transactions") + print_info("") + print_info("3. transaction_group_ledger_state_deltas_for_round(round):") + print_info(" - Returns deltas for ALL transaction groups in a round") + print_info(" - Response has deltas array") + print_info(" - Each LedgerStateDeltaForTransactionGroup has: delta, ids (transaction IDs)") + print_info("") + print_info("State Delta Structure (LedgerStateDelta) - Python SDK uses snake_case:") + print_info(" accounts: LedgerAccountDeltas") + print_info(" - accounts: list[LedgerBalanceRecord] | None (address + micro_algos)") + print_info(" - app_resources: list[LedgerAppResourceRecord] | None") + print_info(" - asset_resources: list[LedgerAssetResourceRecord] | None") + print_info(" block: Block (block.header contains round, timestamp, etc.)") + print_info(" totals: LedgerAccountTotals (online, offline, not_participating)") + print_info(" state_proof_next: int") + print_info(" prev_timestamp: int") + print_info(" kv_mods: dict[bytes, LedgerKvValueDelta] | None") + print_info(" tx_ids: dict[bytes, LedgerIncludedTransactions] | None") + print_info(" creatables: dict[int, LedgerModifiedCreatable] | None") + print_info("") + print_info("Note: Node configuration requirements:") + print_info(" - ledger_state_delta(round) - Works with default LocalNet configuration") + print_info(" - ledger_state_delta_for_transaction_group(tx_id) - Requires EnableTxnEvalTracer=true") + print_info(" - transaction_group_ledger_state_deltas_for_round(round) - Requires EnableTxnEvalTracer=true") + print_info(" - All endpoints need EnableDeveloperAPI=true (enabled by default on LocalNet)") + + +if __name__ == "__main__": + main() diff --git a/examples/algod_client/15_transaction_proof.py b/examples/algod_client/15_transaction_proof.py new file mode 100644 index 00000000..13c81987 --- /dev/null +++ b/examples/algod_client/15_transaction_proof.py @@ -0,0 +1,318 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Transaction Proof + +This example demonstrates how to get transaction proofs using: +- transaction_proof(round, tx_id) - Get the Merkle proof for a transaction + +Transaction proofs are cryptographic proofs that a transaction is included in a specific +block. They are used for light client verification, allowing clients to verify transaction +inclusion without downloading the entire blockchain. + +The proof uses a Merkle tree structure where: +- Each transaction in a block is a leaf in the tree +- The root of the tree is committed in the block header +- The proof provides the sibling hashes needed to reconstruct the root + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from decimal import Decimal + +from shared import ( + create_algod_client, + create_algorand_client, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_algod_client.models import TransactionProof +from algokit_utils import AlgoAmount, PaymentParams + + +def display_transaction_proof(proof: TransactionProof) -> None: + """Display details from a TransactionProof.""" + print_info(" TransactionProof fields:") + print_info(f" idx: {proof.idx}") + print_info(" Index of the transaction in the block's payset") + print_info("") + + if proof.proof and len(proof.proof) > 0: + hex_str = proof.proof.hex()[:64] + print_info(f" proof: {hex_str}...") + print_info(f" ({len(proof.proof)} bytes total - Merkle proof data)") + else: + print_info(" proof: (empty - single transaction in block)") + print_info(" When treedepth=0, stibhash IS the Merkle root") + print_info("") + + print_info(f" stibhash: {proof.stibhash.hex()}") + print_info(f" ({len(proof.stibhash)} bytes - Hash of SignedTxnInBlock)") + print_info("") + + print_info(f" treedepth: {proof.treedepth}") + print_info(" Number of edges from leaf to root in the Merkle tree") + print_info("") + + print_info(f' hashtype: "{proof.hashtype}"') + print_info(" Hash function used to create the proof") + print_info("") + + +def main() -> None: + print_header("Transaction Proof Example") + + # Create clients + algod = create_algod_client() + algorand = create_algorand_client() + + # ========================================================================= + # Step 1: Submit a transaction and wait for confirmation + # ========================================================================= + print_step(1, "Submitting a transaction and waiting for confirmation") + + # Get a funded account from LocalNet (the dispenser) + sender = algorand.account.localnet_dispenser() + print_info(f"Sender address: {shorten_address(str(sender.addr))}") + + # Create a new random account as receiver + receiver = algorand.account.random() + print_info(f"Receiver address: {shorten_address(str(receiver.addr))}") + + # Submit a payment transaction + payment_amount = AlgoAmount.from_algo(1) + print_info(f"Sending {payment_amount.algo} ALGO to receiver...") + + result = algorand.send.payment( + PaymentParams( + sender=str(sender.addr), + receiver=str(receiver.addr), + amount=payment_amount, + ) + ) + + tx_id = result.tx_ids[0] + confirmed_round = result.confirmation.confirmed_round or 0 + + print_success("Transaction confirmed!") + print_info(f"Transaction ID: {tx_id}") + print_info(f"Confirmed in round: {confirmed_round:,}") + print_info("") + + # ========================================================================= + # Step 2: Get transaction proof using transaction_proof(round, tx_id) + # ========================================================================= + print_step(2, "Getting transaction proof using transaction_proof(round, tx_id)") + + print_info("transaction_proof(round, tx_id) returns a Merkle proof that the transaction") + print_info("is included in the specified block. This is used for light client verification.") + print_info("") + + try: + proof = algod.transaction_proof(confirmed_round, tx_id) + print_success("Successfully retrieved transaction proof!") + print_info("") + + display_transaction_proof(proof) + except Exception as e: + error_message = str(e) + print_error(f"Error getting transaction proof: {error_message}") + print_info("") + + # ========================================================================= + # Step 3: Demonstrate proof with different hash type (sha256) + # ========================================================================= + print_step(3, "Getting transaction proof with SHA-256 hash type") + + print_info("The hashtype parameter specifies the hash function used to create the proof.") + print_info('Supported values: "sha512_256" (default) and "sha256"') + print_info("") + + try: + proof_sha256 = algod.transaction_proof(confirmed_round, tx_id, hashtype="sha256") + print_success("Successfully retrieved transaction proof with SHA-256!") + print_info("") + + display_transaction_proof(proof_sha256) + except Exception as e: + error_message = str(e) + if "not supported" in error_message or "400" in error_message: + print_error("SHA-256 hash type may not be supported on this node configuration.") + print_info("The default SHA-512/256 is the native Algorand hash function.") + else: + print_error(f"Error getting transaction proof with SHA-256: {error_message}") + print_info("") + + # ========================================================================= + # Step 4: Demonstrate structure of Merkle proof data + # ========================================================================= + print_step(4, "Understanding the Merkle proof structure") + + print_info("The transaction proof contains data needed to verify transaction inclusion:") + print_info("") + + try: + proof = algod.transaction_proof(confirmed_round, tx_id) + + print_info(" Merkle Proof Structure:") + print_info("") + print_info(" 1. idx (index): Position of the transaction in the block's payset") + print_info(f" Value: {proof.idx}") + print_info(" This tells you which leaf in the Merkle tree corresponds to this transaction.") + print_info("") + + print_info(" 2. treedepth: Number of levels in the Merkle tree") + print_info(f" Value: {proof.treedepth}") + max_txns = 2**proof.treedepth if proof.treedepth > 0 else 1 + print_info(f" A tree with depth {proof.treedepth} can hold up to {max_txns} transactions.") + print_info("") + + print_info(" 3. proof: Sibling hashes needed to reconstruct the Merkle root") + print_info(f" Length: {len(proof.proof)} bytes") + if proof.treedepth > 0: + print_info(f" Number of hashes: {proof.treedepth} (one for each level)") + hash_size = len(proof.proof) // proof.treedepth if proof.treedepth > 0 else 0 + print_info(f" Hash size: {hash_size} bytes per hash") + else: + print_info(" (Empty - single transaction in block, stibhash IS the Merkle root)") + print_info("") + + print_info(" 4. stibhash: Hash of SignedTxnInBlock") + print_info(f" Length: {len(proof.stibhash)} bytes") + print_info(" This is the leaf value - the hash of the transaction as stored in the block.") + print_info("") + + print_info(" 5. hashtype: Hash function used") + print_info(f' Value: "{proof.hashtype}"') + print_info(" SHA-512/256 is Algorand's native hash function (first 256 bits of SHA-512).") + print_info("") + except Exception as e: + error_message = str(e) + print_error(f"Error demonstrating proof structure: {error_message}") + print_info("") + + # ========================================================================= + # Step 5: Handle errors - invalid round or transaction ID + # ========================================================================= + print_step(5, "Handling errors when proof is not available") + + print_info("Transaction proofs may not be available if:") + print_info(" - The round number is invalid or not yet committed") + print_info(" - The transaction ID does not exist in the specified round") + print_info(" - The node does not have the block data") + print_info("") + + # Try getting proof for a non-existent transaction ID + fake_tx_id = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + try: + algod.transaction_proof(confirmed_round, fake_tx_id) + print_info("Unexpectedly succeeded with fake transaction ID") + except Exception as e: + error_message = str(e) + print_success("Correctly rejected invalid transaction ID") + print_info(f"Error: {error_message[:100]}...") + print_info("") + + # Try getting proof for a future round + status = algod.status() + last_round = status.last_round + future_round = last_round + 1000 + try: + algod.transaction_proof(future_round, tx_id) + print_info("Unexpectedly succeeded with future round") + except Exception as e: + error_message = str(e) + print_success("Correctly rejected future round") + print_info(f"Error: {error_message[:100]}...") + print_info("") + + # ========================================================================= + # Step 6: Submit multiple transactions and compare proofs + # ========================================================================= + print_step(6, "Comparing proofs for multiple transactions in the same block") + + print_info("Each transaction in a block has a unique position (idx) in the Merkle tree.") + print_info("Submitting multiple transactions to observe different proof indices...") + print_info("") + + # Submit multiple transactions in sequence (they may end up in different blocks on LocalNet dev mode) + tx_ids: list[str] = [] + confirmed_rounds: list[int] = [] + + for _i in range(3): + new_receiver = algorand.account.random() + tx_result = algorand.send.payment( + PaymentParams( + sender=str(sender.addr), + receiver=str(new_receiver.addr), + amount=AlgoAmount.from_algo(Decimal("0.1")), + ) + ) + tx_ids.append(tx_result.tx_ids[0]) + confirmed_rounds.append(tx_result.confirmation.confirmed_round or 0) + + print_info(f"Submitted {len(tx_ids)} transactions") + print_info("") + + # Get proofs for each transaction + for i in range(len(tx_ids)): + try: + proof = algod.transaction_proof(confirmed_rounds[i], tx_ids[i]) + print_info(f" Transaction {i + 1}:") + print_info(f" Round: {confirmed_rounds[i]:,}") + print_info(f" TX ID: {tx_ids[i][:20]}...") + print_info(f" Index in block (idx): {proof.idx}") + print_info(f" Tree depth: {proof.treedepth}") + print_info("") + except Exception as e: + error_message = str(e) + print_error(f"Error getting proof for transaction {i + 1}: {error_message}") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + + print_info("Transaction Proof Use Cases:") + print_info("") + print_info("1. Light Client Verification:") + print_info(" - Verify a transaction is included in the blockchain without downloading all blocks") + print_info(" - Only need the block header (with Merkle root) and the proof") + print_info(" - Reduces bandwidth and storage requirements significantly") + print_info("") + print_info("2. Cross-Chain Bridges:") + print_info(" - Prove to another blockchain that a transaction occurred on Algorand") + print_info(" - The proof can be verified by a smart contract on the target chain") + print_info("") + print_info("3. Auditing and Compliance:") + print_info(" - Provide cryptographic proof of transaction inclusion") + print_info(" - Third parties can verify without trusting the provider") + print_info("") + print_info("TransactionProof Type Structure:") + print_info(" proof: bytes - Merkle proof (sibling hashes concatenated)") + print_info(" stibhash: bytes - Hash of SignedTxnInBlock (leaf value)") + print_info(" treedepth: int - Depth of the Merkle tree") + print_info(" idx: int - Transaction index in the block's payset") + print_info(" hashtype: str - Hash function used ('sha512_256' or 'sha256')") + print_info("") + print_info("API Method:") + print_info(" transaction_proof(round, tx_id, hashtype=None)") + print_info(" round: int - The round (block) containing the transaction") + print_info(" tx_id: str - The transaction ID") + print_info(" hashtype: str - 'sha512_256' (default) or 'sha256'") + print_info("") + print_info("Verification Process:") + print_info(" 1. Get the stibhash (leaf value) from the proof") + print_info(" 2. Use idx to determine if leaf is left or right child at each level") + print_info(" 3. Combine with sibling hashes from proof, hashing up the tree") + print_info(" 4. Compare computed root with the txnCommitments in the block header") + print_info(" 5. If they match, the transaction is verified as included in the block") + + +if __name__ == "__main__": + main() diff --git a/examples/algod_client/16_lightblock_proof.py b/examples/algod_client/16_lightblock_proof.py new file mode 100644 index 00000000..99c70c76 --- /dev/null +++ b/examples/algod_client/16_lightblock_proof.py @@ -0,0 +1,285 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Light Block Header Proof + +This example demonstrates how to get light block header proofs using: +- light_block_header_proof(round) - Get the proof for a block header + +Light block header proofs are part of Algorand's State Proof system, which allows +light clients and other blockchains to verify Algorand's blockchain state without +needing to sync all blocks or trust intermediaries. + +Key concepts: +- State proofs are generated at regular intervals (every 256 rounds on MainNet) +- Light block header proofs verify that a block header is part of the state proof interval +- The proof uses a vector commitment tree (similar to Merkle tree) structure +- Only blocks within a state proof interval have available light block header proofs + +Prerequisites: +- LocalNet running (via `algokit localnet start`) + +Note: On LocalNet in dev mode, state proofs may not be generated, so this example +demonstrates the API call and handles the expected errors gracefully. +""" + +import base64 + +from shared import ( + create_algod_client, + print_error, + print_header, + print_info, + print_step, + print_success, +) + +from algokit_algod_client.models import LightBlockHeaderProof + + +def display_light_block_header_proof(proof: LightBlockHeaderProof, block_round: int) -> None: + """Display details from a LightBlockHeaderProof.""" + print_info(" LightBlockHeaderProof fields:") + print_info(f" Round: {block_round:,}") + print_info("") + + print_info(f" index: {proof.index}") + print_info(" Position of the block header in the vector commitment tree") + print_info(" (i.e., which leaf in the tree corresponds to this block)") + print_info("") + + max_headers = 2**proof.treedepth if proof.treedepth > 0 else 1 + print_info(f" treedepth: {proof.treedepth}") + print_info(f" Number of edges from leaf to root (tree can hold {max_headers} headers)") + print_info("") + + if proof.proof and len(proof.proof) > 0: + hex_str = proof.proof.hex()[:64] + print_info(f" proof: {hex_str}...") + print_info(f" ({len(proof.proof)} bytes total - Merkle path data)") + else: + print_info(" proof: (empty)") + print_info(" (Single header in commitment, no sibling hashes needed)") + print_info("") + + # Calculate the state proof interval this block belongs to + state_proof_interval = 256 # Default interval + interval_number = block_round // state_proof_interval + interval_start = interval_number * state_proof_interval + 1 + interval_end = (interval_number + 1) * state_proof_interval + print_info(f" State Proof Interval: {interval_number:,}") + print_info(f" Interval Range: rounds {interval_start:,} to {interval_end:,}") + print_info("") + + +def main() -> None: + print_header("Light Block Header Proof Example") + + # Create clients + algod = create_algod_client() + + # ========================================================================= + # Step 1: Understand Light Block Header Proofs and State Proofs + # ========================================================================= + print_step(1, "Understanding light block header proofs and state proofs") + + print_info("Light block header proofs are part of Algorand's State Proof system.") + print_info("") + print_info("What are State Proofs?") + print_info(" - Cryptographic proofs that attest to the state of the Algorand blockchain") + print_info(" - Generated at regular intervals (StateProofInterval, typically 256 rounds)") + print_info(" - Allow light clients to verify blockchain state without syncing all blocks") + print_info(" - Enable secure cross-chain bridges and interoperability") + print_info("") + print_info("What are Light Block Header Proofs?") + print_info(" - Prove that a specific block header is included in a state proof interval") + print_info(" - Use a vector commitment tree (Merkle-like structure)") + print_info(" - The proof contains: index, treedepth, and the proof data") + print_info(" - Combined with the block header, allows verification against the state proof") + print_info("") + + # ========================================================================= + # Step 2: Get current round information + # ========================================================================= + print_step(2, "Getting current round information") + + status = algod.status() + last_round = status.last_round + print_info(f"Current round: {last_round:,}") + print_info("") + + # ========================================================================= + # Step 3: Understand state proof intervals + # ========================================================================= + print_step(3, "Understanding state proof intervals") + + print_info("State proofs are generated at regular intervals:") + print_info(" - MainNet/TestNet: Every 256 rounds (StateProofInterval)") + print_info(" - Light block header proofs are only available for rounds within a state proof interval") + print_info(" - The interval typically covers rounds [N*256 + 1, (N+1)*256] for some N") + print_info("") + print_info("Relationship between blocks and state proofs:") + print_info(" - Each state proof covers a range of block headers") + print_info(" - Light block header proofs verify membership in this range") + print_info(" - The proof index indicates position within the state proof's vector commitment") + print_info("") + + # Try to get consensus parameters to show state proof interval + try: + version = algod.version() + print_info(f"Genesis ID: {version.genesis_id}") + print_info(f"Genesis Hash: {base64.b64encode(version.genesis_hash_b64).decode()}") + print_info("") + except Exception: + # Ignore version errors + pass + + # ========================================================================= + # Step 4: Try to get light block header proof for current round + # ========================================================================= + print_step(4, "Attempting to get light block header proof for current round") + + print_info(f"Trying light_block_header_proof({last_round})...") + print_info("") + + try: + proof = algod.light_block_header_proof(last_round) + print_success("Successfully retrieved light block header proof!") + print_info("") + display_light_block_header_proof(proof, last_round) + except Exception as e: + error_message = str(e) + + # Handle expected cases where proof is not available + if "state proof" in error_message or "not found" in error_message or "404" in error_message: + print_info("Light block header proof is not available for this round.") + print_info("This is expected behavior - proofs are only available for specific rounds.") + print_info("") + print_info("Possible reasons:") + print_info(" 1. The round is not part of a completed state proof interval") + print_info(" 2. State proofs are not enabled on this network (LocalNet dev mode)") + print_info(" 3. The block is too recent (state proof not yet generated)") + print_info(" 4. The block is too old (state proof data may be pruned)") + elif "501" in error_message or "not supported" in error_message or "Not Implemented" in error_message: + print_info("Light block header proofs are not supported on this node.") + print_info("This feature requires a node with state proof support enabled.") + else: + print_error(f"Error: {error_message}") + print_info("") + + # ========================================================================= + # Step 5: Try multiple rounds to find available proofs + # ========================================================================= + print_step(5, "Scanning rounds for available light block header proofs") + + print_info("Checking several rounds to see if any have available proofs...") + print_info("") + + # Try a range of rounds + rounds_to_try = [ + 1, # Very early round + 256, # First state proof interval boundary + 512, # Second interval boundary + last_round - 256 if last_round > 256 else 1, # One interval ago + last_round - 100 if last_round > 100 else 1, # Recent rounds + last_round, # Current round + ] + # Filter to valid rounds + rounds_to_try = [r for r in rounds_to_try if r > 0] + + found_proof = False + for block_round in rounds_to_try: + try: + proof = algod.light_block_header_proof(block_round) + print_success(f"Found proof for round {block_round:,}!") + display_light_block_header_proof(proof, block_round) + found_proof = True + break + except Exception: + print_info(f"Round {block_round:,}: No proof available") + + if not found_proof: + print_info("") + print_info("No light block header proofs found for any tested round.") + print_info("This is expected on LocalNet in dev mode where state proofs are not generated.") + print_info("") + + # ========================================================================= + # Step 6: Demonstrate error handling for invalid rounds + # ========================================================================= + print_step(6, "Demonstrating error handling for invalid rounds") + + print_info("Testing error handling for various invalid round scenarios:") + print_info("") + + # Try a future round + future_round = last_round + 10000 + print_info(f" Future round ({future_round:,}):") + try: + algod.light_block_header_proof(future_round) + print_info(" Unexpectedly succeeded") + except Exception as e: + error_message = str(e) + print_info(f" Error (expected): {error_message[:80]}...") + print_info("") + + # Try round 0 (invalid) + print_info(" Round 0 (invalid):") + try: + algod.light_block_header_proof(0) + print_info(" Unexpectedly succeeded") + except Exception as e: + error_message = str(e) + print_info(f" Error (expected): {error_message[:80]}...") + print_info("") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + + print_info("Light Block Header Proof - Key Points:") + print_info("") + print_info("1. Part of Algorand's State Proof System:") + print_info(" - Enables trustless verification of Algorand's blockchain state") + print_info(" - Critical for cross-chain bridges and light clients") + print_info(" - Uses post-quantum secure cryptographic techniques (Falcon signatures)") + print_info("") + print_info("2. State Proof Intervals:") + print_info(" - Proofs are generated every StateProofInterval rounds (256 on MainNet)") + print_info(" - Each interval commits to a range of block headers") + print_info(" - Light block header proofs verify membership in this commitment") + print_info("") + print_info("3. Availability:") + print_info(" - Only available for rounds within completed state proof intervals") + print_info(" - Not available on LocalNet dev mode (state proofs not generated)") + print_info(" - May not be available for very old rounds (data pruning)") + print_info("") + print_info("LightBlockHeaderProof Type Structure:") + print_info(" index: int - Position of the block header in the vector commitment") + print_info(" treedepth: int - Depth of the vector commitment tree") + print_info(" proof: bytes - The encoded proof data (Merkle path)") + print_info("") + print_info("API Method:") + print_info(" light_block_header_proof(round_: int) -> LightBlockHeaderProof") + print_info("") + print_info("Use Cases:") + print_info(" 1. Cross-Chain Bridges:") + print_info(" - Verify Algorand transactions on other blockchains") + print_info(" - Provide cryptographic proof of block inclusion") + print_info(" 2. Light Clients:") + print_info(" - Verify blockchain state without full node sync") + print_info(" - Reduce bandwidth and storage requirements") + print_info(" 3. Auditing:") + print_info(" - Prove block existence at a specific round") + print_info(" - Third-party verification without trust assumptions") + print_info("") + print_info("Verification Process:") + print_info(" 1. Get the light block header proof for the target round") + print_info(" 2. Get the block header for that round") + print_info(" 3. Verify the proof against the state proof's vector commitment root") + print_info(" 4. Verify the state proof signature (signed by supermajority of stake)") + print_info(" 5. If all checks pass, the block header is cryptographically verified") + + +if __name__ == "__main__": + main() diff --git a/examples/algod_client/17_state_proof.py b/examples/algod_client/17_state_proof.py new file mode 100644 index 00000000..ccd674c8 --- /dev/null +++ b/examples/algod_client/17_state_proof.py @@ -0,0 +1,354 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: State Proof + +This example demonstrates how to get state proofs using: +- state_proof(round) - Get the state proof for a specific round + +State proofs are cryptographic proofs that attest to the state of the Algorand blockchain. +They allow external systems (like bridges, light clients, and other blockchains) to verify +Algorand's blockchain state without trusting any intermediary. + +Key concepts: +- State proofs are generated at regular intervals (every 256 rounds on MainNet) +- Each state proof covers a range of block headers (the interval) +- State proofs are signed by a supermajority of online stake +- The proof uses post-quantum secure cryptographic techniques (Falcon signatures) + +Prerequisites: +- LocalNet running (via `algokit localnet start`) + +Note: On LocalNet in dev mode, state proofs are NOT generated because: +1. Dev mode doesn't run real consensus +2. There are no real participation keys generating state proofs +This example demonstrates the API call and handles the expected errors gracefully. +""" + +from shared import ( + create_algod_client, + print_error, + print_header, + print_info, + print_step, + print_success, +) + +from algokit_algod_client.models import StateProof + + +def display_state_proof(proof: StateProof) -> None: + """Display details from a StateProof.""" + print_info(" StateProof fields:") + print_info("") + print_info(" message (StateProofMessage):") + + message = proof.message + first_attested = message.first_attested_round + print_info(f" first_attested_round: {first_attested:,}") + print_info(" First round covered by this state proof") + print_info("") + + last_attested = message.last_attested_round + print_info(f" last_attested_round: {last_attested:,}") + print_info(" Last round covered by this state proof") + print_info("") + + # Calculate interval size + interval_size = last_attested - first_attested + 1 + print_info(f" Interval size: {interval_size:,} rounds") + print_info("") + + block_headers_commitment = message.block_headers_commitment + if block_headers_commitment: + hex_str = block_headers_commitment.hex()[:64] + length = len(block_headers_commitment) + print_info(f" block_headers_commitment: {hex_str}...") + print_info(f" ({length} bytes)") + print_info(" Vector commitment root for all block headers in interval") + print_info("") + + voters_commitment = message.voters_commitment + if voters_commitment: + hex_str = voters_commitment.hex()[:64] + length = len(voters_commitment) + print_info(f" voters_commitment: {hex_str}...") + print_info(f" ({length} bytes)") + print_info(" Commitment to voters for the next state proof interval") + print_info("") + + ln_proven_weight = message.ln_proven_weight + print_info(f" ln_proven_weight: {ln_proven_weight:,}") + print_info(" Natural log of proven weight with 16-bit precision") + print_info(" Used to verify that supermajority of stake signed") + print_info("") + + state_proof_data = proof.state_proof + print_info(" state_proof (encoded proof):") + if state_proof_data and len(state_proof_data) > 0: + hex_str = state_proof_data.hex()[:64] + length = len(state_proof_data) + print_info(f" {hex_str}...") + print_info(f" ({length:,} bytes total)") + print_info(" Contains Falcon signatures and Merkle proofs") + else: + print_info(" (empty)") + print_info("") + + # Show which rounds this proof covers + print_info(" Coverage:") + print_info(f" This state proof attests to rounds {first_attested:,} to {last_attested:,}") + print_info(" Any block header in this range can be verified against block_headers_commitment") + print_info("") + + +def main() -> None: + print_header("State Proof Example") + + # Create clients + algod = create_algod_client() + + # ========================================================================= + # Step 1: Understand State Proofs + # ========================================================================= + print_step(1, "Understanding state proofs") + + print_info("What are State Proofs?") + print_info(" - Cryptographic proofs that attest to the state of the Algorand blockchain") + print_info(" - Allow external systems to verify Algorand state without trusting intermediaries") + print_info(" - Signed by a supermajority of online stake (using Falcon signatures)") + print_info(" - Use post-quantum secure cryptographic techniques") + print_info("") + print_info("How State Proofs Work:") + print_info(" 1. State proofs are generated at regular intervals (StateProofInterval)") + print_info(" 2. Each proof attests to a range of block headers") + print_info(" 3. The proof includes a vector commitment to all block headers in the interval") + print_info(" 4. A supermajority of stake signs the commitment") + print_info(" 5. The resulting proof can be verified without syncing the full blockchain") + print_info("") + + # ========================================================================= + # Step 2: Get current round and understand intervals + # ========================================================================= + print_step(2, "Getting current round and understanding state proof intervals") + + status = algod.status() + last_round = status.last_round + print_info(f"Current round: {last_round:,}") + print_info("") + + # State proof interval (256 rounds on MainNet) + state_proof_interval = 256 + print_info(f"State Proof Interval: {state_proof_interval:,} rounds") + print_info("") + + print_info("State Proof Interval Boundaries:") + print_info(" - State proofs are NOT generated for every round") + print_info(" - Only rounds that are multiples of the StateProofInterval have proofs") + print_info(" - The proof at round N attests to rounds [(N-1)*interval + 1, N*interval]") + print_info("") + + # Calculate which intervals we might find state proofs for + current_interval = last_round // state_proof_interval + print_info(f"Current interval number: ~{current_interval:,}") + print_info("") + + # Show example interval boundaries + example_proof_round = current_interval * state_proof_interval + interval_start = (current_interval - 1) * state_proof_interval + 1 + interval_end = current_interval * state_proof_interval + print_info(f"Example: If state proof exists for round {example_proof_round:,}:") + print_info(f" It would attest to rounds {interval_start:,} to {interval_end:,}") + print_info("") + + # ========================================================================= + # Step 3: Try to get state proof for current interval + # ========================================================================= + print_step(3, "Attempting to get state proof") + + # State proofs are available at interval boundaries + # Try the most recent complete interval + proof_round = current_interval * state_proof_interval + + print_info(f"Trying state_proof({proof_round:,})...") + print_info("") + + try: + proof: StateProof = algod.state_proof(proof_round) + print_success("Successfully retrieved state proof!") + print_info("") + display_state_proof(proof) + except Exception as e: + error_message = str(e) + + # Handle expected cases where state proof is not available + if "state proof" in error_message or "not found" in error_message or "404" in error_message: + print_info("State proof is not available for this round.") + print_info("This is expected behavior on LocalNet dev mode.") + print_info("") + print_info("Possible reasons:") + print_info(" 1. State proofs are not enabled on this network (LocalNet dev mode)") + print_info(" 2. The requested round is not a state proof interval boundary") + print_info(" 3. The state proof for this interval has not been generated yet") + print_info(" 4. The state proof has been pruned (old data)") + elif "501" in error_message or "not supported" in error_message or "Not Implemented" in error_message: + print_info("State proofs are not supported on this node.") + print_info("This feature requires a node with state proof support enabled.") + else: + print_error(f"Error: {error_message}") + print_info("") + + # ========================================================================= + # Step 4: Try multiple interval rounds to find available proofs + # ========================================================================= + print_step(4, "Scanning interval boundaries for available state proofs") + + print_info("Checking several interval boundaries to find available proofs...") + print_info("") + + # Try a range of interval boundaries + intervals_to_try = [ + state_proof_interval, # First possible interval (round 256) + state_proof_interval * 2, # Second interval (round 512) + state_proof_interval * 4, # Fourth interval (round 1024) + (current_interval - 2) * state_proof_interval, # 2 intervals ago + (current_interval - 1) * state_proof_interval, # 1 interval ago + current_interval * state_proof_interval, # Current interval + ] + # Filter to valid rounds + intervals_to_try = [r for r in intervals_to_try if r > 0 and r <= last_round] + + found_proof = False + for block_round in intervals_to_try: + try: + proof = algod.state_proof(block_round) + print_success(f"Found state proof for round {block_round:,}!") + display_state_proof(proof) + found_proof = True + break + except Exception: + print_info(f"Round {block_round:,}: No state proof available") + + if not found_proof: + print_info("") + print_info("No state proofs found for any tested round.") + print_info("This is expected on LocalNet in dev mode where state proofs are not generated.") + print_info("") + + # ========================================================================= + # Step 5: Demonstrate which rounds have state proofs + # ========================================================================= + print_step(5, "Understanding which rounds have state proofs") + + print_info("State proofs are only generated at specific rounds:") + print_info("") + print_info(" Round 256 -> First state proof (attests to rounds 1-256)") + print_info(" Round 512 -> Second state proof (attests to rounds 257-512)") + print_info(" Round 768 -> Third state proof (attests to rounds 513-768)") + print_info(" ...") + print_info(" Round N*256 -> Attests to rounds [(N-1)*256 + 1, N*256]") + print_info("") + + print_info("Rounds that do NOT have state proofs (examples):") + print_info(" Round 1, 2, 3, ... 255 -> Part of first interval, no individual proofs") + print_info(" Round 257, 300, 400 -> Part of second interval, no individual proofs") + print_info(" Round 100, 500, 1000 -> Not interval boundaries") + print_info("") + + # ========================================================================= + # Step 6: Error handling for invalid rounds + # ========================================================================= + print_step(6, "Demonstrating error handling for invalid rounds") + + print_info("Testing error handling for various round scenarios:") + print_info("") + + # Try a non-interval round (should fail) + non_interval_round = state_proof_interval + 1 + print_info(f" Non-interval round ({non_interval_round:,}):") + try: + algod.state_proof(non_interval_round) + print_info(" Unexpectedly succeeded") + except Exception as e: + error_message = str(e) + truncated = error_message[:80] + suffix = "..." if len(error_message) > 80 else "" + print_info(f" Error (expected): {truncated}{suffix}") + print_info("") + + # Try a future round + future_round = (last_round // state_proof_interval + 10) * state_proof_interval + print_info(f" Future round ({future_round:,}):") + try: + algod.state_proof(future_round) + print_info(" Unexpectedly succeeded") + except Exception as e: + error_message = str(e) + truncated = error_message[:80] + suffix = "..." if len(error_message) > 80 else "" + print_info(f" Error (expected): {truncated}{suffix}") + print_info("") + + # Try round 0 (invalid - no state proof for genesis) + print_info(" Round 0 (invalid):") + try: + algod.state_proof(0) + print_info(" Unexpectedly succeeded") + except Exception as e: + error_message = str(e) + truncated = error_message[:80] + suffix = "..." if len(error_message) > 80 else "" + print_info(f" Error (expected): {truncated}{suffix}") + print_info("") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + + print_info("State Proofs - Key Points:") + print_info("") + print_info("1. What They Are:") + print_info(" - Cryptographic proofs of Algorand blockchain state") + print_info(" - Allow trustless verification by external systems") + print_info(" - Signed by supermajority of online stake (~3+ billion ALGO)") + print_info(" - Use post-quantum secure Falcon signatures") + print_info("") + print_info("2. When They're Generated:") + print_info(" - Every StateProofInterval rounds (256 on MainNet)") + print_info(" - NOT generated for every round") + print_info(" - Only at interval boundary rounds (256, 512, 768, ...)") + print_info("") + print_info("3. StateProof Type Structure:") + print_info(" message: StateProofMessage") + print_info(" - block_headers_commitment: bytes - Vector commitment to block headers") + print_info(" - voters_commitment: bytes - Commitment to voters for next proof") + print_info(" - ln_proven_weight: int - Log of proven weight (16-bit precision)") + print_info(" - first_attested_round: int - First round in the interval") + print_info(" - last_attested_round: int - Last round in the interval") + print_info(" state_proof: bytes - The encoded cryptographic proof") + print_info("") + print_info("4. API Method:") + print_info(" state_proof(round_: int) -> StateProof") + print_info(" - round_ must be a state proof interval boundary") + print_info("") + print_info("5. Use Cases:") + print_info(" - Cross-chain bridges: Verify Algorand state on other chains") + print_info(" - Light clients: Verify state without full node sync") + print_info(" - Trustless verification: No intermediary needed") + print_info(" - Interoperability: Connect Algorand to other ecosystems") + print_info("") + print_info("6. Availability:") + print_info(" - MainNet/TestNet: Available at interval boundaries") + print_info(" - LocalNet dev mode: NOT available (no real consensus)") + print_info(" - Archive nodes: Historical state proofs may be available") + print_info("") + print_info("7. Verification Process:") + print_info(" 1. Get the state proof for an interval boundary") + print_info(" 2. Verify the Falcon signatures against known voters") + print_info(" 3. Check that proven weight represents supermajority") + print_info(" 4. Use block_headers_commitment to verify individual block headers") + print_info(" 5. Chain state proofs together for long-range verification") + + +if __name__ == "__main__": + main() diff --git a/examples/algod_client/18_devmode_timestamp.py b/examples/algod_client/18_devmode_timestamp.py new file mode 100644 index 00000000..a98c20b4 --- /dev/null +++ b/examples/algod_client/18_devmode_timestamp.py @@ -0,0 +1,349 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: DevMode Timestamp Offset + +This example demonstrates how to manage block timestamp offset in DevMode using: +- block_time_stamp_offset() - Get the current timestamp offset +- set_block_time_stamp_offset(offset) - Set a new timestamp offset + +In DevMode, you can control the timestamp of blocks by setting an offset. +This is useful for testing time-dependent smart contracts without waiting +for real time to pass. + +Key concepts: +- Timestamp offset is in seconds +- Setting offset to 0 resets to using the real clock +- New blocks will have timestamps = realTime + offset +- These endpoints only work on DevMode nodes (LocalNet in dev mode) + +Prerequisites: +- LocalNet running in dev mode (via `algokit localnet start`) + +Note: These endpoints return HTTP 404 if not running on a DevMode node. +""" + +import time +from datetime import datetime, timezone + +from shared import ( + create_algod_client, + create_algorand_client, + get_funded_account, + print_error, + print_header, + print_info, + print_step, + print_success, +) + +from algokit_algod_client.models import BlockResponse, GetBlockTimeStampOffsetResponse +from algokit_utils import AlgoAmount, PaymentParams + + +def display_timestamp_offset(response: GetBlockTimeStampOffsetResponse) -> None: + """Display the timestamp offset information.""" + print_info(" GetBlockTimeStampOffsetResponse:") + offset = response.offset + print_info(f" offset: {offset} seconds") + + if offset == 0: + print_info(" (Using real clock - no offset applied)") + elif offset > 0: + hours = offset // 3600 + minutes = (offset % 3600) // 60 + seconds = offset % 60 + print_info(f" ({hours}h {minutes}m {seconds}s in the future)") + else: + abs_offset = abs(offset) + hours = abs_offset // 3600 + minutes = (abs_offset % 3600) // 60 + seconds = abs_offset % 60 + print_info(f" ({hours}h {minutes}m {seconds}s in the past)") + print_info("") + + +def main() -> None: + print_header("DevMode Timestamp Offset Example") + + # Create clients + algod = create_algod_client() + algorand = create_algorand_client() + + # Check if we're running on DevMode + print_step(1, "Checking if running on DevMode") + + # On DevMode, block_time_stamp_offset() returns 404 when offset was never set. + # We detect DevMode by checking the error message - "block timestamp offset was never set" + # means DevMode is active but no offset is set (default behavior). + # A different 404 error means the node is not running DevMode. + is_devmode = False + offset_never_set = False + + try: + algod.block_time_stamp_offset() + is_devmode = True + print_success("Running on DevMode - timestamp offset endpoints are available") + except Exception as e: + error_message = str(e) + + # Check if this is the "never set" message - this means DevMode IS running + if "block timestamp offset was never set" in error_message: + is_devmode = True + offset_never_set = True + print_success("Running on DevMode - timestamp offset was never set (using real clock)") + print_info("The block_time_stamp_offset() endpoint returns 404 when offset was never set.") + print_info("Setting an offset to 0 will initialize it.") + elif "404" in error_message or "not found" in error_message.lower() or "Not Found" in error_message: + print_error("Not running on DevMode - timestamp offset endpoints are not available") + print_info("These endpoints only work on LocalNet in dev mode.") + print_info("Start LocalNet with: algokit localnet start") + print_info("") + print_header("Summary") + print_info("DevMode Timestamp Offset endpoints require a DevMode node.") + print_info("On non-DevMode nodes, these endpoints return HTTP 404.") + return + else: + raise + print_info("") + + if not is_devmode: + return + + # If offset was never set, initialize it by setting to 0 + if offset_never_set: + print_info("Initializing timestamp offset by setting it to 0...") + algod.set_block_time_stamp_offset(0) + print_success("Timestamp offset initialized to 0") + print_info("") + + # ========================================================================= + # Step 2: Get the current timestamp offset + # ========================================================================= + print_step(2, "Getting current timestamp offset") + + initial_offset = algod.block_time_stamp_offset() + display_timestamp_offset(initial_offset) + + # ========================================================================= + # Step 3: Get a baseline block timestamp + # ========================================================================= + print_step(3, "Getting baseline block timestamp") + + # Get the current time for comparison + real_time_now = int(time.time()) + print_info(f"Real time (system clock): {real_time_now}") + print_info(f"Real time (formatted): {datetime.fromtimestamp(real_time_now, tz=timezone.utc).isoformat()}") + print_info("") + + # Trigger a new block to see the current block timestamp + # We use a self-payment (send to self) to trigger a block without minimum balance issues + sender = get_funded_account(algorand) + + print_info("Submitting a transaction to trigger a new block...") + result1 = algorand.send.payment( + PaymentParams( + sender=str(sender.addr), + receiver=str(sender.addr), # Self-payment to trigger block + amount=AlgoAmount.from_micro_algo(0), + note=b"baseline-block", + ) + ) + + # Get the block to see its timestamp + confirmed_round1 = result1.confirmation.confirmed_round or 0 + block1: BlockResponse = algod.block(confirmed_round1) + baseline_timestamp = block1.block.header.timestamp + print_success(f"Block {confirmed_round1} created") + print_info(f"Block timestamp: {baseline_timestamp}") + baseline_dt = datetime.fromtimestamp(baseline_timestamp, tz=timezone.utc).isoformat() + print_info(f"Block timestamp (formatted): {baseline_dt}") + print_info("") + + # ========================================================================= + # Step 4: Set a timestamp offset + # ========================================================================= + print_step(4, "Setting a timestamp offset") + + # Set offset to 1 hour (3600 seconds) in the future + one_hour_in_seconds = 3600 + print_info(f"Setting timestamp offset to {one_hour_in_seconds} seconds (1 hour in the future)...") + + try: + algod.set_block_time_stamp_offset(one_hour_in_seconds) + print_success(f"Timestamp offset set to {one_hour_in_seconds} seconds") + except Exception as e: + error_message = str(e) + print_error(f"Failed to set timestamp offset: {error_message}") + return + print_info("") + + # Verify the offset was set + new_offset = algod.block_time_stamp_offset() + print_info("Verifying the offset was set:") + display_timestamp_offset(new_offset) + + # ========================================================================= + # Step 5: See how timestamp offset affects block timestamps + # ========================================================================= + print_step(5, "Observing the effect on block timestamps") + + print_info("Submitting another transaction to trigger a new block with the offset applied...") + result2 = algorand.send.payment( + PaymentParams( + sender=str(sender.addr), + receiver=str(sender.addr), # Self-payment to trigger block + amount=AlgoAmount.from_micro_algo(0), + note=b"offset-block-1h", + ) + ) + + # Get the new block's timestamp + confirmed_round2 = result2.confirmation.confirmed_round or 0 + block2: BlockResponse = algod.block(confirmed_round2) + offset_timestamp = block2.block.header.timestamp + print_success(f"Block {confirmed_round2} created") + print_info("") + + # Compare timestamps + print_info("Comparing block timestamps:") + print_info(f" Baseline block (round {confirmed_round1}):") + print_info(f" Timestamp: {baseline_timestamp}") + print_info(f" Formatted: {datetime.fromtimestamp(baseline_timestamp, tz=timezone.utc).isoformat()}") + print_info("") + print_info(f" Offset block (round {confirmed_round2}):") + print_info(f" Timestamp: {offset_timestamp}") + print_info(f" Formatted: {datetime.fromtimestamp(offset_timestamp, tz=timezone.utc).isoformat()}") + print_info("") + + # Calculate actual difference + time_diff = offset_timestamp - baseline_timestamp + print_info(f"Time difference between blocks: {time_diff} seconds") + print_info(f"Expected offset: {one_hour_in_seconds} seconds") + print_info("") + + # Note: The actual difference may not exactly match the offset due to real time passing + # between the two transactions, but it should be close to the offset value + if one_hour_in_seconds - 10 <= time_diff <= one_hour_in_seconds + 60: + print_success("Block timestamp reflects the offset (within expected margin)") + else: + print_info("Note: Actual time difference may vary due to real time elapsed between transactions") + print_info("") + + # ========================================================================= + # Step 6: Test with different offset values + # ========================================================================= + print_step(6, "Testing different offset values") + + # Try setting a larger offset (1 day = 86400 seconds) + one_day_in_seconds = 86400 + print_info(f"Setting timestamp offset to {one_day_in_seconds} seconds (1 day in the future)...") + algod.set_block_time_stamp_offset(one_day_in_seconds) + + day_offset = algod.block_time_stamp_offset() + print_success(f"Timestamp offset set to {day_offset.offset} seconds") + print_info("") + + # Trigger another block + print_info("Creating a block with 1-day offset...") + result3 = algorand.send.payment( + PaymentParams( + sender=str(sender.addr), + receiver=str(sender.addr), # Self-payment to trigger block + amount=AlgoAmount.from_micro_algo(0), + note=b"offset-block-1d", + ) + ) + + confirmed_round3 = result3.confirmation.confirmed_round or 0 + block3: BlockResponse = algod.block(confirmed_round3) + future_day_timestamp = block3.block.header.timestamp + future_datetime = datetime.fromtimestamp(future_day_timestamp, tz=timezone.utc).isoformat() + print_info(f" Block {confirmed_round3} timestamp: {future_datetime}") + print_info("") + + # ========================================================================= + # Step 7: Reset the offset to 0 + # ========================================================================= + print_step(7, "Resetting the timestamp offset to 0") + + print_info("Setting timestamp offset back to 0 (real clock)...") + algod.set_block_time_stamp_offset(0) + + reset_offset = algod.block_time_stamp_offset() + print_success("Timestamp offset reset to 0") + display_timestamp_offset(reset_offset) + + # Verify by creating another block + print_info("Creating a block with real clock timestamp...") + result4 = algorand.send.payment( + PaymentParams( + sender=str(sender.addr), + receiver=str(sender.addr), # Self-payment to trigger block + amount=AlgoAmount.from_micro_algo(0), + note=b"reset-block", + ) + ) + + confirmed_round4 = result4.confirmation.confirmed_round or 0 + block4: BlockResponse = algod.block(confirmed_round4) + real_timestamp = block4.block.header.timestamp + current_real_time = int(time.time()) + block4_datetime = datetime.fromtimestamp(real_timestamp, tz=timezone.utc).isoformat() + current_datetime = datetime.fromtimestamp(current_real_time, tz=timezone.utc).isoformat() + print_info(f" Block {confirmed_round4} timestamp: {block4_datetime}") + print_info(f" Current real time: {current_datetime}") + + diff_from_real = abs(real_timestamp - current_real_time) + if diff_from_real < 60: + print_success("Block timestamp is back to real time (within 60 seconds)") + else: + print_info(f"Block timestamp differs from real time by {diff_from_real} seconds") + print_info("") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + + print_info("DevMode Timestamp Offset - Key Points:") + print_info("") + print_info("1. What It Does:") + print_info(" - Allows you to control block timestamps in DevMode") + print_info(" - Useful for testing time-dependent smart contracts") + print_info(" - New blocks will have timestamps = realTime + offset") + print_info("") + print_info("2. API Methods:") + print_info(" block_time_stamp_offset() -> GetBlockTimeStampOffsetResponse") + print_info(" - Returns dataclass with .offset attribute (int, seconds)") + print_info("") + print_info(" set_block_time_stamp_offset(offset: int) -> None") + print_info(" - Sets the timestamp offset in seconds") + print_info(" - offset = 0 resets to using real clock") + print_info("") + print_info("3. GetBlockTimeStampOffsetResponse:") + print_info(" @dataclass") + print_info(" offset: int # Timestamp offset in seconds") + print_info("") + print_info("4. Use Cases:") + print_info(" - Testing time-locked smart contracts") + print_info(" - Simulating future block timestamps") + print_info(" - Testing vesting schedules") + print_info(" - Testing auction end times") + print_info(" - Any time-dependent logic verification") + print_info("") + print_info("5. Important Notes:") + print_info(" - Only works on DevMode nodes (LocalNet in dev mode)") + print_info(" - Returns HTTP 404 on non-DevMode nodes") + print_info(" - Offset is in seconds (not milliseconds)") + print_info(" - Always reset offset to 0 after testing") + print_info(" - The offset affects ALL new blocks until changed") + print_info("") + print_info("6. Best Practices:") + print_info(" - Always check if DevMode is available before using") + print_info(" - Reset offset to 0 in cleanup/finally blocks") + print_info(" - Document time-sensitive test assumptions") + print_info(" - Use try/finally to ensure cleanup happens") + + +if __name__ == "__main__": + main() diff --git a/examples/algod_client/19_sync_round.py b/examples/algod_client/19_sync_round.py new file mode 100644 index 00000000..c6bbbc94 --- /dev/null +++ b/examples/algod_client/19_sync_round.py @@ -0,0 +1,297 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Sync Round Management + +This example demonstrates how to manage the sync round using: +- sync_round() - Get the minimum sync round the ledger will cache +- set_sync_round(round) - Set the minimum sync round +- unset_sync_round() - Unset/reset the sync round + +What is the sync round? +The sync round is a configuration that controls the minimum round the node +will keep data for. When set, the node will: +- Only keep block data from this round onwards +- Allow old block data to be deleted/pruned +- Reduce storage requirements for archival data + +This is useful for: +- Nodes that only need recent data (not full archival history) +- Indexers that only need data from a specific point forward +- Applications that don't need ancient historical data + +Key concepts: +- sync_round() returns GetSyncRoundResponse with round_ attribute +- set_sync_round(round) sets the minimum round to keep +- unset_sync_round() removes the sync round restriction +- Historical data below the sync round may be unavailable + +Prerequisites: +- LocalNet running (via `algokit localnet start`) + +Note: On some nodes, these endpoints may require admin privileges +or return errors if the feature is not supported. +""" + +from shared import ( + create_algod_client, + print_error, + print_header, + print_info, + print_step, + print_success, +) + +from algokit_algod_client.models import GetSyncRoundResponse + + +def display_sync_round_response(response: GetSyncRoundResponse) -> None: + """Display the sync round response information.""" + print_info(" GetSyncRoundResponse:") + print_info(f" round: {response.round_}") + print_info("") + + +def main() -> None: + print_header("Sync Round Management Example") + + # Create algod client + algod = create_algod_client() + + # ========================================================================= + # Step 1: Get the current node status to understand the blockchain state + # ========================================================================= + print_step(1, "Getting current node status") + + status = algod.status() + current_round = status.last_round + catchup_time = status.catchup_time + print_success("Connected to node") + print_info(f" Current round: {current_round}") + print_info(f" Catchup time: {catchup_time} ns") + print_info("") + + # ========================================================================= + # Step 2: Get the current sync round (if any) + # ========================================================================= + print_step(2, "Getting current sync round") + + print_info("Calling sync_round() to get the minimum sync round...") + + try: + sync_round_response = algod.sync_round() + display_sync_round_response(sync_round_response) + + print_info(f"The node will keep data from round {sync_round_response.round_} onwards") + print_info("Data below this round may be pruned or unavailable") + except Exception as e: + error_message = str(e) + + # Check for various error scenarios + if "404" in error_message or "not found" in error_message.lower() or "Not Found" in error_message: + print_info("Sync round is not set - node will keep all historical data") + print_info("This is the default behavior for archival nodes") + elif "501" in error_message or "not implemented" in error_message.lower(): + print_error("Sync round endpoints are not supported on this node") + print_info("These endpoints may require specific node configuration") + elif "403" in error_message or "forbidden" in error_message.lower() or "Forbidden" in error_message: + print_error("Access denied - admin privileges may be required") + print_info("Some nodes restrict sync round management to admin tokens") + else: + # Display error but continue with the example + print_error(f"Error getting sync round: {error_message}") + print_info("") + + # ========================================================================= + # Step 3: Set a sync round + # ========================================================================= + print_step(3, "Setting a sync round") + + # We'll set the sync round to a recent round to demonstrate the API + # In practice, you'd set this to the oldest round you need data for + target_sync_round = current_round - 10 if current_round > 10 else 1 + print_info(f"Attempting to set sync round to {target_sync_round}...") + print_info("This tells the node to keep data from this round onwards") + + try: + algod.set_sync_round(target_sync_round) + print_success(f"Sync round set to {target_sync_round}") + + # Verify the sync round was set + try: + verify_response = algod.sync_round() + print_info(f"Verified: sync round is now {verify_response.round_}") + except Exception: + print_info("Could not verify - sync_round() may not be available") + except Exception as e: + error_message = str(e) + + if "404" in error_message or "not found" in error_message.lower(): + print_error("set_sync_round endpoint not found") + print_info("This endpoint may not be available on this node configuration") + elif "501" in error_message or "not implemented" in error_message.lower(): + print_error("set_sync_round is not implemented on this node") + print_info("Sync round management may require specific node features to be enabled") + elif "403" in error_message or "forbidden" in error_message.lower(): + print_error("Access denied when setting sync round") + print_info("Admin token may be required to modify sync round") + elif "400" in error_message or "bad request" in error_message.lower(): + print_error("Invalid sync round value") + print_info("The sync round must be a valid round number") + else: + print_error(f"Failed to set sync round: {error_message}") + print_info("") + + # ========================================================================= + # Step 4: Explain the impact of sync round on data availability + # ========================================================================= + print_step(4, "Understanding sync round impact on data availability") + + print_info("When a sync round is set:") + print_info("") + print_info("1. Block Data Access:") + print_info(" - Blocks at or after the sync round: Available") + print_info(" - Blocks before the sync round: May be unavailable (pruned)") + print_info("") + print_info("2. Account Information:") + print_info(" - Current state: Always available") + print_info(" - Historical state at old rounds: May be unavailable") + print_info("") + print_info("3. Transaction History:") + print_info(" - Transactions in recent blocks: Available") + print_info(" - Transactions in pruned blocks: Not available") + print_info("") + print_info("4. State Proofs & Deltas:") + print_info(" - Only available for rounds at or after sync round") + print_info("") + + # Demonstrate that recent data is accessible + print_info("Verifying recent block data is accessible...") + try: + block = algod.block(current_round) + timestamp = block.block.header.timestamp + print_success(f"Block {current_round} is accessible (timestamp: {timestamp})") + except Exception as e: + error_message = str(e) + print_error(f"Could not access block {current_round}: {error_message}") + print_info("") + + # ========================================================================= + # Step 5: Demonstrate unset_sync_round + # ========================================================================= + print_step(5, "Unsetting the sync round") + + print_info("Calling unset_sync_round() to remove the sync round restriction...") + print_info("After unsetting, the node will keep all data (archival mode)") + + try: + algod.unset_sync_round() + print_success("Sync round has been unset") + + # Verify it was unset + try: + check_response = algod.sync_round() + # If this succeeds, a sync round is still set + print_info(f"Note: sync_round still returns {check_response.round_}") + print_info("On some nodes, unset may set a default value rather than fully removing it") + except Exception as check_error: + check_message = str(check_error) + if "404" in check_message or "not found" in check_message.lower(): + print_success("Confirmed: sync round is now unset (404 response)") + print_info("Node is in archival mode - keeping all historical data") + else: + print_info(f"Sync round status unclear: {check_message}") + except Exception as e: + error_message = str(e) + + if "404" in error_message or "not found" in error_message.lower(): + print_info("unset_sync_round returned 404 - sync round may already be unset") + elif "501" in error_message or "not implemented" in error_message.lower(): + print_error("unset_sync_round is not implemented on this node") + elif "403" in error_message or "forbidden" in error_message.lower(): + print_error("Access denied when unsetting sync round") + print_info("Admin privileges may be required") + else: + print_error(f"Failed to unset sync round: {error_message}") + print_info("") + + # ========================================================================= + # Step 6: Best practices for sync round management + # ========================================================================= + print_step(6, "Best practices and use cases") + + print_info("When to use sync round:") + print_info("") + print_info("1. Non-Archival Nodes:") + print_info(" - Set sync round to reduce storage requirements") + print_info(" - Only keep data needed for current operations") + print_info("") + print_info("2. Indexer Deployment:") + print_info(" - Set sync round to the indexer's starting point") + print_info(" - Prevents the node from being queried for data it doesn't need") + print_info("") + print_info("3. Fresh Sync from Snapshot:") + print_info(" - After restoring from a snapshot, set sync round to snapshot round") + print_info(" - Tells the node not to try fetching older data") + print_info("") + print_info("When NOT to use sync round:") + print_info("") + print_info("1. Archival Nodes:") + print_info(" - Don't set sync round if you need full history") + print_info(" - Archival nodes should keep all data") + print_info("") + print_info("2. Block Explorers:") + print_info(" - Need historical data for user queries") + print_info(" - Should maintain full history") + print_info("") + print_info("3. Audit/Compliance:") + print_info(" - Regulatory requirements may mandate full history") + print_info("") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + + print_info("Sync Round Management - Key Points:") + print_info("") + print_info("1. What It Does:") + print_info(" - Controls the minimum round the node keeps data for") + print_info(" - Allows pruning of old block data") + print_info(" - Reduces storage requirements for non-archival nodes") + print_info("") + print_info("2. API Methods:") + print_info(" sync_round() -> GetSyncRoundResponse") + print_info(" - Returns GetSyncRoundResponse with round_ attribute") + print_info(" - Returns 404 if no sync round is set (archival mode)") + print_info("") + print_info(" set_sync_round(round_: int) -> None") + print_info(" - Sets the minimum sync round") + print_info(" - Data below this round may be pruned") + print_info("") + print_info(" unset_sync_round() -> None") + print_info(" - Removes the sync round restriction") + print_info(" - Returns node to archival mode") + print_info("") + print_info("3. GetSyncRoundResponse:") + print_info(" round_: int # Minimum sync round (underscore to avoid Python builtin)") + print_info("") + print_info("4. Data Availability Impact:") + print_info(" - Blocks before sync round: May be unavailable") + print_info(" - Account history at old rounds: May be unavailable") + print_info(" - Current state: Always available") + print_info(" - Recent transactions: Available") + print_info("") + print_info("5. Error Scenarios:") + print_info(" - 404: Sync round not set (archival mode)") + print_info(" - 403: Admin privileges required") + print_info(" - 501: Feature not implemented on this node") + print_info("") + print_info("6. Best Practices:") + print_info(" - Only set sync round if you don't need full history") + print_info(" - Consider storage vs. data availability tradeoffs") + print_info(" - Archival nodes should not set a sync round") + print_info(" - Document your sync round configuration") + + +if __name__ == "__main__": + main() diff --git a/examples/algod_client/verify-all.sh b/examples/algod_client/verify-all.sh new file mode 100755 index 00000000..2a294c09 --- /dev/null +++ b/examples/algod_client/verify-all.sh @@ -0,0 +1,91 @@ +#!/bin/bash + +# verify-all.sh - Run all algod_client examples and verify they work +# Exit with non-zero code if any example fails + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +cd "$SCRIPT_DIR" + +# Array of example files in order +EXAMPLES=( + "01_node_health_status.py" + "02_version_genesis.py" + "03_ledger_supply.py" + "04_account_info.py" + "05_transaction_params.py" + "06_send_transaction.py" + "07_pending_transactions.py" + "08_block_data.py" + "09_asset_info.py" + "10_application_info.py" + "11_application_boxes.py" + "12_teal_compile.py" + "13_simulation.py" + "14_state_deltas.py" + "15_transaction_proof.py" + "16_lightblock_proof.py" + "17_state_proof.py" + "18_devmode_timestamp.py" + "19_sync_round.py" +) + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +NC='\033[0m' # No Color + +echo "========================================" +echo "Algod Client Examples Verification Script" +echo "========================================" +echo "" + +if [ ${#EXAMPLES[@]} -eq 0 ]; then + echo "No examples to run yet." + echo "" + echo -e "${GREEN}Algod Client examples suite passed (no examples)${NC}" + exit 0 +fi + +PASSED=0 +FAILED=0 +FAILED_EXAMPLES=() + +for example in "${EXAMPLES[@]}"; do + echo -n "Running $example... " + + if [ ! -f "$example" ]; then + echo -e "${RED}FAILED${NC} (file not found)" + FAILED=$((FAILED + 1)) + FAILED_EXAMPLES+=("$example") + continue + fi + + # Run the example and capture output/exit code + if OUTPUT=$(uv run python "$example" 2>&1); then + echo -e "${GREEN}PASSED${NC}" + PASSED=$((PASSED + 1)) + else + echo -e "${RED}FAILED${NC}" + echo "$OUTPUT" + FAILED=$((FAILED + 1)) + FAILED_EXAMPLES+=("$example") + fi +done + +echo "" +echo "========================================" +echo "Results: ${PASSED} passed, ${FAILED} failed" +echo "========================================" + +if [ $FAILED -gt 0 ]; then + echo "" + echo -e "${RED}Failed examples:${NC}" + for failed in "${FAILED_EXAMPLES[@]}"; do + echo " - $failed" + done + exit 1 +fi + +echo "" +echo -e "${GREEN}All Algod Client examples passed!${NC}" +exit 0 diff --git a/examples/algorand_client/01_client_instantiation.py b/examples/algorand_client/01_client_instantiation.py new file mode 100644 index 00000000..0e77754c --- /dev/null +++ b/examples/algorand_client/01_client_instantiation.py @@ -0,0 +1,297 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Client Instantiation + +This example demonstrates the different ways to create an AlgorandClient instance: +- AlgorandClient.default_localnet() for local development +- AlgorandClient.testnet() for TestNet connection +- AlgorandClient.mainnet() for MainNet connection +- AlgorandClient.from_environment() reading from environment variables +- AlgorandClient.from_config() with explicit AlgoConfig object +- AlgorandClient.from_clients() with pre-configured algod/indexer/kmd clients +- Verifying connection by calling algod.status() + +LocalNet required to verify connection works +""" + +import os + +from shared import ( + print_error, + print_header, + print_info, + print_step, + print_success, +) +from shared.constants import ( + ALGOD_PORT, + ALGOD_SERVER, + ALGOD_TOKEN, + INDEXER_PORT, + INDEXER_SERVER, + INDEXER_TOKEN, + KMD_PORT, + KMD_SERVER, + KMD_TOKEN, +) + +from algokit_algod_client import AlgodClient +from algokit_algod_client.config import ClientConfig as AlgodConfig +from algokit_indexer_client import IndexerClient +from algokit_indexer_client.config import ClientConfig as IndexerConfig +from algokit_kmd_client import KmdClient +from algokit_kmd_client.config import ClientConfig as KmdConfig +from algokit_utils import AlgorandClient +from algokit_utils.models.network import AlgoClientNetworkConfig + + +def main() -> None: + print_header("AlgorandClient Instantiation Example") + + # Step 1: AlgorandClient.default_localnet() + print_step(1, "Create client using default_localnet()") + print_info("AlgorandClient.default_localnet() creates a client pointing at default LocalNet ports") + print_info(" - Algod: http://localhost:4001") + print_info(" - Indexer: http://localhost:8980") + print_info(" - KMD: http://localhost:4002") + + localnet_client = AlgorandClient.default_localnet() + print_success("Created AlgorandClient for LocalNet") + + # Verify connection works + try: + status = localnet_client.client.algod.status() + last_round = status.last_round + print_success(f"Connected to LocalNet - Last round: {last_round}") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 2: AlgorandClient.testnet() + print_step(2, "Create client using testnet()") + print_info("AlgorandClient.testnet() creates a client pointing at TestNet using AlgoNode") + print_info(" - Algod: https://testnet-api.algonode.cloud") + print_info(" - Indexer: https://testnet-idx.algonode.cloud") + print_info(" - KMD: not available on public networks") + + testnet_client = AlgorandClient.testnet() + print_success("Created AlgorandClient for TestNet") + + # Verify TestNet connection + try: + testnet_status = testnet_client.client.algod.status() + testnet_last_round = testnet_status.last_round + print_success(f"Connected to TestNet - Last round: {testnet_last_round}") + except Exception as e: + print_error(f"Failed to connect to TestNet: {e}") + + # Step 3: AlgorandClient.mainnet() + print_step(3, "Create client using mainnet()") + print_info("AlgorandClient.mainnet() creates a client pointing at MainNet using AlgoNode") + print_info(" - Algod: https://mainnet-api.algonode.cloud") + print_info(" - Indexer: https://mainnet-idx.algonode.cloud") + print_info(" - KMD: not available on public networks") + + mainnet_client = AlgorandClient.mainnet() + print_success("Created AlgorandClient for MainNet") + + # Verify MainNet connection + try: + mainnet_status = mainnet_client.client.algod.status() + mainnet_last_round = mainnet_status.last_round + print_success(f"Connected to MainNet - Last round: {mainnet_last_round}") + except Exception as e: + print_error(f"Failed to connect to MainNet: {e}") + + # Step 4: AlgorandClient.from_environment() + print_step(4, "Create client using from_environment()") + print_info("AlgorandClient.from_environment() reads configuration from environment variables:") + print_info(" - ALGOD_SERVER, ALGOD_PORT, ALGOD_TOKEN (for Algod)") + print_info(" - INDEXER_SERVER, INDEXER_PORT, INDEXER_TOKEN (for Indexer)") + print_info(" - KMD_PORT (for KMD, uses ALGOD_SERVER as base)") + print_info("If environment variables are not set, defaults to LocalNet configuration") + + # Display current environment variable status + print_info("") + print_info("Current environment variable status:") + algod_server_env = os.environ.get("ALGOD_SERVER", "(not set - will use LocalNet default)") + print_info(f" ALGOD_SERVER: {algod_server_env}") + algod_port_env = os.environ.get("ALGOD_PORT", "(not set - will use default)") + print_info(f" ALGOD_PORT: {algod_port_env}") + algod_token_set = "(set)" if os.environ.get("ALGOD_TOKEN") else "(not set - will use default)" + print_info(f" ALGOD_TOKEN: {algod_token_set}") + indexer_server_env = os.environ.get("INDEXER_SERVER", "(not set - will use LocalNet default)") + print_info(f" INDEXER_SERVER: {indexer_server_env}") + indexer_port_env = os.environ.get("INDEXER_PORT", "(not set - will use default)") + print_info(f" INDEXER_PORT: {indexer_port_env}") + indexer_token_set = "(set)" if os.environ.get("INDEXER_TOKEN") else "(not set - will use default)" + print_info(f" INDEXER_TOKEN: {indexer_token_set}") + + env_client = AlgorandClient.from_environment() + print_success("Created AlgorandClient from environment") + + # Verify connection (should work since it falls back to LocalNet) + try: + env_status = env_client.client.algod.status() + env_last_round = env_status.last_round + print_success(f"Connected via from_environment() - Last round: {env_last_round}") + except Exception as e: + print_error(f"Failed to connect: {e}") + + # Step 5: AlgorandClient.from_config() + print_step(5, "Create client using from_config()") + print_info("AlgorandClient.from_config() accepts an explicit AlgoConfig object") + print_info("This gives you full control over the client configuration") + + algod_config = AlgoClientNetworkConfig( + server=ALGOD_SERVER, + port=ALGOD_PORT, + token=ALGOD_TOKEN, + ) + indexer_config = AlgoClientNetworkConfig( + server=INDEXER_SERVER, + port=INDEXER_PORT, + token=INDEXER_TOKEN, + ) + kmd_config = AlgoClientNetworkConfig( + server=KMD_SERVER, + port=KMD_PORT, + token=KMD_TOKEN, + ) + + print_info("") + print_info("Using custom configuration:") + print_info(f" algodConfig: {{ server: '{algod_config.server}', port: {algod_config.port} }}") + print_info(f" indexerConfig: {{ server: '{indexer_config.server}', port: {indexer_config.port} }}") + print_info(f" kmdConfig: {{ server: '{kmd_config.server}', port: {kmd_config.port} }}") + + config_client = AlgorandClient.from_config( + algod_config=algod_config, + indexer_config=indexer_config, + kmd_config=kmd_config, + ) + print_success("Created AlgorandClient from config") + + # Verify connection + try: + config_status = config_client.client.algod.status() + config_last_round = config_status.last_round + print_success(f"Connected via from_config() - Last round: {config_last_round}") + except Exception as e: + print_error(f"Failed to connect: {e}") + + # Step 6: AlgorandClient.from_clients() + print_step(6, "Create client using from_clients()") + print_info("AlgorandClient.from_clients() accepts pre-configured client instances") + print_info("Useful when you need custom client configuration or already have clients") + + # Create individual clients + algod_client = AlgodClient( + AlgodConfig( + base_url=f"{ALGOD_SERVER}:{ALGOD_PORT}", + token=ALGOD_TOKEN, + ) + ) + + indexer_client = IndexerClient( + IndexerConfig( + base_url=f"{INDEXER_SERVER}:{INDEXER_PORT}", + token=INDEXER_TOKEN, + ) + ) + + kmd_client = KmdClient( + KmdConfig( + base_url=f"{KMD_SERVER}:{KMD_PORT}", + token=KMD_TOKEN, + ) + ) + + print_info("") + print_info("Created individual clients:") + print_info(" - AlgodClient") + print_info(" - IndexerClient") + print_info(" - KmdClient") + + clients_client = AlgorandClient.from_clients( + algod=algod_client, + indexer=indexer_client, + kmd=kmd_client, + ) + print_success("Created AlgorandClient from pre-configured clients") + + # Verify connection + try: + clients_status = clients_client.client.algod.status() + clients_last_round = clients_status.last_round + print_success(f"Connected via from_clients() - Last round: {clients_last_round}") + except Exception as e: + print_error(f"Failed to connect: {e}") + + # Step 7: Verify connection with detailed status + print_step(7, "Verify Connection - Detailed Status") + print_info("Using algod.status() to verify the connection and get network details") + + try: + detailed_status = localnet_client.client.algod.status() + print_info("") + print_info("Network Status:") + print_info(f" Last round: {detailed_status.last_round}") + print_info(f" Last version: {detailed_status.last_version}") + print_info(f" Next version: {detailed_status.next_version}") + print_info(f" Next version round: {detailed_status.next_version_round}") + print_info(f" Next version supported: {detailed_status.next_version_supported}") + print_info(f" Time since last round (ns): {detailed_status.time_since_last_round}") + print_info(f" Catchup time (ns): {detailed_status.catchup_time}") + print_info(f" Stopped at unsupported round: {detailed_status.stopped_at_unsupported_round}") + print_success("Connection verified successfully!") + except Exception as e: + print_error(f"Failed to get detailed status: {e}") + + # Step 8: Error handling example + print_step(8, "Error Handling Example") + print_info("Demonstrating graceful error handling with an invalid configuration") + + invalid_config = AlgoClientNetworkConfig( + server="http://invalid-server", + port=9999, + token="invalid-token", + ) + + invalid_client = AlgorandClient.from_config(algod_config=invalid_config) + + try: + invalid_client.client.algod.status() + print_info("Unexpectedly connected to invalid server") + except Exception as e: + print_success("Caught expected error when connecting to invalid server") + error_type = type(e).__name__ + error_msg = str(e) + print_info(f"Error type: {error_type}") + # Shorten error message if too long + if len(error_msg) > 100: + error_msg = error_msg[:100] + "..." + print_info(f"Error message: {error_msg}") + + # Summary + print_step(9, "Summary") + print_info("AlgorandClient factory methods:") + print_info(" 1. default_localnet() - Quick setup for local development") + print_info(" 2. testnet() - Connect to TestNet via AlgoNode") + print_info(" 3. mainnet() - Connect to MainNet via AlgoNode") + print_info(" 4. from_environment() - Read config from environment variables") + print_info(" 5. from_config() - Use explicit AlgoConfig object") + print_info(" 6. from_clients() - Use pre-configured client instances") + print_info("") + print_info("Best practices:") + print_info(" - Use default_localnet() for development and testing") + print_info(" - Use from_environment() for deployment flexibility") + print_info(" - Always handle connection errors gracefully") + print_info(" - Verify connection with algod.status() before proceeding") + + print_success("AlgorandClient Instantiation example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/algorand_client/02_algo_amount.py b/examples/algorand_client/02_algo_amount.py new file mode 100644 index 00000000..d5ddb784 --- /dev/null +++ b/examples/algorand_client/02_algo_amount.py @@ -0,0 +1,285 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: AlgoAmount Utility + +This example demonstrates how to use the AlgoAmount utility class to work +with ALGO and microALGO amounts safely, avoiding floating point precision issues. + +Topics covered: +- Creating AlgoAmount using static factory methods +- Accessing values in ALGO and microALGO +- String formatting +- Arithmetic operations (addition, subtraction) +- Comparison operations +- Using AlgoAmount with payment transactions +- Avoiding floating point precision issues + +No LocalNet required - pure utility class demonstration (except for payment example) +""" + +from shared import ( + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_utils import AlgoAmount, AlgorandClient, PaymentParams + + +def main() -> None: + print_header("AlgoAmount Utility Example") + + # Step 1: Creating AlgoAmount using static factory methods + print_step(1, "Creating AlgoAmount using static factory methods") + print_info("AlgoAmount provides static factory methods:") + print_info(" - AlgoAmount.from_algo(amount) - Create from ALGO value") + print_info(" - AlgoAmount.from_micro_algo(amount) - Create from microALGO value") + + # Create using AlgoAmount.from_algo() + one_and_half_algo = AlgoAmount.from_algo(1.5) + print_info("") + print_info(f"AlgoAmount.from_algo(1.5): {one_and_half_algo.algo} ALGO = {one_and_half_algo.micro_algo} uALGO") + + # Create using AlgoAmount.from_micro_algo() + fifty_thousand_micro_algo = AlgoAmount.from_micro_algo(50_000) + print_info( + f"AlgoAmount.from_micro_algo(50000): {fifty_thousand_micro_algo.algo} ALGO = " + f"{fifty_thousand_micro_algo.micro_algo} uALGO" + ) + + # Create another amount + hundred_thousand_micro_algo = AlgoAmount.from_micro_algo(100_000) + print_info( + f"AlgoAmount.from_micro_algo(100000): {hundred_thousand_micro_algo.algo} ALGO = " + f"{hundred_thousand_micro_algo.micro_algo} uALGO" + ) + + print_success("Created AlgoAmount instances using factory methods") + + # Step 2: Accessing values in ALGO and microALGO + print_step(2, "Accessing values using .algo and .micro_algo properties") + print_info("AlgoAmount provides getter properties to access the value:") + print_info(" - .algo - Get value in ALGO (as Decimal)") + print_info(" - .micro_algo - Get value in uALGO (as int)") + + amount = AlgoAmount.from_algo(2.5) + print_info("") + print_info("For amount = AlgoAmount.from_algo(2.5):") + print_info(f" .algo: {amount.algo} (type: {type(amount.algo).__name__})") + print_info(f" .micro_algo: {amount.micro_algo} (type: {type(amount.micro_algo).__name__})") + + print_success("Accessed values using getter properties") + + # Step 3: String formatting with str() + print_step(3, "String formatting") + print_info("You can format AlgoAmount for display using properties") + + formatted_amount = AlgoAmount.from_algo(1.234567) + print_info("") + print_info("AlgoAmount.from_algo(1.234567):") + print_info(f" .algo: {formatted_amount.algo}") + print_info(f" .micro_algo: {formatted_amount.micro_algo}") + + large_amount = AlgoAmount.from_micro_algo(1_234_567_890) + print_info("AlgoAmount.from_micro_algo(1234567890):") + print_info(f" .algo: {large_amount.algo}") + print_info(f" .micro_algo: {large_amount.micro_algo:,}") + + # Custom formatting using properties + print_info("") + print_info("Custom formatting examples:") + print_info(f" {float(amount.algo):.2f} ALGO") + print_info(f" {amount.micro_algo:,} uALGO") + + print_success("Demonstrated string formatting") + + # Step 4: Arithmetic operations + print_step(4, "Arithmetic operations (addition, subtraction)") + print_info("AlgoAmount uses int internally for precision.") + print_info("Arithmetic is done by accessing .micro_algo and creating new AlgoAmount:") + + amount_a = AlgoAmount.from_algo(5) + amount_b = AlgoAmount.from_algo(2.5) + print_info("") + print_info(f"amount_a = AlgoAmount.from_algo(5): {amount_a.algo} ALGO") + print_info(f"amount_b = AlgoAmount.from_algo(2.5): {amount_b.algo} ALGO") + + # Addition + sum_amount = AlgoAmount.from_micro_algo(amount_a.micro_algo + amount_b.micro_algo) + print_info("") + print_info("Addition: amount_a + amount_b") + print_info(f" AlgoAmount.from_micro_algo({amount_a.micro_algo} + {amount_b.micro_algo})") + print_info(f" = {sum_amount.algo} ALGO ({sum_amount.micro_algo:,} uALGO)") + + # Subtraction + difference = AlgoAmount.from_micro_algo(amount_a.micro_algo - amount_b.micro_algo) + print_info("") + print_info("Subtraction: amount_a - amount_b") + print_info(f" AlgoAmount.from_micro_algo({amount_a.micro_algo} - {amount_b.micro_algo})") + print_info(f" = {difference.algo} ALGO ({difference.micro_algo:,} uALGO)") + + # Adding transaction fees (minimum fee is 1000 microAlgo) + min_fee = 1000 + amount_with_fee = AlgoAmount.from_micro_algo(amount_a.micro_algo + min_fee) + print_info("") + print_info("Adding transaction fee:") + print_info(f" {amount_a.algo} ALGO + {min_fee} uALGO fee = {amount_with_fee.algo} ALGO") + + print_success("Demonstrated arithmetic operations") + + # Step 5: Comparison operations + print_step(5, "Comparison operations") + print_info("Compare AlgoAmount instances by comparing their .micro_algo values") + + small = AlgoAmount.from_algo(1) + medium = AlgoAmount.from_algo(5) + large = AlgoAmount.from_algo(10) + equal_to_medium = AlgoAmount.from_micro_algo(5_000_000) + + print_info("") + print_info("small = 1 ALGO, medium = 5 ALGO, large = 10 ALGO, equal_to_medium = 5_000_000 uALGO") + + print_info("") + print_info("Comparison results (using .micro_algo):") + print_info(f" small.micro_algo < medium.micro_algo: {small.micro_algo < medium.micro_algo}") + print_info(f" medium.micro_algo < large.micro_algo: {medium.micro_algo < large.micro_algo}") + print_info(f" large.micro_algo > small.micro_algo: {large.micro_algo > small.micro_algo}") + print_info(f" medium.micro_algo >= equal_to_medium.micro_algo: {medium.micro_algo >= equal_to_medium.micro_algo}") + print_info(f" medium.micro_algo <= equal_to_medium.micro_algo: {medium.micro_algo <= equal_to_medium.micro_algo}") + + # Direct micro_algo comparison for exact equality (recommended) + print_info("") + print_info("For exact equality, compare micro_algo values (int):") + print_info(f" medium.micro_algo == equal_to_medium.micro_algo: {medium.micro_algo == equal_to_medium.micro_algo}") + + print_success("Demonstrated comparison operations") + + # Step 6: Avoiding floating point precision issues + print_step(6, "Avoiding floating point precision issues") + print_info("Python floating point arithmetic has precision issues.") + print_info("AlgoAmount avoids this by using int internally for microAlgo.") + + # Classic floating point problem + float_result = 0.1 + 0.2 + print_info("") + print_info("Classic floating point problem:") + print_info(f" 0.1 + 0.2 = {float_result} (not 0.3!)") + print_info(f" 0.1 + 0.2 == 0.3: {float_result == 0.3}") + + # AlgoAmount handles this correctly + algo_a = AlgoAmount.from_algo(0.1) + algo_b = AlgoAmount.from_algo(0.2) + algo_sum = AlgoAmount.from_micro_algo(algo_a.micro_algo + algo_b.micro_algo) + + print_info("") + print_info("Using AlgoAmount:") + print_info(f" AlgoAmount.from_algo(0.1).micro_algo = {algo_a.micro_algo}") + print_info(f" AlgoAmount.from_algo(0.2).micro_algo = {algo_b.micro_algo}") + print_info(f" Sum in micro_algo: {algo_a.micro_algo} + {algo_b.micro_algo} = {algo_sum.micro_algo}") + print_info(f" Sum in Algo: {algo_sum.algo}") + algo_0_3 = AlgoAmount.from_algo(0.3) + print_info(f" {algo_sum.micro_algo} == {algo_0_3.micro_algo}: {algo_sum.micro_algo == algo_0_3.micro_algo}") + + # Another precision example + print_info("") + print_info("Another example with 1.23456789 ALGO:") + precise_amount = AlgoAmount.from_algo(1.23456789) + print_info(f" AlgoAmount.from_algo(1.23456789).micro_algo = {precise_amount.micro_algo}") + print_info(f" Stored as: {precise_amount.micro_algo:,} uALGO (rounded to 6 decimal places)") + + print_success("Demonstrated floating point precision handling") + + # Step 7: Using AlgoAmount with payment transactions + print_step(7, "Using AlgoAmount with payment transactions") + print_info("AlgoAmount integrates seamlessly with AlgorandClient payment methods") + print_info("This step requires LocalNet to be running") + + try: + algorand = AlgorandClient.default_localnet() + + # Verify connection + algorand.client.algod.status() + + # Get accounts + dispenser = algorand.account.localnet_dispenser() + receiver = algorand.account.random() + + print_info("") + print_info(f"Sender (dispenser): {shorten_address(str(dispenser.addr))}") + print_info(f"Receiver (random): {shorten_address(str(receiver.addr))}") + + # Get initial balance + initial_info = algorand.account.get_information(dispenser.addr) + initial_balance = initial_info.amount + print_info("") + print_info(f"Initial sender balance: {initial_balance.algo} ALGO") + + # Send payment using AlgoAmount + payment_amount = AlgoAmount.from_algo(1.5) + print_info("") + print_info(f"Sending {payment_amount.algo} ALGO ({payment_amount.micro_algo:,} uALGO)...") + + result = algorand.send.payment( + PaymentParams( + sender=dispenser.addr, + receiver=receiver.addr, + amount=payment_amount, + ) + ) + + print_info(f"Transaction ID: {result.tx_ids[0]}") + print_info(f"Confirmed in round: {result.confirmation.confirmed_round}") + + # Check balances after + sender_info = algorand.account.get_information(dispenser.addr) + sender_balance = sender_info.amount + receiver_info = algorand.account.get_information(receiver.addr) + receiver_balance = receiver_info.amount + + print_info("") + print_info("Final balances:") + print_info(f" Sender: {sender_balance.algo} ALGO") + print_info(f" Receiver: {receiver_balance.algo} ALGO ({receiver_balance.micro_algo:,} uALGO)") + + # Verify the receiver got exactly the right amount + print_info("") + print_info("Verification:") + print_info(f" Expected receiver balance: {payment_amount.micro_algo:,} uALGO") + print_info(f" Actual receiver balance: {receiver_balance.micro_algo:,} uALGO") + print_info(f" Match: {receiver_balance.micro_algo == payment_amount.micro_algo}") + + print_success("Payment transaction completed successfully!") + except Exception as e: + print_error(f"Failed to run payment example: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + print_info("This step demonstrates AlgoAmount integration with transactions") + + # Step 8: Summary + print_step(8, "Summary") + print_info("AlgoAmount is a wrapper class for safe ALGO/uALGO handling:") + print_info("") + print_info("Factory methods:") + print_info(" - AlgoAmount.from_algo(n) - From ALGO") + print_info(" - AlgoAmount.from_micro_algo(n) - From uALGO") + print_info("") + print_info("Properties:") + print_info(" - .algo - Get value in ALGO (Decimal)") + print_info(" - .micro_algo - Get value in uALGO (int)") + print_info("") + print_info("Operations:") + print_info(" - Arithmetic: Use .micro_algo + wrap result in AlgoAmount.from_micro_algo()") + print_info(" - Comparison: Compare .micro_algo values for exact equality") + print_info("") + print_info("Best practices:") + print_info(" - Always use AlgoAmount for financial calculations") + print_info(" - Perform arithmetic on .micro_algo (int) to avoid precision loss") + print_info(" - Use AlgoAmount factory methods for cleaner code") + + print_success("AlgoAmount Utility example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/algorand_client/03_signer_config.py b/examples/algorand_client/03_signer_config.py new file mode 100644 index 00000000..45e4bb28 --- /dev/null +++ b/examples/algorand_client/03_signer_config.py @@ -0,0 +1,329 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Signer Configuration + +This example demonstrates how to configure transaction signers on AlgorandClient: +- set_default_signer() to set a fallback signer for all transactions +- set_signer_from_account() to register a signer from an Account object +- set_signer() to register a signer for a specific address +- How signers are automatically used when sending transactions +- Registering multiple signers for different accounts +- How the default signer is used when no specific signer is registered + +LocalNet required for transaction signing +""" + +from shared import ( + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_utils import AlgoAmount, AlgorandClient, PaymentParams + + +def main() -> None: + print_header("Signer Configuration Example") + + # Initialize client and verify LocalNet is running + algorand = AlgorandClient.default_localnet() + + try: + algorand.client.algod.status() + print_success("Connected to LocalNet") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 1: Create random test accounts + print_step(1, "Create random test accounts using algorand.account.random()") + print_info("algorand.account.random() creates a new account with a randomly generated keypair") + print_info("The account is automatically registered with its signer in the AccountManager") + + account1 = algorand.account.random() + account2 = algorand.account.random() + account3 = algorand.account.random() + + print_info("") + print_info("Created accounts:") + print_info(f" Account 1: {shorten_address(str(account1.addr))}") + print_info(f" Account 2: {shorten_address(str(account2.addr))}") + print_info(f" Account 3: {shorten_address(str(account3.addr))}") + + print_success("Created 3 random test accounts") + + # Step 2: Fund the accounts from the dispenser + print_step(2, "Fund accounts from the LocalNet dispenser") + print_info("Using the dispenser account to fund our test accounts") + + dispenser = algorand.account.localnet_dispenser() + print_info(f"Dispenser address: {shorten_address(str(dispenser.addr))}") + + # Fund all three accounts + fund_amount = AlgoAmount.from_algo(10) + print_info("") + print_info(f"Funding each account with {fund_amount.algo} ALGO...") + + for account in [account1, account2, account3]: + algorand.send.payment( + PaymentParams( + sender=dispenser.addr, + receiver=account.addr, + amount=fund_amount, + ) + ) + + print_success("Funded all accounts with 10 ALGO each") + + # Step 3: Demonstrate set_signer_from_account() + print_step(3, "Demonstrate set_signer_from_account() - Register signer from an account object") + print_info("set_signer_from_account() registers the signer from an account that can sign transactions") + print_info("This is useful when you have an account object and want to register it for signing") + + # Create a new AlgorandClient to demonstrate registering signers explicitly + algorand2 = AlgorandClient.default_localnet() + + # Register account1's signer + print_info("") + print_info(f"Registering signer for Account 1: {shorten_address(str(account1.addr))}") + algorand2.account.set_signer_from_account(account1) + + print_info("Now Account 1 can be used as a sender in transactions") + + # Send a payment from account1 to account2 + payment1_result = algorand2.send.payment( + PaymentParams( + sender=account1.addr, + receiver=account2.addr, + amount=AlgoAmount.from_algo(1), + ) + ) + + print_info("") + print_info("Payment transaction sent:") + print_info(f" From: {shorten_address(str(account1.addr))}") + print_info(f" To: {shorten_address(str(account2.addr))}") + print_info(" Amount: 1 ALGO") + print_info(f" Transaction ID: {payment1_result.tx_ids[0]}") + print_info(f" Confirmed in round: {payment1_result.confirmation.confirmed_round}") + + print_success("Successfully sent payment using registered signer") + + # Step 4: Demonstrate set_signer() - Register signer for a specific address + print_step(4, "Demonstrate set_signer() - Register signer for a specific address") + print_info("set_signer(address, signer) registers a TransactionSigner for a specific address") + print_info("This gives you fine-grained control over which signer to use for each address") + + # Create another AlgorandClient to demonstrate set_signer + algorand3 = AlgorandClient.default_localnet() + + # Register account2's signer using set_signer + print_info("") + print_info("Registering signer for Account 2 using set_signer():") + print_info(f" Address: {shorten_address(str(account2.addr))}") + algorand3.set_signer(sender=account2.addr, signer=account2.signer) + + # Send a payment from account2 to account3 + payment2_result = algorand3.send.payment( + PaymentParams( + sender=account2.addr, + receiver=account3.addr, + amount=AlgoAmount.from_algo(0.5), + ) + ) + + print_info("") + print_info("Payment transaction sent:") + print_info(f" From: {shorten_address(str(account2.addr))}") + print_info(f" To: {shorten_address(str(account3.addr))}") + print_info(" Amount: 0.5 ALGO") + print_info(f" Transaction ID: {payment2_result.tx_ids[0]}") + print_info(f" Confirmed in round: {payment2_result.confirmation.confirmed_round}") + + print_success("Successfully sent payment using set_signer()") + + # Step 5: Demonstrate set_default_signer() + print_step(5, "Demonstrate set_default_signer() - Set a fallback signer for all transactions") + print_info("set_default_signer() sets a signer that will be used when no specific signer is registered") + print_info("This is useful when you have a primary account that signs most transactions") + + # Create a new AlgorandClient and set account3 as the default signer + algorand4 = AlgorandClient.default_localnet() + + print_info("") + print_info(f"Setting Account 3 as the default signer: {shorten_address(str(account3.addr))}") + algorand4.set_default_signer(account3.signer) + + # Now we can send a transaction from account3 without explicitly registering it + # The default signer will be used + payment3_result = algorand4.send.payment( + PaymentParams( + sender=account3.addr, + receiver=account1.addr, + amount=AlgoAmount.from_algo(0.25), + ) + ) + + print_info("") + print_info("Payment transaction sent using default signer:") + print_info(f" From: {shorten_address(str(account3.addr))}") + print_info(f" To: {shorten_address(str(account1.addr))}") + print_info(" Amount: 0.25 ALGO") + print_info(f" Transaction ID: {payment3_result.tx_ids[0]}") + print_info(f" Confirmed in round: {payment3_result.confirmation.confirmed_round}") + + print_success("Successfully sent payment using default signer") + + # Step 6: Demonstrate multiple signers with default fallback + print_step(6, "Demonstrate multiple signers with default fallback") + print_info("You can register multiple signers and have a default as fallback") + print_info("Specific signers take precedence over the default signer") + + # Create a new AlgorandClient with multiple signers + algorand5 = AlgorandClient.default_localnet() + + # Set account1 as the default signer + print_info("") + print_info("Setting up signers:") + print_info(f" Default signer: Account 1 ({shorten_address(str(account1.addr))})") + algorand5.set_default_signer(account1.signer) + + # Also register account2's signer explicitly + print_info(f" Registered signer: Account 2 ({shorten_address(str(account2.addr))})") + algorand5.account.set_signer_from_account(account2) + + # Send from account2 (uses registered signer) + print_info("") + print_info("Sending from Account 2 (uses registered signer):") + payment4_result = algorand5.send.payment( + PaymentParams( + sender=account2.addr, + receiver=account3.addr, + amount=AlgoAmount.from_algo(0.1), + ) + ) + print_info(f" Transaction ID: {payment4_result.tx_ids[0]}") + print_info(f" Confirmed in round: {payment4_result.confirmation.confirmed_round}") + + # Send from account1 (uses default signer) + print_info("") + print_info("Sending from Account 1 (uses default signer):") + payment5_result = algorand5.send.payment( + PaymentParams( + sender=account1.addr, + receiver=account3.addr, + amount=AlgoAmount.from_algo(0.1), + ) + ) + print_info(f" Transaction ID: {payment5_result.tx_ids[0]}") + print_info(f" Confirmed in round: {payment5_result.confirmation.confirmed_round}") + + print_success("Successfully demonstrated signer priority (specific > default)") + + # Step 7: Error handling - No signer registered + print_step(7, "Error handling - Attempting to send without a registered signer") + print_info("When no signer is registered for an address and no default signer is set,") + print_info("an error will be thrown when trying to send a transaction") + + # Create a new AlgorandClient without any signers + algorand6 = AlgorandClient.default_localnet() + unregistered_account = algorand6.account.random() + + print_info("") + print_info(f"Attempting to send from unregistered account: {shorten_address(str(unregistered_account.addr))}") + print_info("(Note: algorand.account.random() automatically registers the signer,") + print_info(" but if we create a fresh client and only have the address, it will fail)") + + # Create yet another client that doesn't have the signer registered + algorand7 = AlgorandClient.default_localnet() + + try: + # Try to send from the address without registering a signer + algorand7.send.payment( + PaymentParams( + sender=unregistered_account.addr, # This address has no signer in algorand7 + receiver=account1.addr, + amount=AlgoAmount.from_algo(0.01), + ) + ) + print_info("Unexpectedly succeeded") + except Exception as e: + print_success("Caught expected error when no signer is registered") + error_msg = str(e) + if len(error_msg) > 100: + error_msg = error_msg[:100] + "..." + print_info(f"Error message: {error_msg}") + + # Step 8: Method chaining + print_step(8, "Method chaining - Configure signers fluently") + print_info("All signer methods return the AlgorandClient, allowing method chaining") + + algorand8 = ( + AlgorandClient.default_localnet() + .set_default_signer(account1.signer) + .set_signer(sender=account3.addr, signer=account3.signer) + ) + algorand8.account.set_signer_from_account(account2) + + print_info("") + print_info("Configured AlgorandClient with chained calls:") + print_info(" .set_default_signer(account1.signer)") + print_info(" .set_signer(sender=account3.addr, signer=account3.signer)") + print_info(" .account.set_signer_from_account(account2)") + + # Verify all signers work + balances: dict[str, int] = {} + for name, account in [ + ("Account 1", account1), + ("Account 2", account2), + ("Account 3", account3), + ]: + info = algorand8.account.get_information(account.addr) + balances[name] = info.amount.micro_algo + + print_info("") + print_info("Current balances:") + for name, balance in balances.items(): + algo_value = balance / 1_000_000 + print_info(f" {name}: {algo_value:.6f} ALGO") + + print_success("Successfully configured AlgorandClient with method chaining") + + # Step 9: Summary + print_step(9, "Summary") + print_info("Signer configuration methods:") + print_info("") + print_info("set_default_signer(signer):") + print_info(" - Sets a fallback signer for all transactions") + print_info(" - Used when no specific signer is registered for an address") + print_info(" - Accepts TransactionSigner") + print_info("") + print_info("set_signer_from_account(account):") + print_info(" - Registers a signer from an account object") + print_info(" - Account must have addr and signer properties") + print_info(" - Supports AddressWithTransactionSigner types") + print_info("") + print_info("set_signer(sender, signer):") + print_info(" - Registers a TransactionSigner for a specific address") + print_info(" - Gives fine-grained control over signing") + print_info("") + print_info("Signer resolution order:") + print_info(" 1. Specific signer registered for the address") + print_info(" 2. Default signer (if set)") + print_info(" 3. Error thrown if no signer found") + print_info("") + print_info("Best practices:") + print_info(" - Use algorand.account.random() for test accounts (auto-registers signer)") + print_info(" - Set a default signer for your primary signing account") + print_info(" - Register additional signers as needed for multi-account workflows") + print_info(" - Method chaining makes configuration concise and readable") + + print_success("Signer Configuration example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/algorand_client/04_params_config.py b/examples/algorand_client/04_params_config.py new file mode 100644 index 00000000..507e2e9b --- /dev/null +++ b/examples/algorand_client/04_params_config.py @@ -0,0 +1,289 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Suggested Params Configuration + +This example demonstrates how to configure suggested transaction parameters: +- set_default_validity_window() to set the number of rounds a transaction is valid +- set_suggested_params_cache_timeout() to set cache duration in milliseconds +- get_suggested_params() to manually fetch suggested params +- Performance benefits of caching when sending multiple transactions + +LocalNet required to fetch suggested params and send transactions +""" + +import time + +from shared import ( + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_utils import AlgoAmount, AlgorandClient, PaymentParams + + +def main() -> None: + print_header("Suggested Params Configuration Example") + + # Initialize client and verify LocalNet is running + algorand = AlgorandClient.default_localnet() + + try: + algorand.client.algod.status() + print_success("Connected to LocalNet") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 1: Understanding suggested params + print_step(1, "Understanding suggested params") + print_info("Suggested params contain network information needed for transactions:") + print_info(" - first_valid: The first round the transaction is valid") + print_info(" - last_valid: The last round the transaction is valid (set during tx building)") + print_info(" - genesis_hash: The hash of the genesis block") + print_info(" - genesis_id: The network identifier (e.g., 'localnet-v1')") + print_info(" - fee: The minimum transaction fee") + print_info(" - min_fee: The minimum fee per byte") + + params = algorand.get_suggested_params() + print_info("") + print_info("Current suggested params from LocalNet:") + print_info(f" first_valid: {params.first_valid}") + print_info(f" genesis_id: {params.genesis_id}") + print_info(f" fee: {params.fee} microALGO") + print_info(f" min_fee: {params.min_fee} microALGO") + + print_success("Retrieved suggested params from LocalNet") + + # Step 2: Default validity window behavior + print_step(2, "Understand default validity window behavior") + print_info("The validity window determines: last_valid = first_valid + validity_window") + print_info("Default is 10 rounds, but LocalNet uses 1000 rounds for convenience") + print_info("This is set during transaction building, not in suggested params") + + # Create accounts for demonstrating transactions + dispenser = algorand.account.localnet_dispenser() + sender = algorand.account.random() + receiver = algorand.account.random() + + # Fund the sender + algorand.send.payment( + PaymentParams( + sender=dispenser.addr, + receiver=sender.addr, + amount=AlgoAmount.from_algo(10), + ) + ) + + print_info("") + print_info(f"Sender: {shorten_address(str(sender.addr))}") + print_info(f"Receiver: {shorten_address(str(receiver.addr))}") + + # Send a transaction and inspect its validity window + tx_result = algorand.send.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_algo(0.1), + note=b"Transaction 1", + ) + ) + + # Access the transaction directly from the result + tx = tx_result.transactions[0] + print_info("") + print_info("Transaction built with LocalNet default:") + print_info(f" first_valid: {tx.first_valid}") + print_info(f" last_valid: {tx.last_valid}") + validity_window = tx.last_valid - tx.first_valid + print_info(f" Validity window: {validity_window} rounds (LocalNet default)") + + print_success("Demonstrated default validity window") + + # Step 3: Set custom validity window + print_step(3, "Demonstrate set_default_validity_window()") + print_info("Use set_default_validity_window() to override the default validity window") + print_info("This affects all transactions built by this client") + + # Create a new client with custom validity window + algorand_custom = AlgorandClient.default_localnet().set_default_validity_window(50) + algorand_custom.account.set_signer_from_account(sender) + + tx_result_custom = algorand_custom.send.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_algo(0.1), + note=b"Transaction with custom validity", + ) + ) + + # Access the transaction directly from the result + tx_custom = tx_result_custom.transactions[0] + print_info("") + print_info("Transaction built with set_default_validity_window(50):") + print_info(f" first_valid: {tx_custom.first_valid}") + print_info(f" last_valid: {tx_custom.last_valid}") + custom_validity = tx_custom.last_valid - tx_custom.first_valid + print_info(f" Validity window: {custom_validity} rounds") + + print_success("Demonstrated custom validity window") + + # Step 4: When to use different validity windows + print_step(4, "When to use longer vs shorter validity windows") + print_info("") + print_info("Shorter validity windows (5-10 rounds):") + print_info(" - High-frequency trading applications") + print_info(" - When you want quick transaction expiration") + print_info(" - Reduces risk of delayed/stale transactions being confirmed") + print_info("") + print_info("Longer validity windows (100-1000 rounds):") + print_info(" - Batch operations with many transactions") + print_info(" - When network congestion is expected") + print_info(" - When user confirmation takes time") + print_info(" - Offline signing scenarios") + + print_success("Explained validity window use cases") + + # Step 5: Suggested params caching basics + print_step(5, "Demonstrate get_suggested_params() caching") + print_info("get_suggested_params() caches results to avoid repeated network calls") + print_info("Default cache timeout is 3 seconds (3000ms)") + + # Create a fresh client to demonstrate caching + algorand_cache = AlgorandClient.default_localnet() + + # Demonstrate that the cache is working + print_info("") + print_info("Fetching params twice in quick succession...") + start_time1 = time.time() + algorand_cache.get_suggested_params() + duration1 = (time.time() - start_time1) * 1000 + + start_time2 = time.time() + algorand_cache.get_suggested_params() + duration2 = (time.time() - start_time2) * 1000 + + print_info(f" First call: ~{duration1:.0f}ms (includes network fetch)") + print_info(f" Second call: ~{duration2:.0f}ms (from cache)") + + print_success("Demonstrated params caching") + + # Step 6: Configure cache timeout + print_step(6, "Demonstrate set_suggested_params_cache_timeout()") + print_info("Use set_suggested_params_cache_timeout() to set how long params are cached") + print_info("Value is in milliseconds") + + # Create a client with longer cache timeout + algorand_long_cache = AlgorandClient.default_localnet().set_suggested_params_cache_timeout(60_000) + print_info("") + print_info("With set_suggested_params_cache_timeout(60_000): 60 second cache") + print_info("Good for: High-throughput apps sending many transactions quickly") + + # Create a client with shorter cache timeout + algorand_short_cache = AlgorandClient.default_localnet().set_suggested_params_cache_timeout(500) + print_info("With set_suggested_params_cache_timeout(500): 0.5 second cache") + print_info("Good for: Apps that need the most current round information") + + # Fetch to demonstrate they work + algorand_long_cache.get_suggested_params() + algorand_short_cache.get_suggested_params() + + print_success("Demonstrated cache timeout configuration") + + # Step 7: Performance benefit with multiple transactions + print_step(7, "Show performance benefit of caching with multiple transactions") + print_info("When sending many transactions, caching reduces network calls") + print_info("Each transaction needs suggested params to set validity window") + + # Send 5 transactions with unique notes and measure time + num_transactions = 5 + print_info("") + print_info(f"Sending {num_transactions} transactions with caching enabled (default)...") + + start_with_cache = time.time() + for i in range(num_transactions): + algorand.send.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_algo(0.01), + note=f"Performance test transaction {i + 1} at {time.time()}".encode(), + ) + ) + duration_with_cache = (time.time() - start_with_cache) * 1000 + + print_info(f" Total time: {duration_with_cache:.0f}ms") + print_info(f" Average per transaction: {duration_with_cache / num_transactions:.0f}ms") + print_info(" Note: Params are fetched once and cached for subsequent transactions") + + print_success("Demonstrated caching performance benefit") + + # Step 8: Method chaining + print_step(8, "Method chaining - Configure params fluently") + print_info("All configuration methods return the AlgorandClient for chaining") + + configured_client = ( + AlgorandClient.default_localnet().set_default_validity_window(25).set_suggested_params_cache_timeout(10_000) + ) + configured_client.account.set_signer_from_account(sender) + + print_info("") + print_info("Configured client with:") + print_info(" .set_default_validity_window(25)") + print_info(" .set_suggested_params_cache_timeout(10_000)") + print_info(" .account.set_signer_from_account(sender)") + + # Send a transaction to verify the configuration + chained_tx_result = configured_client.send.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_algo(0.01), + note=b"Chained config test", + ) + ) + + # Access the transaction directly from the result + chained_tx = chained_tx_result.transactions[0] + chained_validity = chained_tx.last_valid - chained_tx.first_valid + print_info("") + print_info(f"Resulting transaction validity window: {chained_validity} rounds") + + print_success("Demonstrated method chaining") + + # Step 9: Summary + print_step(9, "Summary") + print_info("Suggested params configuration methods:") + print_info("") + print_info("get_suggested_params():") + print_info(" - Returns cached params or fetches from network") + print_info(" - Automatically manages cache expiry") + print_info(" - Use for manual param inspection or custom transactions") + print_info("") + print_info("set_default_validity_window(rounds):") + print_info(" - Sets how many rounds a transaction stays valid") + print_info(" - Default is 10 rounds (1000 for LocalNet)") + print_info(" - Affects last_valid = first_valid + validity_window") + print_info("") + print_info("set_suggested_params_cache_timeout(milliseconds):") + print_info(" - Sets how long params are cached before refresh") + print_info(" - Default is 3000ms (3 seconds)") + print_info(" - Longer = fewer network calls, possibly stale data") + print_info(" - Shorter = more network calls, fresher data") + print_info("") + print_info("Best practices:") + print_info(" - Use default settings for most applications") + print_info(" - Increase cache timeout for high-throughput apps") + print_info(" - Use shorter validity windows for time-sensitive transactions") + print_info(" - Use longer validity windows for batch operations") + + print_success("Suggested Params Configuration example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/algorand_client/05_account_manager.py b/examples/algorand_client/05_account_manager.py new file mode 100644 index 00000000..e3125161 --- /dev/null +++ b/examples/algorand_client/05_account_manager.py @@ -0,0 +1,415 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Account Manager + +This example demonstrates how to use the account manager to create, import, +and manage accounts including: +- algorand.account.random() to generate a new random account +- algorand.account.from_mnemonic() to import from 25-word mnemonic +- algorand.account.from_environment() to load from env var +- algorand.account.from_kmd() to get account from KMD wallet +- algorand.account.multisig() to create a multisig account +- algorand.account.logicsig() to create a logic signature account +- algorand.account.rekeyed() to create a rekeyed account reference +- algorand.account.get_information() to fetch account details from network +- algorand.account.ensure_funded() to ensure account has minimum balance +- algorand.account.ensure_funded_from_environment() for dispenser funding + +LocalNet required for KMD access and account operations +""" + +import secrets + +from shared import ( + format_algo, + load_teal_source, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_algo25 import mnemonic_from_seed +from algokit_transact import MultisigMetadata +from algokit_utils import AlgoAmount, AlgorandClient + + +def main() -> None: + print_header("Account Manager Example") + + # Initialize client and verify LocalNet is running + algorand = AlgorandClient.default_localnet() + + try: + algorand.client.algod.status() + print_success("Connected to LocalNet") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 1: Generate a random account with algorand.account.random() + print_step(1, "Generate random account with algorand.account.random()") + print_info("random() creates a new account with a randomly generated keypair") + print_info("The account is automatically registered with its signer in AccountManager") + + random_account = algorand.account.random() + + print_info("") + print_info("Random account created:") + print_info(f" addr: {random_account.addr}") + print_info(" signer: [TransactionSigner function] - automatically registered") + + print_success("Generated random account") + + # Step 2: Import account from 25-word mnemonic with algorand.account.from_mnemonic() + print_step(2, "Import account from mnemonic with algorand.account.from_mnemonic()") + print_info("from_mnemonic() loads an account from a 25-word mnemonic secret") + print_info("WARNING: Never commit mnemonics to source control!") + + # Generate a test mnemonic for demo purposes + # In practice, you would load this from environment variables or secure storage + random_seed = secrets.token_bytes(32) + demo_mnemonic = mnemonic_from_seed(random_seed) + + first_five_words = " ".join(demo_mnemonic.split()[:5]) + print_info("") + print_info(f'Example mnemonic (first 5 words): "{first_five_words}..."') + + # Import using the mnemonic + mnemonic_account = algorand.account.from_mnemonic(mnemonic=demo_mnemonic) + + print_info("") + print_info("Mnemonic account imported:") + print_info(f" addr: {shorten_address(str(mnemonic_account.addr))}") + print_info(" signer: [TransactionSigner function] - ready for signing") + + print_success("Imported account from mnemonic") + + # Step 3: Load account from environment with algorand.account.from_environment() + print_step(3, "Load account from environment with algorand.account.from_environment()") + print_info("from_environment() loads account based on environment variable conventions:") + print_info("") + print_info("Non-LocalNet convention:") + print_info(" - Loads {NAME}_MNEMONIC as mnemonic secret") + print_info(" - Optionally loads {NAME}_SENDER for rekeyed accounts") + print_info("") + print_info("LocalNet convention:") + print_info(" - Creates/retrieves a KMD wallet named {NAME}") + print_info(" - Auto-funds with 1000 ALGO by default") + + # On LocalNet, this will create a wallet named "DEMO" and fund it + env_account = algorand.account.from_environment("DEMO", fund_with=AlgoAmount.from_algo(10)) + + print_info("") + print_info('Environment account loaded (LocalNet wallet "DEMO"):') + print_info(f" addr: {shorten_address(str(env_account.addr))}") + + # Verify it was funded + env_info = algorand.account.get_information(env_account.addr) + print_info(f" balance: {format_algo(env_info.amount)}") + + print_success("Loaded account from environment") + + # Step 4: Get account from KMD wallet with algorand.account.from_kmd() + print_step(4, "Get account from KMD wallet with algorand.account.from_kmd()") + print_info("from_kmd() retrieves an account from a KMD wallet by name") + print_info("Optional predicate filter to find specific accounts") + + # Get an account from the default LocalNet wallet + kmd_account = algorand.account.from_kmd( + "unencrypted-default-wallet", + # Filter: accounts with > 1000 ALGO (predicate) + predicate=lambda a: a["amount"] > 1_000_000_000, + ) + + print_info("") + print_info("KMD account retrieved:") + print_info(f" addr: {shorten_address(str(kmd_account.addr))}") + print_info(" wallet: unencrypted-default-wallet") + + kmd_info = algorand.account.get_information(kmd_account.addr) + print_info(f" balance: {format_algo(kmd_info.amount)}") + + print_success("Retrieved account from KMD wallet") + + # Step 5: Create a multisig account with algorand.account.multisig() + print_step(5, "Create multisig account with algorand.account.multisig()") + print_info("multisig() creates a multisig account from multiple sub-signers") + print_info("Requires: version, threshold (min signatures), and participant addresses") + + # Create 3 accounts for the multisig + msig1 = algorand.account.random() + msig2 = algorand.account.random() + msig3 = algorand.account.random() + + multisig_metadata = MultisigMetadata( + version=1, # Multisig version (always 1) + threshold=2, # Require 2 of 3 signatures + addrs=[msig1.addr, msig2.addr, msig3.addr], # Participant addresses (order matters!) + ) + + # Create multisig with 2 sub-signers (accounts 1 and 2) + multisig_account = algorand.account.multisig(multisig_metadata, [msig1, msig2]) + + print_info("") + print_info("Multisig account created:") + print_info(f" addr: {shorten_address(str(multisig_account.addr))}") + print_info(f" version: {multisig_metadata.version}") + print_info(f" threshold: {multisig_metadata.threshold} of {len(multisig_metadata.addrs)}") + print_info(" participants:") + print_info(f" 1: {shorten_address(str(msig1.addr))}") + print_info(f" 2: {shorten_address(str(msig2.addr))}") + print_info(f" 3: {shorten_address(str(msig3.addr))}") + print_info(" signer: [MultisigSigner function] - signs with accounts 1 and 2") + + print_success("Created multisig account") + + # Step 6: Create a logic signature account with algorand.account.logicsig() + print_step(6, "Create logic signature account with algorand.account.logicsig()") + print_info("logicsig() creates an account backed by a compiled TEAL program") + print_info("The program defines the conditions under which transactions are approved") + + # Load TEAL program that always approves (for demo purposes only!) + # In production, use meaningful logic that validates transactions + teal_source = load_teal_source("always-approve.teal") + + # Compile the TEAL program using algorand.app.compile_teal() + compile_result = algorand.app.compile_teal(teal_source) + program = compile_result.compiled_base64_to_bytes + + # Create the logic signature account + logicsig_account = algorand.account.logicsig(program) + + print_info("") + print_info("Logic signature account created:") + print_info(f" addr: {shorten_address(str(logicsig_account.addr))}") + print_info(f" program hash: {str(logicsig_account.addr)[:16]}...") + print_info(f" program size: {len(program)} bytes") + print_info(" signer: [LogicSigSigner function] - evaluates TEAL program") + print_info("") + print_info("Note: Logic sig address is derived from the program hash") + print_info("Anyone can send transactions from this address if the program approves") + + print_success("Created logic signature account") + + # Step 7: Create a rekeyed account reference with algorand.account.rekeyed() + print_step(7, "Create rekeyed account with algorand.account.rekeyed()") + print_info("rekeyed() creates a reference to an account that has been rekeyed") + print_info('The "sender" is the original address, but signing uses a different account') + + # Create an account that will be the "auth" account (the one that signs) + auth_account = algorand.account.random() + + # Create a rekeyed reference: sender = random_account, but auth = auth_account + rekeyed_account = algorand.account.rekeyed(sender=random_account.addr, account=auth_account) + + print_info("") + print_info("Rekeyed account reference created:") + print_info(f" sender addr: {shorten_address(str(rekeyed_account.addr))}") + print_info(f" auth account: {shorten_address(str(auth_account.addr))}") + print_info(" signer: Uses auth_account's signer") + print_info("") + print_info("Use case: After rekeying account A to account B,") + print_info("transactions from A are signed by B's private key") + + print_success("Created rekeyed account reference") + + # Step 8: Fetch account information with algorand.account.get_information() + print_step(8, "Fetch account info with algorand.account.get_information()") + print_info("get_information() fetches current account status from the network") + print_info("Returns balance, min balance, rewards, opted-in assets/apps, and more") + + # Get the dispenser account to demonstrate + dispenser = algorand.account.localnet_dispenser() + account_info = algorand.account.get_information(dispenser.addr) + + print_info("") + print_info("Account information for dispenser:") + print_info(f" address: {shorten_address(str(account_info.address))}") + print_info(f" balance: {format_algo(account_info.amount)}") + print_info(f" min_balance: {format_algo(account_info.min_balance)}") + spendable = account_info.amount.micro_algo - account_info.min_balance.micro_algo + print_info(f" spendable: {format_algo(spendable)} (balance - min_balance)") + print_info(f" pending_rewards: {format_algo(account_info.pending_rewards)}") + print_info(f" rewards: {format_algo(account_info.rewards)}") + print_info(f" status: {account_info.status}") + print_info(f" round: {account_info.round}") + print_info(f" total_apps_opted_in: {account_info.total_apps_opted_in}") + print_info(f" total_assets_opted_in: {account_info.total_assets_opted_in}") + print_info(f" total_created_apps: {account_info.total_created_apps}") + print_info(f" total_created_assets: {account_info.total_created_assets}") + if account_info.auth_addr: + print_info(f" auth_addr (rekey): {account_info.auth_addr}") + + print_success("Fetched account information") + + # Step 9: Ensure account is funded with algorand.account.ensure_funded() + print_step(9, "Ensure account is funded with algorand.account.ensure_funded()") + print_info("ensure_funded() funds an account to have a minimum spending balance") + print_info("Only sends funds if needed (idempotent)") + print_info("min_spending_balance is the balance ABOVE the minimum balance requirement") + + # Create a new account to fund + account_to_fund = algorand.account.random() + + print_info("") + print_info(f"New account: {shorten_address(str(account_to_fund.addr))}") + + # Check initial balance + before_info = algorand.account.get_information(account_to_fund.addr) + print_info(f"Initial balance: {format_algo(before_info.amount)}") + + # Ensure it has at least 5 ALGO to spend + fund_result = algorand.account.ensure_funded( + account_to_fund.addr, + dispenser.addr, + AlgoAmount.from_algo(5), # Minimum spending balance (above min balance requirement) + ) + + if fund_result: + print_info("") + print_info("Funding transaction:") + print_info(f" tx_id: {fund_result.transaction_id}") + print_info(f" amount_funded: {format_algo(fund_result.amount_funded)}") + else: + print_info("No funding needed - account already has sufficient balance") + + # Check new balance + after_info = algorand.account.get_information(account_to_fund.addr) + print_info(f"New balance: {format_algo(after_info.amount)}") + print_info(f"Min balance: {format_algo(after_info.min_balance)}") + spendable_after = after_info.amount.micro_algo - after_info.min_balance.micro_algo + print_info(f"Spendable: {format_algo(spendable_after)}") + + # Call again to show it's idempotent + fund_result2 = algorand.account.ensure_funded( + account_to_fund.addr, + dispenser.addr, + AlgoAmount.from_algo(5), + ) + + if not fund_result2: + print_info("") + print_info("Second call: No funding needed (idempotent)") + + print_success("Demonstrated ensure_funded()") + + # Step 10: Ensure funded from environment with algorand.account.ensure_funded_from_environment() + print_step(10, "Ensure funded from environment with algorand.account.ensure_funded_from_environment()") + print_info("ensure_funded_from_environment() uses the dispenser from environment variables") + print_info("On LocalNet: uses default LocalNet dispenser") + print_info("On other networks: uses DISPENSER_MNEMONIC env var") + + # Create another account to fund + account_to_fund2 = algorand.account.random() + + print_info("") + print_info(f"New account: {shorten_address(str(account_to_fund2.addr))}") + + # Fund using environment dispenser + env_fund_result = algorand.account.ensure_funded_from_environment( + account_to_fund2.addr, + AlgoAmount.from_algo(2), # Minimum spending balance + min_funding_increment=AlgoAmount.from_algo(5), # But fund at least 5 ALGO when funding + ) + + if env_fund_result: + print_info("") + print_info("Funding from environment:") + print_info(f" tx_id: {env_fund_result.transaction_id}") + print_info(f" amount_funded: {format_algo(env_fund_result.amount_funded)}") + print_info(" Note: min_funding_increment(5) > min_spending_balance(2)") + + after_info2 = algorand.account.get_information(account_to_fund2.addr) + print_info(f"Final balance: {format_algo(after_info2.amount)}") + + print_success("Demonstrated ensure_funded_from_environment()") + + # Step 11: Account properties summary + print_step(11, "Account properties summary") + print_info("All account types share common properties:") + print_info("") + print_info("addr:") + print_info(" - The address string for the account") + print_info(" - The 58-character string representation") + print_info("") + print_info("signer (TransactionSigner):") + print_info(" - Function that signs transaction groups") + print_info(" - Automatically used when sending transactions") + print_info("") + print_info("Different account types may have additional properties:") + print_info(" - MultisigAccount: metadata (multisig metadata)") + print_info(" - LogicSigAccount: underlying logic sig") + print_info(" - Rekeyed: underlying auth account") + + # Demonstrate accessing properties + print_info("") + print_info("Example - Random account properties:") + print_info(f" random_account.addr: {random_account.addr}") + print_info(" random_account.signer: [Function]") + + print_info("") + print_info("Example - Multisig account properties:") + print_info(f" multisig_account.addr: {shorten_address(str(multisig_account.addr))}") + print_info(" multisig_account metadata: { version: 1, threshold: 2, addrs: [...] }") + + print_success("Account properties summary complete") + + # Step 12: Summary + print_step(12, "Summary") + print_info("Account creation methods:") + print_info("") + print_info("random():") + print_info(" - Generates new random keypair") + print_info(" - Account is automatically tracked for signing") + print_info(" - Returns AddressAndSigner") + print_info("") + print_info("from_mnemonic(mnemonic, sender?):") + print_info(" - Imports from 25-word mnemonic") + print_info(" - Optional sender for rekeyed accounts") + print_info(" - Returns AddressAndSigner") + print_info("") + print_info("from_environment(name, fund_with?):") + print_info(" - LocalNet: creates/gets KMD wallet, auto-funds") + print_info(" - Other: loads {NAME}_MNEMONIC env var") + print_info(" - Returns AddressAndSigner") + print_info("") + print_info("from_kmd(wallet_name, predicate?, sender?):") + print_info(" - Gets account from KMD wallet by name") + print_info(" - Optional predicate to filter accounts") + print_info(" - Returns AddressAndSigner") + print_info("") + print_info("multisig(params, sub_signers):") + print_info(" - Creates multisig from sub-signers") + print_info(" - Returns AddressAndSigner") + print_info("") + print_info("logicsig(program, args?):") + print_info(" - Creates logic signature account") + print_info(" - Returns AddressAndSigner") + print_info("") + print_info("rekeyed(sender, auth_account):") + print_info(" - Creates rekeyed account reference") + print_info(" - Returns AddressAndSigner") + print_info("") + print_info("Account operations:") + print_info("") + print_info("get_information(address):") + print_info(" - Fetches account details from network") + print_info(" - Returns AccountInformation with balance, etc.") + print_info("") + print_info("ensure_funded(account_to_fund, dispenser, min_spending):") + print_info(" - Funds account to have min spending balance") + print_info(" - Idempotent - only funds if needed") + print_info("") + print_info("ensure_funded_from_environment(account_to_fund, min_spending):") + print_info(" - Same as ensure_funded but uses env dispenser") + print_info(" - LocalNet: default dispenser, Other: DISPENSER_MNEMONIC") + + print_success("Account Manager example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/algorand_client/06_send_payment.py b/examples/algorand_client/06_send_payment.py new file mode 100644 index 00000000..f840d0da --- /dev/null +++ b/examples/algorand_client/06_send_payment.py @@ -0,0 +1,386 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Send Payment + +This example demonstrates how to send ALGO payment transactions: +- algorand.send.payment() with basic parameters (sender, receiver, amount) +- Using AlgoAmount for the amount parameter +- Payment with note field +- Payment with close_remainder_to to close account and send remaining balance +- Understanding the SendSingleTransactionResult return value +- Displaying transaction ID and confirmed round +- Verifying balances before and after payment + +LocalNet required for sending transactions +""" + +import json +from datetime import datetime, timezone + +from shared import ( + format_algo, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_utils import AlgoAmount, AlgorandClient, PaymentParams + + +def main() -> None: + print_header("Send Payment Example") + + # Initialize client and verify LocalNet is running + algorand = AlgorandClient.default_localnet() + + try: + algorand.client.algod.status() + print_success("Connected to LocalNet") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 1: Create and fund test accounts + print_step(1, "Create and fund test accounts using account manager") + print_info("Creating test accounts and funding them from the LocalNet dispenser") + + sender = algorand.account.random() + receiver = algorand.account.random() + close_to_account = algorand.account.random() + + print_info("") + print_info("Created accounts:") + print_info(f" Sender: {shorten_address(str(sender.addr))}") + print_info(f" Receiver: {shorten_address(str(receiver.addr))}") + print_info(f" CloseToAccount: {shorten_address(str(close_to_account.addr))}") + + # Fund the sender account using ensure_funded_from_environment + fund_result = algorand.account.ensure_funded_from_environment( + sender.addr, + AlgoAmount.from_algo(20), + ) + if fund_result: + print_info(f" Funded sender with: {format_algo(fund_result.amount_funded)}") + + # Also fund close_to_account so it exists on the network + algorand.account.ensure_funded_from_environment( + close_to_account.addr, + AlgoAmount.from_algo(1), + ) + + # Get initial balances + sender_initial_info = algorand.account.get_information(sender.addr) + receiver_initial_info = algorand.account.get_information(receiver.addr) + + print_info("") + print_info("Initial balances:") + print_info(f" Sender: {format_algo(sender_initial_info.amount)}") + print_info(f" Receiver: {format_algo(receiver_initial_info.amount)}") + + print_success("Created and funded test accounts") + + # Step 2: Basic payment with algorand.send.payment() + print_step(2, "Basic payment with algorand.send.payment()") + print_info("Sending a simple ALGO payment with sender, receiver, and amount") + + basic_payment_result = algorand.send.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_algo(5), # Using AlgoAmount helper + ) + ) + + print_info("") + print_info("Basic payment sent:") + print_info(f" From: {shorten_address(str(sender.addr))}") + print_info(f" To: {shorten_address(str(receiver.addr))}") + print_info(" Amount: 5 ALGO") + + # Examine the SendSingleTransactionResult return value + print_info("") + print_info("SendSingleTransactionResult properties:") + print_info(f" tx_ids[0]: {basic_payment_result.tx_ids[0]}") + print_info(f" confirmation.confirmed_round: {basic_payment_result.confirmation.confirmed_round}") + print_info(f" transaction.tx_id(): {basic_payment_result.transaction.tx_id()}") + group_id = basic_payment_result.group_id or "undefined (single transaction)" + print_info(f" group_id: {group_id}") + print_info(f" transactions length: {len(basic_payment_result.transactions)}") + print_info(f" confirmations length: {len(basic_payment_result.confirmations)}") + + print_success("Basic payment completed") + + # Step 3: Using AlgoAmount for the amount parameter + print_step(3, "Using AlgoAmount for the amount parameter") + print_info("AlgoAmount provides type-safe handling of ALGO and microALGO values") + + # Different ways to specify amounts + amount1 = AlgoAmount.from_algo(1) # 1 ALGO using helper function + amount2 = AlgoAmount.from_micro_algo(500_000) # 0.5 ALGO in microALGO + + print_info("") + print_info("Different amount specifications:") + print_info(f" AlgoAmount.from_algo(1) = {format_algo(amount1)} ({amount1.micro_algo} uALGO)") + print_info(f" AlgoAmount.from_micro_algo(500_000) = {format_algo(amount2)} ({amount2.micro_algo} uALGO)") + + # Send payment with microAlgo amount + micro_algo_payment_result = algorand.send.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_micro_algo(250_000), # 0.25 ALGO + ) + ) + + print_info("") + print_info("Payment with microAlgo amount:") + print_info(f" Amount: {format_algo(AlgoAmount.from_micro_algo(250_000))} (250,000 uALGO)") + print_info(f" Transaction ID: {micro_algo_payment_result.tx_ids[0]}") + + print_success("Demonstrated AlgoAmount usage") + + # Step 4: Payment with note field + print_step(4, "Payment with note field") + print_info("Adding arbitrary data to a payment using the note field") + print_info("Notes can be strings, byte arrays, or structured data (JSON)") + + # String note + string_note_result = algorand.send.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_algo(0.1), + note=b"Payment for services rendered", + ) + ) + + print_info("") + print_info("Payment with string note:") + print_info(' Note: "Payment for services rendered"') + print_info(f" Transaction ID: {string_note_result.tx_ids[0]}") + + # JSON note (useful for structured data) + json_note = json.dumps( + { + "type": "invoice", + "id": "12345", + "timestamp": datetime.now(timezone.utc).isoformat(), + } + ) + + json_note_result = algorand.send.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_algo(0.1), + note=json_note.encode(), + ) + ) + + print_info("") + print_info("Payment with JSON note:") + print_info(f" Note: {json_note}") + print_info(f" Transaction ID: {json_note_result.tx_ids[0]}") + + # Byte array note + byte_note = b"Binary data note" + + byte_note_result = algorand.send.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_algo(0.1), + note=byte_note, + ) + ) + + print_info("") + print_info("Payment with byte array note:") + print_info(f' Note: bytes({len(byte_note)}) - "Binary data note"') + print_info(f" Transaction ID: {byte_note_result.tx_ids[0]}") + + print_success("Demonstrated payment with notes") + + # Step 5: Verify balances before and after payment + print_step(5, "Verify balances before and after payment using get_information()") + print_info("Using algorand.account.get_information() to check account balances") + + # Get current balances + sender_before_info = algorand.account.get_information(sender.addr) + receiver_before_info = algorand.account.get_information(receiver.addr) + + print_info("") + print_info("Balances before payment:") + print_info(f" Sender: {format_algo(sender_before_info.amount)}") + print_info(f" Receiver: {format_algo(receiver_before_info.amount)}") + + # Send a precise amount + precise_amount = AlgoAmount.from_algo(2) + algorand.send.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=precise_amount, + ) + ) + + # Get balances after payment + sender_after_info = algorand.account.get_information(sender.addr) + receiver_after_info = algorand.account.get_information(receiver.addr) + + print_info("") + print_info(f"Balances after sending {format_algo(precise_amount)}:") + print_info(f" Sender: {format_algo(sender_after_info.amount)}") + print_info(f" Receiver: {format_algo(receiver_after_info.amount)}") + + # Calculate the difference (includes transaction fee) + sender_diff = sender_before_info.amount.micro_algo - sender_after_info.amount.micro_algo + receiver_diff = receiver_after_info.amount.micro_algo - receiver_before_info.amount.micro_algo + + print_info("") + print_info("Balance changes:") + print_info(f" Sender lost: {format_algo(sender_diff)} (amount + fee)") + print_info(f" Receiver gained: {format_algo(receiver_diff)}") + print_info(f" Transaction fee: {format_algo(sender_diff - receiver_diff)}") + + print_success("Verified balance changes") + + # Step 6: Demonstrate close_remainder_to to close account + print_step(6, "Demonstrate close_remainder_to to close account and send remaining balance") + print_info("close_remainder_to closes the sender account and sends ALL remaining balance") + print_info("WARNING: This permanently closes the account - use with caution!") + + # Create a new account specifically for closing + account_to_close = algorand.account.random() + algorand.account.ensure_funded_from_environment(account_to_close.addr, AlgoAmount.from_algo(5)) + + account_to_close_initial_info = algorand.account.get_information(account_to_close.addr) + close_to_initial_info = algorand.account.get_information(close_to_account.addr) + + print_info("") + print_info(f"Account to close: {shorten_address(str(account_to_close.addr))}") + print_info(f" Initial balance: {format_algo(account_to_close_initial_info.amount)}") + print_info(f"Close remainder to: {shorten_address(str(close_to_account.addr))}") + print_info(f" Initial balance: {format_algo(close_to_initial_info.amount)}") + + # Send a payment with close_remainder_to + # This will: + # 1. Send the specified amount to receiver + # 2. Send ALL remaining balance to close_remainder_to address + # 3. Close the sender account + close_result = algorand.send.payment( + PaymentParams( + sender=account_to_close.addr, + receiver=receiver.addr, # Receiver gets the explicit amount + amount=AlgoAmount.from_algo(1), # Explicit amount to receiver + close_remainder_to=close_to_account.addr, # Remainder goes here, account closes + ) + ) + + print_info("") + print_info("Close account transaction:") + print_info(f" Transaction ID: {close_result.tx_ids[0]}") + print_info(f" Confirmed round: {close_result.confirmation.confirmed_round}") + print_info(f" Explicit amount to receiver: {format_algo(AlgoAmount.from_algo(1))}") + + # Verify the close operation + account_to_close_final_info = algorand.account.get_information(account_to_close.addr) + receiver_final_info = algorand.account.get_information(receiver.addr) + close_to_final_info = algorand.account.get_information(close_to_account.addr) + + receiver_gained = receiver_final_info.amount.micro_algo - receiver_before_info.amount.micro_algo + close_to_gained = close_to_final_info.amount.micro_algo - close_to_initial_info.amount.micro_algo + + print_info("") + print_info("After closing:") + print_info(f" Closed account balance: {format_algo(account_to_close_final_info.amount)} (should be 0)") + print_info(f" Receiver gained: {format_algo(receiver_gained)}") + print_info(f" CloseToAccount balance: {format_algo(close_to_final_info.amount)}") + print_info(f" CloseToAccount gained: {format_algo(close_to_gained)}") + + print_success("Demonstrated close_remainder_to") + + # Step 7: Waiting for confirmation + print_step(7, "Understanding transaction confirmation") + print_info("algorand.send.payment() automatically waits for confirmation") + print_info("The result includes confirmation details from the network") + + confirmation_result = algorand.send.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_algo(0.5), + ) + ) + + print_info("") + print_info("Transaction confirmation details:") + print_info(f" Transaction ID: {confirmation_result.tx_ids[0]}") + print_info(f" Confirmed round: {confirmation_result.confirmation.confirmed_round}") + pool_error = confirmation_result.confirmation.pool_error or "none" + print_info(f" Pool error: {pool_error}") + + # Access the Transaction object + txn = confirmation_result.transaction + print_info("") + print_info("Transaction object details:") + print_info(f" tx_id(): {txn.tx_id()}") + print_info(f" transaction_type: {txn.transaction_type}") + print_info(f" first_valid: {txn.first_valid}") + print_info(f" last_valid: {txn.last_valid}") + print_info(f" fee: {txn.fee} uALGO") + + print_success("Demonstrated transaction confirmation") + + # Step 8: Summary of SendSingleTransactionResult + print_step(8, "Summary - SendSingleTransactionResult properties") + print_info("When you call algorand.send.payment(), you get a SendSingleTransactionResult:") + print_info("") + print_info("Primary transaction properties:") + print_info(" tx_ids[0]: str - The transaction ID for single transactions") + print_info(" transaction: Transaction - The Transaction object") + print_info(" confirmation: PendingTransactionResponse - Confirmation details") + print_info("") + print_info("Group properties (also present for single transactions):") + print_info(" group_id: str | None - The group ID if part of a group") + print_info(" tx_ids: list[str] - List of transaction IDs") + print_info(" transactions: list[Transaction] - List of Transaction objects") + print_info(" confirmations: list[PendingTransactionResponse] - List of confirmations") + print_info("") + print_info("Useful confirmation properties:") + print_info(" confirmation.confirmed_round - The round the transaction was confirmed") + print_info(" confirmation.pool_error - Any error message from the pool") + print_info(" confirmation.closing_amount - Amount sent to close_remainder_to (if used)") + print_info("") + print_info("Payment parameters:") + print_info(" sender: str - Who is sending the payment") + print_info(" receiver: str - Who receives the payment") + print_info(" amount: AlgoAmount - How much to send") + print_info(" note: str | bytes - Optional note data") + print_info(" close_remainder_to: str - Close account and send remainder here") + + # Final balance summary + print_step(9, "Final balance summary") + + final_sender_info = algorand.account.get_information(sender.addr) + final_receiver_info = algorand.account.get_information(receiver.addr) + + print_info("") + print_info("Final balances:") + print_info( + f" Sender: {format_algo(final_sender_info.amount)} (started with {format_algo(sender_initial_info.amount)})" + ) + print_info( + f" Receiver: {format_algo(final_receiver_info.amount)} " + f"(started with {format_algo(receiver_initial_info.amount)})" + ) + + print_success("Send Payment example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/algorand_client/07_send_asset_ops.py b/examples/algorand_client/07_send_asset_ops.py new file mode 100644 index 00000000..b68e51ff --- /dev/null +++ b/examples/algorand_client/07_send_asset_ops.py @@ -0,0 +1,470 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Send Asset Operations + +This example demonstrates how to perform ASA (Algorand Standard Asset) operations: +- algorand.send.asset_create() to create a new ASA with all parameters +- algorand.send.asset_config() to reconfigure an asset +- algorand.send.asset_opt_in() for receiver to opt into the asset +- algorand.send.asset_transfer() to transfer assets between accounts +- algorand.send.asset_freeze() to freeze/unfreeze an account's asset holding +- algorand.send.asset_transfer() with clawback_target for clawback operations +- algorand.send.asset_opt_out() to opt out and close asset holding +- algorand.send.asset_destroy() to destroy an asset + +LocalNet required for sending transactions +""" + +from shared import ( + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_utils import AlgoAmount, AlgorandClient +from algokit_utils.transactions.types import ( + AssetConfigParams, + AssetCreateParams, + AssetDestroyParams, + AssetFreezeParams, + AssetOptInParams, + AssetOptOutParams, + AssetTransferParams, +) + + +def main() -> None: + print_header("Send Asset Operations Example") + + # Initialize client and verify LocalNet is running + algorand = AlgorandClient.default_localnet() + + try: + algorand.client.algod.status() + print_success("Connected to LocalNet") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 1: Create and fund test accounts + print_step(1, "Create and fund test accounts") + print_info("Creating creator, receiver, and frozen_account for asset operations") + + creator = algorand.account.random() + receiver = algorand.account.random() + frozen_account = algorand.account.random() + + print_info("") + print_info("Created accounts:") + print_info(f" Creator: {shorten_address(str(creator.addr))}") + print_info(f" Receiver: {shorten_address(str(receiver.addr))}") + print_info(f" FrozenAccount: {shorten_address(str(frozen_account.addr))}") + + # Fund all accounts + algorand.account.ensure_funded_from_environment(creator.addr, AlgoAmount.from_algo(10)) + algorand.account.ensure_funded_from_environment(receiver.addr, AlgoAmount.from_algo(5)) + algorand.account.ensure_funded_from_environment(frozen_account.addr, AlgoAmount.from_algo(5)) + + print_success("Created and funded test accounts") + + # Step 2: Create a new ASA with all parameters + print_step(2, "Create a new ASA with algorand.send.asset_create()") + print_info("Creating an asset with all configurable parameters") + + # Create a metadata hash (32 bytes) + metadata_hash = bytes(range(32)) + + create_result = algorand.send.asset_create( + AssetCreateParams( + sender=creator.addr, + total=1_000_000, # 1 million units (10,000 whole tokens with 2 decimals) + decimals=2, + asset_name="AlgoKit Example Token", + unit_name="AKEX", + url="https://example.com/asset", + metadata_hash=metadata_hash, + default_frozen=False, + manager=creator.addr, # Can reconfigure the asset + reserve=creator.addr, # Holds uncirculated supply + freeze=creator.addr, # Can freeze/unfreeze accounts + clawback=creator.addr, # Can clawback assets + ) + ) + + asset_id = create_result.asset_id + print_info("") + print_info("Asset created:") + print_info(f" Asset ID: {asset_id}") + print_info(f" Transaction ID: {create_result.tx_ids[0]}") + print_info(f" Confirmed round: {create_result.confirmation.confirmed_round}") + + # Retrieve and display asset details + asset_info = algorand.asset.get_by_id(asset_id) + print_info("") + print_info("Asset details from chain:") + print_info(f" Name: {asset_info.asset_name}") + print_info(f" Unit: {asset_info.unit_name}") + print_info(f" Total: {asset_info.total} (smallest units)") + print_info(f" Decimals: {asset_info.decimals}") + print_info(f" Creator: {shorten_address(str(asset_info.creator))}") + manager_addr = str(asset_info.manager) if asset_info.manager else "none" + reserve_addr = str(asset_info.reserve) if asset_info.reserve else "none" + freeze_addr = str(asset_info.freeze) if asset_info.freeze else "none" + clawback_addr = str(asset_info.clawback) if asset_info.clawback else "none" + print_info(f" Manager: {shorten_address(manager_addr)}") + print_info(f" Reserve: {shorten_address(reserve_addr)}") + print_info(f" Freeze: {shorten_address(freeze_addr)}") + print_info(f" Clawback: {shorten_address(clawback_addr)}") + print_info(f" Default Frozen: {asset_info.default_frozen}") + print_info(f" URL: {asset_info.url}") + + print_success("Asset created successfully") + + # Step 3: Reconfigure the asset + print_step(3, "Reconfigure the asset with algorand.send.asset_config()") + print_info("Changing the reserve address to a different account") + + # Create a new reserve account + new_reserve = algorand.account.random() + algorand.account.ensure_funded_from_environment(new_reserve.addr, AlgoAmount.from_algo(1)) + + config_result = algorand.send.asset_config( + AssetConfigParams( + sender=creator.addr, # Must be the manager + asset_id=asset_id, + manager=creator.addr, # Keep manager the same + reserve=new_reserve.addr, # Change reserve + freeze=creator.addr, # Keep freeze the same + clawback=creator.addr, # Keep clawback the same + ) + ) + + print_info("") + print_info("Asset reconfigured:") + print_info(f" Transaction ID: {config_result.tx_ids[0]}") + print_info(f" Confirmed round: {config_result.confirmation.confirmed_round}") + + # Verify the change + updated_asset_info = algorand.asset.get_by_id(asset_id) + updated_reserve = str(updated_asset_info.reserve) if updated_asset_info.reserve else "none" + print_info(f" New Reserve: {shorten_address(updated_reserve)}") + + print_success("Asset reconfigured successfully") + + # Step 4: Opt-in receiver to the asset + print_step(4, "Opt-in receiver with algorand.send.asset_opt_in()") + print_info("Before receiving assets, an account must opt-in to the asset") + + opt_in_result = algorand.send.asset_opt_in( + AssetOptInParams( + sender=receiver.addr, + asset_id=asset_id, + ) + ) + + print_info("") + print_info("Receiver opted in:") + print_info(f" Transaction ID: {opt_in_result.tx_ids[0]}") + print_info(f" Confirmed round: {opt_in_result.confirmation.confirmed_round}") + + # Verify opt-in + receiver_asset_info = algorand.asset.get_account_information(receiver.addr, asset_id) + print_info(f" Receiver balance after opt-in: {receiver_asset_info.balance}") + print_info(f" Receiver frozen status: {receiver_asset_info.frozen}") + + print_success("Receiver opted in successfully") + + # Step 5: Transfer assets to receiver + print_step(5, "Transfer assets with algorand.send.asset_transfer()") + print_info("Transferring 100 whole tokens (10000 smallest units) to receiver") + + transfer_result = algorand.send.asset_transfer( + AssetTransferParams( + sender=creator.addr, + receiver=receiver.addr, + asset_id=asset_id, + amount=10_000, # 100 whole tokens (100 * 10^2) + note=b"Initial token distribution", + ) + ) + + print_info("") + print_info("Transfer completed:") + print_info(f" Transaction ID: {transfer_result.tx_ids[0]}") + print_info(f" Confirmed round: {transfer_result.confirmation.confirmed_round}") + + # Check balances + creator_asset_info = algorand.asset.get_account_information(creator.addr, asset_id) + receiver_after_transfer = algorand.asset.get_account_information(receiver.addr, asset_id) + creator_tokens = creator_asset_info.balance / 100 + receiver_tokens = receiver_after_transfer.balance / 100 + print_info(f" Creator balance: {creator_asset_info.balance} ({creator_tokens} tokens)") + print_info(f" Receiver balance: {receiver_after_transfer.balance} ({receiver_tokens} tokens)") + + print_success("Asset transfer completed successfully") + + # Step 6: Freeze an account's asset holding + print_step(6, "Freeze account with algorand.send.asset_freeze()") + print_info("First opt-in frozen_account, then freeze its asset holding") + + # Opt-in frozen_account + algorand.send.asset_opt_in( + AssetOptInParams( + sender=frozen_account.addr, + asset_id=asset_id, + ) + ) + + # Transfer some tokens to frozen_account + algorand.send.asset_transfer( + AssetTransferParams( + sender=creator.addr, + receiver=frozen_account.addr, + asset_id=asset_id, + amount=5_000, # 50 whole tokens + ) + ) + + # Now freeze the account + freeze_result = algorand.send.asset_freeze( + AssetFreezeParams( + sender=creator.addr, # Must be the freeze address + asset_id=asset_id, + account=frozen_account.addr, + frozen=True, + ) + ) + + print_info("") + print_info("Account frozen:") + print_info(f" Transaction ID: {freeze_result.tx_ids[0]}") + print_info(f" Confirmed round: {freeze_result.confirmation.confirmed_round}") + + # Verify frozen status + frozen_account_info = algorand.asset.get_account_information(frozen_account.addr, asset_id) + print_info(f" Frozen account balance: {frozen_account_info.balance}") + print_info(f" Frozen status: {frozen_account_info.frozen}") + + # Try to transfer from frozen account (should fail) + print_info("") + print_info("Attempting transfer from frozen account (should fail)...") + try: + algorand.send.asset_transfer( + AssetTransferParams( + sender=frozen_account.addr, + receiver=receiver.addr, + asset_id=asset_id, + amount=1_000, + ) + ) + print_error("Transfer should have failed!") + except Exception: + print_info(" Transfer failed as expected: account is frozen") + + print_success("Freeze operation completed successfully") + + # Step 7: Unfreeze and demonstrate clawback + print_step(7, "Unfreeze and demonstrate clawback operation") + print_info("Unfreezing the account, then using clawback to reclaim assets") + + # Unfreeze the account + unfreeze_result = algorand.send.asset_freeze( + AssetFreezeParams( + sender=creator.addr, + asset_id=asset_id, + account=frozen_account.addr, + frozen=False, + ) + ) + + print_info("") + print_info("Account unfrozen:") + print_info(f" Transaction ID: {unfreeze_result.tx_ids[0]}") + + unfrozen_account_info = algorand.asset.get_account_information(frozen_account.addr, asset_id) + print_info(f" Frozen status after unfreeze: {unfrozen_account_info.frozen}") + + # Demonstrate clawback - reclaim assets from frozen_account + print_info("") + print_info("Clawback operation: reclaiming assets from frozen_account to creator") + + clawback_result = algorand.send.asset_transfer( + AssetTransferParams( + sender=creator.addr, # Clawback address sends the transaction + receiver=creator.addr, # Assets go back to creator + asset_id=asset_id, + amount=2_500, # Clawback 25 tokens + clawback_target=frozen_account.addr, # Account to clawback from + note=b"Clawback operation", + ) + ) + + print_info("") + print_info("Clawback completed:") + print_info(f" Transaction ID: {clawback_result.tx_ids[0]}") + print_info(f" Confirmed round: {clawback_result.confirmation.confirmed_round}") + + # Check balances after clawback + creator_after_clawback = algorand.asset.get_account_information(creator.addr, asset_id) + frozen_after_clawback = algorand.asset.get_account_information(frozen_account.addr, asset_id) + print_info(f" Creator balance after clawback: {creator_after_clawback.balance}") + print_info(f" FrozenAccount balance after clawback: {frozen_after_clawback.balance}") + + print_success("Clawback operation completed successfully") + + # Step 8: Opt-out of the asset + print_step(8, "Opt-out with algorand.send.asset_opt_out()") + print_info("Receiver will opt-out of the asset, returning remaining balance to creator") + + # First transfer all assets back to creator so receiver has zero balance + receiver_current_balance = algorand.asset.get_account_information(receiver.addr, asset_id) + if receiver_current_balance.balance > 0: + algorand.send.asset_transfer( + AssetTransferParams( + sender=receiver.addr, + receiver=creator.addr, + asset_id=asset_id, + amount=receiver_current_balance.balance, + ) + ) + print_info(f" Transferred {receiver_current_balance.balance} units back to creator") + + # Now opt-out + opt_out_result = algorand.send.asset_opt_out( + AssetOptOutParams( + sender=receiver.addr, + asset_id=asset_id, + creator=creator.addr, + ), + ensure_zero_balance=True, + ) + + print_info("") + print_info("Receiver opted out:") + print_info(f" Transaction ID: {opt_out_result.tx_ids[0]}") + print_info(f" Confirmed round: {opt_out_result.confirmation.confirmed_round}") + + # Verify opt-out (get_account_information will throw if not opted in) + try: + algorand.asset.get_account_information(receiver.addr, asset_id) + print_error("Receiver should not be opted in!") + except Exception: + print_info(" Receiver successfully opted out of asset") + + print_success("Opt-out completed successfully") + + # Step 9: Destroy the asset + print_step(9, "Destroy the asset with algorand.send.asset_destroy()") + print_info("All assets must be returned to creator before destruction") + + # Return assets from frozen_account + frozen_current_balance = algorand.asset.get_account_information(frozen_account.addr, asset_id) + if frozen_current_balance.balance > 0: + algorand.send.asset_transfer( + AssetTransferParams( + sender=frozen_account.addr, + receiver=creator.addr, + asset_id=asset_id, + amount=frozen_current_balance.balance, + ) + ) + print_info(f" Transferred {frozen_current_balance.balance} units from frozen_account to creator") + + # Opt-out frozen_account + algorand.send.asset_opt_out( + AssetOptOutParams( + sender=frozen_account.addr, + asset_id=asset_id, + creator=creator.addr, + ), + ensure_zero_balance=True, + ) + print_info(" FrozenAccount opted out") + + # Verify creator has all assets + creator_final_balance = algorand.asset.get_account_information(creator.addr, asset_id) + print_info(f" Creator final balance: {creator_final_balance.balance} (should be {asset_info.total})") + + # Destroy the asset + destroy_result = algorand.send.asset_destroy( + AssetDestroyParams( + sender=creator.addr, # Must be the manager + asset_id=asset_id, + ) + ) + + print_info("") + print_info("Asset destroyed:") + print_info(f" Transaction ID: {destroy_result.tx_ids[0]}") + print_info(f" Confirmed round: {destroy_result.confirmation.confirmed_round}") + + # Verify destruction + try: + algorand.asset.get_by_id(asset_id) + print_error("Asset should not exist!") + except Exception: + print_info(f" Asset {asset_id} no longer exists") + + print_success("Asset destroyed successfully") + + # Step 10: Summary of asset operations + print_step(10, "Summary - Asset Operations API") + print_info("Asset operations available through algorand.send:") + print_info("") + print_info("asset_create(params):") + print_info(" sender: str - Creator of the asset") + print_info(" total: int - Total units in smallest divisible unit") + print_info(" decimals: int - Decimal places (0-19)") + print_info(" asset_name: str - Asset name (max 32 bytes)") + print_info(" unit_name: str - Unit name/ticker (max 8 bytes)") + print_info(" url: str - URL for asset info (max 96 bytes)") + print_info(" metadata_hash: bytes - 32-byte metadata hash") + print_info(" default_frozen: bool - Default freeze status") + print_info(" manager: str - Can reconfigure/destroy asset") + print_info(" reserve: str - Holds uncirculated supply (informational)") + print_info(" freeze: str - Can freeze/unfreeze holdings") + print_info(" clawback: str - Can clawback from any account") + print_info("") + print_info("asset_config(params):") + print_info(" sender: str - Must be current manager") + print_info(" asset_id: int - Asset to reconfigure") + print_info(" manager, reserve, freeze, clawback: Addresses to update") + print_info("") + print_info("asset_opt_in(params):") + print_info(" sender: str - Account opting in") + print_info(" asset_id: int - Asset to opt into") + print_info("") + print_info("asset_transfer(params):") + print_info(" sender: str - Sender (or clawback address)") + print_info(" receiver: str - Recipient") + print_info(" asset_id: int - Asset to transfer") + print_info(" amount: int - Amount in smallest units") + print_info(" clawback_target: str - Account to clawback from") + print_info(" close_asset_to: str - Close holding to this address") + print_info("") + print_info("asset_freeze(params):") + print_info(" sender: str - Must be freeze address") + print_info(" asset_id: int - Asset ID") + print_info(" account: str - Account to freeze/unfreeze") + print_info(" frozen: bool - Freeze (True) or unfreeze (False)") + print_info("") + print_info("asset_opt_out(params):") + print_info(" sender: str - Account opting out") + print_info(" asset_id: int - Asset to opt out of") + print_info(" creator: str - Asset creator (receives remaining units)") + print_info(" ensure_zero_balance: bool - Safety check") + print_info("") + print_info("asset_destroy(params):") + print_info(" sender: str - Must be manager") + print_info(" asset_id: int - Asset to destroy") + print_info(" Note: All units must be in creator account") + + print_success("Send Asset Operations example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/algorand_client/08_send_app_ops.py b/examples/algorand_client/08_send_app_ops.py new file mode 100644 index 00000000..040adce0 --- /dev/null +++ b/examples/algorand_client/08_send_app_ops.py @@ -0,0 +1,469 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Send Application Operations + +This example demonstrates how to perform smart contract (application) operations: +- algorand.send.app_create() to deploy a new application with global/local schema +- algorand.send.app_update() to update application code +- algorand.send.app_call() for NoOp application calls with args +- algorand.send.app_call() with OnComplete.OptIn for account opt-in +- algorand.send.app_call() with OnComplete.CloseOut for account close-out +- algorand.send.app_call() with OnComplete.ClearState to clear local state +- algorand.send.app_delete() to delete the application +- Passing application arguments, accounts, assets, apps references + +LocalNet required for sending transactions +""" + +from shared import ( + load_teal_source, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_transact import OnApplicationComplete +from algokit_utils import AlgoAmount, AlgorandClient +from algokit_utils.transactions.types import ( + AppCallParams, + AppCreateParams, + AppDeleteParams, + AppUpdateParams, + AssetCreateParams, +) + +# ============================================================================ +# TEAL Programs - loaded from shared artifacts +# ============================================================================ + +# A counter app that supports all lifecycle operations +APPROVAL_PROGRAM = load_teal_source("approval-lifecycle-full.teal") + +# Updated version of the approval program (increments by 2 instead of 1) +APPROVAL_PROGRAM_V2 = load_teal_source("approval-lifecycle-full-v2.teal") + +# Clear state program (must always approve) +CLEAR_STATE_PROGRAM = load_teal_source("clear-state-approve.teal") + + +def main() -> None: + print_header("Send Application Operations Example") + + # Initialize client and verify LocalNet is running + algorand = AlgorandClient.default_localnet() + + try: + algorand.client.algod.status() + print_success("Connected to LocalNet") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 1: Create and fund test accounts + print_step(1, "Create and fund test accounts") + print_info("Creating creator and user accounts for app operations") + + creator = algorand.account.random() + user = algorand.account.random() + + print_info("") + print_info("Created accounts:") + print_info(f" Creator: {shorten_address(str(creator.addr))}") + print_info(f" User: {shorten_address(str(user.addr))}") + + # Fund all accounts + algorand.account.ensure_funded_from_environment(creator.addr, AlgoAmount.from_algo(10)) + algorand.account.ensure_funded_from_environment(user.addr, AlgoAmount.from_algo(5)) + + print_success("Created and funded test accounts") + + # Step 2: Create a new application with algorand.send.app_create() + print_step(2, "Create a new application with algorand.send.app_create()") + print_info("Deploying a counter app with global and local state schema") + print_info("") + print_info("Schema specification:") + print_info(" globalInts: 1 (for the counter)") + print_info(" globalByteSlices: 1 (for the message)") + print_info(" localInts: 1 (for user_visits)") + print_info(" localByteSlices: 0") + + create_result = algorand.send.app_create( + AppCreateParams( + sender=creator.addr, + approval_program=APPROVAL_PROGRAM, + clear_state_program=CLEAR_STATE_PROGRAM, + schema={ + "global_ints": 1, + "global_byte_slices": 1, + "local_ints": 1, + "local_byte_slices": 0, + }, + ) + ) + + app_id = create_result.app_id + app_address = create_result.app_address + + print_info("") + print_info("Application created:") + print_info(f" App ID: {app_id}") + print_info(f" App Address: {shorten_address(str(app_address))}") + print_info(f" Transaction ID: {create_result.tx_ids[0]}") + print_info(f" Confirmed round: {create_result.confirmation.confirmed_round}") + + # Check global state after creation + global_state = algorand.app.get_global_state(app_id) + counter_state = global_state.get("counter") + counter_value = counter_state.value if counter_state else 0 + message_state = global_state.get("message") + message_value = message_state.value if message_state else "" + print_info("") + print_info("Initial global state:") + print_info(f" counter: {counter_value}") + print_info(f' message: "{message_value}"') + + print_success("Application created successfully") + + # Step 3: Call the application with algorand.send.app_call() - NoOp + print_step(3, "Call the application with algorand.send.app_call() - NoOp") + print_info("Calling the app to increment the counter") + + call_result = algorand.send.app_call( + AppCallParams( + sender=creator.addr, + app_id=app_id, + note=b"First NoOp call", + # on_complete defaults to NoOp + ) + ) + + print_info("") + print_info("NoOp call completed:") + print_info(f" Transaction ID: {call_result.tx_ids[0]}") + print_info(f" Confirmed round: {call_result.confirmation.confirmed_round}") + + # Check global state after call + state_after_call = algorand.app.get_global_state(app_id) + counter_after_state = state_after_call.get("counter") + counter_after = counter_after_state.value if counter_after_state else 0 + print_info(f" Counter after call: {counter_after}") + + print_success("NoOp call completed successfully") + + # Step 4: Call with application arguments + print_step(4, "Call with application arguments") + print_info("Passing arguments to the app call (will be logged)") + + # Arguments must be bytes + arg1 = b"hello" + arg2 = b"world" + + call_with_args_result = algorand.send.app_call( + AppCallParams( + sender=creator.addr, + app_id=app_id, + args=[arg1, arg2], + note=b"Call with arguments", + ) + ) + + print_info("") + print_info("Call with arguments:") + print_info(f" Transaction ID: {call_with_args_result.tx_ids[0]}") + print_info(' Args passed: ["hello", "world"]') + + # Check logs from the transaction + logs = call_with_args_result.confirmation.logs or [] + print_info(f" Logs from app: {len(logs)} entries") + if logs: + first_log = logs[0].decode("utf-8", errors="replace") + print_info(f' First log: "{first_log}"') + + state_after_args = algorand.app.get_global_state(app_id) + counter_after_args_state = state_after_args.get("counter") + counter_after_args = counter_after_args_state.value if counter_after_args_state else 0 + print_info(f" Counter after call: {counter_after_args}") + + print_success("Call with arguments completed") + + # Step 5: Opt-in to the application with OnComplete.OptIn + print_step(5, "Opt-in to the application with app_call and OptIn") + print_info("User opting in to the app to enable local state") + + opt_in_result = algorand.send.app_call( + AppCallParams( + sender=user.addr, + app_id=app_id, + on_complete=OnApplicationComplete.OptIn, + note=b"Initial opt-in", + ) + ) + + print_info("") + print_info("Opt-in completed:") + print_info(f" Transaction ID: {opt_in_result.tx_ids[0]}") + print_info(f" Confirmed round: {opt_in_result.confirmation.confirmed_round}") + + # Check local state after opt-in + local_state = algorand.app.get_local_state(app_id, user.addr) + user_visits_state = local_state.get("user_visits") + user_visits = user_visits_state.value if user_visits_state else 0 + print_info(" User local state:") + print_info(f" user_visits: {user_visits}") + + print_success("User opted in successfully") + + # Step 6: Update the application with algorand.send.app_update() + print_step(6, "Update the application with algorand.send.app_update()") + print_info("Updating the app to increment by 2 instead of 1") + + update_result = algorand.send.app_update( + AppUpdateParams( + sender=creator.addr, + app_id=app_id, + approval_program=APPROVAL_PROGRAM_V2, + clear_state_program=CLEAR_STATE_PROGRAM, + ) + ) + + print_info("") + print_info("Application updated:") + print_info(f" Transaction ID: {update_result.tx_ids[0]}") + print_info(f" Confirmed round: {update_result.confirmation.confirmed_round}") + + # Test the updated logic + pre_update_state = algorand.app.get_global_state(app_id) + pre_update_counter_state = pre_update_state.get("counter") + pre_update_counter = pre_update_counter_state.value if pre_update_counter_state else 0 + + algorand.send.app_call( + AppCallParams( + sender=creator.addr, + app_id=app_id, + note=b"Testing updated logic", + ) + ) + + state_after_update = algorand.app.get_global_state(app_id) + post_update_counter_state = state_after_update.get("counter") + post_update_counter = post_update_counter_state.value if post_update_counter_state else 0 + + print_info("") + print_info("Verifying updated logic:") + print_info(f" Counter before update call: {pre_update_counter}") + print_info(f" Counter after update call: {post_update_counter}") + increment = int(post_update_counter) - int(pre_update_counter) + print_info(f" Increment amount: {increment} (was 1, now 2)") + + print_success("Application updated successfully") + + # Step 7: Demonstrate passing references (accounts, apps, assets) + print_step(7, "Demonstrate passing references to app calls") + print_info("App calls can include references to accounts, assets, and other apps") + + # Create a dummy asset to reference + asset_result = algorand.send.asset_create( + AssetCreateParams( + sender=creator.addr, + total=1000, + decimals=0, + asset_name="Reference Test", + unit_name="REF", + ) + ) + + asset_id = asset_result.asset_id + + # Create another app to reference + other_app_result = algorand.send.app_create( + AppCreateParams( + sender=creator.addr, + approval_program=load_teal_source("simple-approve.teal"), + clear_state_program=load_teal_source("clear-state-approve.teal"), + ) + ) + + other_app_id = other_app_result.app_id + + # Make a call with all reference types + ref_call_result = algorand.send.app_call( + AppCallParams( + sender=creator.addr, + app_id=app_id, + account_references=[user.addr], # Reference another account + app_references=[other_app_id], # Reference another app + asset_references=[asset_id], # Reference an asset + note=b"Call with references", + ) + ) + + print_info("") + print_info("Call with references:") + print_info(f" Transaction ID: {ref_call_result.tx_ids[0]}") + print_info(f" Account references: [{shorten_address(str(user.addr))}]") + print_info(f" App references: [{other_app_id}]") + print_info(f" Asset references: [{asset_id}]") + print_info(" Note: These references allow the app to read data from these resources") + + print_success("References passed successfully") + + # Step 8: Close out of the application + print_step(8, "Close out with app_call and CloseOut") + print_info("User closing out of the app (removes local state)") + + close_out_result = algorand.send.app_call( + AppCallParams( + sender=user.addr, + app_id=app_id, + on_complete=OnApplicationComplete.CloseOut, + note=b"Close out from app", + ) + ) + + print_info("") + print_info("Close out completed:") + print_info(f" Transaction ID: {close_out_result.tx_ids[0]}") + print_info(f" Confirmed round: {close_out_result.confirmation.confirmed_round}") + + # Verify user is no longer opted in + try: + algorand.app.get_local_state(app_id, user.addr) + print_error("User should not have local state after close out!") + except Exception: + print_info(" User no longer has local state (as expected)") + + print_success("User closed out successfully") + + # Step 9: Demonstrate ClearState + print_step(9, "Demonstrate ClearState operation") + print_info("ClearState forcefully removes local state (cannot be rejected by the app)") + + # First, opt the user back in + algorand.send.app_call( + AppCallParams( + sender=user.addr, + app_id=app_id, + on_complete=OnApplicationComplete.OptIn, + note=b"Re-opt-in for ClearState demo", + ) + ) + print_info("User re-opted in to demonstrate ClearState") + + # Now use ClearState + clear_state_result = algorand.send.app_call( + AppCallParams( + sender=user.addr, + app_id=app_id, + on_complete=OnApplicationComplete.ClearState, + note=b"Clear state operation", + ) + ) + + print_info("") + print_info("ClearState completed:") + print_info(f" Transaction ID: {clear_state_result.tx_ids[0]}") + print_info(f" Confirmed round: {clear_state_result.confirmation.confirmed_round}") + print_info(" Note: ClearState always succeeds, even if the clear program rejects") + + # Verify user is no longer opted in + try: + algorand.app.get_local_state(app_id, user.addr) + print_error("User should not have local state after clear state!") + except Exception: + print_info(" User local state cleared (as expected)") + + print_success("ClearState completed successfully") + + # Step 10: Delete the application with algorand.send.app_delete() + print_step(10, "Delete the application with algorand.send.app_delete()") + print_info("Deleting the app (only creator can delete in this example)") + + # Get final state before deletion + final_state = algorand.app.get_global_state(app_id) + final_counter_state = final_state.get("counter") + final_counter = final_counter_state.value if final_counter_state else 0 + final_message_state = final_state.get("message") + final_message = final_message_state.value if final_message_state else "" + print_info("") + print_info("Final global state before deletion:") + print_info(f" counter: {final_counter}") + print_info(f' message: "{final_message}"') + + delete_result = algorand.send.app_delete( + AppDeleteParams( + sender=creator.addr, + app_id=app_id, + ) + ) + + print_info("") + print_info("Application deleted:") + print_info(f" Transaction ID: {delete_result.tx_ids[0]}") + print_info(f" Confirmed round: {delete_result.confirmation.confirmed_round}") + + print_info(f" App {app_id} deleted from the ledger") + + print_success("Application deleted successfully") + + # Clean up the other test app + algorand.send.app_delete( + AppDeleteParams( + sender=creator.addr, + app_id=other_app_id, + ) + ) + + # Step 11: Summary of application operations + print_step(11, "Summary - Application Operations API") + print_info("Application operations available through algorand.send:") + print_info("") + print_info("app_create(params):") + print_info(" sender: str - Creator of the application") + print_info(" approval_program: str | bytes - TEAL code or compiled bytes") + print_info(" clear_state_program: str | bytes - TEAL code or compiled bytes") + print_info(" schema: { global_ints, global_byte_slices, local_ints, local_byte_slices }") + print_info(" extra_program_pages: int - For large programs (auto-calculated)") + print_info(" Returns: { app_id, app_address, ...SendSingleTransactionResult }") + print_info("") + print_info("app_update(params):") + print_info(" sender: str - Must be authorized to update") + print_info(" app_id: int - Application to update") + print_info(" approval_program: str | bytes - New TEAL code") + print_info(" clear_state_program: str | bytes - New TEAL code") + print_info("") + print_info("app_call(params):") + print_info(" sender: str - Caller") + print_info(" app_id: int - Application to call") + print_info(" on_complete: OnComplete - NoOp, OptIn, CloseOut, ClearState") + print_info(" args: list[bytes] - Application arguments") + print_info(" account_references: list[str] - Accounts the app can access") + print_info(" app_references: list[int] - Apps the app can call") + print_info(" asset_references: list[int] - Assets the app can read") + print_info(" box_references: list[BoxReference] - Boxes the app can access") + print_info("") + print_info("app_delete(params):") + print_info(" sender: str - Must be authorized to delete") + print_info(" app_id: int - Application to delete") + print_info("") + print_info("OnComplete enum values:") + print_info(" NoOp (0) - Call without state changes") + print_info(" OptIn (1) - Opt into app (creates local state)") + print_info(" CloseOut (2) - Close out of app (removes local state)") + print_info(" ClearState (3) - Force clear local state (always succeeds)") + print_info(" UpdateApplication (4) - Update app code") + print_info(" DeleteApplication (5) - Delete the app") + print_info("") + print_info("Reading app state:") + print_info(" algorand.app.get_global_state(app_id) - Get global state") + print_info(" algorand.app.get_local_state(app_id, address) - Get local state") + print_info(" algorand.app.get_by_id(app_id) - Get app info including state") + + print_success("Send Application Operations example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/algorand_client/09_create_transaction.py b/examples/algorand_client/09_create_transaction.py new file mode 100644 index 00000000..ee0628aa --- /dev/null +++ b/examples/algorand_client/09_create_transaction.py @@ -0,0 +1,468 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Create Transaction (Unsigned Transactions) + +This example demonstrates how to create unsigned transactions without immediately +sending them, which is useful for: +- Transaction inspection and debugging +- Multi-party signing workflows +- Custom signing flows (hardware wallets, HSMs, etc.) +- Modifying transaction fields before signing +- Building transaction groups for atomic transactions + +Key concepts: +- algorand.create_transaction.payment() creates unsigned payment transactions +- algorand.create_transaction.asset_create() creates unsigned asset creation +- algorand.create_transaction.asset_transfer() creates unsigned asset transfers +- algorand.create_transaction.app_call() creates unsigned app calls +- Transaction objects have properties like tx_id(), fee, first_valid, last_valid +- Manual signing with account.signer() function +- Sending signed transactions via algorand.client.algod.send_raw_transaction() + +LocalNet required for suggested params and account funding +""" + +from shared import ( + format_algo, + load_teal_source, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_algod_client import AlgodClient +from algokit_algod_client.models import PendingTransactionResponse +from algokit_utils import AlgoAmount, AlgorandClient +from algokit_utils.transactions.types import ( + AppCallParams, + AppCreateParams, + AppDeleteParams, + AssetCreateParams, + AssetOptInParams, + AssetTransferParams, + PaymentParams, +) + +# Simple approval and clear state programs for demonstration +APPROVAL_PROGRAM = load_teal_source("simple-approve.teal") +CLEAR_STATE_PROGRAM = load_teal_source("clear-state-approve.teal") + + +def wait_for_confirmation(algod: AlgodClient, tx_id: str, max_rounds: int = 5) -> PendingTransactionResponse: + """Wait for a transaction to be confirmed using the model-based algod client.""" + status = algod.status() + current_round = status.last_round + end_round = current_round + max_rounds + + while current_round < end_round: + pending_info = algod.pending_transaction_information(tx_id) + if pending_info.confirmed_round and pending_info.confirmed_round > 0: + return pending_info + if pending_info.pool_error: + raise Exception(f"Transaction rejected: {pending_info.pool_error}") + algod.status_after_block(current_round) + current_round += 1 + + raise Exception(f"Transaction {tx_id} not confirmed after {max_rounds} rounds") + + +def main() -> None: + print_header("Create Transaction Example") + + # Initialize client and verify LocalNet is running + algorand = AlgorandClient.default_localnet() + + try: + algorand.client.algod.status() + print_success("Connected to LocalNet") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 1: Create and fund test accounts + print_step(1, "Create and fund test accounts") + print_info("Creating accounts for transaction creation demonstrations") + + sender = algorand.account.random() + receiver = algorand.account.random() + + print_info("") + print_info("Created accounts:") + print_info(f" Sender: {shorten_address(str(sender.addr))}") + print_info(f" Receiver: {shorten_address(str(receiver.addr))}") + + # Fund the sender account + algorand.account.ensure_funded_from_environment(sender.addr, AlgoAmount.from_algo(10)) + print_success("Created and funded test accounts") + + # Step 2: Create unsigned payment transaction + print_step(2, "Create unsigned payment with algorand.create_transaction.payment()") + print_info("Creating a payment transaction WITHOUT immediately sending it") + print_info("This allows inspection, modification, and custom signing flows") + + payment_txn = algorand.create_transaction.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_algo(1), + note=b"Unsigned payment transaction", + ) + ) + + print_info("") + print_info("Unsigned Payment Transaction created:") + print_info(f" Transaction ID: {payment_txn.tx_id()}") + print_info(f" Type: {payment_txn.transaction_type}") + print_info(f" Sender: {shorten_address(str(payment_txn.sender))}") + print_info(f" Receiver: {shorten_address(str(payment_txn.payment.receiver))}") + print_info(f" Amount: {format_algo(AlgoAmount.from_micro_algo(payment_txn.payment.amount))}") + print_info(f" Fee: {payment_txn.fee} uALGO") + print_info(f" First Valid: {payment_txn.first_valid}") + print_info(f" Last Valid: {payment_txn.last_valid}") + print_info(f" Genesis ID: {payment_txn.genesis_id}") + + print_success("Unsigned payment transaction created") + + # Step 3: Examine Transaction object properties + print_step(3, "Examine Transaction object properties and methods") + print_info("The Transaction object provides several useful properties and methods") + + print_info("") + print_info("Transaction properties:") + print_info(" tx_id(): str - Unique transaction identifier") + print_info(f" Example: {payment_txn.tx_id()}") + print_info("") + print_info(" transaction_type: TransactionType - Transaction type (Payment, AssetTransfer, etc.)") + print_info(f" Example: {payment_txn.transaction_type}") + print_info("") + print_info(" sender: str - The sender's address") + print_info(f" Example: {shorten_address(str(payment_txn.sender))}") + print_info("") + print_info(" fee: int - Transaction fee in microALGO") + print_info(f" Example: {payment_txn.fee} uALGO") + print_info("") + print_info(" first_valid/last_valid: int - Validity window (rounds)") + print_info(f" Example: {payment_txn.first_valid} to {payment_txn.last_valid}") + print_info("") + print_info(" note: bytes - Optional note field") + note_text = payment_txn.note.decode("utf-8") if payment_txn.note else "N/A" + print_info(f" Example: {note_text}") + print_info("") + print_info(" genesis_hash/genesis_id: Network identification") + print_info(f" Genesis ID: {payment_txn.genesis_id}") + + print_success("Transaction properties examined") + + # Step 4: Create unsigned asset creation transaction + print_step(4, "Create unsigned asset creation with algorand.create_transaction.asset_create()") + print_info("Creating an asset creation transaction without sending it") + + asset_create_txn = algorand.create_transaction.asset_create( + AssetCreateParams( + sender=sender.addr, + total=1_000_000, + decimals=2, + asset_name="Example Token", + unit_name="EXT", + url="https://example.com", + manager=sender.addr, + reserve=sender.addr, + freeze=sender.addr, + clawback=sender.addr, + ) + ) + + print_info("") + print_info("Unsigned Asset Create Transaction:") + print_info(f" Transaction ID: {asset_create_txn.tx_id()}") + print_info(f" Type: {asset_create_txn.transaction_type}") + print_info(f" Total supply: {asset_create_txn.asset_config.total} units") + print_info(f" Decimals: {asset_create_txn.asset_config.decimals}") + print_info(f" Asset name: {asset_create_txn.asset_config.asset_name}") + print_info(f" Unit name: {asset_create_txn.asset_config.unit_name}") + print_info(f" Fee: {asset_create_txn.fee} uALGO") + + print_success("Unsigned asset creation transaction created") + + # Step 5: Manually sign a transaction + print_step(5, "Manually sign a transaction with account.signer()") + print_info("Signing the payment transaction using the sender's signer function") + print_info("") + print_info("The signer function signature:") + print_info(" signer(txn_group: list[Transaction], indexes_to_sign: list[int]) -> list[bytes]") + print_info("") + print_info("Parameters:") + print_info(" txn_group: List of transactions (can be a single transaction)") + print_info(" indexes_to_sign: Indices of transactions to sign in the group") + + # Sign the transaction + signed_txns = sender.signer([payment_txn], [0]) + + print_info("") + print_info("Transaction signed:") + print_info(f" Number of signed transactions: {len(signed_txns)}") + print_info(f" Signed transaction size: {len(signed_txns[0])} bytes") + print_info(f" Transaction ID (unchanged): {payment_txn.tx_id()}") + + print_success("Transaction signed manually") + + # Step 6: Send a manually signed transaction + print_step(6, "Send a manually signed transaction") + print_info("Sending the signed transaction using algorand.client.algod.send_raw_transaction()") + + submit_result = algorand.client.algod.send_raw_transaction(signed_txns) + print_info("") + print_info("Transaction submitted:") + print_info(f" Transaction ID: {submit_result.tx_id}") + + # Wait for confirmation + algod = algorand.client.algod + confirmation = wait_for_confirmation(algod, payment_txn.tx_id()) + print_info(f" Confirmed in round: {confirmation.confirmed_round}") + + # Verify the transfer + receiver_info = algorand.account.get_information(receiver.addr) + print_info(f" Receiver balance: {format_algo(receiver_info.amount)}") + + print_success("Manually signed transaction sent and confirmed") + + # Step 7: Create and send unsigned asset creation (with signing) + print_step(7, "Create, sign, and send asset creation transaction") + print_info("Demonstrating the full workflow: create -> sign -> send") + + # Sign the asset creation transaction + signed_asset_create = sender.signer([asset_create_txn], [0]) + + # Send it + algorand.client.algod.send_raw_transaction(signed_asset_create) + asset_confirmation = wait_for_confirmation(algod, asset_create_txn.tx_id()) + + # Get the asset ID from the confirmation + asset_id = asset_confirmation.asset_id + + print_info("") + print_info("Asset created:") + print_info(f" Asset ID: {asset_id}") + print_info(f" Transaction ID: {asset_create_txn.tx_id()}") + print_info(f" Confirmed in round: {asset_confirmation.confirmed_round}") + + print_success("Asset creation completed via manual signing") + + # Step 8: Create unsigned asset transfer transaction + print_step(8, "Create unsigned asset transfer with algorand.create_transaction.asset_transfer()") + print_info("Creating an asset opt-in transaction (transfer to self with amount 0)") + + # First, opt-in the receiver to the asset + opt_in_txn = algorand.create_transaction.asset_opt_in( + AssetOptInParams( + sender=receiver.addr, + asset_id=asset_id, + ) + ) + + print_info("") + print_info("Unsigned Asset Opt-In Transaction:") + print_info(f" Transaction ID: {opt_in_txn.tx_id()}") + print_info(f" Type: {opt_in_txn.transaction_type}") + print_info(f" Asset ID: {opt_in_txn.asset_transfer.asset_id}") + print_info(f" Sender: {shorten_address(str(opt_in_txn.sender))}") + print_info(f" Receiver: {shorten_address(str(opt_in_txn.asset_transfer.receiver))}") + print_info(f" Amount: {opt_in_txn.asset_transfer.amount} (0 for opt-in)") + + # Fund receiver and sign/send opt-in + algorand.account.ensure_funded_from_environment(receiver.addr, AlgoAmount.from_algo(1)) + signed_opt_in = receiver.signer([opt_in_txn], [0]) + algorand.client.algod.send_raw_transaction(signed_opt_in) + wait_for_confirmation(algod, opt_in_txn.tx_id()) + + print_info("") + print_info("Opt-in completed") + + # Now create an asset transfer + asset_transfer_txn = algorand.create_transaction.asset_transfer( + AssetTransferParams( + sender=sender.addr, + receiver=receiver.addr, + asset_id=asset_id, + amount=100, + note=b"Asset transfer via unsigned transaction", + ) + ) + + print_info("") + print_info("Unsigned Asset Transfer Transaction:") + print_info(f" Transaction ID: {asset_transfer_txn.tx_id()}") + print_info(f" Asset ID: {asset_transfer_txn.asset_transfer.asset_id}") + print_info(f" Amount: {asset_transfer_txn.asset_transfer.amount} units") + + # Sign and send + signed_asset_transfer = sender.signer([asset_transfer_txn], [0]) + algorand.client.algod.send_raw_transaction(signed_asset_transfer) + wait_for_confirmation(algod, asset_transfer_txn.tx_id()) + + print_info(" Transfer completed successfully") + + print_success("Unsigned asset transfer demonstrated") + + # Step 9: Create unsigned app call transaction + print_step(9, "Create unsigned app call with algorand.create_transaction.app_call()") + print_info("First, create an app to call") + + # Create the app first (using send for simplicity) + app_create_result = algorand.send.app_create( + AppCreateParams( + sender=sender.addr, + approval_program=APPROVAL_PROGRAM, + clear_state_program=CLEAR_STATE_PROGRAM, + ) + ) + + app_id = app_create_result.app_id + print_info(f" App created with ID: {app_id}") + + # Now create an unsigned app call + app_call_txn = algorand.create_transaction.app_call( + AppCallParams( + sender=sender.addr, + app_id=app_id, + args=[b"hello", b"world"], + note=b"Unsigned app call", + ) + ) + + print_info("") + print_info("Unsigned App Call Transaction:") + print_info(f" Transaction ID: {app_call_txn.tx_id()}") + print_info(f" Type: {app_call_txn.transaction_type}") + print_info(f" App ID: {app_call_txn.application_call.app_id}") + print_info(f" On Complete: {app_call_txn.application_call.on_complete} (NoOp)") + args_count = len(app_call_txn.application_call.args) if app_call_txn.application_call.args else 0 + print_info(f" Args count: {args_count}") + print_info(f" Fee: {app_call_txn.fee} uALGO") + + # Sign and send + signed_app_call = sender.signer([app_call_txn], [0]) + algorand.client.algod.send_raw_transaction(signed_app_call) + wait_for_confirmation(algod, app_call_txn.tx_id()) + + print_info(" App call completed successfully") + + print_success("Unsigned app call demonstrated") + + # Step 10: Demonstrate modifying transaction fields before signing + print_step(10, "Demonstrate transaction inspection before signing") + print_info("You can inspect transaction fields before deciding to sign") + print_info("") + print_info("Use cases for unsigned transactions:") + print_info("") + print_info("1. Transaction Inspection:") + print_info(" - Verify sender, receiver, and amount before signing") + print_info(" - Check validity window (first_valid to last_valid)") + print_info(" - Ensure correct fees") + print_info("") + print_info("2. Multi-Party Signing:") + print_info(" - Create transaction on one device") + print_info(" - Send unsigned txn to another party for signing") + print_info(" - Useful for multi-sig wallets") + print_info("") + print_info("3. Custom Signing Flows:") + print_info(" - Hardware wallet integration") + print_info(" - HSM (Hardware Security Module) signing") + print_info(" - Air-gapped signing workflows") + print_info("") + print_info("4. Transaction Groups (Atomic Transactions):") + print_info(" - Create multiple unsigned transactions") + print_info(" - Group them together for atomic execution") + print_info(" - Sign all transactions in the group") + print_info("") + print_info("5. Simulation and Testing:") + print_info(" - Create transactions to simulate their effects") + print_info(" - Test transaction validity before signing") + + # Example: inspect before signing + inspect_txn = algorand.create_transaction.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_algo(0.5), + ) + ) + + print_info("") + print_info("Example - Inspecting before signing:") + print_info(f" Will send: {format_algo(AlgoAmount.from_micro_algo(inspect_txn.payment.amount))}") + print_info(f" To: {shorten_address(str(inspect_txn.payment.receiver))}") + print_info(f" Fee: {inspect_txn.fee} uALGO") + print_info(f" Valid until round: {inspect_txn.last_valid}") + + # Decide to sign based on inspection + one_algo_micro = AlgoAmount.from_algo(1).micro_algo + should_sign = inspect_txn.payment.amount <= one_algo_micro + if should_sign: + print_info(" Decision: Amount is acceptable, proceeding with signing") + signed = sender.signer([inspect_txn], [0]) + algorand.client.algod.send_raw_transaction(signed) + wait_for_confirmation(algod, inspect_txn.tx_id()) + print_info(" Transaction confirmed") + + print_success("Transaction inspection demonstrated") + + # Step 11: Summary + print_step(11, "Summary - Create Transaction API") + print_info("Transaction creation methods available through algorand.create_transaction:") + print_info("") + print_info("Payment:") + print_info(" create_transaction.payment(PaymentParams(sender, receiver, amount, ...))") + print_info(" Returns: Transaction (with .payment sub-fields)") + print_info("") + print_info("Asset Operations:") + print_info(" create_transaction.asset_create(AssetCreateParams(sender, total, decimals, ...))") + print_info(" create_transaction.asset_config(AssetConfigParams(sender, asset_id, ...))") + print_info(" create_transaction.asset_transfer(AssetTransferParams(sender, receiver, asset_id, amount))") + print_info(" create_transaction.asset_opt_in(AssetOptInParams(sender, asset_id))") + print_info(" create_transaction.asset_opt_out(AssetOptOutParams(sender, asset_id, creator))") + print_info(" create_transaction.asset_freeze(AssetFreezeParams(sender, asset_id, account, frozen))") + print_info(" create_transaction.asset_destroy(AssetDestroyParams(sender, asset_id))") + print_info("") + print_info("Application Operations:") + print_info(" create_transaction.app_create(AppCreateParams(sender, approval_program, clear_state_program))") + print_info( + " create_transaction.app_update(AppUpdateParams(sender, app_id, approval_program, clear_state_program))" + ) + print_info(" create_transaction.app_call(AppCallParams(sender, app_id, args, on_complete))") + print_info(" create_transaction.app_delete(AppDeleteParams(sender, app_id))") + print_info("") + print_info("Transaction Object Properties:") + print_info(" tx_id(): str - Get the transaction ID") + print_info(" transaction_type: TransactionType - Transaction type") + print_info(" sender: str - Sender address") + print_info(" fee: int - Fee in microALGO") + print_info(" first_valid/last_valid: int - Validity window") + print_info(" note: bytes - Note field") + print_info(" genesis_id/genesis_hash: Network identification") + print_info("") + print_info("Manual Signing:") + print_info(" signed_txns = account.signer([transaction], [0])") + print_info(" Returns: list[bytes] (encoded signed transactions)") + print_info("") + print_info("Sending Signed Transactions:") + print_info(" algorand.client.algod.send_raw_transaction(signed_txns)") + print_info(" Returns: { txId: str }") + + # Clean up + algorand.send.app_delete( + AppDeleteParams( + sender=sender.addr, + app_id=app_id, + ) + ) + + print_success("Create Transaction example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/algorand_client/10_transaction_composer.py b/examples/algorand_client/10_transaction_composer.py new file mode 100644 index 00000000..48dc9dcc --- /dev/null +++ b/examples/algorand_client/10_transaction_composer.py @@ -0,0 +1,460 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Transaction Composer (Atomic Transaction Groups) + +This example demonstrates how to build atomic transaction groups using +the transaction composer: +- algorand.new_group() creates a new transaction composer +- Adding multiple transactions using .add_payment(), .add_asset_opt_in(), etc. +- Method chaining: algorand.new_group().add_payment(...).add_payment(...) +- .simulate() to simulate the transaction group before sending +- .send() to execute the atomic transaction group +- Atomicity: all transactions succeed or fail together +- Adding transactions with different signers +- Group ID assigned to all transactions in the group + +LocalNet required for sending transactions +""" + +import base64 + +from shared import ( + format_algo, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_utils import AlgoAmount, AlgorandClient +from algokit_utils.transactions.types import ( + AssetCreateParams, + AssetDestroyParams, + AssetOptInParams, + AssetOptOutParams, + AssetTransferParams, + PaymentParams, +) + + +def main() -> None: + print_header("Transaction Composer Example") + + # Initialize client and verify LocalNet is running + algorand = AlgorandClient.default_localnet() + + try: + algorand.client.algod.status() + print_success("Connected to LocalNet") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 1: Create and fund test accounts + print_step(1, "Create and fund test accounts") + print_info("Creating multiple accounts to demonstrate atomic transactions with different signers") + + alice = algorand.account.random() + bob = algorand.account.random() + charlie = algorand.account.random() + + print_info("") + print_info("Created accounts:") + print_info(f" Alice: {shorten_address(str(alice.addr))}") + print_info(f" Bob: {shorten_address(str(bob.addr))}") + print_info(f" Charlie: {shorten_address(str(charlie.addr))}") + + # Fund accounts + algorand.account.ensure_funded_from_environment(alice.addr, AlgoAmount.from_algo(20)) + algorand.account.ensure_funded_from_environment(bob.addr, AlgoAmount.from_algo(10)) + algorand.account.ensure_funded_from_environment(charlie.addr, AlgoAmount.from_algo(5)) + + print_success("Created and funded test accounts") + + # Step 2: Demonstrate algorand.new_group() to create a new transaction composer + print_step(2, "Demonstrate algorand.new_group() to create a new transaction composer") + print_info("algorand.new_group() returns a TransactionComposer for building atomic groups") + print_info("") + print_info("The TransactionComposer provides:") + print_info(" - .add_payment() - Add payment transactions") + print_info(" - .add_asset_create() - Add asset creation transactions") + print_info(" - .add_asset_opt_in() - Add asset opt-in transactions") + print_info(" - .add_asset_transfer() - Add asset transfer transactions") + print_info(" - .add_app_call() - Add application call transactions") + print_info(" - .simulate() - Simulate the group before sending") + print_info(" - .send() - Execute the atomic transaction group") + + composer = algorand.new_group() + print_info("") + print_info("Created new transaction composer") + print_info(f" Initial transaction count: {composer.count()}") + + print_success("Transaction composer created") + + # Step 3: Add multiple transactions to the group + print_step(3, "Add multiple transactions using .add_payment(), etc.") + print_info("Each add method returns the composer for chaining") + + # Add first payment + composer.add_payment( + PaymentParams( + sender=alice.addr, + receiver=bob.addr, + amount=AlgoAmount.from_algo(1), + note=b"Payment 1: Alice to Bob", + ) + ) + print_info("") + print_info("Added payment: Alice -> Bob (1 ALGO)") + print_info(f" Transaction count: {composer.count()}") + + # Add second payment + composer.add_payment( + PaymentParams( + sender=alice.addr, + receiver=charlie.addr, + amount=AlgoAmount.from_algo(0.5), + note=b"Payment 2: Alice to Charlie", + ) + ) + print_info("Added payment: Alice -> Charlie (0.5 ALGO)") + print_info(f" Transaction count: {composer.count()}") + + print_success("Added multiple transactions to the group") + + # Step 4: Demonstrate method chaining + print_step(4, "Demonstrate chaining: algorand.new_group().add_payment(...).add_payment(...)") + print_info("Methods can be chained for fluent, readable code") + + chained_composer = ( + algorand.new_group() + .add_payment( + PaymentParams( + sender=alice.addr, + receiver=bob.addr, + amount=AlgoAmount.from_algo(0.25), + note=b"Chained payment 1", + ) + ) + .add_payment( + PaymentParams( + sender=alice.addr, + receiver=charlie.addr, + amount=AlgoAmount.from_algo(0.25), + note=b"Chained payment 2", + ) + ) + .add_payment( + PaymentParams( + sender=alice.addr, + receiver=bob.addr, + amount=AlgoAmount.from_algo(0.25), + note=b"Chained payment 3", + ) + ) + ) + + print_info("") + print_info("Chained 3 payments in a single fluent expression") + print_info(f" Transaction count: {chained_composer.count()}") + + print_success("Demonstrated method chaining") + + # Step 5: Demonstrate .simulate() to simulate before sending + print_step(5, "Demonstrate .simulate() to simulate the transaction group before sending") + print_info("Simulation allows you to preview results and check for failures without sending") + + simulate_result = chained_composer.simulate(skip_signatures=True) + + print_info("") + print_info("Simulation results:") + print_info(f" Transactions simulated: {len(simulate_result.transactions)}") + print_info(" Transaction IDs:") + for i, tx_id in enumerate(simulate_result.tx_ids): + print_info(f" [{i}]: {tx_id}") + print_info(f" Group ID: {simulate_result.group_id}") + + # Check simulation response for failures + simulate_response = simulate_result.simulate_response + group_result = simulate_response.txn_groups[0] + + print_info("") + print_info("Simulation response:") + would_succeed = group_result.failure_message is None + print_info(f" Would succeed: {would_succeed}") + if not would_succeed: + print_info(f" Failure message: {group_result.failure_message or 'N/A'}") + failed_at = group_result.failed_at or [] + print_info(f" Failed at index: {', '.join(map(str, failed_at)) if failed_at else 'N/A'}") + + # Show transaction results from simulation + print_info("") + print_info("Simulated transaction results:") + txn_results = group_result.txn_results or [] + for i, txn_result in enumerate(txn_results): + confirmed_round = ( + txn_result.txn_result.confirmed_round if txn_result.txn_result.confirmed_round else "N/A (simulated)" + ) + print_info(f" [{i}]: Confirmed round: {confirmed_round}") + + print_success("Simulation completed successfully") + + # Step 6: Demonstrate .send() to execute the atomic transaction group + print_step(6, "Demonstrate .send() to execute the atomic transaction group") + print_info("Calling .send() signs and submits all transactions atomically") + + # Use the original composer (not the chained one which was already used for simulation) + send_result = composer.send() + + print_info("") + print_info("Send results:") + print_info(f" Transactions sent: {len(send_result.transactions)}") + print_info(f" Group ID: {send_result.group_id}") + print_info("") + print_info("Transaction IDs and confirmations:") + for i, tx_id in enumerate(send_result.tx_ids): + confirmation = send_result.confirmations[i] + print_info(f" [{i}]: {tx_id}") + print_info(f" Confirmed in round: {confirmation.confirmed_round}") + + print_success("Atomic transaction group executed") + + # Step 7: Show that all transactions succeed or fail together (atomicity) + print_step(7, "Show that all transactions succeed or fail together (atomicity)") + print_info("Atomic groups ensure all-or-nothing execution") + print_info("") + print_info("Key atomicity properties:") + print_info(" - All transactions share the same group ID") + print_info(" - If any transaction fails, none are committed") + print_info(" - Transactions are executed in order within the group") + print_info("") + + # Verify all transactions have the same group ID + transactions = send_result.transactions + first_group_id = transactions[0].group if transactions[0].group else None + first_group_b64 = base64.b64encode(first_group_id).decode() if first_group_id else "" + all_same_group = all( + txn.group and first_group_id and base64.b64encode(txn.group).decode() == first_group_b64 for txn in transactions + ) + + print_info(f"All transactions have same group ID: {all_same_group}") + print_info(f"Group ID (base64): {send_result.group_id}") + + # Verify all confirmations are in the same round + first_round = send_result.confirmations[0].confirmed_round + all_same_round = all(conf.confirmed_round == first_round for conf in send_result.confirmations) + + print_info(f"All transactions confirmed in same round: {all_same_round}") + print_info(f"Confirmed round: {first_round}") + + print_success("Atomicity verified") + + # Step 8: Demonstrate adding transactions with different signers + print_step(8, "Demonstrate adding transactions with different signers") + print_info("Atomic groups can include transactions from multiple signers") + print_info("Each transaction uses the signer registered for its sender") + + # Create an asset first (Alice creates it with manager role for cleanup) + asset_create_result = algorand.send.asset_create( + AssetCreateParams( + sender=alice.addr, + total=1_000_000, + decimals=0, + asset_name="Multi-Signer Token", + unit_name="MST", + manager=alice.addr, # Manager role needed to destroy the asset later + ) + ) + asset_id = asset_create_result.asset_id + + print_info("") + print_info("Created asset for multi-signer demo:") + print_info(f" Asset ID: {asset_id}") + print_info(" Asset name: Multi-Signer Token") + + # Build a multi-signer atomic group: + # 1. Bob opts in to the asset (signed by Bob) + # 2. Alice transfers asset to Bob (signed by Alice) + # 3. Charlie pays Alice (signed by Charlie) + multi_signer_result = ( + algorand.new_group() + .add_asset_opt_in( + AssetOptInParams( + sender=bob.addr, # Signed by Bob + asset_id=asset_id, + ) + ) + .add_asset_transfer( + AssetTransferParams( + sender=alice.addr, # Signed by Alice + receiver=bob.addr, + asset_id=asset_id, + amount=100, + ) + ) + .add_payment( + PaymentParams( + sender=charlie.addr, # Signed by Charlie + receiver=alice.addr, + amount=AlgoAmount.from_algo(0.1), + note=b"Payment for asset", + ) + ) + .send() + ) + + print_info("") + print_info("Multi-signer atomic group executed:") + print_info(f" Transactions: {len(multi_signer_result.transactions)}") + print_info(f" Group ID: {multi_signer_result.group_id}") + print_info("") + print_info("Signer breakdown:") + txn0_sender = shorten_address(str(multi_signer_result.transactions[0].sender)) + txn1_sender = shorten_address(str(multi_signer_result.transactions[1].sender)) + txn2_sender = shorten_address(str(multi_signer_result.transactions[2].sender)) + print_info(f" [0] Asset Opt-In: Sender {txn0_sender} (Bob)") + print_info(f" [1] Asset Transfer: Sender {txn1_sender} (Alice)") + print_info(f" [2] Payment: Sender {txn2_sender} (Charlie)") + + print_success("Multi-signer atomic group completed") + + # Step 9: Show the group ID assigned to transactions + print_step(9, "Show the group ID assigned to transactions") + print_info("All transactions in a group share a unique group ID") + print_info("The group ID is a hash of all transactions in the group") + + print_info("") + print_info("Group ID details:") + group_id_len = len(multi_signer_result.group_id) if multi_signer_result.group_id else 0 + print_info(f" Group ID (base64): {multi_signer_result.group_id}") + print_info(f" Group ID length: {group_id_len} characters (base64)") + + print_info("") + print_info("Transaction group membership:") + for i, txn in enumerate(multi_signer_result.transactions): + group_base64 = base64.b64encode(txn.group).decode() if txn.group else "N/A" + matches = group_base64 == multi_signer_result.group_id + print_info(f" Transaction [{i}]:") + print_info(f" Type: {txn.transaction_type}") + print_info(f" Sender: {shorten_address(str(txn.sender))}") + print_info(f" Group ID matches: {matches}") + + print_success("Group ID demonstrated") + + # Step 10: Display all transaction IDs and confirmations + print_step(10, "Display all transaction IDs and confirmations") + print_info("Complete summary of the multi-signer atomic group") + + separator = "-" * 70 + print_info("") + print_info(separator) + print_info("Transaction Group Summary") + print_info(separator) + print_info(f"Group ID: {multi_signer_result.group_id}") + print_info(f"Total Transactions: {len(multi_signer_result.transactions)}") + print_info(separator) + + for i, txn in enumerate(multi_signer_result.transactions): + confirmation = multi_signer_result.confirmations[i] + tx_id = multi_signer_result.tx_ids[i] + + print_info("") + print_info(f"Transaction [{i}]:") + print_info(f" Transaction ID: {tx_id}") + print_info(f" Type: {txn.transaction_type}") + print_info(f" Sender: {shorten_address(str(txn.sender))}") + print_info(f" Fee: {txn.fee} uALGO") + print_info(f" First Valid: {txn.first_valid}") + print_info(f" Last Valid: {txn.last_valid}") + print_info(f" Confirmed Round: {confirmation.confirmed_round}") + + print_info("") + print_info(separator) + + # Verify final balances + alice_info = algorand.account.get_information(alice.addr) + bob_info = algorand.account.get_information(bob.addr) + charlie_info = algorand.account.get_information(charlie.addr) + + print_info("") + print_info("Final account balances:") + print_info(f" Alice: {format_algo(alice_info.amount)}") + print_info(f" Bob: {format_algo(bob_info.amount)}") + print_info(f" Charlie: {format_algo(charlie_info.amount)}") + + # Check Bob's asset balance + bob_assets = bob_info.assets + bob_asset_holding = None + if bob_assets: + for asset in bob_assets: + if asset["asset-id"] == asset_id: + bob_asset_holding = asset + break + bob_asset_amount = bob_asset_holding["amount"] if bob_asset_holding else 0 + print_info("") + print_info("Bob's asset holdings:") + print_info(f" Asset ID {asset_id}: {bob_asset_amount} units") + + print_success("Transaction Composer example completed!") + + # Step 11: Summary of TransactionComposer API + print_step(11, "Summary - TransactionComposer API") + print_info("The TransactionComposer provides a fluent API for atomic transaction groups:") + print_info("") + print_info("Creating a composer:") + print_info(" composer = algorand.new_group()") + print_info("") + print_info("Adding transactions:") + print_info(" .add_payment(PaymentParams(sender=..., receiver=..., amount=...))") + print_info(" .add_asset_create(AssetCreateParams(sender=..., total=..., decimals=...))") + print_info(" .add_asset_opt_in(AssetOptInParams(sender=..., asset_id=...))") + print_info(" .add_asset_transfer(AssetTransferParams(sender=..., receiver=..., asset_id=..., amount=...))") + print_info(" .add_asset_opt_out(AssetOptOutParams(sender=..., asset_id=..., creator=...))") + print_info(" .add_asset_config(AssetConfigParams(sender=..., asset_id=...))") + print_info(" .add_asset_freeze(AssetFreezeParams(sender=..., asset_id=..., account=..., frozen=...))") + print_info(" .add_asset_destroy(AssetDestroyParams(sender=..., asset_id=...))") + print_info(" .add_app_create(AppCreateParams(sender=..., approval_program=..., clear_state_program=...))") + print_info( + " .add_app_update(AppUpdateParams(sender=..., app_id=..., approval_program=..., clear_state_program=...))" + ) + print_info(" .add_app_call(AppCallParams(sender=..., app_id=...))") + print_info(" .add_app_delete(AppDeleteParams(sender=..., app_id=...))") + print_info(" .add_transaction(txn, signer?) - Add a pre-built transaction") + print_info("") + print_info("Executing:") + print_info(" .simulate(skip_signatures=True) - Preview without signing") + print_info(" .send() - Sign and submit atomically") + print_info("") + print_info("Utility methods:") + print_info(" .count() - Get number of transactions in the group") + print_info(" .build() - Build transactions without sending") + print_info(" .build_transactions() - Get raw unsigned transactions") + print_info("") + print_info("Key concepts:") + print_info(" - All transactions in a group share a unique group ID") + print_info(" - Atomic execution: all succeed or all fail") + print_info(" - Multiple signers supported (each tx uses its sender's signer)") + print_info(" - Maximum 16 transactions per group") + + # Clean up - Bob opts out (returns assets to Alice), then Alice destroys the asset + algorand.send.asset_opt_out( + AssetOptOutParams( + sender=bob.addr, + asset_id=asset_id, + creator=alice.addr, + ), + ensure_zero_balance=False, + ) + algorand.send.asset_destroy( + AssetDestroyParams( + sender=alice.addr, + asset_id=asset_id, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/examples/algorand_client/11_asset_manager.py b/examples/algorand_client/11_asset_manager.py new file mode 100644 index 00000000..3a4c69a1 --- /dev/null +++ b/examples/algorand_client/11_asset_manager.py @@ -0,0 +1,478 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Asset Manager + +This example demonstrates the AssetManager functionality for querying +asset information and performing bulk opt-in/opt-out operations: +- algorand.asset.get_by_id() to fetch asset information by asset ID +- algorand.asset.get_account_information() to get an account's asset holding +- algorand.asset.bulk_opt_in() to opt into multiple assets at once +- algorand.asset.bulk_opt_out() to opt out of multiple assets at once +- Efficiency comparison: bulk operations vs individual opt-ins +- Error handling for non-existent assets and non-opted-in accounts + +LocalNet required for asset operations +""" + +from shared import ( + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_utils import AlgoAmount, AlgorandClient +from algokit_utils.transactions.types import ( + AssetCreateParams, + AssetDestroyParams, + AssetOptInParams, + AssetOptOutParams, + AssetTransferParams, +) + + +def main() -> None: + print_header("Asset Manager Example") + + # Initialize client and verify LocalNet is running + algorand = AlgorandClient.default_localnet() + + try: + algorand.client.algod.status() + print_success("Connected to LocalNet") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 1: Create and fund test accounts + print_step(1, "Create and fund test accounts") + print_info("Creating accounts for asset manager demonstrations") + + creator = algorand.account.random() + holder = algorand.account.random() + + print_info("") + print_info("Created accounts:") + print_info(f" Creator: {shorten_address(str(creator.addr))}") + print_info(f" Holder: {shorten_address(str(holder.addr))}") + + # Fund accounts + algorand.account.ensure_funded_from_environment(creator.addr, AlgoAmount.from_algo(20)) + algorand.account.ensure_funded_from_environment(holder.addr, AlgoAmount.from_algo(10)) + + print_success("Created and funded test accounts") + + # Step 2: Create test assets + print_step(2, "Create test assets") + print_info("Creating multiple assets to demonstrate bulk operations") + + # Create first asset + asset1_result = algorand.send.asset_create( + AssetCreateParams( + sender=creator.addr, + total=1_000_000, + decimals=2, + asset_name="Asset Manager Token 1", + unit_name="AMT1", + url="https://example.com/amt1", + manager=creator.addr, + ) + ) + asset1_id = asset1_result.asset_id + + # Create second asset + asset2_result = algorand.send.asset_create( + AssetCreateParams( + sender=creator.addr, + total=500_000, + decimals=0, + asset_name="Asset Manager Token 2", + unit_name="AMT2", + url="https://example.com/amt2", + manager=creator.addr, + ) + ) + asset2_id = asset2_result.asset_id + + # Create third asset + asset3_result = algorand.send.asset_create( + AssetCreateParams( + sender=creator.addr, + total=10_000_000, + decimals=6, + asset_name="Asset Manager Token 3", + unit_name="AMT3", + url="https://example.com/amt3", + manager=creator.addr, + ) + ) + asset3_id = asset3_result.asset_id + + print_info("") + print_info("Created assets:") + print_info(f" Asset 1 (AMT1): ID {asset1_id}") + print_info(f" Asset 2 (AMT2): ID {asset2_id}") + print_info(f" Asset 3 (AMT3): ID {asset3_id}") + + print_success("Test assets created") + + # Step 3: Demonstrate algorand.asset.get_by_id() + print_step(3, "Demonstrate algorand.asset.get_by_id() to fetch asset information") + print_info("Fetching detailed information about an asset by its ID") + + asset_info = algorand.asset.get_by_id(asset1_id) + + print_info("") + print_info(f"Asset information for ID {asset1_id}:") + print_info(f" Asset ID (index): {asset_info.asset_id}") + print_info(f" Name: {asset_info.asset_name}") + print_info(f" Unit Name: {asset_info.unit_name}") + print_info(f" Total Supply: {asset_info.total} (smallest units)") + print_info(f" Decimals: {asset_info.decimals}") + print_info(f" Creator: {shorten_address(str(asset_info.creator))}") + manager_str = shorten_address(str(asset_info.manager)) if asset_info.manager else "none" + print_info(f" Manager: {manager_str}") + reserve_str = shorten_address(str(asset_info.reserve)) if asset_info.reserve else "none" + print_info(f" Reserve: {reserve_str}") + freeze_str = shorten_address(str(asset_info.freeze)) if asset_info.freeze else "none" + print_info(f" Freeze: {freeze_str}") + clawback_str = shorten_address(str(asset_info.clawback)) if asset_info.clawback else "none" + print_info(f" Clawback: {clawback_str}") + print_info(f" Default Frozen: {asset_info.default_frozen}") + print_info(f" URL: {asset_info.url or 'none'}") + + # Show all three assets for comparison + print_info("") + print_info("Comparing all created assets:") + asset2_info = algorand.asset.get_by_id(asset2_id) + asset3_info = algorand.asset.get_by_id(asset3_id) + + print_info("") + print_info(f" Asset 1: {asset_info.asset_name} ({asset_info.unit_name})") + print_info(f" Total: {asset_info.total} | Decimals: {asset_info.decimals}") + print_info(f" Asset 2: {asset2_info.asset_name} ({asset2_info.unit_name})") + print_info(f" Total: {asset2_info.total} | Decimals: {asset2_info.decimals}") + print_info(f" Asset 3: {asset3_info.asset_name} ({asset3_info.unit_name})") + print_info(f" Total: {asset3_info.total} | Decimals: {asset3_info.decimals}") + + print_success("Asset information retrieved") + + # Step 4: Handle case where asset doesn't exist + print_step(4, "Handle case where asset does not exist") + print_info("Demonstrating error handling for non-existent asset IDs") + + non_existent_asset_id = 999999999 + print_info("") + print_info(f"Attempting to fetch asset with ID {non_existent_asset_id}...") + + try: + algorand.asset.get_by_id(non_existent_asset_id) + print_error("Expected an error but none was thrown!") + except Exception as e: + error_message = str(e) + print_info(" Error caught: Asset not found") + print_info(f" Error details: {error_message[:80]}...") + + print_success("Non-existent asset handled correctly") + + # Step 5: Demonstrate algorand.asset.bulk_opt_in() + print_step(5, "Demonstrate algorand.asset.bulk_opt_in() to opt into multiple assets at once") + print_info("Bulk opt-in is more efficient than individual opt-ins") + print_info("Transactions are batched in groups of up to 16") + + asset_ids = [asset1_id, asset2_id, asset3_id] + print_info("") + print_info(f"Opting holder into {len(asset_ids)} assets in a single batch...") + + bulk_opt_in_results = algorand.asset.bulk_opt_in( + holder.addr, + asset_ids, + ) + + print_info("") + print_info("Bulk opt-in results:") + for result in bulk_opt_in_results: + tx_id_short = result.transaction_id[:20] + print_info(f" Asset {result.asset_id}: Transaction {tx_id_short}...") + + print_info("") + print_info(f"Total transactions: {len(bulk_opt_in_results)}") + print_info(f"Efficiency: {len(asset_ids)} assets opted in with a single method call") + + print_success("Bulk opt-in completed") + + # Step 6: Demonstrate algorand.asset.get_account_information() + print_step(6, "Demonstrate algorand.asset.get_account_information() to get account asset holding") + print_info("Fetching holder's asset holding information after opt-in") + + holding_info1 = algorand.asset.get_account_information(holder.addr, asset1_id) + + print_info("") + print_info(f"Holder's holding for Asset {asset1_id}:") + print_info(f" Asset ID: {holding_info1.asset_id}") + print_info(f" Balance: {holding_info1.balance} (smallest units)") + print_info(f" Frozen: {holding_info1.frozen}") + + # Transfer some assets to show non-zero balance + print_info("") + print_info("Transferring assets to holder...") + algorand.send.asset_transfer( + AssetTransferParams( + sender=creator.addr, + receiver=holder.addr, + asset_id=asset1_id, + amount=10_000, # 100 whole tokens (100 * 10^2) + ) + ) + algorand.send.asset_transfer( + AssetTransferParams( + sender=creator.addr, + receiver=holder.addr, + asset_id=asset2_id, + amount=500, + ) + ) + + # Re-fetch holding info + holding_info1_updated = algorand.asset.get_account_information(holder.addr, asset1_id) + holding_info2 = algorand.asset.get_account_information(holder.addr, asset2_id) + holding_info3 = algorand.asset.get_account_information(holder.addr, asset3_id) + + print_info("") + print_info("Updated holder balances:") + print_info(f" Asset {asset1_id} (AMT1): {holding_info1_updated.balance} (100 tokens with 2 decimals)") + print_info(f" Asset {asset2_id} (AMT2): {holding_info2.balance} (500 whole units)") + print_info(f" Asset {asset3_id} (AMT3): {holding_info3.balance} (no transfers yet)") + + print_success("Account asset information retrieved") + + # Step 7: Handle case where account not opted in + print_step(7, "Handle case where account is not opted in") + print_info("Demonstrating error handling when querying for assets not opted in") + + # Create a new account that hasn't opted in to any assets + non_opted_account = algorand.account.random() + algorand.account.ensure_funded_from_environment(non_opted_account.addr, AlgoAmount.from_algo(1)) + + print_info("") + print_info("Querying asset holding for account that hasn't opted in...") + + try: + algorand.asset.get_account_information(non_opted_account.addr, asset1_id) + print_error("Expected an error but none was thrown!") + except Exception as e: + error_message = str(e) + print_info(" Error caught: Account not opted in to asset") + print_info(f" Error details: {error_message[:80]}...") + + print_success("Non-opted-in account handled correctly") + + # Step 8: Compare bulk operations vs individual opt-ins + print_step(8, "Show how bulk operations are more efficient than individual opt-ins") + print_info("Comparing the approaches for clarity") + + print_info("") + print_info("Individual opt-in approach (NOT RECOMMENDED for multiple assets):") + print_info(" # Requires 3 separate transactions and 3 API calls") + print_info(" algorand.send.asset_opt_in(AssetOptInParams(sender=addr, asset_id=asset1_id))") + print_info(" algorand.send.asset_opt_in(AssetOptInParams(sender=addr, asset_id=asset2_id))") + print_info(" algorand.send.asset_opt_in(AssetOptInParams(sender=addr, asset_id=asset3_id))") + + print_info("") + print_info("Bulk opt-in approach (RECOMMENDED):") + print_info(" # Single method call, transactions batched in groups of 16") + print_info(" algorand.asset.bulk_opt_in(account, [asset1_id, asset2_id, asset3_id])") + + print_info("") + print_info("Efficiency benefits:") + print_info(" - Single method call for any number of assets") + print_info(" - Automatic batching (up to 16 transactions per group)") + print_info(" - Reduced code complexity") + print_info(" - Better error handling with clear result mapping") + + print_success("Efficiency comparison demonstrated") + + # Step 9: Prepare for bulk opt-out by transferring assets back + print_step(9, "Prepare for bulk opt-out") + print_info("Before opting out, all asset balances must be zero") + print_info("Transferring all held assets back to creator") + + # Transfer assets back + current_balance1 = algorand.asset.get_account_information(holder.addr, asset1_id) + current_balance2 = algorand.asset.get_account_information(holder.addr, asset2_id) + + if current_balance1.balance > 0: + algorand.send.asset_transfer( + AssetTransferParams( + sender=holder.addr, + receiver=creator.addr, + asset_id=asset1_id, + amount=current_balance1.balance, + ) + ) + print_info(f" Transferred {current_balance1.balance} units of Asset {asset1_id} back to creator") + + if current_balance2.balance > 0: + algorand.send.asset_transfer( + AssetTransferParams( + sender=holder.addr, + receiver=creator.addr, + asset_id=asset2_id, + amount=current_balance2.balance, + ) + ) + print_info(f" Transferred {current_balance2.balance} units of Asset {asset2_id} back to creator") + + # Verify zero balances + final_balance1 = algorand.asset.get_account_information(holder.addr, asset1_id) + final_balance2 = algorand.asset.get_account_information(holder.addr, asset2_id) + final_balance3 = algorand.asset.get_account_information(holder.addr, asset3_id) + + print_info("") + print_info("Verified zero balances:") + print_info(f" Asset {asset1_id}: {final_balance1.balance}") + print_info(f" Asset {asset2_id}: {final_balance2.balance}") + print_info(f" Asset {asset3_id}: {final_balance3.balance}") + + print_success("Ready for bulk opt-out") + + # Step 10: Demonstrate algorand.asset.bulk_opt_out() + print_step(10, "Demonstrate algorand.asset.bulk_opt_out() to opt out of multiple assets at once") + print_info("Bulk opt-out validates zero balances by default (ensure_zero_balance=True)") + + opt_out_asset_ids = [asset1_id, asset2_id, asset3_id] + print_info("") + print_info(f"Opting holder out of {len(opt_out_asset_ids)} assets in a single batch...") + + bulk_opt_out_results = algorand.asset.bulk_opt_out( + account=holder.addr, + asset_ids=opt_out_asset_ids, + ensure_zero_balance=True, # Default - validates balances before opting out + ) + + print_info("") + print_info("Bulk opt-out results:") + for result in bulk_opt_out_results: + tx_id_short = result.transaction_id[:20] + print_info(f" Asset {result.asset_id}: Transaction {tx_id_short}...") + + print_info("") + print_info(f"Total transactions: {len(bulk_opt_out_results)}") + print_info(f"Efficiency: {len(opt_out_asset_ids)} assets opted out with a single method call") + + # Verify opt-out + print_info("") + print_info("Verifying holder is no longer opted in...") + for asset_id in opt_out_asset_ids: + try: + algorand.asset.get_account_information(holder.addr, asset_id) + print_error(f"Holder should not be opted in to asset {asset_id}!") + except Exception: + print_info(f" Asset {asset_id}: Confirmed not opted in") + + print_success("Bulk opt-out completed") + + # Step 11: Demonstrate error handling for bulk opt-out with non-zero balance + print_step(11, "Demonstrate error handling: bulk opt-out with non-zero balance") + print_info("bulk_opt_out throws an error if ensure_zero_balance is True and balance is non-zero") + + # First, opt back in to an asset and transfer some tokens + algorand.send.asset_opt_in( + AssetOptInParams( + sender=holder.addr, + asset_id=asset1_id, + ) + ) + algorand.send.asset_transfer( + AssetTransferParams( + sender=creator.addr, + receiver=holder.addr, + asset_id=asset1_id, + amount=100, + ) + ) + + print_info("") + print_info(f"Holder has balance of 100 for Asset {asset1_id}") + print_info("Attempting bulk opt-out with ensure_zero_balance=True...") + + try: + algorand.asset.bulk_opt_out( + account=holder.addr, + asset_ids=[asset1_id], + ensure_zero_balance=True, + ) + print_error("Expected an error but none was thrown!") + except Exception as e: + error_message = str(e) + print_info(" Error caught: Non-zero balance prevents opt-out") + print_info(f" Error details: {error_message[:100]}...") + + # Clean up - transfer back and opt out + algorand.send.asset_transfer( + AssetTransferParams( + sender=holder.addr, + receiver=creator.addr, + asset_id=asset1_id, + amount=100, + ) + ) + algorand.send.asset_opt_out( + AssetOptOutParams( + sender=holder.addr, + asset_id=asset1_id, + creator=creator.addr, + ), + ensure_zero_balance=True, + ) + + print_success("Error handling demonstrated") + + # Step 12: Summary + print_step(12, "Summary - Asset Manager API") + print_info("The AssetManager provides efficient asset operations:") + print_info("") + print_info("algorand.asset.get_by_id(asset_id):") + print_info(" - Fetches complete asset information by ID") + print_info(" - Returns: AssetInformation object with all asset properties") + print_info(" - Properties: asset_id, asset_name, unit_name, total, decimals,") + print_info(" creator, manager, reserve, freeze, clawback, default_frozen, url") + print_info("") + print_info("algorand.asset.get_account_information(account, asset_id):") + print_info(" - Fetches an account's holding for a specific asset") + print_info(" - Returns: AccountAssetInformation object") + print_info(" - Properties: asset_id, balance, frozen") + print_info(" - Throws if account is not opted in to the asset") + print_info("") + print_info("algorand.asset.bulk_opt_in(account, asset_ids):") + print_info(" - Opts an account into multiple assets at once") + print_info(" - Batches transactions in groups of 16 (max atomic group size)") + print_info(" - Returns: list[BulkAssetOptInOutResult] with asset_id and transaction_id") + print_info(" - More efficient than individual asset_opt_in calls") + print_info("") + print_info("algorand.asset.bulk_opt_out(account=..., asset_ids=..., ensure_zero_balance=True):") + print_info(" - Opts an account out of multiple assets at once") + print_info(" - ensure_zero_balance=True (default) validates balances first") + print_info(" - Batches transactions in groups of 16") + print_info(" - Returns: list[BulkAssetOptInOutResult] with asset_id and transaction_id") + print_info(" - Automatically fetches asset creators for opt-out transactions") + print_info("") + print_info("Bulk operation benefits:") + print_info(" - Single method call for any number of assets") + print_info(" - Automatic batching for optimal efficiency") + print_info(" - Consistent result format with asset ID to transaction ID mapping") + print_info(" - Built-in validation for safe opt-out operations") + + # Clean up - destroy test assets + algorand.send.asset_destroy(AssetDestroyParams(sender=creator.addr, asset_id=asset1_id)) + algorand.send.asset_destroy(AssetDestroyParams(sender=creator.addr, asset_id=asset2_id)) + algorand.send.asset_destroy(AssetDestroyParams(sender=creator.addr, asset_id=asset3_id)) + + print_success("Asset Manager example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/algorand_client/12_app_manager.py b/examples/algorand_client/12_app_manager.py new file mode 100644 index 00000000..cb306c2b --- /dev/null +++ b/examples/algorand_client/12_app_manager.py @@ -0,0 +1,486 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: App Manager + +This example demonstrates the AppManager functionality for querying +application information, state, box storage, and TEAL compilation: +- algorand.app.get_by_id() to fetch application information +- algorand.app.get_global_state() to read global state +- algorand.app.get_local_state() to read account's local state +- algorand.app.get_box_names() to list all box names for an app +- algorand.app.get_box_value() to read a specific box value +- algorand.app.get_box_values() to read multiple box values +- algorand.app.get_box_values_from_abi_type() to decode typed box values +- algorand.app.compile_teal() to compile TEAL source code +- algorand.app.compile_teal_template() to compile TEAL with template variables + +LocalNet required for app operations +""" + +from shared import ( + load_teal_source, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_abi.abi import ABIType +from algokit_transact import OnApplicationComplete +from algokit_utils import AlgoAmount, AlgorandClient +from algokit_utils.transactions.types import ( + AppCallParams, + AppCreateParams, + AppDeleteParams, + PaymentParams, +) + +# ============================================================================ +# TEAL Programs - loaded from shared artifacts +# ============================================================================ + +# A stateful app that supports global state, local state, and box storage +APPROVAL_PROGRAM = load_teal_source("approval-box-storage.teal") + +# Clear state program (must always approve) +CLEAR_STATE_PROGRAM = load_teal_source("clear-state-approve.teal") + +# A TEAL template with replaceable parameters +TEAL_TEMPLATE = load_teal_source("teal-template-basic.teal") + +# A TEAL template with AlgoKit deploy-time control parameters +ALGOKIT_TEMPLATE = load_teal_source("teal-template-deploy-control.teal") + + +def main() -> None: + print_header("App Manager Example") + + # Initialize client and verify LocalNet is running + algorand = AlgorandClient.default_localnet() + + try: + algorand.client.algod.status() + print_success("Connected to LocalNet") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 1: Create and fund test accounts + print_step(1, "Create and fund test accounts") + print_info("Creating accounts for app manager demonstrations") + + creator = algorand.account.random() + user = algorand.account.random() + + print_info("") + print_info("Created accounts:") + print_info(f" Creator: {shorten_address(str(creator.addr))}") + print_info(f" User: {shorten_address(str(user.addr))}") + + # Fund accounts + algorand.account.ensure_funded_from_environment(creator.addr, AlgoAmount.from_algo(20)) + algorand.account.ensure_funded_from_environment(user.addr, AlgoAmount.from_algo(10)) + + print_success("Created and funded test accounts") + + # Step 2: Deploy a test application with state and boxes + print_step(2, "Deploy a test application with state and boxes") + print_info("Creating an app with global state, local state schema, and box storage") + + create_result = algorand.send.app_create( + AppCreateParams( + sender=creator.addr, + approval_program=APPROVAL_PROGRAM, + clear_state_program=CLEAR_STATE_PROGRAM, + schema={ + "global_ints": 1, # counter + "global_byte_slices": 2, # message, creator + "local_ints": 2, # user_score, opted_in_round + "local_byte_slices": 0, + }, + ) + ) + + app_id = create_result.app_id + app_address = create_result.app_address + + print_info("") + print_info("Application created:") + print_info(f" App ID: {app_id}") + print_info(f" App Address: {shorten_address(str(app_address))}") + print_info(f" Transaction ID: {create_result.tx_ids[0]}") + + print_success("Test application deployed") + + # Step 3: Demonstrate algorand.app.get_by_id() + print_step(3, "Demonstrate algorand.app.get_by_id() to fetch application information") + print_info("Fetching complete application information by ID") + + app_info = algorand.app.get_by_id(app_id) + + print_info("") + print_info("Application information:") + print_info(f" App ID: {app_info.app_id}") + print_info(f" App Address: {shorten_address(str(app_info.app_address))}") + print_info(f" Creator: {shorten_address(str(app_info.creator))}") + print_info(" Global State Schema:") + print_info(f" global_ints: {app_info.global_ints}") + print_info(f" global_byte_slices: {app_info.global_byte_slices}") + print_info(" Local State Schema:") + print_info(f" local_ints: {app_info.local_ints}") + print_info(f" local_byte_slices: {app_info.local_byte_slices}") + extra_pages = app_info.extra_program_pages if app_info.extra_program_pages else 0 + print_info(f" Extra Program Pages: {extra_pages}") + print_info(f" Approval Program: {len(app_info.approval_program)} bytes") + print_info(f" Clear State Program: {len(app_info.clear_state_program)} bytes") + + print_success("Application information retrieved") + + # Step 4: Demonstrate algorand.app.get_global_state() + print_step(4, "Demonstrate algorand.app.get_global_state() to read global state") + print_info("Reading all global state key-value pairs") + + global_state = algorand.app.get_global_state(app_id) + + print_info("") + print_info("Global state entries:") + for key, state_value in global_state.items(): + if state_value.value_raw is not None: + # Byte slice value + print_info(f' "{key}": "{state_value.value}" (bytes)') + else: + # Integer value + print_info(f' "{key}": {state_value.value} (uint64)') + + # Increment counter a few times + print_info("") + print_info("Incrementing counter...") + for i in range(3): + algorand.send.app_call( + AppCallParams( + sender=creator.addr, + app_id=app_id, + args=[b"increment"], + note=f"increment-{i}".encode(), + ) + ) + + updated_global_state = algorand.app.get_global_state(app_id) + counter_entry = updated_global_state.get("counter") + counter_value = counter_entry.value if counter_entry else 0 + print_info(f" Counter after 3 increments: {counter_value}") + + print_success("Global state read successfully") + + # Step 5: Demonstrate algorand.app.get_local_state() + print_step(5, "Demonstrate algorand.app.get_local_state() to read local state") + print_info("User must opt in first to have local state") + + # Opt user into the app + algorand.send.app_call( + AppCallParams( + sender=user.addr, + app_id=app_id, + on_complete=OnApplicationComplete.OptIn, + ) + ) + print_info("User opted in to the application") + + local_state = algorand.app.get_local_state(app_id, user.addr) + + print_info("") + print_info("User's local state:") + for key, state_value in local_state.items(): + if state_value.value_raw is not None: + print_info(f' "{key}": "{state_value.value}" (bytes)') + else: + print_info(f' "{key}": {state_value.value} (uint64)') + + print_info("") + print_info("Local state was initialized on opt-in with:") + user_score_entry = local_state.get("user_score") + user_score_value = user_score_entry.value if user_score_entry else 0 + opted_in_round_entry = local_state.get("opted_in_round") + opted_in_round_value = opted_in_round_entry.value if opted_in_round_entry else 0 + print_info(f" user_score: {user_score_value} (initial value)") + print_info(f" opted_in_round: {opted_in_round_value} (round when opted in)") + + print_success("Local state read successfully") + + # Step 6: Create boxes and demonstrate box operations + print_step(6, "Demonstrate box storage operations") + print_info("Creating boxes to store application data") + + # Fund the app account for box storage (boxes require MBR) + algorand.send.payment( + PaymentParams( + sender=creator.addr, + receiver=app_address, + amount=AlgoAmount.from_algo(1), # Fund for box storage MBR + ) + ) + + # Create multiple boxes with different content + box_data = [ + {"name": "user_data", "value": "Alice:100:premium"}, + {"name": "config", "value": '{"version":1,"enabled":true}'}, + {"name": "scores", "value": "high:9999,low:1"}, + ] + + for box in box_data: + algorand.send.app_call( + AppCallParams( + sender=creator.addr, + app_id=app_id, + args=[ + b"set_box", + box["name"].encode(), + box["value"].encode(), + ], + box_references=[box["name"]], + ) + ) + print_info(f' Created box "{box["name"]}" with {len(box["value"])} bytes') + + print_success("Boxes created") + + # Step 7: Demonstrate algorand.app.get_box_names() + print_step(7, "Demonstrate algorand.app.get_box_names() to list all boxes") + print_info("Retrieving all box names for the application") + + box_names = algorand.app.get_box_names(app_id) + + print_info("") + print_info(f"Application has {len(box_names)} boxes:") + for box_name in box_names: + print_info(f' Name: "{box_name.name}"') + print_info(f" Raw bytes: {len(box_name.name_raw)} bytes") + print_info(f" Base64: {box_name.name_base64}") + + print_success("Box names retrieved") + + # Step 8: Demonstrate algorand.app.get_box_value() + print_step(8, "Demonstrate algorand.app.get_box_value() to read a single box") + print_info("Reading the value of a specific box by name") + + box_value = algorand.app.get_box_value(app_id, "user_data") + + print_info("") + print_info('Box "user_data" value:') + print_info(f" Raw bytes: {len(box_value)} bytes") + print_info(f' As string: "{box_value.decode()}"') + + # Read another box + config_value = algorand.app.get_box_value(app_id, "config") + print_info("") + print_info('Box "config" value:') + print_info(f' As string: "{config_value.decode()}"') + + print_success("Box value retrieved") + + # Step 9: Demonstrate algorand.app.get_box_values() + print_step(9, "Demonstrate algorand.app.get_box_values() to read multiple boxes at once") + print_info("Reading multiple box values in a single call") + + all_box_values = algorand.app.get_box_values(app_id, ["user_data", "config", "scores"]) + + print_info("") + print_info(f"Retrieved {len(all_box_values)} box values:") + box_names_array = ["user_data", "config", "scores"] + for i, val in enumerate(all_box_values): + print_info(f' "{box_names_array[i]}": "{val.decode()}"') + + print_success("Multiple box values retrieved") + + # Step 10: Demonstrate algorand.app.get_box_values_from_abi_type() + print_step(10, "Demonstrate algorand.app.get_box_values_from_abi_type() for typed box decoding") + print_info("Creating boxes with ABI-encoded values and decoding them") + + # Create a box with ABI-encoded uint64 value + abi_type = ABIType.from_string("uint64") + encoded_value = abi_type.encode(42) + + algorand.send.app_call( + AppCallParams( + sender=creator.addr, + app_id=app_id, + args=[ + b"set_box", + b"abi_number", + encoded_value, + ], + box_references=[b"abi_number"], + ) + ) + print_info('Created box "abi_number" with ABI-encoded uint64 value') + + # Read and decode the ABI value + decoded_values = algorand.app.get_box_values_from_abi_type(app_id, ["abi_number"], abi_type) + + print_info("") + print_info("Decoded ABI values:") + print_info(f' "abi_number" (uint64): {decoded_values[0]}') + + # Create boxes with ABI-encoded string values + string_type = ABIType.from_string("string") + encoded_string = string_type.encode("Hello, ABI!") + + algorand.send.app_call( + AppCallParams( + sender=creator.addr, + app_id=app_id, + args=[ + b"set_box", + b"abi_string", + encoded_string, + ], + box_references=[b"abi_string"], + ) + ) + + decoded_strings = algorand.app.get_box_values_from_abi_type(app_id, ["abi_string"], string_type) + + print_info(f' "abi_string" (string): "{decoded_strings[0]}"') + + print_success("ABI-typed box values decoded") + + # Step 11: Demonstrate algorand.app.compile_teal() + print_step(11, "Demonstrate algorand.app.compile_teal() to compile TEAL source") + print_info("Compiling TEAL code and examining the result") + + simple_teal = load_teal_source("simple-approve.teal") + + compiled = algorand.app.compile_teal(simple_teal) + + print_info("") + print_info("Compilation result:") + print_info(f" Original TEAL: {len(compiled.teal.splitlines())} lines") + print_info(f" Compiled (base64): {compiled.compiled[:30]}...") + print_info(f" Compiled hash: {compiled.compiled_hash}") + print_info(f" Compiled bytes: {len(compiled.compiled_base64_to_bytes)} bytes") + source_map_available = compiled.source_map is not None + print_info(f" Source map available: {source_map_available}") + + # Compile the approval program + approval_compiled = algorand.app.compile_teal(APPROVAL_PROGRAM) + print_info("") + print_info("Approval program compilation:") + print_info(f" Original: {len(APPROVAL_PROGRAM.splitlines())} lines") + print_info(f" Compiled: {len(approval_compiled.compiled_base64_to_bytes)} bytes") + + print_success("TEAL compilation successful") + + # Step 12: Demonstrate algorand.app.compile_teal_template() + print_step(12, "Demonstrate algorand.app.compile_teal_template() with template variables") + print_info("Compiling TEAL templates with parameter substitution") + + # Compile template with custom parameters + compiled_template = algorand.app.compile_teal_template( + TEAL_TEMPLATE, + template_params={ + "TMPL_INT_VALUE": 42, + "TMPL_BYTES_VALUE": "hello", + }, + ) + + print_info("") + print_info("Template compilation with custom parameters:") + print_info(" TMPL_INT_VALUE: 42") + print_info(' TMPL_BYTES_VALUE: "hello"') + print_info(f" Compiled bytes: {len(compiled_template.compiled_base64_to_bytes)} bytes") + + # Compile AlgoKit template with deploy-time control parameters + compiled_updatable = algorand.app.compile_teal_template( + ALGOKIT_TEMPLATE, + template_params=None, + deployment_metadata={"updatable": True, "deletable": False}, + ) + + print_info("") + print_info("AlgoKit template with deploy-time controls:") + print_info(" updatable: True") + print_info(" deletable: False") + print_info(f" Compiled bytes: {len(compiled_updatable.compiled_base64_to_bytes)} bytes") + + # Compile with different control values + compiled_immutable = algorand.app.compile_teal_template( + ALGOKIT_TEMPLATE, + template_params=None, + deployment_metadata={"updatable": False, "deletable": False}, + ) + + print_info("") + print_info("Immutable version (updatable: False, deletable: False):") + print_info(f" Compiled bytes: {len(compiled_immutable.compiled_base64_to_bytes)} bytes") + print_info(" Note: Different control values produce different bytecode") + + print_success("TEAL template compilation successful") + + # Step 13: Summary + print_step(13, "Summary - App Manager API") + print_info("The AppManager provides comprehensive application query and compile capabilities:") + print_info("") + print_info("algorand.app.get_by_id(app_id):") + print_info(" - Fetches complete application information") + print_info(" - Returns: AppInformation with app_id, app_address, creator, programs, schemas") + print_info("") + print_info("algorand.app.get_global_state(app_id):") + print_info(" - Reads all global state key-value pairs") + print_info(" - Returns: dict[str, AppState] keyed by UTF-8 strings") + print_info(" - Values are AppState dataclasses with .value attribute") + print_info("") + print_info("algorand.app.get_local_state(app_id, address):") + print_info(" - Reads an account's local state for an app") + print_info(" - Account must be opted in to the application") + print_info(" - Returns: dict[str, AppState] with local key-value pairs") + print_info("") + print_info("algorand.app.get_box_names(app_id):") + print_info(" - Lists all box names for an application") + print_info(" - Returns: list[BoxName] with name, name_raw, name_base64") + print_info("") + print_info("algorand.app.get_box_value(app_id, box_name):") + print_info(" - Reads a single box value by name") + print_info(" - Returns: bytes of raw box contents") + print_info("") + print_info("algorand.app.get_box_values(app_id, box_names):") + print_info(" - Reads multiple box values in one call") + print_info(" - Returns: list[bytes] in same order as input names") + print_info("") + print_info("algorand.app.get_box_values_from_abi_type(app_id, box_names, abi_type):") + print_info(" - Reads and decodes box values using ABI types") + print_info(" - Supports all ABI types: uint64, string, address, arrays, tuples") + print_info(" - Returns: list of decoded values according to specified type") + print_info("") + print_info("algorand.app.compile_teal(teal_code):") + print_info(" - Compiles TEAL source code") + print_info(" - Returns: CompiledTeal with compiled bytes, hash, source map") + print_info(" - Results are cached to avoid recompilation") + print_info("") + print_info("algorand.app.compile_teal_template(template, template_params, deployment_metadata):") + print_info(" - Compiles TEAL with template parameter substitution") + print_info(" - Supports custom TMPL_* parameters") + print_info(" - Supports AlgoKit deploy-time controls (TMPL_UPDATABLE, TMPL_DELETABLE)") + + # Clean up - close out user and delete app + algorand.send.app_call( + AppCallParams( + sender=user.addr, + app_id=app_id, + on_complete=OnApplicationComplete.CloseOut, + ) + ) + algorand.send.app_delete( + AppDeleteParams( + sender=creator.addr, + app_id=app_id, + ) + ) + + print_success("App Manager example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/algorand_client/13_app_deployer.py b/examples/algorand_client/13_app_deployer.py new file mode 100644 index 00000000..8ac4b8d6 --- /dev/null +++ b/examples/algorand_client/13_app_deployer.py @@ -0,0 +1,515 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: App Deployer + +This example demonstrates the AppDeployer functionality for idempotent +application deployment with create, update, and replace strategies: +- algorand.app_deployer.deploy() for initial deployment +- Deploy parameters: name, version, approval_program, clear_program, schema, on_update, on_schema_break +- Idempotency: calling deploy() again with same version does nothing +- on_update: 'update' to update existing app when version changes +- on_update: 'replace' to delete and recreate app when version changes +- on_update: 'fail' to fail if app already exists with different code +- on_schema_break: 'replace' when schema changes require new app +- Deployment metadata stored in app global state +- App name used for idempotent lookups + +LocalNet required for app deployment +""" + +from shared import ( + load_teal_source, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_utils import ( + AlgoAmount, + AlgorandClient, + AppCreateParams, + AppDeleteParams, + AppDeploymentMetaData, + AppDeployParams, + AppUpdateParams, + OperationPerformed, +) + +# ============================================================================ +# TEAL Programs - Versioned Application (loaded from shared artifacts) +# ============================================================================ + + +def get_versioned_approval_program(version: int) -> str: + """ + Generate a versioned approval program that supports updates and deletes. + Uses TMPL_UPDATABLE and TMPL_DELETABLE for deploy-time control. + The version parameter changes the bytecode to simulate code updates. + """ + return load_teal_source("teal-template-versioned.teal").replace("TMPL_VERSION", str(version)) + + +# Clear state program (always approves) +CLEAR_STATE_PROGRAM = load_teal_source("clear-state-approve.teal") + + +def main() -> None: + print_header("App Deployer Example") + + # Initialize client and verify LocalNet is running + algorand = AlgorandClient.default_localnet() + + try: + algorand.client.algod.status() + print_success("Connected to LocalNet") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 1: Create and fund test accounts + print_step(1, "Create and fund test accounts") + print_info("Creating account for app deployment demonstrations") + + deployer = algorand.account.random() + + print_info("") + print_info("Created account:") + print_info(f" Deployer: {shorten_address(str(deployer.addr))}") + + # Fund account generously for multiple deployments + algorand.account.ensure_funded_from_environment(deployer.addr, AlgoAmount.from_algo(50)) + + print_success("Created and funded test account") + + # Step 2: Initial deployment with app_deployer.deploy() + print_step(2, "Initial deployment with algorand.app_deployer.deploy()") + print_info("Deploying a versioned application for the first time") + + app_name = "MyVersionedApp" + + result1 = algorand.app_deployer.deploy( + AppDeployParams( + metadata=AppDeploymentMetaData( + name=app_name, + version="1.0.0", + updatable=True, # Allow updates via TMPL_UPDATABLE + deletable=True, # Allow deletion via TMPL_DELETABLE + ), + create_params=AppCreateParams( + sender=deployer.addr, + approval_program=get_versioned_approval_program(1), + clear_state_program=CLEAR_STATE_PROGRAM, + schema={ + "global_ints": 2, # version, counter + "global_byte_slices": 0, + "local_ints": 0, + "local_byte_slices": 0, + }, + ), + update_params=AppUpdateParams( + sender=deployer.addr, + app_id=0, + approval_program="", + clear_state_program="", + ), + delete_params=AppDeleteParams( + sender=deployer.addr, + app_id=0, + ), + ) + ) + + print_info("") + print_info("Deployment result:") + print_info(f" Operation performed: {result1.operation_performed}") + print_info(f" App ID: {result1.app.app_id}") + print_info(f" App Address: {shorten_address(str(result1.app.app_address))}") + print_info(f" App Name: {result1.app.name}") + print_info(f" Version: {result1.app.version}") + print_info(f" Updatable: {result1.app.updatable}") + print_info(f" Deletable: {result1.app.deletable}") + if result1.create_result and result1.create_result.tx_ids: + print_info(f" Transaction ID: {result1.create_result.tx_ids[0]}") + + print_success("Initial deployment completed (operation: create)") + + # Step 3: Demonstrate idempotency - same version does nothing + print_step(3, "Demonstrate idempotency - deploy same version again") + print_info("Calling deploy() again with the same version should do nothing") + + result2 = algorand.app_deployer.deploy( + AppDeployParams( + metadata=AppDeploymentMetaData( + name=app_name, + version="1.0.0", # Same version + updatable=True, + deletable=True, + ), + create_params=AppCreateParams( + sender=deployer.addr, + approval_program=get_versioned_approval_program(1), # Same code + clear_state_program=CLEAR_STATE_PROGRAM, + schema={ + "global_ints": 2, + "global_byte_slices": 0, + "local_ints": 0, + "local_byte_slices": 0, + }, + ), + update_params=AppUpdateParams( + sender=deployer.addr, + app_id=0, + approval_program="", + clear_state_program="", + ), + delete_params=AppDeleteParams( + sender=deployer.addr, + app_id=0, + ), + ) + ) + + print_info("") + print_info("Idempotent deployment result:") + print_info(f" Operation performed: {result2.operation_performed}") + print_info(f" App ID: {result2.app.app_id} (same as before)") + print_info(f" Version: {result2.app.version}") + if result2.operation_performed == OperationPerformed.Nothing: + print_info(" Note: No transaction was sent - app is unchanged") + + print_success("Idempotency verified - no action taken for same version") + + # Step 4: Demonstrate on_update: 'update' + print_step(4, "Demonstrate on_update: 'update' - update existing app") + print_info('Deploying version 2.0.0 with on_update="update" to update the existing app') + + result3 = algorand.app_deployer.deploy( + AppDeployParams( + metadata=AppDeploymentMetaData( + name=app_name, + version="2.0.0", # New version + updatable=True, + deletable=True, + ), + create_params=AppCreateParams( + sender=deployer.addr, + approval_program=get_versioned_approval_program(2), # Updated code + clear_state_program=CLEAR_STATE_PROGRAM, + schema={ + "global_ints": 2, + "global_byte_slices": 0, + "local_ints": 0, + "local_byte_slices": 0, + }, + ), + update_params=AppUpdateParams( + sender=deployer.addr, + app_id=0, + approval_program="", + clear_state_program="", + ), + delete_params=AppDeleteParams( + sender=deployer.addr, + app_id=0, + ), + on_update="update", # Update the existing app + ) + ) + + print_info("") + print_info("Update deployment result:") + print_info(f" Operation performed: {result3.operation_performed}") + print_info(f" App ID: {result3.app.app_id} (same app, updated in place)") + print_info(f" Version: {result3.app.version}") + print_info(f" Created round: {result3.app.created_round}") + print_info(f" Updated round: {result3.app.updated_round}") + if result3.update_result and result3.update_result.tx_ids: + print_info(f" Transaction ID: {result3.update_result.tx_ids[0]}") + + # Verify the global state was preserved but version updated + global_state = algorand.app.get_global_state(result3.app.app_id) + print_info("") + print_info("Global state after update:") + version_entry = global_state.get("version") + version_value = version_entry.value if version_entry else "N/A" + counter_entry = global_state.get("counter") + counter_value = counter_entry.value if counter_entry else "N/A" + print_info(f" version: {version_value} (from TEAL)") + print_info(f" counter: {counter_value} (preserved)") + + print_success("App updated in place with new code") + + # Step 5: Demonstrate on_update: 'fail' + print_step(5, "Demonstrate on_update: 'fail' - fails if update detected") + print_info('Trying to deploy version 3.0.0 with on_update="fail" should throw an error') + + try: + algorand.app_deployer.deploy( + AppDeployParams( + metadata=AppDeploymentMetaData( + name=app_name, + version="3.0.0", # New version + updatable=True, + deletable=True, + ), + create_params=AppCreateParams( + sender=deployer.addr, + approval_program=get_versioned_approval_program(3), + clear_state_program=CLEAR_STATE_PROGRAM, + schema={ + "global_ints": 2, + "global_byte_slices": 0, + "local_ints": 0, + "local_byte_slices": 0, + }, + ), + update_params=AppUpdateParams( + sender=deployer.addr, + app_id=0, + approval_program="", + clear_state_program="", + ), + delete_params=AppDeleteParams( + sender=deployer.addr, + app_id=0, + ), + on_update="fail", # Fail if update detected + ) + ) + print_error("Expected an error but deployment succeeded") + except Exception as e: + print_info("") + print_info("Expected error caught:") + print_info(f" {e}") + print_success('on_update="fail" correctly prevents updates') + + # Step 6: Demonstrate on_update: 'replace' + print_step(6, "Demonstrate on_update: 'replace' - delete and recreate app") + print_info('Deploying version 3.0.0 with on_update="replace" deletes old app and creates new one') + + old_app_id = result3.app.app_id + + result4 = algorand.app_deployer.deploy( + AppDeployParams( + metadata=AppDeploymentMetaData( + name=app_name, + version="3.0.0", + updatable=True, + deletable=True, + ), + create_params=AppCreateParams( + sender=deployer.addr, + approval_program=get_versioned_approval_program(3), + clear_state_program=CLEAR_STATE_PROGRAM, + schema={ + "global_ints": 2, + "global_byte_slices": 0, + "local_ints": 0, + "local_byte_slices": 0, + }, + ), + update_params=AppUpdateParams( + sender=deployer.addr, + app_id=0, + approval_program="", + clear_state_program="", + ), + delete_params=AppDeleteParams( + sender=deployer.addr, + app_id=0, + ), + on_update="replace", # Delete old and create new + ) + ) + + print_info("") + print_info("Replace deployment result:") + print_info(f" Operation performed: {result4.operation_performed}") + print_info(f" Old App ID: {old_app_id} (deleted)") + print_info(f" New App ID: {result4.app.app_id}") + print_info(f" App Address: {shorten_address(str(result4.app.app_address))}") + print_info(f" Version: {result4.app.version}") + if result4.operation_performed == OperationPerformed.Replace and result4.delete_result: + print_info(f" Delete transaction confirmed: round {result4.delete_result.confirmation.confirmed_round}") + + print_success("Old app deleted and new app created") + + # Step 7: Demonstrate on_schema_break: 'replace' + print_step(7, "Demonstrate on_schema_break: 'replace' - handle schema changes") + print_info("Deploying version 4.0.0 with increased schema (more global ints)") + print_info("Schema changes cannot be done via update, so replace is required") + + result5 = algorand.app_deployer.deploy( + AppDeployParams( + metadata=AppDeploymentMetaData( + name=app_name, + version="4.0.0", + updatable=True, + deletable=True, + ), + create_params=AppCreateParams( + sender=deployer.addr, + approval_program=get_versioned_approval_program(4), + clear_state_program=CLEAR_STATE_PROGRAM, + schema={ + "global_ints": 3, # Schema break: increased from 2 to 3 + "global_byte_slices": 1, # Schema break: increased from 0 to 1 + "local_ints": 0, + "local_byte_slices": 0, + }, + ), + update_params=AppUpdateParams( + sender=deployer.addr, + app_id=0, + approval_program="", + clear_state_program="", + ), + delete_params=AppDeleteParams( + sender=deployer.addr, + app_id=0, + ), + on_update="update", # Would normally try to update + on_schema_break="replace", # But schema change forces replace + ) + ) + + print_info("") + print_info("Schema break deployment result:") + print_info(f" Operation performed: {result5.operation_performed}") + print_info(f" Previous App ID: {result4.app.app_id}") + print_info(f" New App ID: {result5.app.app_id}") + print_info(f" Version: {result5.app.version}") + + # Verify new schema + app_info = algorand.app.get_by_id(result5.app.app_id) + print_info("") + print_info("New app schema:") + print_info(f" global_ints: {app_info.global_ints}") + print_info(f" global_byte_slices: {app_info.global_byte_slices}") + + print_success("Schema break handled with replace strategy") + + # Step 8: Show deployment metadata lookup by name + print_step(8, "Show deployment metadata lookup by name") + print_info("The app_deployer uses app name for idempotent lookups across deployments") + + # Look up the app by creator + creator_apps = algorand.app_deployer.get_creator_apps_by_name(creator_address=deployer.addr) + + print_info("") + print_info(f"Apps deployed by {shorten_address(str(deployer.addr))}:") + for name, app_meta in creator_apps.apps.items(): + print_info("") + print_info(f' App Name: "{name}"') + print_info(f" App ID: {app_meta.app_id}") + print_info(f" Version: {app_meta.version}") + print_info(f" Updatable: {app_meta.updatable}") + print_info(f" Deletable: {app_meta.deletable}") + print_info(f" Created Round: {app_meta.created_round}") + print_info(f" Updated Round: {app_meta.updated_round}") + print_info(f" Deleted: {app_meta.deleted}") + print_info(" Deploy Metadata:") + print_info(f" Name: {app_meta.deploy_metadata.name}") + print_info(f" Version: {app_meta.deploy_metadata.version}") + + print_success("Deployment metadata retrieved") + + # Step 9: Demonstrate how name enables idempotency + print_step(9, "Demonstrate how app name enables idempotent deployments") + print_info("Deploy a second app with a different name to show name-based lookup") + + result6 = algorand.app_deployer.deploy( + AppDeployParams( + metadata=AppDeploymentMetaData( + name="AnotherApp", # Different name + version="1.0.0", + updatable=False, + deletable=False, + ), + create_params=AppCreateParams( + sender=deployer.addr, + approval_program=get_versioned_approval_program(100), + clear_state_program=CLEAR_STATE_PROGRAM, + schema={ + "global_ints": 2, # version, counter + "global_byte_slices": 0, + "local_ints": 0, + "local_byte_slices": 0, + }, + ), + update_params=AppUpdateParams( + sender=deployer.addr, + app_id=0, + approval_program="", + clear_state_program="", + ), + delete_params=AppDeleteParams( + sender=deployer.addr, + app_id=0, + ), + ) + ) + + print_info("") + print_info("Second app deployment:") + print_info(" Name: AnotherApp") + print_info(f" App ID: {result6.app.app_id}") + print_info(f" Operation: {result6.operation_performed}") + + # Now list all apps again + all_apps = algorand.app_deployer.get_creator_apps_by_name(creator_address=deployer.addr) + print_info("") + num_apps = len(all_apps.apps) + print_info(f"All apps by creator ({num_apps} apps):") + for name in all_apps.apps: + print_info(f' - "{name}" (App ID: {all_apps.apps[name].app_id})') + + print_success("Multiple apps tracked by name") + + # Step 10: Summary + print_step(10, "Summary - App Deployer API") + print_info("The AppDeployer provides idempotent application deployment:") + print_info("") + print_info("algorand.app_deployer.deploy(AppDeployParams(...)):") + print_info(" - Deploys applications with idempotent behavior based on app name") + print_info(" - Returns: AppDeployResult with operation_performed (OperationPerformed enum)") + print_info("") + print_info("Key parameters (all dataclass objects):") + print_info(" metadata: AppDeploymentMetaData(name, version, updatable, deletable)") + print_info(" - name: Unique identifier for idempotent lookups") + print_info(" - version: Semantic version string") + print_info(" - updatable/deletable: Deploy-time controls (TMPL_UPDATABLE/TMPL_DELETABLE)") + print_info("") + print_info(" create_params: AppCreateParams(sender, approval_program, clear_state_program, schema)") + print_info(" update_params: AppUpdateParams(sender, app_id=0, ...) - deployer overrides app_id") + print_info(" delete_params: AppDeleteParams(sender, app_id=0) - deployer overrides app_id") + print_info("") + print_info(" on_update: Controls behavior when code changes:") + print_info(" 'fail' - Throw error (default)") + print_info(" 'update' - Update app in place (preserves app ID)") + print_info(" 'replace' - Delete old app, create new one") + print_info(" 'append' - Create new app, leave old one") + print_info("") + print_info(" on_schema_break: Controls behavior when schema changes:") + print_info(" 'fail' - Throw error (default)") + print_info(" 'replace' - Delete old app, create new one") + print_info(" 'append' - Create new app, leave old one") + print_info("") + print_info("Result: AppDeployResult") + print_info(" .operation_performed: OperationPerformed enum (Create, Update, Replace, Nothing)") + print_info(" .app: ApplicationMetaData (app_id, app_address, name, version, ...)") + print_info(" .create_result / .update_result / .delete_result: transaction results") + print_info("") + print_info("algorand.app_deployer.get_creator_apps_by_name(creator_address=...):") + print_info(" - Lists all apps deployed by a creator with their metadata") + print_info(" - Used internally for idempotent lookup by name") + + print_success("App Deployer example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/algorand_client/14_client_manager.py b/examples/algorand_client/14_client_manager.py new file mode 100644 index 00000000..22e88bd4 --- /dev/null +++ b/examples/algorand_client/14_client_manager.py @@ -0,0 +1,526 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Client Manager + +This example demonstrates how to access the underlying raw clients through +the ClientManager (algorand.client), and how to get typed app clients: +- algorand.client.algod - Access the raw Algod client +- algorand.client.indexer - Access the raw Indexer client +- algorand.client.kmd - Access the raw KMD client +- algorand.client.indexer_if_present - Safely access Indexer (returns None if not configured) +- algorand.client.get_app_client_by_id() - Get typed app client by ID +- algorand.client.get_app_client_by_creator_and_name() - Get typed app client by creator/name +- algorand.client.get_app_factory() - Get app factory for creating/deploying apps +- When to use raw clients vs AlgorandClient methods + +LocalNet required for client access +""" + +import base64 + +from shared import ( + load_teal_source, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_kmd_client.models import ( + InitWalletHandleTokenRequest, + ListKeysRequest, + ReleaseWalletHandleTokenRequest, +) +from algokit_utils import AlgoAmount, AlgorandClient +from algokit_utils.applications.app_deployer import AppDeploymentMetaData, AppDeployParams +from algokit_utils.models.network import AlgoClientNetworkConfig +from algokit_utils.transactions.types import AppCreateParams, AppDeleteParams, AppUpdateParams + +# ============================================================================ +# Simple TEAL Programs for App Client Demonstrations (loaded from shared artifacts) +# ============================================================================ + +SIMPLE_APPROVAL_PROGRAM = load_teal_source("approval-counter-simple.teal") +CLEAR_STATE_PROGRAM = load_teal_source("clear-state-approve.teal") + +# A minimal ARC-56 compatible app spec for demonstration +SIMPLE_APP_SPEC: dict = { + "name": "SimpleCounter", + "desc": "A simple counter application for demonstration", + "methods": [], + "state": { + "schema": { + "global": { + "ints": 1, + "bytes": 0, + }, + "local": { + "ints": 0, + "bytes": 0, + }, + }, + "keys": { + "global": { + "counter": { + "keyType": "AVMString", + "valueType": "AVMUint64", + "key": base64.b64encode(b"counter").decode(), # base64 of "counter" + }, + }, + "local": {}, + "box": {}, + }, + "maps": { + "global": {}, + "local": {}, + "box": {}, + }, + }, + "bareActions": { + "create": ["NoOp"], + "call": ["NoOp", "DeleteApplication"], + }, + "arcs": [56], + "structs": {}, + "source": { + "approval": SIMPLE_APPROVAL_PROGRAM, + "clear": CLEAR_STATE_PROGRAM, + }, + "byteCode": { + "approval": "", + "clear": "", + }, + "compilerInfo": { + "compiler": "algod", + "compilerVersion": { + "major": 3, + "minor": 0, + "patch": 0, + }, + }, + "events": [], + "templateVariables": {}, + "networks": {}, + "sourceInfo": { + "approval": {"sourceInfo": [], "pcOffsetMethod": "none"}, + "clear": {"sourceInfo": [], "pcOffsetMethod": "none"}, + }, + "scratchVariables": {}, +} + + +def main() -> None: + print_header("Client Manager Example") + + # Initialize client and verify LocalNet is running + algorand = AlgorandClient.default_localnet() + + try: + algorand.client.algod.status() + print_success("Connected to LocalNet") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 1: Access raw Algod client via algorand.client.algod + print_step(1, "Access raw Algod client via algorand.client.algod") + print_info("The Algod client provides direct access to the Algorand node REST API") + + algod = algorand.client.algod + + # Get node status + status = algod.status() + print_info("") + print_info("Algod status():") + print_info(f" Last round: {status.last_round}") + print_info(f" Time since last round: {status.time_since_last_round}ns") + print_info(f" Catchup time: {status.catchup_time}ns") + print_info(f" Last version: {status.last_version}") + + # Get suggested transaction parameters + suggested_params = algod.suggested_params() + print_info("") + print_info("Algod suggested_params():") + print_info(f" Genesis ID: {suggested_params.genesis_id}") + genesis_hash_b64 = base64.b64encode(suggested_params.genesis_hash or b"").decode()[:20] + print_info(f" Genesis Hash: {genesis_hash_b64}...") + print_info(f" First valid round: {suggested_params.first_valid}") + print_info(f" Last valid round: {suggested_params.last_valid}") + print_info(f" Min fee: {suggested_params.min_fee}") + + # Get genesis information + genesis = algod.genesis() + print_info("") + print_info("Algod genesis():") + print_info(f" Network: {genesis.network}") + print_info(f" Protocol: {genesis.proto}") + + # Get supply information + supply = algod.supply() + print_info("") + print_info("Algod supply():") + print_info(f" Total money: {supply.total_money} microAlgo") + print_info(f" Online money: {supply.online_money} microAlgo") + + print_success("Raw Algod client accessed successfully") + + # Step 2: Access raw Indexer client via algorand.client.indexer + print_step(2, "Access raw Indexer client via algorand.client.indexer") + print_info("The Indexer client provides access to historical blockchain data") + + indexer = algorand.client.indexer + + # Health check + health = indexer.health_check() + print_info("") + print_info("Indexer health_check():") + print_info(f" Database available: {health.db_available}") + print_info(f" Is migrating: {health.is_migrating}") + print_info(f" Round: {health.round_}") + print_info(f" Version: {health.version}") + + # Search for transactions + txn_search_result = indexer.search_for_transactions(limit=3) + print_info("") + print_info("Indexer search_for_transactions(limit=3):") + print_info(f" Found {len(txn_search_result.transactions)} transactions") + print_info(f" Current round: {txn_search_result.current_round}") + for txn in txn_search_result.transactions: + txn_id = txn.id_[:12] if txn.id_ else "unknown" + print_info(f" - {txn_id}... (type: {txn.tx_type})") + + # Lookup an account + dispenser = algorand.account.dispenser_from_environment() + account_result = indexer.lookup_account_by_id(dispenser.addr) + print_info("") + print_info("Indexer lookup_account_by_id():") + print_info(f" Address: {shorten_address(account_result.account.address)}") + print_info(f" Balance: {account_result.account.amount} microAlgo") + print_info(f" Status: {account_result.account.status}") + + print_success("Raw Indexer client accessed successfully") + + # Step 3: Access raw KMD client via algorand.client.kmd + print_step(3, "Access raw KMD client via algorand.client.kmd") + print_info("The KMD (Key Management Daemon) client manages wallets and keys") + + kmd = algorand.client.kmd + + # List wallets + wallets_result = kmd.list_wallets() + print_info("") + print_info("KMD list_wallets():") + print_info(f" Found {len(wallets_result.wallets)} wallet(s)") + for wallet in wallets_result.wallets: + wallet_id_short = wallet.id_[:8] + print_info(f' - "{wallet.name}" (ID: {wallet_id_short}...)') + + # Get the default LocalNet wallet and list keys + default_wallet = None + for wallet in wallets_result.wallets: + if wallet.name == "unencrypted-default-wallet": + default_wallet = wallet + break + + if default_wallet: + handle_result = kmd.init_wallet_handle( + InitWalletHandleTokenRequest( + wallet_id=default_wallet.id_, + wallet_password="", + ) + ) + wallet_handle_token = handle_result.wallet_handle_token + + keys_result = kmd.list_keys_in_wallet(ListKeysRequest(wallet_handle_token=wallet_handle_token)) + addresses = keys_result.addresses + + print_info("") + print_info("KMD list_keys_in_wallet() for default wallet:") + print_info(f" Found {len(addresses)} key(s)") + for address in addresses[:3]: + print_info(f" - {shorten_address(str(address))}") + if len(addresses) > 3: + print_info(f" ... and {len(addresses) - 3} more") + + # Release the wallet handle + kmd.release_wallet_handle_token(ReleaseWalletHandleTokenRequest(wallet_handle_token=wallet_handle_token)) + + print_success("Raw KMD client accessed successfully") + + # Step 4: Demonstrate algorand.client.indexer_if_present + print_step(4, "Demonstrate algorand.client.indexer_if_present") + print_info("indexer_if_present returns None if Indexer is not configured (instead of throwing)") + + # With LocalNet, indexer is configured + indexer_if_present = algorand.client.indexer_if_present + if indexer_if_present: + print_info("") + print_info("Indexer is present: True") + indexer_health = indexer_if_present.health_check() + print_info(f" Indexer round: {indexer_health.round_}") + + # Create a client without indexer to demonstrate None behavior + algod_only_config = AlgoClientNetworkConfig( + server="http://localhost", + port=4001, + token="a" * 64, + ) + # Note: No indexer_config provided + algod_only_client = AlgorandClient.from_config(algod_only_config) + + no_indexer = algod_only_client.client.indexer_if_present + print_info("") + print_info("For client without Indexer configured:") + indexer_status = "None" if no_indexer is None else "present" + print_info(f" indexer_if_present: {indexer_status}") + print_info(" Use this to gracefully handle missing Indexer configuration") + + print_success("indexer_if_present demonstrated") + + # Step 5: Create an application for app client demonstrations + print_step(5, "Create test application for app client demonstrations") + + creator = algorand.account.random() + algorand.account.ensure_funded_from_environment(creator.addr, AlgoAmount.from_algo(10)) + + create_result = algorand.send.app_create( + AppCreateParams( + sender=creator.addr, + approval_program=SIMPLE_APPROVAL_PROGRAM, + clear_state_program=CLEAR_STATE_PROGRAM, + schema={ + "global_ints": 1, + "global_byte_slices": 0, + "local_ints": 0, + "local_byte_slices": 0, + }, + ) + ) + + app_id = create_result.app_id + print_info("") + print_info("Created test application:") + print_info(f" App ID: {app_id}") + print_info(f" Creator: {shorten_address(creator.addr)}") + + print_success("Test application created") + + # Step 6: Demonstrate algorand.client.get_app_client_by_id() + print_step(6, "Demonstrate algorand.client.get_app_client_by_id()") + print_info("Creates an AppClient for an existing application by its ID") + + app_client_by_id = algorand.client.get_app_client_by_id( + app_spec=SIMPLE_APP_SPEC, + app_id=app_id, + default_sender=creator.addr, + ) + + print_info("") + print_info("AppClient created with get_app_client_by_id():") + print_info(f" App ID: {app_client_by_id.app_id}") + print_info(f" App Name: {app_client_by_id.app_name}") + print_info(f" App Address: {shorten_address(str(app_client_by_id.app_address))}") + + # Use the app client to make a call + call_result = app_client_by_id.send.bare.call() + print_info("") + print_info("Called app via AppClient:") + print_info(f" Transaction ID: {call_result.tx_ids[0]}") + + # Read state using the app client + global_state = app_client_by_id.state.global_state.get_all() + print_info(f" Global state after call: counter = {global_state.get('counter')}") + + print_success("get_app_client_by_id() demonstrated") + + # Step 7: Demonstrate algorand.client.get_app_client_by_creator_and_name() + print_step(7, "Demonstrate algorand.client.get_app_client_by_creator_and_name()") + print_info("Creates an AppClient by looking up app ID from creator and app name") + + # First, deploy an app using the app deployer (which stores name metadata) + # Note: We don't use deploy-time controls (updatable/deletable) since our TEAL + # doesn't have TMPL_UPDATABLE/TMPL_DELETABLE placeholders + deployed_app = algorand.app_deployer.deploy( + AppDeployParams( + metadata=AppDeploymentMetaData( + name="NamedCounterApp", + version="1.0.0", + deletable=None, + updatable=None, + ), + create_params=AppCreateParams( + sender=creator.addr, + approval_program=SIMPLE_APPROVAL_PROGRAM, + clear_state_program=CLEAR_STATE_PROGRAM, + schema={ + "global_ints": 1, + "global_byte_slices": 0, + "local_ints": 0, + "local_byte_slices": 0, + }, + ), + update_params=AppUpdateParams( + sender=creator.addr, + app_id=0, + approval_program="", + clear_state_program="", + ), + delete_params=AppDeleteParams( + sender=creator.addr, + app_id=0, + ), + ) + ) + + print_info("") + print_info("Deployed named app:") + print_info(" Name: NamedCounterApp") + print_info(f" App ID: {deployed_app.app.app_id}") + + # Now get the app client by creator and name (async - returns Promise in TS) + app_client_by_name = algorand.client.get_app_client_by_creator_and_name( + app_spec=SIMPLE_APP_SPEC, + creator_address=creator.addr, + app_name="NamedCounterApp", + default_sender=creator.addr, + ) + + print_info("") + print_info("AppClient from get_app_client_by_creator_and_name():") + print_info(f" Resolved App ID: {app_client_by_name.app_id}") + print_info(f" App Name: {app_client_by_name.app_name}") + print_info(" Note: App ID was resolved by looking up the creator's apps") + + print_success("get_app_client_by_creator_and_name() demonstrated") + + # Step 8: Demonstrate algorand.client.get_app_factory() + print_step(8, "Demonstrate algorand.client.get_app_factory()") + print_info("Creates an AppFactory for deploying and managing multiple app instances") + + app_factory = algorand.client.get_app_factory( + app_spec=SIMPLE_APP_SPEC, + default_sender=creator.addr, + ) + + print_info("") + print_info("AppFactory created with get_app_factory():") + print_info(f" App Name: {app_factory.app_name}") + print_info("") + print_info("AppFactory provides methods for:") + print_info(" - factory.send.bare.create() - Create app with bare call") + print_info(" - factory.send.create() - Create app with ABI method") + print_info(" - factory.deploy() - Idempotent deployment with version management") + print_info(" - factory.params.* - Get transaction params for app operations") + print_info("") + print_info("Note: Creating apps via factory requires a properly compiled ARC-56 app spec") + print_info("with either compiled bytecode or TEAL source that the factory can compile.") + + print_success("get_app_factory() demonstrated") + + # Step 9: Explain when to use raw clients vs AlgorandClient methods + print_step(9, "When to use raw clients vs AlgorandClient methods") + print_info("") + print_info("When to use AlgorandClient high-level methods (algorand.send.*, algorand.app.*, etc.):") + print_info(" - Creating and sending transactions (automatic signer management)") + print_info(" - Account management and funding") + print_info(" - Reading app state (get_global_state, get_local_state)") + print_info(" - Common operations that benefit from SDK convenience") + print_info(" - When you want automatic transaction composition and signing") + + print_info("") + print_info("When to use raw Algod client (algorand.client.algod):") + print_info(" - Direct node status queries (status(), genesis(), supply())") + print_info(" - Low-level transaction submission (send_raw_transaction)") + print_info(" - Block information queries") + print_info(" - Pending transaction information") + print_info(" - Node configuration queries") + print_info(" - When you need fine-grained control over API calls") + + print_info("") + print_info("When to use raw Indexer client (algorand.client.indexer):") + print_info(" - Historical transaction searches with complex filters") + print_info(" - Account lookups with specific query parameters") + print_info(" - Asset and application searches") + print_info(" - Block lookups and searches") + print_info(" - Paginated queries with custom limits") + print_info(" - When AlgorandClient does not expose the specific query you need") + + print_info("") + print_info("When to use raw KMD client (algorand.client.kmd):") + print_info(" - Wallet management (create, list, rename wallets)") + print_info(" - Key generation and import/export") + print_info(" - Signing transactions with KMD-managed keys") + print_info(" - LocalNet development with default wallets") + print_info(" - When you need direct control over key management") + + print_info("") + print_info("When to use AppClient (get_app_client_by_id, get_app_client_by_creator_and_name):") + print_info(" - Interacting with a specific deployed application") + print_info(" - Type-safe method calls based on ARC-56 app spec") + print_info(" - Reading/writing app state with type information") + print_info(" - When you have the app spec and want IDE autocompletion") + + print_info("") + print_info("When to use AppFactory (get_app_factory):") + print_info(" - Deploying new application instances") + print_info(" - Creating multiple instances of the same app") + print_info(" - Idempotent deployment with version management") + print_info(" - When you need to create apps programmatically") + + print_success("Usage guidance provided") + + # Step 10: Summary + print_step(10, "Summary - Client Manager API") + print_info("The ClientManager (algorand.client) provides access to underlying clients:") + print_info("") + print_info("algorand.client.algod:") + print_info(" - Raw AlgodClient for direct node API access") + print_info(" - Methods: status(), suggested_params(), genesis(), supply(), etc.") + print_info("") + print_info("algorand.client.indexer:") + print_info(" - Raw IndexerClient for historical data queries") + print_info(" - Methods: search_for_transactions(), lookup_account_by_id(), etc.") + print_info(" - Throws error if Indexer not configured") + print_info("") + print_info("algorand.client.indexer_if_present:") + print_info(" - Same as indexer but returns None if not configured") + print_info(" - Use for graceful handling of optional Indexer") + print_info("") + print_info("algorand.client.kmd:") + print_info(" - Raw KmdClient for wallet/key management") + print_info(" - Methods: list_wallets(), list_keys_in_wallet(), etc.") + print_info(" - Only available on LocalNet or custom KMD setups") + print_info("") + print_info("algorand.client.get_app_client_by_id(app_spec, app_id):") + print_info(" - Creates AppClient for existing app by ID") + print_info(" - Provides type-safe app interaction") + print_info("") + print_info("algorand.client.get_app_client_by_creator_and_name(app_spec, creator, name):") + print_info(" - Creates AppClient by resolving app ID from creator and name") + print_info(" - Uses AlgoKit app deployment metadata for lookup") + print_info(" - Returns AppClient directly (sync in Python)") + print_info("") + print_info("algorand.client.get_app_factory(app_spec):") + print_info(" - Creates AppFactory for deploying new app instances") + print_info(" - Supports bare and ABI-based app creation") + print_info("") + print_info("Best practices:") + print_info(" - Use high-level AlgorandClient methods for common operations") + print_info(" - Drop to raw clients when you need specific API features") + print_info(" - Use indexer_if_present for portable code that may run without Indexer") + print_info(" - Use AppClient/AppFactory for type-safe smart contract interaction") + + # Clean up - delete the apps we created + algorand.send.app_delete(AppDeleteParams(sender=creator.addr, app_id=app_id, note=b"cleanup-1")) + deployed_app_id = deployed_app.app.app_id + if deployed_app_id != app_id: + algorand.send.app_delete(AppDeleteParams(sender=creator.addr, app_id=deployed_app_id, note=b"cleanup-2")) + + print_success("Client Manager example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/algorand_client/15_error_transformers.py b/examples/algorand_client/15_error_transformers.py new file mode 100644 index 00000000..2a728f11 --- /dev/null +++ b/examples/algorand_client/15_error_transformers.py @@ -0,0 +1,530 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Error Transformers + +This example demonstrates how to register custom error transformers to enhance +error messages and debugging information for failed transactions: +- What error transformers are and why they're useful +- algorand.register_error_transformer() to add custom error transformers +- Creating transformers that add source code context to logic errors +- Creating transformers that provide user-friendly error messages +- How transformers receive errors and can return enhanced errors +- algorand.unregister_error_transformer() to remove transformers +- Triggering intentional errors and showing enhanced output +- How multiple transformers can be chained +- The transformer function signature: (error: Exception) -> Exception + +LocalNet required for triggering transaction errors +""" + +from __future__ import annotations + +import re +from collections.abc import Callable +from datetime import datetime, timezone + +from shared import ( + load_teal_source, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_transact import OnApplicationComplete +from algokit_utils import AlgoAmount, AlgorandClient +from algokit_utils.transactions.types import ( + AppCallParams, + AppCreateParams, + AppDeleteParams, + AssetCreateParams, + AssetTransferParams, + PaymentParams, +) + +# ============================================================================ +# TEAL Programs for Demonstrating Errors (loaded from shared artifacts) +# ============================================================================ + +# A more complex app that conditionally rejects based on arguments +CONDITIONAL_APPROVAL_PROGRAM = load_teal_source("approval-error-triggers.teal") + +CLEAR_STATE_PROGRAM = load_teal_source("clear-state-approve.teal") + +# ============================================================================ +# Custom Error Transformer Examples +# ============================================================================ + +# Type alias for error transformer function +ErrorTransformer = Callable[[Exception], Exception] + + +def source_code_context_transformer(error: Exception) -> Exception: + """ + Example transformer that adds source code context to logic errors. + This is useful for debugging TEAL program failures. + """ + error_message = str(error) + + # Only transform errors that mention "logic eval error" + if "logic eval error" not in error_message: + return error + + # Try to extract PC (program counter) from error message + pc_match = re.search(r"pc=(\d+)", error_message) + pc = int(pc_match.group(1)) if pc_match else None + + # Create enhanced error with source context + enhanced_parts = [ + error_message, + "", + "--- Source Context (added by source_code_context_transformer) ---", + f" Program Counter (PC): {pc}" if pc is not None else " Program Counter: unknown", + " Tip: Use the source map from compilation to map PC to TEAL line number", + " Tip: The PC indicates which TEAL instruction caused the failure", + "-----------------------------------------------------------", + ] + enhanced_message = "\n".join(enhanced_parts) + + return Exception(enhanced_message) + + +def user_friendly_transformer(error: Exception) -> Exception: + """ + Example transformer that provides user-friendly error messages. + Maps technical error messages to human-readable explanations. + """ + message = str(error) + + # Map common error patterns to user-friendly messages + error_mappings: list[tuple[str, str]] = [ + ( + r"asset (\d+) missing from", + "The account has not opted in to the asset. Please opt in first before receiving this asset.", + ), + ( + r"transaction already in ledger", + "This transaction has already been submitted. Wait for the previous transaction to confirm.", + ), + ( + r"underflow on subtracting|overspend", + "Insufficient balance for this operation. " + "The account does not have enough funds to complete the transaction.", + ), + ( + r"division by zero", + "A division by zero occurred in the smart contract. This is usually a logic error in the TEAL program.", + ), + ( + r"assert failed", + "An assertion failed in the smart contract. A required condition was not met.", + ), + ( + r"err opcode executed", + "The smart contract explicitly rejected this call using the err opcode. Check your transaction parameters.", + ), + ( + r"would result negative", + "This operation would result in a negative balance, which is not allowed on Algorand.", + ), + ] + + for pattern, friendly_message in error_mappings: + if re.search(pattern, message, re.IGNORECASE): + enhanced_parts = [ + "User-Friendly Error:", + f" {friendly_message}", + "", + "Technical Details:", + f" {message}", + ] + enhanced_message = "\n".join(enhanced_parts) + return Exception(enhanced_message) + + # Return original error if no mapping found + return error + + +def transaction_context_transformer(error: Exception) -> Exception: + """ + Example transformer that adds transaction context. + Shows how to add additional debugging information. + """ + # Add timestamp and environment info to all errors + timestamp = datetime.now(tz=timezone.utc).isoformat() + + enhanced_parts = [ + str(error), + "", + "--- Debug Context (added by transaction_context_transformer) ---", + f" Timestamp: {timestamp}", + " Network: LocalNet", + " SDK: algokit-utils-py", + "--------------------------------------------------------------", + ] + enhanced_message = "\n".join(enhanced_parts) + + return Exception(enhanced_message) + + +def create_error_counting_transformer() -> tuple[ErrorTransformer, Callable[[], int], Callable[[], None]]: + """ + Example transformer that counts errors (demonstrates stateful transformers). + This could be useful for monitoring/alerting systems. + + Returns: + A tuple of (transformer, get_count, reset) functions + """ + error_count = [0] # Use list for mutable closure + + def transformer(error: Exception) -> Exception: + error_count[0] += 1 + enhanced_message = f"[Error #{error_count[0]}] {error}" + return Exception(enhanced_message) + + def get_count() -> int: + return error_count[0] + + def reset() -> None: + error_count[0] = 0 + + return transformer, get_count, reset + + +def main() -> None: + print_header("Error Transformers Example") + + # Initialize client and verify LocalNet is running + algorand = AlgorandClient.default_localnet() + + try: + algorand.client.algod.status() + print_success("Connected to LocalNet") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 1: Explain what error transformers are + print_step(1, "What are error transformers?") + print_info("Error transformers are functions that process errors before they are thrown.") + print_info("They allow you to:") + print_info(" - Add source code context to TEAL logic errors") + print_info(" - Translate technical errors into user-friendly messages") + print_info(" - Add debugging information (timestamps, transaction IDs, etc.)") + print_info(" - Log errors for monitoring before re-throwing") + print_info(" - Chain multiple transformers for layered error handling") + print_info("") + print_info("Function signature: (error: Exception) -> Exception") + print_info(" - Receives the error that was caught") + print_info(" - Returns a (possibly transformed) error") + print_info(" - Should return the original error if it cannot/should not transform it") + print_success("Error transformers explained") + + # Create and fund test account + test_account = algorand.account.random() + algorand.account.ensure_funded_from_environment(test_account.addr, AlgoAmount.from_algo(10)) + print_info("") + print_info(f"Test account: {shorten_address(str(test_account.addr))}") + + # Step 2: Demonstrate algorand.register_error_transformer() + print_step(2, "Register custom error transformers with algorand.register_error_transformer()") + print_info("Transformers registered on AlgorandClient apply to all new_group() composers") + + algorand.register_error_transformer(user_friendly_transformer) + print_info(" Registered: user_friendly_transformer") + + algorand.register_error_transformer(transaction_context_transformer) + print_info(" Registered: transaction_context_transformer") + + print_success("Error transformers registered on AlgorandClient") + + # Step 3: Create an app that will reject calls (for error demonstration) + print_step(3, "Create test application that can trigger errors") + + create_result = algorand.send.app_create( + AppCreateParams( + sender=test_account.addr, + approval_program=CONDITIONAL_APPROVAL_PROGRAM, + clear_state_program=CLEAR_STATE_PROGRAM, + schema={ + "global_ints": 0, + "global_byte_slices": 0, + "local_ints": 0, + "local_byte_slices": 0, + }, + ) + ) + + app_id = create_result.app_id + print_info(f"Created app ID: {app_id}") + print_success("Test application created") + + # Step 4: Trigger an intentional error and show enhanced output + print_step(4, "Trigger intentional error to see transformed output") + print_info('Calling app with "reject_assert" argument to trigger assertion failure...') + + try: + algorand.send.app_call( + AppCallParams( + sender=test_account.addr, + app_id=app_id, + args=[b"reject_assert"], + ) + ) + except Exception as e: + print_info("") + print_info("Caught transformed error:") + separator = "-" * 60 + print_info(separator) + print(str(e)) # noqa: T201 + print_info(separator) + print_info("") + print_info("Notice the user-friendly message and debug context added by transformers!") + + print_success("Error transformation demonstrated") + + # Step 5: Show how multiple transformers chain together + print_step(5, "Demonstrate transformer chaining") + print_info("When multiple transformers are registered, they run in sequence.") + print_info("Each transformer receives the output of the previous one.") + + # Register the source code context transformer + algorand.register_error_transformer(source_code_context_transformer) + print_info(" Additionally registered: source_code_context_transformer") + print_info("") + print_info("Chain order: user_friendly -> transaction_context -> source_code_context") + + print_info("") + print_info('Triggering "err opcode" error to see all transformers in action...') + + try: + algorand.send.app_call( + AppCallParams( + sender=test_account.addr, + app_id=app_id, + args=[b"unknown_action"], + ) + ) + except Exception as e: + print_info("") + print_info("Caught error with all transformers applied:") + separator = "-" * 60 + print_info(separator) + print(str(e)) # noqa: T201 + print_info(separator) + + print_success("Transformer chaining demonstrated") + + # Step 6: Demonstrate unregister_error_transformer() + print_step(6, "Remove transformers with algorand.unregister_error_transformer()") + print_info("You can unregister transformers when they are no longer needed") + + algorand.unregister_error_transformer(transaction_context_transformer) + print_info(" Unregistered: transaction_context_transformer") + + algorand.unregister_error_transformer(source_code_context_transformer) + print_info(" Unregistered: source_code_context_transformer") + + print_info("") + print_info("Triggering error with only user_friendly_transformer active...") + + try: + algorand.send.app_call( + AppCallParams( + sender=test_account.addr, + app_id=app_id, + args=[b"reject_division"], + ) + ) + except Exception as e: + print_info("") + print_info("Caught error with only user-friendly transformer:") + separator = "-" * 60 + print_info(separator) + print(str(e)) # noqa: T201 + print_info(separator) + print_info("") + print_info("Notice: No debug context section (that transformer was unregistered)") + + print_success("Transformer unregistration demonstrated") + + # Step 7: Demonstrate composer-level error transformers + print_step(7, "Register error transformers on specific composers") + print_info("You can also register transformers on individual TransactionComposer instances") + + # Unregister all from AlgorandClient + algorand.unregister_error_transformer(user_friendly_transformer) + print_info("Cleared all transformers from AlgorandClient") + + # Create a stateful error counting transformer + counting_transformer, get_count, reset = create_error_counting_transformer() + + # Create a composer with a registered transformer + composer = algorand.new_group() + composer.register_error_transformer(counting_transformer) + print_info("Registered counting_transformer on this composer only") + + composer.add_app_call( + AppCallParams( + sender=test_account.addr, + app_id=app_id, + args=[b"reject_assert"], + ) + ) + + try: + composer.send() + except Exception as e: + print_info("") + print_info(f"Error count after first failure: {get_count()}") + error_first_line = str(e).split("\n")[0] + print_info(f"Error message: {error_first_line}") + + # Second composer with same transformer + composer2 = algorand.new_group() + composer2.register_error_transformer(counting_transformer) + + composer2.add_app_call( + AppCallParams( + sender=test_account.addr, + app_id=app_id, + args=[b"reject_division"], + ) + ) + + try: + composer2.send() + except Exception as e: + print_info("") + print_info(f"Error count after second failure: {get_count()}") + error_first_line = str(e).split("\n")[0] + print_info(f"Error message: {error_first_line}") + + reset() + print_info("") + print_info(f"Error count after reset: {get_count()}") + + print_success("Composer-level transformers demonstrated") + + # Step 8: Show transformer for insufficient funds error + print_step(8, "Trigger insufficient funds error with transformer") + + algorand.register_error_transformer(user_friendly_transformer) + + # Create an account with minimal funds + poor_account = algorand.account.random() + # Just enough for min balance + algorand.account.ensure_funded_from_environment(poor_account.addr, AlgoAmount.from_algo(0.2)) + + print_info(f"Poor account: {shorten_address(str(poor_account.addr))}") + print_info("Attempting to send more ALGO than account has...") + + try: + algorand.send.payment( + PaymentParams( + sender=poor_account.addr, + receiver=test_account.addr, + amount=AlgoAmount.from_algo(1000), # Way more than account has + ) + ) + except Exception as e: + print_info("") + print_info("Caught transformed insufficient funds error:") + separator = "-" * 60 + print_info(separator) + print(str(e)) # noqa: T201 + print_info(separator) + + print_success("Insufficient funds error transformation demonstrated") + + # Step 9: Show transformer for asset opt-in error + print_step(9, "Trigger asset opt-in error with transformer") + + # Create an asset + asset_result = algorand.send.asset_create( + AssetCreateParams( + sender=test_account.addr, + total=1000, + decimals=0, + asset_name="ErrorTestAsset", + unit_name="ERR", + ) + ) + + asset_id = asset_result.asset_id + print_info(f"Created test asset ID: {asset_id}") + + # Try to transfer to an account that hasn't opted in + not_opted_in_account = algorand.account.random() + algorand.account.ensure_funded_from_environment(not_opted_in_account.addr, AlgoAmount.from_algo(1)) + + print_info(f"Not-opted-in account: {shorten_address(str(not_opted_in_account.addr))}") + print_info("Attempting to send asset to account without opt-in...") + + try: + algorand.send.asset_transfer( + AssetTransferParams( + sender=test_account.addr, + receiver=not_opted_in_account.addr, + asset_id=asset_id, + amount=10, + ) + ) + except Exception as e: + print_info("") + print_info("Caught transformed asset error:") + separator = "-" * 60 + print_info(separator) + print(str(e)) # noqa: T201 + print_info(separator) + + print_success("Asset opt-in error transformation demonstrated") + + # Step 10: Summary + print_step(10, "Summary - Error Transformers API") + print_info("Error transformers enhance error handling for transaction failures:") + print_info("") + print_info("Registration (AlgorandClient level):") + print_info(" algorand.register_error_transformer(transformer)") + print_info(" - Applies to ALL new_group() composers created from this client") + print_info(" - Multiple transformers are chained in registration order") + print_info(" algorand.unregister_error_transformer(transformer)") + print_info(" - Removes a specific transformer from the client") + print_info("") + print_info("Registration (Composer level):") + print_info(" composer.register_error_transformer(transformer)") + print_info(" - Applies only to this specific composer instance") + print_info(" - Useful for one-off error handling scenarios") + print_info("") + print_info("Transformer function signature:") + print_info(" (error: Exception) -> Exception") + print_info(" - Receives the error that was caught during simulate() or send()") + print_info(" - Must return an Exception object (transformed or original)") + print_info(" - Return the original error if transformation is not applicable") + print_info("") + print_info("Common use cases:") + print_info(" - Add TEAL source code context using compilation source maps") + print_info(" - Translate technical errors to user-friendly messages") + print_info(" - Add debugging context (timestamps, network, transaction IDs)") + print_info(" - Log errors for monitoring before re-throwing") + print_info(" - Implement custom error classification and handling") + + # Clean up - unregister transformer first so cleanup isn't affected + algorand.unregister_error_transformer(user_friendly_transformer) + algorand.send.app_delete( + AppDeleteParams( + sender=test_account.addr, + app_id=app_id, + on_complete=OnApplicationComplete.DeleteApplication, + note=b"cleanup", + ) + ) + + print_success("Error Transformers example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/algorand_client/verify-all.sh b/examples/algorand_client/verify-all.sh new file mode 100755 index 00000000..b2bc1a3d --- /dev/null +++ b/examples/algorand_client/verify-all.sh @@ -0,0 +1,87 @@ +#!/bin/bash + +# verify-all.sh - Run all algorand_client examples and verify they work +# Exit with non-zero code if any example fails + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +cd "$SCRIPT_DIR" + +# Array of example files in order +EXAMPLES=( + "01_client_instantiation.py" + "02_algo_amount.py" + "03_signer_config.py" + "04_params_config.py" + "05_account_manager.py" + "06_send_payment.py" + "07_send_asset_ops.py" + "08_send_app_ops.py" + "09_create_transaction.py" + "10_transaction_composer.py" + "11_asset_manager.py" + "12_app_manager.py" + "13_app_deployer.py" + "14_client_manager.py" + "15_error_transformers.py" +) + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +NC='\033[0m' # No Color + +echo "========================================" +echo "Algorand Client Examples Verification Script" +echo "========================================" +echo "" + +if [ ${#EXAMPLES[@]} -eq 0 ]; then + echo "No examples to run yet." + echo "" + echo -e "${GREEN}Algorand Client examples suite passed (no examples)${NC}" + exit 0 +fi + +PASSED=0 +FAILED=0 +FAILED_EXAMPLES=() + +for example in "${EXAMPLES[@]}"; do + echo -n "Running $example... " + + if [ ! -f "$example" ]; then + echo -e "${RED}FAILED${NC} (file not found)" + FAILED=$((FAILED + 1)) + FAILED_EXAMPLES+=("$example") + continue + fi + + # Run the example and capture output/exit code + if OUTPUT=$(uv run python "$example" 2>&1); then + echo -e "${GREEN}PASSED${NC}" + PASSED=$((PASSED + 1)) + else + echo -e "${RED}FAILED${NC}" + echo "$OUTPUT" + FAILED=$((FAILED + 1)) + FAILED_EXAMPLES+=("$example") + fi +done + +echo "" +echo "========================================" +echo "Results: ${PASSED} passed, ${FAILED} failed" +echo "========================================" + +if [ $FAILED -gt 0 ]; then + echo "" + echo -e "${RED}Failed examples:${NC}" + for failed in "${FAILED_EXAMPLES[@]}"; do + echo " - $failed" + done + exit 1 +fi + +echo "" +echo -e "${GREEN}All Algorand Client examples passed!${NC}" +exit 0 diff --git a/examples/common/01_address_basics.py b/examples/common/01_address_basics.py new file mode 100644 index 00000000..e0a7574b --- /dev/null +++ b/examples/common/01_address_basics.py @@ -0,0 +1,186 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Address Basics + +This example demonstrates basic address operations using the algokit_common module: +- Parsing addresses from base32 strings with public_key_from_address() +- Creating addresses from public keys with address_from_public_key() +- Using the zero address constant ZERO_ADDRESS +- Computing the 4-byte checksum via SHA-512/256 +- Validating addresses by attempting to parse them +- Accessing the 32-byte public key from an address +- Using address constants: ADDRESS_LENGTH, ZERO_ADDRESS + +No LocalNet required - pure utility functions +""" + +from shared import ( + format_bytes, + format_hex, + print_header, + print_info, + print_step, + print_success, +) + +from algokit_common import ( + ADDRESS_LENGTH, + CHECKSUM_BYTE_LENGTH, + PUBLIC_KEY_BYTE_LENGTH, + ZERO_ADDRESS, + address_from_public_key, + public_key_from_address, + sha512_256, +) + + +def is_valid_address(address: str) -> bool: + """Check if a string is a valid Algorand address.""" + try: + public_key_from_address(address) + return True + except (ValueError, TypeError): + return False + + +def get_checksum(public_key: bytes) -> bytes: + """Compute the 4-byte checksum for a public key.""" + return sha512_256(public_key)[-CHECKSUM_BYTE_LENGTH:] + + +def main() -> None: + print_header("Address Basics Example") + + # Step 1: Address constants + print_step(1, "Address Constants") + + print_info(f"ADDRESS_LENGTH: {ADDRESS_LENGTH} characters") + print_info(f"ZERO_ADDRESS: {ZERO_ADDRESS}") + print_info(f"PUBLIC_KEY_BYTE_LENGTH: {PUBLIC_KEY_BYTE_LENGTH} bytes") + print_info(f"CHECKSUM_BYTE_LENGTH: {CHECKSUM_BYTE_LENGTH} bytes") + + # Step 2: Parse an address from base32 string using public_key_from_address() + print_step(2, "Parse Address from Base32 String") + + # Valid address created from bytes [0, 1, 2, ... 31] + sample_address_string = "AAAQEAYEAUDAOCAJBIFQYDIOB4IBCEQTCQKRMFYYDENBWHA5DYP7MUPJQE" + print_info(f"Input address string: {sample_address_string}") + print_info(f"String length: {len(sample_address_string)} characters") + + parsed_public_key = public_key_from_address(sample_address_string) + print_info("Successfully parsed address using public_key_from_address()") + + # Step 3: Access the public key (32-byte bytes object) + print_step(3, "Public Key Property") + + print_info(f"Public key length: {len(parsed_public_key)} bytes") + print_info(f"Public key: {format_bytes(parsed_public_key, 8)}") + print_info(f"Public key (hex): {format_hex(parsed_public_key)}") + + # Step 4: Encode back to base32 string using address_from_public_key() + print_step(4, "Encode Address to Base32 String") + + encoded_string = address_from_public_key(parsed_public_key) + print_info(f"Encoded address: {encoded_string}") + print_info(f"Round-trip matches: {encoded_string == sample_address_string}") + + # Step 5: Use the zero address constant + print_step(5, "Zero Address") + + print_info(f"Zero address string: {ZERO_ADDRESS}") + zero_public_key = public_key_from_address(ZERO_ADDRESS) + print_info(f"Public key: {format_bytes(zero_public_key, 8)}") + + # Verify all bytes are zero + all_zeros = all(byte == 0 for byte in zero_public_key) + print_info(f"All public key bytes are zero: {all_zeros}") + + # Verify round-trip + zero_encoded = address_from_public_key(zero_public_key) + print_info(f"Round-trip matches ZERO_ADDRESS: {zero_encoded == ZERO_ADDRESS}") + + # Step 6: Compare addresses + print_step(6, "Address Equality") + + # Compare two addresses created from the same string + pk1 = public_key_from_address(sample_address_string) + pk2 = public_key_from_address(sample_address_string) + print_info(f"pk1 == pk2 (same address): {pk1 == pk2}") + + # Compare with zero address public key + print_info(f"parsed_public_key == zero_public_key: {parsed_public_key == zero_public_key}") + + # Step 7: Compute checksum + print_step(7, "Compute Checksum") + + checksum = get_checksum(parsed_public_key) + print_info(f"Checksum length: {len(checksum)} bytes") + print_info(f"Checksum: {format_bytes(checksum, 4)}") + print_info(f"Checksum (hex): {format_hex(checksum)}") + + # Zero address checksum + zero_checksum = get_checksum(zero_public_key) + print_info(f"Zero address checksum: {format_hex(zero_checksum)}") + + # Step 8: Validate addresses using is_valid_address() + print_step(8, "Address Validation") + + print_info("Testing is_valid_address() with various inputs:") + + # Valid address + valid_result = is_valid_address(sample_address_string) + addr_preview = sample_address_string[:20] + print_info(f" Valid address: is_valid_address('{addr_preview}...') = {valid_result}") + + # Zero address + print_info(f" Zero address: is_valid_address(ZERO_ADDRESS) = {is_valid_address(ZERO_ADDRESS)}") + + # Invalid - wrong length + wrong_length = "ABC123" + print_info(f" Wrong length: is_valid_address('{wrong_length}') = {is_valid_address(wrong_length)}") + + # Invalid - bad characters + bad_chars = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFK0" + print_info(f" Bad characters (has '0'): is_valid_address('...Y5HFK0') = {is_valid_address(bad_chars)}") + + # Invalid - bad checksum (modified last character) + bad_checksum = "AAAQEAYEAUDAOCAJBIFQYDIOB4IBCEQTCQKRMFYYDENBWHA5DYP7MUPJQA" + print_info(f" Bad checksum: is_valid_address('...PJQA') = {is_valid_address(bad_checksum)}") + + # Step 9: Create address from raw public key bytes + print_step(9, "Create Address from Public Key Bytes") + + # Create a 32-byte public key + raw_public_key = bytes(range(32)) + + print_info(f"Raw public key: {format_bytes(raw_public_key, 8)}") + + address_from_bytes = address_from_public_key(raw_public_key) + print_info(f"Address from bytes: {address_from_bytes}") + + # Round-trip verification + pk_back = public_key_from_address(address_from_bytes) + print_info(f"Public key matches: {pk_back == raw_public_key}") + + # Verify it's valid + print_info(f"is_valid_address(address_from_bytes): {is_valid_address(address_from_bytes)}") + + # Step 10: Summary + print_step(10, "Summary") + + print_info("Address functions:") + print_info(" - public_key_from_address(str) - Parse base32 address to 32-byte public key") + print_info(" - address_from_public_key(bytes) - Encode 32-byte key to base32 (58 chars)") + print_info(" - sha512_256(bytes) - Compute hash (last 4 bytes = checksum)") + + print_info("\nConstants:") + print_info(f" - ADDRESS_LENGTH = {ADDRESS_LENGTH}") + print_info(f" - PUBLIC_KEY_BYTE_LENGTH = {PUBLIC_KEY_BYTE_LENGTH}") + print_info(f" - CHECKSUM_BYTE_LENGTH = {CHECKSUM_BYTE_LENGTH}") + print_info(f" - ZERO_ADDRESS = {ZERO_ADDRESS[:20]}...") + + print_success("Address Basics example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/common/02_address_encoding.py b/examples/common/02_address_encoding.py new file mode 100644 index 00000000..f9ae73c5 --- /dev/null +++ b/examples/common/02_address_encoding.py @@ -0,0 +1,201 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Address Encoding + +This example demonstrates how to encode and decode addresses between different formats +and compute application addresses: +- address_from_public_key() to convert 32-byte public key to base32 string +- public_key_from_address() to convert base32 string to public key bytes +- get_application_address() to compute an app's escrow address from app ID +- Round-trip verification: encode(decode(address)) equals original +- Understanding the relationship between public key bytes and checksum + +No LocalNet required - pure utility functions +""" + +from shared import ( + format_bytes, + format_hex, + print_header, + print_info, + print_step, + print_success, +) + +from algokit_common import ( + CHECKSUM_BYTE_LENGTH, + ZERO_ADDRESS, + address_from_public_key, + get_application_address, + public_key_from_address, + sha512_256, +) + + +def get_checksum(public_key: bytes) -> bytes: + """Compute the 4-byte checksum for a public key.""" + return sha512_256(public_key)[-CHECKSUM_BYTE_LENGTH:] + + +def main() -> None: + print_header("Address Encoding Example") + + # Step 1: address_from_public_key() - Convert 32-byte public key to base32 string + print_step(1, "address_from_public_key() - Public Key to Base32 String") + + # Create a 32-byte public key (bytes 0-31) + public_key = bytes(range(32)) + + print_info("Input: 32-byte public key") + print_info(f"Public key bytes: {format_bytes(public_key, 8)}") + print_info(f"Public key (hex): {format_hex(public_key)}") + + encoded_address = address_from_public_key(public_key) + print_info("\nOutput: Base32 encoded address") + print_info(f"Encoded address: {encoded_address}") + print_info(f"Address length: {len(encoded_address)} characters") + + # Step 2: public_key_from_address() - Convert base32 string to public key bytes + print_step(2, "public_key_from_address() - Base32 String to Public Key Bytes") + + print_info(f'Input: "{encoded_address}"') + + decoded_public_key = public_key_from_address(encoded_address) + print_info("\nOutput: Public key bytes") + print_info(f"Type: {type(decoded_public_key).__name__}") + print_info(f"Public key length: {len(decoded_public_key)} bytes") + print_info(f"Public key bytes: {format_bytes(decoded_public_key, 8)}") + + # Step 3: Round-trip verification + print_step(3, "Round-Trip Verification") + + # encode(decode(address)) == address + original_address = "AAAQEAYEAUDAOCAJBIFQYDIOB4IBCEQTCQKRMFYYDENBWHA5DYP7MUPJQE" + print_info(f"Original address: {original_address}") + + decoded = public_key_from_address(original_address) + re_encoded = address_from_public_key(decoded) + + print_info(f"After decode -> encode: {re_encoded}") + print_info(f"Round-trip matches: {original_address == re_encoded}") + + # decode(encode(public_key)) == public_key + print_info("\nVerifying bytes round-trip:") + encoded = address_from_public_key(public_key) + decoded_back = public_key_from_address(encoded) + bytes_match = public_key == decoded_back + print_info(f"Original public key matches decoded: {bytes_match}") + + # Step 4: Public Key Bytes and Checksum Relationship + print_step(4, "Public Key Bytes and Checksum Relationship") + + print_info("An Algorand address consists of:") + print_info(" - 32 bytes: public key") + print_info(" - 4 bytes: checksum (last 4 bytes of SHA512/256 hash of public key)") + print_info(" - Encoded together as 58 character base32 string") + + print_info("\nFor our sample address:") + print_info(f" Public key (32 bytes): {format_hex(decoded_public_key)}") + + checksum = get_checksum(decoded_public_key) + print_info(f" Checksum (4 bytes): {format_hex(checksum)}") + + # Show how the checksum is computed + print_info("\nThe checksum is computed by:") + print_info(" 1. Taking SHA512/256 hash of the public key") + print_info(" 2. Using the last 4 bytes of that hash") + + # Demonstrate with zero address + zero_public_key = public_key_from_address(ZERO_ADDRESS) + zero_checksum = get_checksum(zero_public_key) + print_info("\nZero address example:") + print_info(f" Public key: {format_hex(zero_public_key[:8])}... (all zeros)") + print_info(f" Checksum: {format_hex(zero_checksum)}") + print_info(f" Full address: {ZERO_ADDRESS}") + + # Step 5: get_application_address() - Compute App Escrow Address + print_step(5, "get_application_address() - Application Escrow Address") + + print_info("Every application has an escrow address derived from its app ID.") + print_info("This address can hold Algos and ASAs for the application.") + + # Compute addresses for some app IDs + app_ids = [1, 123, 1234567890] + + for app_id in app_ids: + app_address = get_application_address(app_id) + app_pk = public_key_from_address(app_address) + print_info(f"\nApp ID {app_id}:") + print_info(f" Escrow address: {app_address}") + print_info(f" Public key (first 8 bytes): {format_hex(app_pk[:8])}...") + + print_info("\nThe address is computed by:") + print_info(' 1. Concatenating "appID" prefix with 8-byte big-endian app ID') + print_info(" 2. Taking SHA512/256 hash of the result") + print_info(" 3. Using the 32-byte hash as the public key") + + # Step 6: Working with different address representations + print_step(6, "Working with Different Representations") + + print_info("Different ways to work with addresses:") + print_info(" - Base32 string: human-readable, used in UIs and APIs") + print_info(" - Public key bytes: used for cryptographic operations") + print_info(" - Hex string: useful for debugging and logging") + + # From string + sample_str = "AAAQEAYEAUDAOCAJBIFQYDIOB4IBCEQTCQKRMFYYDENBWHA5DYP7MUPJQE" + from_string_pk = public_key_from_address(sample_str) + print_info(f"\nFrom string: {sample_str[:30]}...") + print_info(f" -> public_key_from_address() -> {len(from_string_pk)} bytes") + + # From public key back to string + back_to_string = address_from_public_key(from_string_pk) + print_info(f" -> address_from_public_key() -> {back_to_string[:30]}...") + + # All match + print_info(f"\nRound-trip verified: {sample_str == back_to_string}") + + # Step 7: Practical Use Cases + print_step(7, "Practical Use Cases") + + print_info("Common scenarios for address encoding/decoding:") + + print_info("\n1. Converting wallet public keys to displayable addresses:") + wallet_pub_key = bytes([42] * 32) # Simulated wallet public key + wallet_address = address_from_public_key(wallet_pub_key) + print_info(f" Public key -> Address: {wallet_address[:30]}...") + + print_info("\n2. Extracting public key from address for cryptographic operations:") + some_address = "AAAQEAYEAUDAOCAJBIFQYDIOB4IBCEQTCQKRMFYYDENBWHA5DYP7MUPJQE" + extracted = public_key_from_address(some_address) + print_info(f" Address -> Public key: {format_hex(extracted[:8])}...") + + print_info("\n3. Computing application escrow for sending funds:") + my_app_id = 12345 + escrow = get_application_address(my_app_id) + print_info(f" App {my_app_id} escrow: {escrow[:30]}...") + + print_info("\n4. Normalizing address inputs in functions:") + print_info(" def send_payment(to: str) -> None:") + print_info(" pk = public_key_from_address(to) # Validates and extracts") + print_info(" # ... rest of implementation") + + # Step 8: Summary + print_step(8, "Summary") + + print_info("Encoding/Decoding Functions:") + print_info(" - address_from_public_key(pk) - 32-byte bytes -> 58-char base32 string") + print_info(" - public_key_from_address(addr) - 58-char base32 string -> 32-byte bytes") + + print_info("\nApplication Address:") + print_info(" - get_application_address(app_id) - App ID -> Escrow Address string") + + print_info("\nAddress Structure:") + print_info(" - 32 bytes public key + 4 bytes checksum = 36 bytes") + print_info(" - Base32 encoded to 58 character string") + + print_success("Address Encoding example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/common/03_array_utilities.py b/examples/common/03_array_utilities.py new file mode 100644 index 00000000..1a292615 --- /dev/null +++ b/examples/common/03_array_utilities.py @@ -0,0 +1,250 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Array Utilities + +This example demonstrates array utility operations for comparing and +concatenating byte arrays in Python: +- Comparing arrays with == operator for element-by-element comparison +- Concatenating arrays using + operator or bytes concatenation +- Using list comprehensions for array manipulation + +Note: Python's bytes type provides native support for these operations, +unlike JavaScript's Uint8Array which needs utility functions. + +No LocalNet required - pure utility functions +""" + +from shared import ( + format_bytes, + print_header, + print_info, + print_step, + print_success, +) + + +def array_equal(a: bytes, b: bytes) -> bool: + """ + Compare two byte arrays element-by-element. + + Python's bytes == operator already does this, but we define + this for parity with the TypeScript SDK's arrayEqual() function. + """ + return a == b + + +def concat_arrays(*arrays: bytes) -> bytes: + """ + Concatenate multiple byte arrays into a new array. + + Python's bytes can be concatenated with +, or we can use b''.join(). + """ + return b"".join(arrays) + + +def main() -> None: + print_header("Array Utilities Example") + + # Step 1: Array comparison - Comparing Equal Arrays + print_step(1, "array_equal() - Comparing Equal Arrays") + + arr1 = bytes([1, 2, 3, 4, 5]) + arr2 = bytes([1, 2, 3, 4, 5]) + + print_info(f"Array 1: {format_bytes(arr1)}") + print_info(f"Array 2: {format_bytes(arr2)}") + print_info(f"array_equal(arr1, arr2): {array_equal(arr1, arr2)}") + print_info("Arrays with identical content return True") + + # Step 2: array_equal() - Different Length Arrays + print_step(2, "array_equal() - Different Length Arrays") + + short_arr = bytes([1, 2, 3]) + long_arr = bytes([1, 2, 3, 4, 5]) + + print_info(f"Short array (length {len(short_arr)}): {format_bytes(short_arr)}") + print_info(f"Long array (length {len(long_arr)}): {format_bytes(long_arr)}") + print_info(f"array_equal(short_arr, long_arr): {array_equal(short_arr, long_arr)}") + print_info("Different lengths return False (fast check before element comparison)") + + # Step 3: array_equal() - Same Length, Different Content + print_step(3, "array_equal() - Same Length, Different Content") + + arr_a = bytes([1, 2, 3, 4, 5]) + arr_b = bytes([1, 2, 99, 4, 5]) # Different value at index 2 + + print_info(f"Array A: {format_bytes(arr_a)}") + print_info(f"Array B: {format_bytes(arr_b)}") + print_info(f"array_equal(arr_a, arr_b): {array_equal(arr_a, arr_b)}") + print_info("Same length but different content at index 2 returns False") + + # Step 4: array_equal() - Edge Cases + print_step(4, "array_equal() - Edge Cases") + + # Empty arrays + empty1 = b"" + empty2 = b"" + print_info(f"Empty arrays: array_equal(b'', b''): {array_equal(empty1, empty2)}") + + # Single element + single1 = bytes([42]) + single2 = bytes([42]) + print_info(f"Single element: array_equal([42], [42]): {array_equal(single1, single2)}") + + # Same reference + same_ref = bytes([1, 2, 3]) + print_info(f"Same reference: array_equal(arr, arr): {array_equal(same_ref, same_ref)}") + + # Step 5: concat_arrays() - Joining Multiple Arrays + print_step(5, "concat_arrays() - Joining Multiple Arrays") + + first = bytes([1, 2, 3]) + second = bytes([4, 5, 6]) + third = bytes([7, 8, 9]) + + print_info(f"First array: {format_bytes(first)}") + print_info(f"Second array: {format_bytes(second)}") + print_info(f"Third array: {format_bytes(third)}") + + concatenated = concat_arrays(first, second, third) + print_info("\nconcat_arrays(first, second, third):") + print_info(f"Result: {format_bytes(concatenated)}") + print_info(f"Result length: {len(concatenated)} bytes") + + # Step 6: concat_arrays() - Different Sized Arrays + print_step(6, "concat_arrays() - Different Sized Arrays") + + tiny = bytes([1]) + small = bytes([2, 3]) + medium = bytes([4, 5, 6, 7]) + large = bytes([8, 9, 10, 11, 12, 13, 14, 15]) + + print_info(f"Tiny (1 byte): {format_bytes(tiny)}") + print_info(f"Small (2 bytes): {format_bytes(small)}") + print_info(f"Medium (4 bytes): {format_bytes(medium)}") + print_info(f"Large (8 bytes): {format_bytes(large)}") + + combined = concat_arrays(tiny, small, medium, large) + print_info("\nconcat_arrays(tiny, small, medium, large):") + print_info(f"Result: {format_bytes(combined)}") + print_info(f"Result length: {len(combined)} bytes (1 + 2 + 4 + 8 = 15)") + + # Step 7: concat_arrays() Returns New Array (Doesn't Modify Inputs) + print_step(7, "concat_arrays() - Returns New Array (Non-Mutating)") + + original1 = bytes([10, 20, 30]) + original2 = bytes([40, 50, 60]) + + print_info("Before concat:") + print_info(f" original1: {format_bytes(original1)}") + print_info(f" original2: {format_bytes(original2)}") + + result = concat_arrays(original1, original2) + + print_info("\nAfter concat:") + print_info(f" original1: {format_bytes(original1)} (unchanged)") + print_info(f" original2: {format_bytes(original2)} (unchanged)") + print_info(f" result: {format_bytes(result)} (new array)") + + # Prove they are different objects + print_info("\nVerifying result is a new array:") + print_info(f" result is original1: {result is original1}") + print_info(f" result is original2: {result is original2}") + + # Note: Python bytes are immutable, so we can't modify result in place + # This is different from TypeScript Uint8Array which is mutable + print_info("\nNote: Python bytes are immutable (cannot modify result[0])") + print_info(" This provides additional safety compared to mutable arrays") + + # Step 8: concat_arrays() - Edge Cases + print_step(8, "concat_arrays() - Edge Cases") + + # Single array + single_input = bytes([1, 2, 3]) + single_result = concat_arrays(single_input) + print_info(f"Single input: concat_arrays([1,2,3]) = {format_bytes(single_result)}") + print_info(f" Is new object: {single_result is not single_input}") + + # Empty arrays + empty_result = concat_arrays(b"", bytes([1, 2]), b"") + print_info(f"With empty arrays: concat_arrays(b'', [1,2], b'') = {format_bytes(empty_result)}") + + # No arguments + no_args = concat_arrays() + print_info(f"No arguments: concat_arrays() = {format_bytes(no_args)} (empty bytes)") + + # Step 9: Python Native Array Operations + print_step(9, "Python Native Array Operations") + + print_info("Python provides native support for byte array operations:") + + # Direct comparison with == + bytes_a = bytes([1, 2, 3]) + bytes_b = bytes([1, 2, 3]) + print_info("\n1. Direct comparison with ==:") + print_info(f" bytes([1,2,3]) == bytes([1,2,3]): {bytes_a == bytes_b}") + + # Concatenation with + + bytes_c = bytes_a + bytes([4, 5, 6]) + print_info("\n2. Concatenation with +:") + print_info(f" bytes([1,2,3]) + bytes([4,5,6]) = {format_bytes(bytes_c)}") + + # Using b''.join() + arrays_to_join = [bytes([1, 2]), bytes([3, 4]), bytes([5, 6])] + joined = b"".join(arrays_to_join) + print_info("\n3. Using b''.join():") + print_info(f" b''.join([...]) = {format_bytes(joined)}") + + # Slicing + sliced = bytes_c[2:5] + print_info("\n4. Slicing:") + print_info(f" bytes([1,2,3,4,5,6])[2:5] = {format_bytes(sliced)}") + + # Step 10: Practical Use Cases + print_step(10, "Practical Use Cases") + + print_info("Common scenarios for array utilities:") + + print_info("\n1. Comparing cryptographic hashes:") + hash1 = bytes([0xAB, 0xCD, 0xEF, 0x12]) + hash2 = bytes([0xAB, 0xCD, 0xEF, 0x12]) + print_info(f" hash1 is hash2 (reference): {hash1 is hash2}") + print_info(f" hash1 == hash2 (content): {hash1 == hash2}") + + print_info("\n2. Building transaction data:") + prefix = bytes([0x54, 0x58]) # "TX" + tx_data = bytes([0x01, 0x02, 0x03]) + prefixed_tx = concat_arrays(prefix, tx_data) + print_info(f" Prefix + TxData: {format_bytes(prefixed_tx)}") + + print_info("\n3. Concatenating signature components:") + r = bytes([0x30, 0x31, 0x32, 0x33]) # r component + s = bytes([0x40, 0x41, 0x42, 0x43]) # s component + signature = concat_arrays(r, s) + print_info(f" r + s = {format_bytes(signature)}") + + # Step 11: Summary + print_step(11, "Summary") + + print_info("Array Comparison:") + print_info(" - array_equal(a, b) - Compare two arrays element-by-element") + print_info(" - Python's == operator does the same natively") + print_info(" - Returns False immediately if lengths differ (efficient)") + + print_info("\nArray Concatenation:") + print_info(" - concat_arrays(*arrays) - Join multiple byte arrays") + print_info(" - Returns a new bytes object (non-mutating)") + print_info(" - Python's + operator and b''.join() work natively") + print_info(" - Handles empty arrays and single inputs gracefully") + + print_info("\nPython bytes vs TypeScript Uint8Array:") + print_info(" - Python bytes are immutable (safer)") + print_info(" - Native == comparison (no utility function needed)") + print_info(" - Native + concatenation (no utility function needed)") + print_info(" - Native slicing with [start:end] syntax") + + print_success("Array Utilities example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/common/04_constants.py b/examples/common/04_constants.py new file mode 100644 index 00000000..cd1f4113 --- /dev/null +++ b/examples/common/04_constants.py @@ -0,0 +1,197 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Constants Reference + +This example displays all the protocol constants available in the algokit_common package. +These constants define limits, sizes, and separators used throughout Algorand. + +No LocalNet required - pure constants display +""" + +from shared import ( + format_bytes, + print_header, + print_info, + print_step, + print_success, +) + +from algokit_common import ( + # Address constants + ADDRESS_LENGTH, + BOOL_FALSE_BYTE, + BOOL_TRUE_BYTE, + CHECKSUM_BYTE_LENGTH, + EMPTY_SIGNATURE, + # Cryptographic constants + HASH_BYTES_LENGTH, + # Encoding constants + LENGTH_ENCODE_BYTE_SIZE, + MAX_ACCOUNT_REFERENCES, + MAX_APP_ARGS, + MAX_APP_REFERENCES, + MAX_ARGS_SIZE, + MAX_ASSET_DECIMALS, + # Asset configuration limits + MAX_ASSET_NAME_LENGTH, + MAX_ASSET_REFERENCES, + MAX_ASSET_UNIT_NAME_LENGTH, + MAX_ASSET_URL_LENGTH, + MAX_BOX_REFERENCES, + # Application program constants + MAX_EXTRA_PROGRAM_PAGES, + # Application state schema limits + MAX_GLOBAL_STATE_KEYS, + MAX_LOCAL_STATE_KEYS, + # Application reference limits + MAX_OVERALL_REFERENCES, + MAX_TRANSACTION_GROUP_SIZE, + PROGRAM_PAGE_SIZE, + PUBLIC_KEY_BYTE_LENGTH, + SIGNATURE_BYTE_LENGTH, + # Transaction-related constants + TRANSACTION_DOMAIN_SEPARATOR, + TRANSACTION_GROUP_DOMAIN_SEPARATOR, + TRANSACTION_ID_LENGTH, +) + + +def main() -> None: + print_header("Constants Reference Example") + + # Step 1: Transaction-Related Constants + print_step(1, "Transaction-Related Constants") + + print_info(f"TRANSACTION_DOMAIN_SEPARATOR: {TRANSACTION_DOMAIN_SEPARATOR!r}") + print_info(" Used as prefix when hashing transactions for signing") + print_info(f"TRANSACTION_GROUP_DOMAIN_SEPARATOR: {TRANSACTION_GROUP_DOMAIN_SEPARATOR!r}") + print_info(" Used as prefix when hashing transaction groups") + print_info(f"MAX_TRANSACTION_GROUP_SIZE: {MAX_TRANSACTION_GROUP_SIZE}") + print_info(" Maximum number of transactions in an atomic group") + + # Step 2: Cryptographic Constants + print_step(2, "Cryptographic Constants") + + print_info(f"HASH_BYTES_LENGTH: {HASH_BYTES_LENGTH} bytes") + print_info(" Length of SHA512/256 hash output") + print_info(f"PUBLIC_KEY_BYTE_LENGTH: {PUBLIC_KEY_BYTE_LENGTH} bytes") + print_info(" Length of Ed25519 public key") + print_info(f"SIGNATURE_BYTE_LENGTH: {SIGNATURE_BYTE_LENGTH} bytes") + print_info(" Length of Ed25519 signature") + print_info(f"EMPTY_SIGNATURE: {format_bytes(EMPTY_SIGNATURE)}") + print_info(f" Pre-allocated empty signature ({len(EMPTY_SIGNATURE)} zero bytes)") + + # Step 3: Address Constants + print_step(3, "Address Constants") + + print_info(f"ADDRESS_LENGTH: {ADDRESS_LENGTH} characters") + print_info(" Length of base32-encoded Algorand address string") + print_info(f"CHECKSUM_BYTE_LENGTH: {CHECKSUM_BYTE_LENGTH} bytes") + print_info(" Length of address checksum (last 4 bytes of SHA512/256 hash)") + print_info(f"TRANSACTION_ID_LENGTH: {TRANSACTION_ID_LENGTH} characters") + print_info(" Length of base32-encoded transaction ID string") + + # Step 4: Application Program Constants + print_step(4, "Application Program Constants") + + print_info(f"MAX_EXTRA_PROGRAM_PAGES: {MAX_EXTRA_PROGRAM_PAGES}") + print_info(" Maximum additional pages beyond the base page") + print_info(f"PROGRAM_PAGE_SIZE: {PROGRAM_PAGE_SIZE} bytes") + print_info(" Size of each program page (approval + clear combined)") + total_pages = 1 + MAX_EXTRA_PROGRAM_PAGES + max_program_size = PROGRAM_PAGE_SIZE * total_pages + print_info(f" Total max program size: {max_program_size} bytes ({total_pages} pages)") + print_info(f"MAX_APP_ARGS: {MAX_APP_ARGS}") + print_info(" Maximum number of application call arguments") + print_info(f"MAX_ARGS_SIZE: {MAX_ARGS_SIZE} bytes") + print_info(" Maximum total size of all application arguments combined") + + # Step 5: Application Reference Limits + print_step(5, "Application Reference Limits") + + print_info(f"MAX_OVERALL_REFERENCES: {MAX_OVERALL_REFERENCES}") + print_info(" Maximum total foreign references (accounts + apps + assets + boxes)") + print_info(f"MAX_ACCOUNT_REFERENCES: {MAX_ACCOUNT_REFERENCES}") + print_info(" Maximum foreign accounts in a single app call") + print_info(f"MAX_APP_REFERENCES: {MAX_APP_REFERENCES}") + print_info(" Maximum foreign applications in a single app call") + print_info(f"MAX_ASSET_REFERENCES: {MAX_ASSET_REFERENCES}") + print_info(" Maximum foreign assets in a single app call") + print_info(f"MAX_BOX_REFERENCES: {MAX_BOX_REFERENCES}") + print_info(" Maximum box references in a single app call") + + # Step 6: Application State Schema Limits + print_step(6, "Application State Schema Limits") + + print_info(f"MAX_GLOBAL_STATE_KEYS: {MAX_GLOBAL_STATE_KEYS}") + print_info(" Maximum key-value pairs in application global state") + print_info(f"MAX_LOCAL_STATE_KEYS: {MAX_LOCAL_STATE_KEYS}") + print_info(" Maximum key-value pairs in per-account local state") + + # Step 7: Asset Configuration Limits + print_step(7, "Asset Configuration Limits") + + print_info(f"MAX_ASSET_NAME_LENGTH: {MAX_ASSET_NAME_LENGTH} bytes") + print_info(" Maximum length of asset name") + print_info(f"MAX_ASSET_UNIT_NAME_LENGTH: {MAX_ASSET_UNIT_NAME_LENGTH} bytes") + print_info(" Maximum length of asset unit name (ticker symbol)") + print_info(f"MAX_ASSET_URL_LENGTH: {MAX_ASSET_URL_LENGTH} bytes") + print_info(" Maximum length of asset URL") + print_info(f"MAX_ASSET_DECIMALS: {MAX_ASSET_DECIMALS}") + print_info(" Maximum decimal places for asset divisibility") + + # Step 8: Encoding Constants + print_step(8, "Encoding Constants") + + print_info(f"LENGTH_ENCODE_BYTE_SIZE: {LENGTH_ENCODE_BYTE_SIZE} bytes") + print_info(" Size of length prefix in ABI encoding") + bool_true_hex = f"0x{BOOL_TRUE_BYTE:02X}" + print_info(f"BOOL_TRUE_BYTE: {bool_true_hex} ({BOOL_TRUE_BYTE})") + print_info(" Byte value representing boolean true in ABI encoding") + bool_false_hex = f"0x{BOOL_FALSE_BYTE:02X}" + print_info(f"BOOL_FALSE_BYTE: {bool_false_hex} ({BOOL_FALSE_BYTE})") + print_info(" Byte value representing boolean false in ABI encoding") + + # Step 9: Quick Reference Summary + print_step(9, "Quick Reference Summary") + + print_info("Transaction Limits:") + print_info(f" - Max group size: {MAX_TRANSACTION_GROUP_SIZE} transactions") + print_info(f" - Transaction ID: {TRANSACTION_ID_LENGTH} chars") + + print_info("\nCryptographic Sizes:") + print_info( + f" - Hash: {HASH_BYTES_LENGTH} bytes | " + f"Public Key: {PUBLIC_KEY_BYTE_LENGTH} bytes | " + f"Signature: {SIGNATURE_BYTE_LENGTH} bytes" + ) + + print_info("\nAddress Format:") + print_info(f" - String: {ADDRESS_LENGTH} chars | Checksum: {CHECKSUM_BYTE_LENGTH} bytes") + + print_info("\nApplication Limits:") + print_info(f" - Program: {max_program_size} bytes max ({total_pages} pages x {PROGRAM_PAGE_SIZE})") + print_info(f" - Args: {MAX_APP_ARGS} max, {MAX_ARGS_SIZE} bytes total") + refs_detail = ( + f"{MAX_ACCOUNT_REFERENCES} accounts, " + f"{MAX_APP_REFERENCES} apps, " + f"{MAX_ASSET_REFERENCES} assets, " + f"{MAX_BOX_REFERENCES} boxes" + ) + print_info(f" - References: {MAX_OVERALL_REFERENCES} total ({refs_detail})") + print_info(f" - State: {MAX_GLOBAL_STATE_KEYS} global keys, {MAX_LOCAL_STATE_KEYS} local keys") + + print_info("\nAsset Limits:") + asset_limits = ( + f"Name: {MAX_ASSET_NAME_LENGTH} bytes | " + f"Unit: {MAX_ASSET_UNIT_NAME_LENGTH} bytes | " + f"URL: {MAX_ASSET_URL_LENGTH} bytes | " + f"Decimals: {MAX_ASSET_DECIMALS} max" + ) + print_info(f" - {asset_limits}") + + print_success("Constants Reference example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/common/05_crypto_hash.py b/examples/common/05_crypto_hash.py new file mode 100644 index 00000000..2ab31b2a --- /dev/null +++ b/examples/common/05_crypto_hash.py @@ -0,0 +1,195 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Crypto Hash (SHA-512/256) + +This example demonstrates the sha512_256() function for computing Algorand-compatible +SHA-512/256 hashes. This hash algorithm is used throughout Algorand for: +- Transaction IDs +- Address checksums +- Application escrow addresses +- State proof verification + +No LocalNet required - pure cryptographic function +""" + +from shared import ( + format_bytes, + format_hex, + print_header, + print_info, + print_step, + print_success, +) + +from algokit_common import ( + HASH_BYTES_LENGTH, + TRANSACTION_DOMAIN_SEPARATOR, + sha512_256, +) + + +def main() -> None: + print_header("Crypto Hash (SHA-512/256) Example") + + # Step 1: Hash a simple message + print_step(1, "Hash a Simple Message") + + message = "Hello, Algorand!" + message_bytes = message.encode("utf-8") + message_hash = sha512_256(message_bytes) + + print_info(f'Input message: "{message}"') + print_info(f"Input bytes: {format_bytes(message_bytes)}") + print_info(f"Hash output: {format_bytes(message_hash)}") + print_info(f"Hash as hex: {format_hex(message_hash)}") + + # Step 2: Hash empty bytes + print_step(2, "Hash Empty Bytes") + + empty_bytes = b"" + empty_hash = sha512_256(empty_bytes) + + print_info("Input: empty byte array (0 bytes)") + print_info(f"Hash output: {format_bytes(empty_hash)}") + print_info(f"Hash as hex: {format_hex(empty_hash)}") + print_info("Note: Even empty input produces a 32-byte hash") + + # Step 3: Verify hash always returns exactly 32 bytes (HASH_BYTES_LENGTH) + print_step(3, "Verify Hash Always Returns 32 Bytes") + + print_info(f"HASH_BYTES_LENGTH constant: {HASH_BYTES_LENGTH} bytes") + + # Test with various input sizes + test_inputs = [ + ("empty", b""), + ("1 byte", bytes([0x42])), + ("32 bytes", bytes([0xAA] * 32)), + ("100 bytes", bytes([0xBB] * 100)), + ("1000 bytes", bytes([0xCC] * 1000)), + ] + + for name, data in test_inputs: + input_hash = sha512_256(data) + length_match = len(input_hash) == HASH_BYTES_LENGTH + checkmark = "OK" if length_match else "FAIL" + print_info(f"Input: {name:<12} -> Output: {len(input_hash)} bytes [{checkmark}]") + + print_success(f"All hash outputs are exactly {HASH_BYTES_LENGTH} bytes") + + # Step 4: Hash a transaction-like payload + print_step(4, "Hash a Transaction-Like Payload") + + # Algorand transaction hashing uses a domain separator prefix + print_info(f"Transaction domain separator: {TRANSACTION_DOMAIN_SEPARATOR!r}") + + # Simulate a minimal transaction-like structure + fake_tx_payload = bytes( + [ + 0x01, # version + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x01, # first valid round (8 bytes) + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x0A, # last valid round (8 bytes) + # ... simplified for demonstration + ] + ) + + # In Algorand, transaction ID = hash(domain_separator + msgpack(transaction)) + prefixed_payload = TRANSACTION_DOMAIN_SEPARATOR + fake_tx_payload + + tx_like_hash = sha512_256(prefixed_payload) + + print_info(f"Domain separator bytes: {format_bytes(TRANSACTION_DOMAIN_SEPARATOR)}") + print_info(f"Payload bytes: {format_bytes(fake_tx_payload)}") + print_info(f"Combined (prefixed) bytes: {format_bytes(prefixed_payload)}") + print_info(f"Transaction-like hash: {format_hex(tx_like_hash)}") + + # Step 5: Demonstrate hex representation + print_step(5, "Hex Representation of Hash Output") + + # Hash a known value for demonstration + known_input = bytes([0x00, 0x01, 0x02, 0x03]) + known_hash = sha512_256(known_input) + + print_info(f"Input bytes: {format_bytes(known_input, 4)}") + print_info(f"Hash (raw bytes): {format_bytes(known_hash, 16)}") + print_info(f"Hash (full hex): {format_hex(known_hash)}") + + # Show the hex format breakdown + hex_string = known_hash.hex() + print_info(f"Hash length: {len(hex_string)} hex characters ({len(hex_string) // 2} bytes)") + + # Step 6: Verify determinism - same input always produces same hash + print_step(6, "Verify Determinism") + + deterministic_input = b"Algorand is great!" + + # Hash the same input multiple times + hash1 = sha512_256(deterministic_input) + hash2 = sha512_256(deterministic_input) + hash3 = sha512_256(deterministic_input) + + print_info('"Algorand is great!"') + print_info(f"Hash #1: {format_hex(hash1)}") + print_info(f"Hash #2: {format_hex(hash2)}") + print_info(f"Hash #3: {format_hex(hash3)}") + + all_equal = hash1 == hash2 == hash3 + checkmark = "Yes [OK]" if all_equal else "No [FAIL]" + print_info(f"All hashes equal: {checkmark}") + + if all_equal: + print_success("Determinism verified: same input always produces same hash") + + # Step 7: Show that different inputs produce different hashes + print_step(7, "Different Inputs Produce Different Hashes") + + input_a = b"input A" + input_b = b"input B" + input_c = b"input a" # lowercase 'a' vs uppercase 'A' + + hash_a = sha512_256(input_a) + hash_b = sha512_256(input_b) + hash_c = sha512_256(input_c) + + print_info(f'"input A" -> {format_hex(hash_a)[:24]}...') + print_info(f'"input B" -> {format_hex(hash_b)[:24]}...') + print_info(f'"input a" -> {format_hex(hash_c)[:24]}...') + + ab_different = hash_a != hash_b + ac_different = hash_a != hash_c + + ab_status = "Different [OK]" if ab_different else "Same [FAIL]" + ac_status = "Different [OK]" if ac_different else "Same [FAIL]" + + print_info(f'"input A" vs "input B": {ab_status}') + print_info(f'"input A" vs "input a": {ac_status}') + print_info("Note: Even a single-bit change produces a completely different hash") + + # Summary + print_step(8, "Summary") + + print_info("SHA-512/256 in Algorand:") + print_info(f" - Always produces exactly {HASH_BYTES_LENGTH} bytes (256 bits)") + print_info(" - Deterministic: same input always yields same output") + print_info(" - Collision-resistant: different inputs produce different outputs") + print_info(" - Used for: transaction IDs, address checksums, app addresses") + print_info(f" - Domain separator {TRANSACTION_DOMAIN_SEPARATOR!r} prevents cross-protocol attacks") + + print_success("Crypto Hash example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/common/06_logger.py b/examples/common/06_logger.py new file mode 100644 index 00000000..939b6071 --- /dev/null +++ b/examples/common/06_logger.py @@ -0,0 +1,423 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLE1205 +""" +Logger Type Example + +This example demonstrates the Logger protocol/interface for consistent logging +across the AlgoKit Utils SDK. + +Topics covered: +- Logger protocol definition with all log levels +- Console-based Logger implementation +- No-op (silent) logger for production +- Custom formatting logger +- Compatibility with common logging patterns + +No LocalNet required - pure type/interface example +""" + +import logging +from datetime import datetime, timezone +from typing import Any, Protocol + +from shared import ( + print_header, + print_info, + print_step, + print_success, +) + +# ============================================================================ +# Logger Protocol Definition +# ============================================================================ + + +class Logger(Protocol): + """ + Protocol defining the standard logging interface. + + This protocol matches the Logger type from the TypeScript SDK, + providing a consistent interface across both SDKs. + """ + + def error(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log an error message.""" + ... + + def warn(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log a warning message.""" + ... + + def info(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log an informational message.""" + ... + + def verbose(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log a verbose/trace message.""" + ... + + def debug(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log a debug message.""" + ... + + +# ============================================================================ +# Logger Implementations +# ============================================================================ + + +class ConsoleLogger: + """Console-based Logger implementation using print statements.""" + + def error(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log an error message.""" + self._log("ERROR", message, args, kwargs) + + def warn(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log a warning message.""" + self._log("WARN ", message, args, kwargs) + + def info(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log an informational message.""" + self._log("INFO ", message, args, kwargs) + + def verbose(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log a verbose/trace message.""" + self._log("VERB ", message, args, kwargs) + + def debug(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log a debug message.""" + self._log("DEBUG", message, args, kwargs) + + def _log(self, level: str, message: str, args: tuple, kwargs: dict) -> None: + """Internal logging helper.""" + extra = "" + if args: + extra = f" {args}" + if kwargs: + extra += f" {kwargs}" + print(f"[{level}] {message}{extra}") # noqa: T201 + + +class NullLogger: + """No-op (silent) logger that discards all messages.""" + + def error(self, message: str, *args: Any, **kwargs: Any) -> None: + """Discard error message.""" + + def warn(self, message: str, *args: Any, **kwargs: Any) -> None: + """Discard warning message.""" + + def info(self, message: str, *args: Any, **kwargs: Any) -> None: + """Discard informational message.""" + + def verbose(self, message: str, *args: Any, **kwargs: Any) -> None: + """Discard verbose message.""" + + def debug(self, message: str, *args: Any, **kwargs: Any) -> None: + """Discard debug message.""" + + +class TimestampLogger: + """Logger with custom formatting including timestamp and prefix.""" + + def __init__(self, prefix: str) -> None: + """Initialize with a prefix for all log messages.""" + self.prefix = prefix + + def _format_message(self, level: str, message: str) -> str: + """Format a message with timestamp and prefix.""" + timestamp = datetime.now(timezone.utc).isoformat() + return f"{timestamp} [{self.prefix}] {level:<7} {message}" + + def error(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log an error message.""" + print(self._format_message("ERROR", message), args if args else "", kwargs if kwargs else "") # noqa: T201 + + def warn(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log a warning message.""" + print(self._format_message("WARN", message), args if args else "", kwargs if kwargs else "") # noqa: T201 + + def info(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log an informational message.""" + print(self._format_message("INFO", message), args if args else "", kwargs if kwargs else "") # noqa: T201 + + def verbose(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log a verbose message.""" + print(self._format_message("VERBOSE", message), args if args else "", kwargs if kwargs else "") # noqa: T201 + + def debug(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log a debug message.""" + print(self._format_message("DEBUG", message), args if args else "", kwargs if kwargs else "") # noqa: T201 + + +# Log level priority for filtering +LOG_LEVEL_PRIORITY = { + "error": 0, + "warn": 1, + "info": 2, + "verbose": 3, + "debug": 4, +} + + +class FilteredLogger: + """Logger that filters messages based on minimum log level.""" + + def __init__(self, min_level: str) -> None: + """Initialize with minimum log level to display.""" + self.min_priority = LOG_LEVEL_PRIORITY.get(min_level, 4) + + def _should_log(self, level: str) -> bool: + """Check if a message at this level should be logged.""" + return LOG_LEVEL_PRIORITY.get(level, 4) <= self.min_priority + + def error(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log an error message if level permits.""" + if self._should_log("error"): + print(f"[ERROR] {message}", args if args else "", kwargs if kwargs else "") # noqa: T201 + + def warn(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log a warning message if level permits.""" + if self._should_log("warn"): + print(f"[WARN] {message}", args if args else "", kwargs if kwargs else "") # noqa: T201 + + def info(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log an informational message if level permits.""" + if self._should_log("info"): + print(f"[INFO] {message}", args if args else "", kwargs if kwargs else "") # noqa: T201 + + def verbose(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log a verbose message if level permits.""" + if self._should_log("verbose"): + print(f"[VERB] {message}", args if args else "", kwargs if kwargs else "") # noqa: T201 + + def debug(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log a debug message if level permits.""" + if self._should_log("debug"): + print(f"[DEBUG] {message}", args if args else "", kwargs if kwargs else "") # noqa: T201 + + +class PythonLoggingAdapter: + """Adapter that wraps Python's standard logging module.""" + + def __init__(self, name: str = "algokit") -> None: + """Initialize with a logger name.""" + self.logger = logging.getLogger(name) + + def error(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log an error message.""" + self.logger.error(message, *args, **kwargs) + + def warn(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log a warning message.""" + self.logger.warning(message, *args, **kwargs) + + def info(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log an informational message.""" + self.logger.info(message, *args, **kwargs) + + def verbose(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log a verbose message (maps to DEBUG in standard logging).""" + self.logger.debug(message, *args, **kwargs) + + def debug(self, message: str, *args: Any, **kwargs: Any) -> None: + """Log a debug message.""" + self.logger.debug(message, *args, **kwargs) + + +# ============================================================================ +# Main Example +# ============================================================================ + + +def main() -> None: + print_header("Logger Type Example") + + # ============================================================================ + # Step 1: Logger Protocol Definition + # ============================================================================ + print_step(1, "Logger Protocol Definition") + + print_info("The Logger protocol defines a standard logging interface:") + print_info("") + print_info(" class Logger(Protocol):") + print_info(" def error(message: str, *args, **kwargs) -> None") + print_info(" def warn(message: str, *args, **kwargs) -> None") + print_info(" def info(message: str, *args, **kwargs) -> None") + print_info(" def verbose(message: str, *args, **kwargs) -> None") + print_info(" def debug(message: str, *args, **kwargs) -> None") + print_info("") + print_info("Log levels (from most to least severe):") + print_info(" 1. error - Critical errors that need immediate attention") + print_info(" 2. warn - Warning conditions that should be reviewed") + print_info(" 3. info - Informational messages for normal operations") + print_info(" 4. verbose - Detailed tracing for troubleshooting") + print_info(" 5. debug - Developer debugging information") + print_success("Logger protocol provides 5 standard log levels") + + # ============================================================================ + # Step 2: Console-based Logger Implementation + # ============================================================================ + print_step(2, "Console-based Logger Implementation") + + console_logger = ConsoleLogger() + + print_info("Created a console-based Logger implementation") + print_info("Demonstrating each log level:") + print_info("") + + console_logger.error("Database connection failed", {"code": "ECONNREFUSED", "port": 5432}) + console_logger.warn("API rate limit approaching", {"current": 95, "limit": 100}) + console_logger.info("Transaction submitted", {"txId": "ABC123..."}) + console_logger.verbose("Processing block", {"round": 12345, "txCount": 7}) + console_logger.debug("Raw response payload", {"bytes": 1024}) + + print_info("") + print_success("All 5 log levels demonstrated") + + # ============================================================================ + # Step 3: No-op (Silent) Logger + # ============================================================================ + print_step(3, "No-op (Silent) Logger") + + null_logger = NullLogger() + + print_info("Created a no-op (silent) logger") + print_info("Silent loggers are useful for:") + print_info(" - Production environments where logging is disabled") + print_info(" - Unit tests where log output is not wanted") + print_info(" - Default parameter values when no logger is provided") + print_info("") + print_info("Calling silent logger (no output expected):") + null_logger.error("This error will not be logged") + null_logger.warn("This warning will not be logged") + null_logger.info("This info will not be logged") + null_logger.verbose("This verbose message will not be logged") + null_logger.debug("This debug message will not be logged") + print_success("No-op logger created - produces no output") + + # ============================================================================ + # Step 4: Custom Formatting Logger + # ============================================================================ + print_step(4, "Custom Formatting Logger") + + app_logger = TimestampLogger("MyApp") + + print_info("Created a logger with custom formatting:") + print_info(" - ISO timestamp prefix") + print_info(" - Application name prefix") + print_info(" - Padded log level for alignment") + print_info("") + print_info("Demonstrating custom formatted output:") + print_info("") + + app_logger.info("Application started") + app_logger.debug("Configuration loaded", {"env": "development"}) + app_logger.warn("Deprecated API endpoint called") + + print_info("") + print_success("Custom formatting logger created and demonstrated") + + # ============================================================================ + # Step 5: Level-filtered Logger + # ============================================================================ + print_step(5, "Level-filtered Logger") + + print_info("Created a level-filtered logger factory") + print_info("Filter levels control which messages are logged:") + print_info(' - "error" -> only errors') + print_info(' - "warn" -> errors + warnings') + print_info(' - "info" -> errors + warnings + info') + print_info(' - "verbose" -> all except debug') + print_info(' - "debug" -> all messages') + print_info("") + + print_info('Testing with min_level="warn" (only error and warn):') + warn_logger = FilteredLogger("warn") + print_info("") + warn_logger.error("This error IS logged") + warn_logger.warn("This warning IS logged") + warn_logger.info("This info is NOT logged") + warn_logger.debug("This debug is NOT logged") + + print_info("") + print_success("Level-filtered logger demonstrated") + + # ============================================================================ + # Step 6: Logger Interface Compatibility + # ============================================================================ + print_step(6, "Logger Interface Compatibility") + + print_info("The Logger protocol is compatible with common logging approaches:") + print_info("") + print_info(" 1. Python's logging module:") + print_info(' adapter = PythonLoggingAdapter("myapp")') + print_info(" # Maps verbose() to debug() level") + print_info("") + print_info(" 2. Custom implementations - as shown in this example") + print_info(" ConsoleLogger, TimestampLogger, FilteredLogger") + print_info("") + print_info(" 3. Third-party loggers (structlog, loguru, etc.)") + print_info(" Can be adapted to match the Logger protocol") + print_info("") + + # Demonstrate Python logging adapter + print_info("Demonstrating PythonLoggingAdapter:") + # Configure basic logging for demo + logging.basicConfig(level=logging.DEBUG, format="%(levelname)s:%(name)s:%(message)s") + python_logger = PythonLoggingAdapter("demo") + print_info("") + python_logger.info("Using Python standard logging") + python_logger.debug("This maps to DEBUG level") + + print_info("") + print_success("Logger protocol compatible with Python logging ecosystem") + + # ============================================================================ + # Step 7: Using Logger in Functions + # ============================================================================ + print_step(7, "Using Logger in Functions") + + def simulate_transaction(tx_id: str, logger: Logger | None = None) -> None: + """Simulate a transaction with optional logging.""" + # Use null logger if none provided + log: Logger = logger if logger is not None else NullLogger() + + log.info(f"Starting transaction: {tx_id}") + log.debug("Validating transaction parameters") + log.verbose("Serializing transaction data") + log.info(f"Transaction {tx_id} completed successfully") + + print_info("Created a function that accepts Logger as optional parameter") + print_info("When no logger is provided, it defaults to NullLogger (silent)") + print_info("") + + print_info("Calling with no logger (silent):") + simulate_transaction("TX-001") + print_info(" (no output produced)") + print_info("") + + print_info("Calling with console_logger:") + print_info("") + simulate_transaction("TX-002", console_logger) + + print_info("") + print_success("Logger can be used as optional dependency injection") + + # ============================================================================ + # Summary + # ============================================================================ + print_step(8, "Summary") + + print_info("Logger protocol provides:") + print_info(" - 5 standard log levels (error, warn, info, verbose, debug)") + print_info(" - Support for additional parameters (*args, **kwargs)") + print_info(" - Compatibility with Python's logging module") + print_info(" - Easy to implement custom formatters and filters") + print_info(" - No-op logger for disabling output") + print_info("") + print_success("Logger Type Example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/common/07_json_bigint.py b/examples/common/07_json_bigint.py new file mode 100644 index 00000000..1eaf0bde --- /dev/null +++ b/examples/common/07_json_bigint.py @@ -0,0 +1,295 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: JSON BigInt Support + +This example demonstrates how Python handles large integers in JSON, which is +simpler than JavaScript due to Python's native arbitrary-precision integers. + +Topics covered: +- Python's int type has unlimited precision (no MAX_SAFE_INTEGER limit) +- json.dumps() and json.loads() work with large integers natively +- Round-trip preservation of large numbers +- Comparison with JavaScript's precision issues +- Algorand-relevant examples with microAlgo amounts +- Custom JSON encoders for specific serialization needs + +No LocalNet required - pure JSON utility functions +""" + +import json +import sys +from decimal import Decimal + +from shared import ( + print_error, + print_header, + print_info, + print_step, + print_success, +) + + +def main() -> None: + print_header("JSON BigInt Example") + + # Step 1: Understanding Python's Integer Precision + print_step(1, "Python's Unlimited Integer Precision") + + print_info("Unlike JavaScript, Python integers have unlimited precision:") + print_info(f" sys.maxsize = {sys.maxsize:,}") + print_info(" (This is just the max value for C-level integers)") + print_info("") + + # Python can handle arbitrarily large numbers + js_max_safe_integer = 9007199254740991 # 2^53 - 1 + print_info(f"JavaScript MAX_SAFE_INTEGER: {js_max_safe_integer:,}") + + # Python has no such limit + large_number = 99999999999999999999999999999999999999999999999999 + print_info(f"Python can handle: {large_number:,}") + print_info("") + + # Arithmetic works perfectly + result = large_number + 1 + print_info(f"large_number + 1 = {result}") + print_success("Python integers have unlimited precision!") + + # Step 2: JSON Parsing - No Precision Loss + print_step(2, "JSON Parsing - No Precision Loss") + + print_info("Python's json.loads() preserves large integers:") + print_info("") + + # JSON with large numbers + large_number_json = '{"amount": 9007199254740993}' + parsed = json.loads(large_number_json) + + print_info(f" Original JSON: {large_number_json}") + print_info(f" Parsed value: {parsed['amount']}") + print_info(f" Type: {type(parsed['amount']).__name__}") + print_info("") + + # Verify no precision loss + expected_value = 9007199254740993 + if parsed["amount"] == expected_value: + print_success(f"Value preserved: {parsed['amount']} === {expected_value}") + else: + print_error("Precision was lost!") + + # Step 3: JSON with Various Integer Sizes + print_step(3, "JSON with Various Integer Sizes") + + print_info("JSON parsing handles all integer sizes correctly:") + print_info("") + + test_cases = [ + ("Small integer", '{"value": 123456789}'), + ("MAX_SAFE_INTEGER", '{"value": 9007199254740991}'), + ("MAX_SAFE + 1", '{"value": 9007199254740992}'), + ("MAX_SAFE + 2", '{"value": 9007199254740993}'), + ("uint64 max", '{"value": 18446744073709551615}'), + ("Very large", '{"value": 99999999999999999999}'), + ] + + for label, json_str in test_cases: + parsed_val = json.loads(json_str)["value"] + print_info(f" {label:20} | {parsed_val:>25}") + + print_info("") + print_success("All integer values parsed without precision loss") + + # Step 4: JSON Serialization of Large Integers + print_step(4, "JSON Serialization of Large Integers") + + print_info("json.dumps() handles large integers natively:") + print_info("") + + obj_with_large_int = { + "name": "Large Amount", + "value": 18446744073709551615, # max uint64 + } + + serialized = json.dumps(obj_with_large_int) + print_info(f" Input: {obj_with_large_int}") + print_info(f" Output: {serialized}") + print_info("") + + # In JavaScript, BigInt would throw an error with JSON.stringify + print_info("Unlike JavaScript, Python requires no special handling for large ints") + print_success("json.dumps() serializes large integers without error") + + # Step 5: Round-trip Preservation + print_step(5, "Round-trip Preservation") + + print_info("Round-trip: json.loads(json.dumps(obj)) preserves large numbers") + print_info("") + + original_obj = { + "id": 1, + "balance": 12345678901234567890, + "active": True, + } + + print_info(f" Original: {original_obj}") + + serialized_obj = json.dumps(original_obj) + print_info(f" JSON: {serialized_obj}") + + round_tripped = json.loads(serialized_obj) + print_info(f" Parsed: {round_tripped}") + print_info("") + + # Verify round-trip + all_match = ( + round_tripped["id"] == original_obj["id"] + and round_tripped["balance"] == original_obj["balance"] + and round_tripped["active"] == original_obj["active"] + ) + + if all_match: + print_success("Round-trip preserves all values including large numbers") + else: + print_error("Round-trip failed") + + # Step 6: Algorand-Relevant Examples - MicroAlgo Amounts + print_step(6, "Algorand-Relevant Examples - MicroAlgo Amounts") + + print_info("Algorand uses microAlgos (1 Algo = 1,000,000 microAlgos)") + print_info("Large Algo balances can be very large in microAlgos") + print_info("") + + algo_amounts = { + "smallWallet": 1000000000, # 1,000 Algos + "mediumWallet": 100000000000000, # 100M Algos + "largeWallet": 10000000000000000, # 10B Algos + } + + algo_json = json.dumps(algo_amounts) + print_info(f" JSON: {algo_json}") + print_info("") + + algo_parsed = json.loads(algo_json) + print_info(" Parsed amounts:") + print_info(f" smallWallet: {algo_parsed['smallWallet']:>20} microAlgos") + print_info(f" = {algo_parsed['smallWallet'] / 1_000_000:,.0f} Algos") + print_info(f" mediumWallet: {algo_parsed['mediumWallet']:>20} microAlgos") + print_info(f" = {algo_parsed['mediumWallet'] / 1_000_000:,.0f} Algos") + print_info(f" largeWallet: {algo_parsed['largeWallet']:>20} microAlgos") + print_info(f" = {algo_parsed['largeWallet'] / 1_000_000:,.0f} Algos") + print_info("") + + # Demonstrate calculation with large integers + print_info(" Safe arithmetic with large integers:") + large_balance = algo_parsed["largeWallet"] + transfer_amount = 5000000000000000 # 5B Algos + remaining = large_balance - transfer_amount + + print_info(f" Balance: {large_balance:>20} microAlgos") + print_info(f" Transfer: {transfer_amount:>20} microAlgos") + print_info(f" Remaining: {remaining:>20} microAlgos") + + print_success("Python integers enable safe arithmetic with large Algorand amounts") + + # Step 7: Contrast with JavaScript Precision Issues + print_step(7, "JavaScript Precision Issues (for reference)") + + print_info("In JavaScript, numbers > 2^53 - 1 lose precision with JSON.parse:") + print_info("") + + # Simulate what happens in JavaScript + large_value = 9007199254740993 # MAX_SAFE_INTEGER + 2 + + print_info(f" Original value: {large_value}") + print_info(" In JavaScript: 9007199254740992 (precision lost!)") + print_info(f" In Python: {large_value} (exact)") + print_info("") + print_info(" JavaScript native JSON.parse rounds large numbers to") + print_info(" the nearest representable IEEE 754 double.") + print_info("") + print_info(" JavaScript solutions:") + print_info(" - Use libraries like json-bigint") + print_info(" - Keep large numbers as strings") + print_info(" - Use BigInt with custom serialization") + print_info("") + print_success("Python's native int type avoids JavaScript's precision issues") + + # Step 8: Pretty Printing with json.dumps + print_step(8, "Pretty Printing with json.dumps") + + print_info("json.dumps supports optional spacing for readability:") + print_info("") + + complex_obj = { + "transaction": { + "type": "pay", + "sender": "ALGORAND...", + "receiver": "RECEIVER...", + "amount": 18446744073709551615, + "fee": 1000, + }, + "timestamp": 1704067200, + } + + print_info("Compact output (default):") + print_info(f" {json.dumps(complex_obj)}") + print_info("") + + print_info("Pretty output (indent=2):") + pretty_json = json.dumps(complex_obj, indent=2) + for line in pretty_json.split("\n"): + print_info(f" {line}") + + print_success("json.dumps supports formatting options") + + # Step 9: Custom JSON Encoder for Decimal + print_step(9, "Custom JSON Encoder for Decimal") + + print_info("For high-precision decimal numbers, use Decimal with custom encoder:") + print_info("") + + class DecimalEncoder(json.JSONEncoder): + def default(self, obj: object) -> object: + if isinstance(obj, Decimal): + return str(obj) + return super().default(obj) + + decimal_obj = { + "price": Decimal("123.456789012345678901234567890"), + "quantity": 1000, + } + + print_info(f" Input: {decimal_obj}") + decimal_json = json.dumps(decimal_obj, cls=DecimalEncoder) + print_info(f" Output: {decimal_json}") + print_info("") + print_info(" Note: Decimal values are serialized as strings to preserve precision") + + print_success("Custom encoders handle special types like Decimal") + + # Step 10: Summary + print_step(10, "Summary") + + print_info("Python vs JavaScript JSON integer handling:") + print_info("") + print_info(" Python advantages:") + print_info(" - Unlimited integer precision (no MAX_SAFE_INTEGER limit)") + print_info(" - json.loads() preserves large integers exactly") + print_info(" - json.dumps() serializes large integers without error") + print_info(" - No special libraries needed for BigInt-like functionality") + print_info(" - Arithmetic on large integers works correctly") + print_info("") + print_info(" JavaScript challenges:") + print_info(" - Numbers > 2^53 - 1 lose precision with JSON.parse") + print_info(" - JSON.stringify throws error on BigInt values") + print_info(" - Requires libraries like json-bigint or custom handling") + print_info("") + print_info(" For Algorand:") + print_info(" - Python handles all microAlgo amounts safely") + print_info(" - No special handling needed for large balances") + print_info(" - Round-trip JSON serialization preserves precision") + print_info("") + print_success("JSON BigInt Example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/common/08_msgpack.py b/examples/common/08_msgpack.py new file mode 100644 index 00000000..9798b858 --- /dev/null +++ b/examples/common/08_msgpack.py @@ -0,0 +1,345 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: MessagePack Encoding + +This example demonstrates encoding and decoding MessagePack data, +which is used for Algorand transaction encoding. + +Topics covered: +- encode_msgpack() to serialize data to MessagePack format +- decode_msgpack() to deserialize MessagePack bytes +- Encoding simple objects with various types (strings, numbers, bytes) +- Key handling in MessagePack +- Uint8Array (bytes) encoding +- Size comparison: MessagePack vs JSON + +No LocalNet required - pure encoding utility functions +""" + +import json + +from shared import ( + format_bytes, + format_hex, + print_header, + print_info, + print_step, + print_success, +) + +from algokit_transact.codec.msgpack import decode_msgpack, encode_msgpack + + +def main() -> None: + print_header("MessagePack Example") + + # Step 1: Basic MessagePack Encoding + print_step(1, "Basic MessagePack Encoding") + + print_info("MessagePack is a binary serialization format used by Algorand") + print_info("encode_msgpack() converts Python objects to compact binary bytes") + print_info("") + + simple_object = { + "name": "Alice", + "balance": 1000, + "active": True, + } + + encoded = encode_msgpack(simple_object) + print_info("Input object:") + print_info(" { 'name': 'Alice', 'balance': 1000, 'active': True }") + print_info("") + print_info(f"Encoded MessagePack ({len(encoded)} bytes):") + print_info(f" {format_hex(encoded)}") + print_info(f" Raw bytes: {format_bytes(encoded, 16)}") + print_success("Object encoded to MessagePack binary format") + + # Step 2: MessagePack Decoding + print_step(2, "MessagePack Decoding") + + print_info("decode_msgpack() decodes binary bytes back to data") + print_info("") + + decoded = decode_msgpack(encoded) + + print_info(f"Decoded type: {type(decoded).__name__}") + print_info(f"Decoded value: {decoded}") + print_info("") + + # Access values directly (Python returns dict, not Map) + if isinstance(decoded, dict): + print_info("Accessing values from decoded dict:") + print_info(f" name: {decoded.get('name')}") + print_info(f" balance: {decoded.get('balance')}") + print_info(f" active: {decoded.get('active')}") + print_info("") + print_success("decode_msgpack() returns dict for object data") + + # Step 3: Encoding Various Types + print_step(3, "Encoding Various Types") + + print_info("MessagePack supports various Python types:") + print_info("") + + # Strings + string_data = {"message": "Hello, Algorand!"} + encoded_string = encode_msgpack(string_data) + print_info(f'String: "Hello, Algorand!" -> {len(encoded_string)} bytes') + + # Numbers + number_data = {"small": 42, "medium": 1000000, "large": 4294967295} + encoded_numbers = encode_msgpack(number_data) + print_info(f"Numbers: {{ small: 42, medium: 1000000, large: 4294967295 }} -> {len(encoded_numbers)} bytes") + + # Boolean + bool_data = {"enabled": True, "disabled": False} + encoded_bool = encode_msgpack(bool_data) + print_info(f"Boolean: {{ enabled: True, disabled: False }} -> {len(encoded_bool)} bytes") + + # Array + array_data = {"items": [1, 2, 3, "four", True]} + encoded_array = encode_msgpack(array_data) + print_info(f"Array: {{ items: [1, 2, 3, 'four', True] }} -> {len(encoded_array)} bytes") + + # None + none_data = {"value": None} + encoded_none = encode_msgpack(none_data) + print_info(f"None: {{ value: None }} -> {len(encoded_none)} bytes") + + # Nested object + nested_data = { + "level1": { + "level2": { + "value": "deep", + }, + }, + } + encoded_nested = encode_msgpack(nested_data) + print_info(f"Nested: {{ level1: {{ level2: {{ value: 'deep' }} }} }} -> {len(encoded_nested)} bytes") + + print_info("") + print_success("All common Python types encoded successfully") + + # Step 4: Large Integer Encoding/Decoding + print_step(4, "Large Integer Encoding/Decoding") + + print_info("MessagePack can encode large integers (uint64 values)") + print_info("This is essential for Algorand which uses large numeric values") + print_info("") + + big_int_data = { + "normalNumber": 1000000, + "bigNumber": 9007199254740993, # MAX_SAFE_INTEGER + 2 + "maxUint64": 18446744073709551615, # 2^64 - 1 + } + + print_info("Input with large integer values:") + print_info(f" normalNumber: {big_int_data['normalNumber']}") + print_info(f" bigNumber: {big_int_data['bigNumber']} (> MAX_SAFE_INTEGER)") + print_info(f" maxUint64: {big_int_data['maxUint64']} (2^64 - 1)") + print_info("") + + encoded_big_int = encode_msgpack(big_int_data) + print_info(f"Encoded to {len(encoded_big_int)} bytes:") + print_info(f" {format_hex(encoded_big_int)}") + print_info("") + + decoded_big_int = decode_msgpack(encoded_big_int) + if isinstance(decoded_big_int, dict): + print_info("Decoded values:") + normal_num = decoded_big_int.get("normalNumber") + big_num = decoded_big_int.get("bigNumber") + max_u64 = decoded_big_int.get("maxUint64") + print_info(f" normalNumber: {normal_num} (type: {type(normal_num).__name__})") + print_info(f" bigNumber: {big_num} (type: {type(big_num).__name__})") + print_info(f" maxUint64: {max_u64} (type: {type(max_u64).__name__})") + print_info("") + + # Verify preservation + if isinstance(decoded_big_int, dict) and decoded_big_int.get("maxUint64") == big_int_data["maxUint64"]: + print_success("Large integer values preserved through encode/decode cycle") + + # Step 5: Bytes Encoding + print_step(5, "Bytes Encoding") + + print_info("Algorand uses bytes for binary data (addresses, keys, etc.)") + print_info("MessagePack has native support for binary (bytes) type") + print_info("") + + # Create sample byte arrays + sample_bytes = bytes([0x01, 0x02, 0x03, 0x04, 0x05]) + address_bytes = bytes([0xAB] * 32) # Simulated 32-byte public key + + bytes_data = { + "shortBytes": sample_bytes, + "addressKey": address_bytes, + } + + print_info("Input with bytes values:") + print_info(f" shortBytes: {format_hex(sample_bytes)} ({len(sample_bytes)} bytes)") + print_info(f" addressKey: {format_hex(address_bytes[:8])}... ({len(address_bytes)} bytes)") + print_info("") + + encoded_bytes = encode_msgpack(bytes_data) + print_info(f"Encoded to {len(encoded_bytes)} bytes") + print_info("") + + decoded_bytes = decode_msgpack(encoded_bytes) + if isinstance(decoded_bytes, dict): + decoded_short = decoded_bytes.get("shortBytes") + decoded_address = decoded_bytes.get("addressKey") + + if isinstance(decoded_short, bytes) and isinstance(decoded_address, bytes): + print_info("Decoded values:") + print_info(f" shortBytes: {format_hex(decoded_short)} ({len(decoded_short)} bytes)") + print_info(f" addressKey: {format_hex(decoded_address[:8])}... ({len(decoded_address)} bytes)") + print_info("") + + # Verify bytes match + if decoded_short == sample_bytes: + print_success("Bytes values preserved through encode/decode cycle") + + # Step 6: MessagePack vs JSON Size Comparison + print_step(6, "MessagePack vs JSON Size Comparison") + + print_info("MessagePack typically produces smaller output than JSON") + print_info("") + + # Test data representative of Algorand transaction fields + transaction_like = { + "type": "pay", + "sender": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ", + "receiver": "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBAR7CWY", + "amount": 1000000, + "fee": 1000, + "firstValid": 10000000, + "lastValid": 10001000, + "note": "Payment for services", + } + + msgpack_size = len(encode_msgpack(transaction_like)) + json_size = len(json.dumps(transaction_like)) + + space_saved = json_size - msgpack_size + pct_saved = (1 - msgpack_size / json_size) * 100 + + print_info("Transaction-like data:") + print_info(f" MessagePack size: {msgpack_size} bytes") + print_info(f" JSON size: {json_size} bytes") + print_info(f" Space saved: {space_saved} bytes ({pct_saved:.1f}%)") + print_info("") + + # Another comparison with numeric data + numeric_data = { + "values": [1, 10, 100, 1000, 10000, 100000, 1000000], + "metadata": {"count": 7, "sum": 1111111}, + } + + numeric_msgpack = len(encode_msgpack(numeric_data)) + numeric_json = len(json.dumps(numeric_data)) + numeric_saved = numeric_json - numeric_msgpack + numeric_pct = (1 - numeric_msgpack / numeric_json) * 100 + + print_info("Numeric-heavy data:") + print_info(f" MessagePack size: {numeric_msgpack} bytes") + print_info(f" JSON size: {numeric_json} bytes") + print_info(f" Space saved: {numeric_saved} bytes ({numeric_pct:.1f}%)") + print_info("") + + print_success("MessagePack provides significant space savings over JSON") + + # Step 7: Working with Decoded Data + print_step(7, "Working with Decoded Data") + + print_info("decode_msgpack() returns Python dict for object data.") + print_info("Access values directly using dictionary syntax.") + print_info("") + + sample_data = { + "name": "TestTx", + "amount": 5000000, + "tags": ["transfer", "urgent"], + } + + encoded_sample = encode_msgpack(sample_data) + decoded_map = decode_msgpack(encoded_sample) + + if isinstance(decoded_map, dict): + print_info("Getting individual values:") + print_info(f" name: {decoded_map.get('name')}") + print_info(f" amount: {decoded_map.get('amount')}") + tags = decoded_map.get("tags", []) + print_info(f" tags: {tags}") + print_info("") + + print_info("Iterating over entries:") + for key, value in decoded_map.items(): + value_str = value if not isinstance(value, bytes) else format_hex(value) + print_info(f" {key}: {value_str}") + print_info("") + + print_success("Dict provides flexible data access patterns") + + # Step 8: Round-trip Verification + print_step(8, "Round-trip Verification") + + print_info("Verifying encode/decode round-trip for various data types:") + print_info("") + + test_cases = [ + ("Empty dict", {}), + ("Simple string", {"value": "hello"}), + ("Integer", {"value": 42}), + ("Large integer", {"value": 18446744073709551615}), + ("Boolean", {"value": True}), + ("None", {"value": None}), + ("Bytes", {"value": b"\x01\x02\x03"}), + ("Array", {"value": [1, 2, 3]}), + ("Nested", {"outer": {"inner": "value"}}), + ] + + all_passed = True + for name, original in test_cases: + encoded_case = encode_msgpack(original) + decoded_case = decode_msgpack(encoded_case) + matches = decoded_case == original + status = "PASS" if matches else "FAIL" + print_info(f" [{status}] {name}") + if not matches: + all_passed = False + print_info(f" Original: {original}") + print_info(f" Decoded: {decoded_case}") + + print_info("") + if all_passed: + print_success("All round-trip verifications passed!") + else: + print_info("Some round-trips failed") + + # Step 9: Summary + print_step(9, "Summary") + + print_info("MessagePack encoding/decoding for Algorand:") + print_info("") + print_info(" encode_msgpack(data):") + print_info(" - Serializes Python objects to binary MessagePack") + print_info(" - Supports strings, numbers, bytes, arrays, dicts") + print_info(" - Handles large integers (uint64)") + print_info("") + print_info(" decode_msgpack(bytes):") + print_info(" - Deserializes MessagePack bytes to Python objects") + print_info(" - Returns dict for object data (not Map)") + print_info(" - Preserves bytes for binary data") + print_info(" - Preserves large integers") + print_info("") + print_info(" Use cases:") + print_info(" - Algorand transaction encoding") + print_info(" - Compact data serialization") + print_info(" - Efficient binary data storage") + print_info("") + print_success("MessagePack Example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/common/09_primitive_codecs.py b/examples/common/09_primitive_codecs.py new file mode 100644 index 00000000..e9a4ca1f --- /dev/null +++ b/examples/common/09_primitive_codecs.py @@ -0,0 +1,373 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Primitive Serde (Serialization/Deserialization) + +This example demonstrates how to use primitive serialization patterns in Python +for encoding/decoding basic values in wire format. + +Note: Unlike the TypeScript SDK which uses explicit codec classes (numberCodec, +bigIntCodec, etc.), the Python SDK uses a dataclass-based approach with field +metadata helpers. This example shows both native Python serialization and the +serde utilities available in algokit_common. + +Topics covered: +- Python's native type handling for serialization +- Using wire() metadata for dataclass fields +- Address encoding/decoding with addr() helper +- Bytes encoding (base64 for JSON, raw for msgpack) +- Round-trip verification for various types +- The serde module's to_wire() and from_wire() functions + +No LocalNet required - pure codec/serde functions +""" + +import base64 +from dataclasses import dataclass, field + +from shared import ( + format_hex, + print_header, + print_info, + print_step, + print_success, +) + +from algokit_common import ( + ZERO_ADDRESS, + addr, + address_from_public_key, + from_wire, + public_key_from_address, + to_wire, + wire, +) +from algokit_transact.codec.msgpack import decode_msgpack, encode_msgpack + + +def main() -> None: + print_header("Primitive Serde Example") + + # Step 1: Introduction to Python's Approach + print_step(1, "Python's Approach to Serialization") + + print_info("Unlike TypeScript, Python handles types natively without explicit codecs.") + print_info("") + print_info("TypeScript approach:") + print_info(" - Explicit codec objects: numberCodec, bigIntCodec, etc.") + print_info(" - encode(value, format) / decode(value, format) methods") + print_info("") + print_info("Python approach:") + print_info(" - Native type handling for numbers, strings, booleans") + print_info(" - Dataclass field metadata with wire() for custom encoding") + print_info(" - Helper functions: addr(), bytes_seq(), int_seq()") + print_info(" - to_wire() / from_wire() for dataclass serialization") + print_info("") + print_success("Python provides simpler, more Pythonic serialization") + + # Step 2: Native Number Handling + print_step(2, "Native Number Handling") + + print_info("Python integers have unlimited precision - no special codec needed:") + print_info("") + + test_numbers = [0, 42, -100, 9007199254740991, 18446744073709551615] + + for num in test_numbers: + # Encode/decode via msgpack + encoded = encode_msgpack({"value": num}) + decoded = decode_msgpack(encoded) + decoded_val = decoded["value"] if isinstance(decoded, dict) else None + + print_info(f" {num:>25}:") + print_info(f" Type: {type(num).__name__}, Round-trip match: {num == decoded_val}") + + print_info("") + print_success("Numbers of any size are handled natively in Python") + + # Step 3: Boolean and None Handling + print_step(3, "Boolean and None Handling") + + print_info("Booleans and None are handled directly:") + print_info("") + + for val in [True, False, None]: + encoded = encode_msgpack({"value": val}) + decoded = decode_msgpack(encoded) + decoded_val = decoded["value"] if isinstance(decoded, dict) else "ERROR" + + type_name = type(val).__name__ if val is not None else "NoneType" + val_str = "None" if val is None else str(val) + match = val is decoded_val or val == decoded_val + print_info(f" {val_str:>10}: Type={type_name}, Round-trip match: {match}") + + print_info("") + print_success("Boolean and None values preserved through encoding") + + # Step 4: String Handling + print_step(4, "String Handling") + + print_info("UTF-8 strings are handled natively:") + print_info("") + + test_strings = ["", "Hello", "Hello, Algorand!", "Unicode: \u00e9\u00e8\u00ea"] + + for string in test_strings: + encoded = encode_msgpack({"value": string}) + decoded = decode_msgpack(encoded) + decoded_val = decoded["value"] if isinstance(decoded, dict) else None + + display = "(empty)" if string == "" else f'"{string}"' + print_info(f" {display}:") + print_info(f" Round-trip match: {string == decoded_val}") + + print_info("") + print_success("Strings of all types preserved through encoding") + + # Step 5: Bytes Handling + print_step(5, "Bytes Handling") + + print_info("Bytes require different handling for JSON vs MessagePack:") + print_info(" JSON: base64 encode/decode") + print_info(" MessagePack: raw bytes") + print_info("") + + test_bytes_list = [ + bytes([]), + bytes([0x01, 0x02, 0x03]), + bytes([0xDE, 0xAD, 0xBE, 0xEF]), + bytes([0xAB] * 32), # 32-byte key simulation + ] + + for test_bytes in test_bytes_list: + # MessagePack encoding + encoded = encode_msgpack({"value": test_bytes}) + decoded = decode_msgpack(encoded) + decoded_val = decoded["value"] if isinstance(decoded, dict) else None + + # JSON encoding (base64) + b64_encoded = base64.b64encode(test_bytes).decode("utf-8") + b64_decoded = base64.b64decode(b64_encoded) + + byte_limit = 8 + if len(test_bytes) == 0: + display = "(empty)" + else: + suffix = "..." if len(test_bytes) > byte_limit else "" + display = f"{format_hex(test_bytes[:byte_limit])}{suffix}" + print_info(f" {display} ({len(test_bytes)} bytes):") + print_info(f" msgpack: Round-trip match: {test_bytes == decoded_val}") + print_info(f' base64: "{b64_encoded}", Round-trip match: {test_bytes == b64_decoded}') + + print_info("") + print_success("Bytes handled correctly in both formats") + + # Step 6: Address Handling with addr() Helper + print_step(6, "Address Handling with addr() Helper") + + print_info("Algorand addresses require special handling:") + print_info(" - Storage: 32-byte public key") + print_info(" - Display: 58-character base32 string") + print_info("") + + # Define a dataclass with address field + @dataclass + class Transfer: + sender: str = field(default=ZERO_ADDRESS, metadata=addr("snd")) + receiver: str = field(default=ZERO_ADDRESS, metadata=addr("rcv")) + amount: int = field(default=0, metadata=wire("amt")) + + # Create a transfer + sender_bytes = bytes(range(32)) + receiver_bytes = bytes(range(32, 64)) + sender_addr = address_from_public_key(sender_bytes) + receiver_addr = address_from_public_key(receiver_bytes) + + transfer = Transfer(sender=sender_addr, receiver=receiver_addr, amount=1000000) + + print_info("Transfer object:") + print_info(f" sender: {sender_addr[:20]}...") + print_info(f" receiver: {receiver_addr[:20]}...") + print_info(f" amount: {transfer.amount}") + print_info("") + + # Encode to wire format + wire_data = to_wire(transfer) + print_info("Wire format (to_wire):") + for key, value in wire_data.items(): + if isinstance(value, bytes): + print_info(f" {key}: {format_hex(value[:8])}... (32 bytes)") + else: + print_info(f" {key}: {value}") + print_info("") + + # Decode back + decoded_transfer = from_wire(Transfer, wire_data) + print_info("Decoded back (from_wire):") + print_info(f" sender: {decoded_transfer.sender[:20]}...") + print_info(f" receiver: {decoded_transfer.receiver[:20]}...") + print_info(f" amount: {decoded_transfer.amount}") + print_info("") + + # Verify round-trip + matches = ( + decoded_transfer.sender == transfer.sender + and decoded_transfer.receiver == transfer.receiver + and decoded_transfer.amount == transfer.amount + ) + if matches: + print_success("Address fields round-trip correctly via addr() helper") + + # Step 7: The wire() Metadata Helper + print_step(7, "The wire() Metadata Helper") + + print_info("wire() provides fine-grained control over field serialization:") + print_info("") + print_info(" wire(alias,") + print_info(" encode=..., # Custom encoder function") + print_info(" decode=..., # Custom decoder function") + print_info(" omit_if_none=True,") + print_info(" keep_zero=False,") + print_info(" keep_false=False,") + print_info(" required=False)") + print_info("") + + @dataclass + class Example: + name: str = field(default="", metadata=wire("n")) + count: int = field(default=0, metadata=wire("c", keep_zero=True)) + active: bool = field(default=False, metadata=wire("a", keep_false=True)) + + # Encode with default values + default_obj = Example() + default_wire = to_wire(default_obj) + print_info(f"Default values: {default_wire}") + print_info(" 'count' and 'active' preserved due to keep_zero/keep_false=True") + print_info("") + + # Encode with non-default values + filled_obj = Example(name="test", count=42, active=True) + filled_wire = to_wire(filled_obj) + print_info(f"Filled values: {filled_wire}") + print_info("") + + print_success("wire() provides flexible field serialization control") + + # Step 8: Manual Address Encoding/Decoding + print_step(8, "Manual Address Encoding/Decoding") + + print_info("You can also handle addresses manually without dataclasses:") + print_info("") + + # Create test address + test_pk = bytes(range(32)) + test_addr = address_from_public_key(test_pk) + + print_info(f"Original address: {test_addr[:20]}...") + print_info(f"Original pk: {format_hex(test_pk[:8])}... ({len(test_pk)} bytes)") + print_info("") + + # Encode: address string -> 32-byte public key + encoded_pk = public_key_from_address(test_addr) + print_info(f"Encoded (pk): {format_hex(encoded_pk[:8])}... ({len(encoded_pk)} bytes)") + + # Decode: 32-byte public key -> address string + decoded_addr = address_from_public_key(encoded_pk) + print_info(f"Decoded (addr): {decoded_addr[:20]}...") + print_info("") + + if decoded_addr == test_addr and encoded_pk == test_pk: + print_success("Manual address encoding/decoding works correctly") + + # Step 9: Zero Address Handling + print_step(9, "Zero Address Handling") + + print_info("The zero address gets special treatment in wire encoding:") + print_info(f" ZERO_ADDRESS = {ZERO_ADDRESS[:20]}...") + print_info("") + + @dataclass + class ZeroExample: + addr: str = field(default=ZERO_ADDRESS, metadata=addr("a")) + + # Zero address - should be omitted in wire format + zero_obj = ZeroExample() + zero_wire = to_wire(zero_obj) + print_info(f"Zero address wire: {zero_wire}") + print_info(" Note: 'a' field is omitted because ZERO_ADDRESS is the default") + print_info("") + + # Non-zero address - should be included + non_zero_obj = ZeroExample(addr=test_addr) + non_zero_wire = to_wire(non_zero_obj) + addr_val = non_zero_wire.get("a") + if isinstance(addr_val, bytes): + addr_display = format_hex(addr_val[:8]) + else: + addr_display = str(addr_val) + print_info(f"Non-zero address wire: {{'a': {addr_display}...}}") + print_info(" Non-zero addresses are included in wire output") + print_info("") + + print_success("Zero addresses are handled correctly (omitted when default)") + + # Step 10: Round-Trip Summary + print_step(10, "Round-Trip Summary") + + print_info("All primitive types support round-trip encoding:") + print_info("") + + results = [ + ("number (small)", 42), + ("number (large)", 18446744073709551615), + ("boolean (true)", True), + ("boolean (false)", False), + ("string", "Algorand"), + ("bytes", bytes([1, 2, 3, 4, 5])), + ("None", None), + ] + + all_passed = True + for name, value in results: + encoded = encode_msgpack({"v": value}) + decoded = decode_msgpack(encoded) + decoded_val = decoded["v"] if isinstance(decoded, dict) else "ERROR" + passed = value == decoded_val or (value is None and decoded_val is None) + status = "PASS" if passed else "FAIL" + print_info(f" [{status}] {name}") + if not passed: + all_passed = False + + print_info("") + if all_passed: + print_success("All round-trip verifications passed!") + + # Step 11: Summary + print_step(11, "Summary") + + print_info("Python serialization approach (vs TypeScript codecs):") + print_info("") + print_info(" Native Python handling:") + print_info(" - int: Unlimited precision, no special handling") + print_info(" - bool: Native True/False") + print_info(" - str: UTF-8 strings") + print_info(" - bytes: Raw in msgpack, base64 in JSON") + print_info(" - None: Null/nil handling") + print_info("") + print_info(" algokit_common.serde helpers:") + print_info(" - wire(alias, ...) Field metadata for encoding") + print_info(" - addr(alias, ...) Address string <-> bytes") + print_info(" - bytes_seq(alias) Byte array sequences") + print_info(" - int_seq(alias) Integer sequences") + print_info(" - to_wire(obj) Dataclass -> wire dict") + print_info(" - from_wire(cls, data) Wire dict -> dataclass") + print_info("") + print_info(" Key differences from TypeScript:") + print_info(" - No explicit codec objects (numberCodec, etc.)") + print_info(" - Field metadata on dataclass fields") + print_info(" - Simpler, more Pythonic approach") + print_info("") + print_success("Primitive Serde Example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/common/10_composite_codecs.py b/examples/common/10_composite_codecs.py new file mode 100644 index 00000000..e113c3c0 --- /dev/null +++ b/examples/common/10_composite_codecs.py @@ -0,0 +1,442 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Composite Serde (Serialization/Deserialization) + +This example demonstrates how to serialize/deserialize composite data structures +like arrays, maps, and records in Python using the serde utilities. + +Note: Unlike the TypeScript SDK which uses explicit ArrayCodec, MapCodec, and +RecordCodec classes, the Python SDK handles these natively through: +- Native Python lists for arrays +- Native Python dicts for records/maps +- Dataclass fields with serde helpers for structured data + +Topics covered: +- Encoding/decoding typed arrays (lists) +- Encoding/decoding maps (dictionaries) +- Using bytes_seq(), int_seq(), addr_seq() helpers +- Nested structures (list of lists, dict of lists) +- Round-trip verification for composite types + +No LocalNet required - pure serde functions +""" + +from dataclasses import dataclass, field + +from shared import ( + format_hex, + print_header, + print_info, + print_step, + print_success, +) + +from algokit_common import ( + addr_seq, + address_from_public_key, + bytes_seq, + from_wire, + int_seq, + to_wire, + wire, +) +from algokit_transact.codec.msgpack import decode_msgpack, encode_msgpack + + +def main() -> None: + print_header("Composite Serde Example") + + # Step 1: Introduction to Composite Types in Python + print_step(1, "Introduction to Composite Types") + + print_info("Python handles composite types natively without explicit codec classes.") + print_info("") + print_info("TypeScript approach:") + print_info(" - ArrayCodec for typed arrays") + print_info(" - MapCodec for Maps") + print_info(" - RecordCodec for Record") + print_info("") + print_info("Python approach:") + print_info(" - Native list for arrays") + print_info(" - Native dict for maps/records") + print_info(" - Dataclass field helpers: bytes_seq(), int_seq(), addr_seq()") + print_info("") + print_success("Python provides simpler, more natural composite handling") + + # Step 2: Native List (Array) Encoding/Decoding + print_step(2, "Native List (Array) Encoding/Decoding") + + print_info("Python lists serialize directly with msgpack:") + print_info("") + + # Number arrays + numbers = [1, 2, 3, 4, 5] + encoded_nums = encode_msgpack({"values": numbers}) + decoded_nums = decode_msgpack(encoded_nums) + decoded_nums_val = decoded_nums["values"] if isinstance(decoded_nums, dict) else [] + print_info(f" Number array: {numbers}") + print_info(f" Round-trip: {decoded_nums_val}") + print_info(f" Match: {list(decoded_nums_val) == numbers}") + print_info("") + + # String arrays + strings = ["Alice", "Bob", "Charlie"] + encoded_strs = encode_msgpack({"values": strings}) + decoded_strs = decode_msgpack(encoded_strs) + decoded_strs_val = decoded_strs["values"] if isinstance(decoded_strs, dict) else [] + print_info(f" String array: {strings}") + print_info(f" Round-trip: {list(decoded_strs_val)}") + print_info(f" Match: {list(decoded_strs_val) == strings}") + print_info("") + + # Boolean arrays + booleans = [True, False, True, False] + encoded_bools = encode_msgpack({"values": booleans}) + decoded_bools = decode_msgpack(encoded_bools) + decoded_bools_val = decoded_bools["values"] if isinstance(decoded_bools, dict) else [] + print_info(f" Boolean array: {booleans}") + print_info(f" Round-trip: {list(decoded_bools_val)}") + print_info(f" Match: {list(decoded_bools_val) == booleans}") + print_info("") + + # Large integer arrays + big_ints = [100, 9007199254740993, 18446744073709551615] + encoded_bigs = encode_msgpack({"values": big_ints}) + decoded_bigs = decode_msgpack(encoded_bigs) + decoded_bigs_val = decoded_bigs["values"] if isinstance(decoded_bigs, dict) else [] + print_info(f" Large int array: {big_ints}") + print_info(f" Round-trip: {list(decoded_bigs_val)}") + print_info(f" Match: {list(decoded_bigs_val) == big_ints}") + print_info("") + + print_success("Native lists handle all element types correctly") + + # Step 3: Bytes Arrays with bytes_seq() + print_step(3, "Bytes Arrays with bytes_seq()") + + print_info("Use bytes_seq() helper for sequences of byte arrays in dataclasses:") + print_info("") + + @dataclass + class BytesContainer: + items: tuple[bytes, ...] = field(default=(), metadata=bytes_seq("items")) + + bytes_list = [ + bytes([0x01, 0x02, 0x03]), + bytes([0x04, 0x05, 0x06]), + bytes([0x07, 0x08, 0x09]), + ] + + container = BytesContainer(items=tuple(bytes_list)) + print_info(f" Original: [{', '.join(format_hex(b) for b in bytes_list)}]") + + wire_data = to_wire(container) + print_info(f" Wire format: {{'items': [...{len(wire_data.get('items', []))} bytes objects...]}}") + + decoded_container = from_wire(BytesContainer, wire_data) + print_info(f" Decoded: [{', '.join(format_hex(b) for b in decoded_container.items)}]") + + match = list(container.items) == list(decoded_container.items) + print_info(f" Match: {match}") + print_info("") + + print_success("bytes_seq() handles byte array sequences correctly") + + # Step 4: Integer Arrays with int_seq() + print_step(4, "Integer Arrays with int_seq()") + + print_info("Use int_seq() helper for sequences of integers in dataclasses:") + print_info("") + + @dataclass + class IntContainer: + values: tuple[int, ...] = field(default=(), metadata=int_seq("vals")) + + int_list = [10, 20, 30, 40, 50] + int_container = IntContainer(values=tuple(int_list)) + print_info(f" Original: {int_list}") + + wire_int = to_wire(int_container) + print_info(f" Wire format: {wire_int}") + + decoded_int_container = from_wire(IntContainer, wire_int) + print_info(f" Decoded: {list(decoded_int_container.values)}") + + match_int = list(int_container.values) == list(decoded_int_container.values) + print_info(f" Match: {match_int}") + print_info("") + + print_success("int_seq() handles integer sequences correctly") + + # Step 5: Address Arrays with addr_seq() + print_step(5, "Address Arrays with addr_seq()") + + print_info("Use addr_seq() helper for sequences of addresses in dataclasses:") + print_info("") + + @dataclass + class AddressContainer: + addresses: tuple[str, ...] = field(default=(), metadata=addr_seq("addrs")) + + # Create test addresses + addr1 = address_from_public_key(bytes([0x11] * 32)) + addr2 = address_from_public_key(bytes([0x22] * 32)) + addr3 = address_from_public_key(bytes([0x33] * 32)) + + addr_container = AddressContainer(addresses=(addr1, addr2, addr3)) + print_info(f" Original: [{addr1[:12]}..., {addr2[:12]}..., {addr3[:12]}...]") + + wire_addr = to_wire(addr_container) + print_info(f" Wire format: {{'addrs': [...{len(wire_addr.get('addrs', []))} pubkeys...]}}") + + decoded_addr_container = from_wire(AddressContainer, wire_addr) + print_info(f" Decoded: [{decoded_addr_container.addresses[0][:12]}..., ...]") + + match_addr = list(addr_container.addresses) == list(decoded_addr_container.addresses) + print_info(f" Match: {match_addr}") + print_info("") + + print_success("addr_seq() handles address sequences correctly") + + # Step 6: Native Dict (Map/Record) Encoding/Decoding + print_step(6, "Native Dict (Map/Record) Encoding/Decoding") + + print_info("Python dicts serialize directly with msgpack:") + print_info("") + + # String -> Number mapping + scores = {"alice": 95, "bob": 87, "charlie": 92} + encoded_scores = encode_msgpack({"data": scores}) + decoded_scores = decode_msgpack(encoded_scores) + decoded_scores_val = decoded_scores["data"] if isinstance(decoded_scores, dict) else {} + print_info(f" String->Number: {scores}") + print_info(f" Round-trip: {dict(decoded_scores_val)}") + print_info(f" Match: {dict(decoded_scores_val) == scores}") + print_info("") + + # String -> String mapping + metadata = {"name": "My App", "version": "1.0.0", "author": "Developer"} + encoded_meta = encode_msgpack({"data": metadata}) + decoded_meta = decode_msgpack(encoded_meta) + decoded_meta_val = decoded_meta["data"] if isinstance(decoded_meta, dict) else {} + print_info(f" String->String: {metadata}") + print_info(f" Round-trip: {dict(decoded_meta_val)}") + print_info(f" Match: {dict(decoded_meta_val) == metadata}") + print_info("") + + # Nested dict + nested = {"level1": {"level2": {"value": 42}}} + encoded_nested = encode_msgpack({"data": nested}) + decoded_nested = decode_msgpack(encoded_nested) + decoded_nested_val = decoded_nested["data"] if isinstance(decoded_nested, dict) else {} + print_info(f" Nested dict: {nested}") + print_info(f" Round-trip: {dict(decoded_nested_val)}") + # Convert recursively for comparison + print_info(f" Match: {decoded_nested_val == nested}") + print_info("") + + print_success("Native dicts handle various value types correctly") + + # Step 7: Dict of Arrays + print_step(7, "Dict of Arrays") + + print_info("Dicts can contain array values:") + print_info("") + + # User scores (string -> list of numbers) + user_scores = { + "alice": [95, 88, 92], + "bob": [78, 85, 90], + } + + encoded_user_scores = encode_msgpack({"data": user_scores}) + decoded_user_scores = decode_msgpack(encoded_user_scores) + decoded_user_val = decoded_user_scores["data"] if isinstance(decoded_user_scores, dict) else {} + + print_info(" Dict of number arrays:") + for name, score_list in user_scores.items(): + print_info(f" {name}: {score_list}") + print_info("") + print_info(" Round-trip:") + for name, score_list in decoded_user_val.items(): + print_info(f" {name}: {list(score_list)}") + print_info("") + + # Category items (string -> list of strings) + categories = { + "fruits": ["apple", "banana", "cherry"], + "colors": ["red", "green", "blue"], + } + + encoded_cats = encode_msgpack({"data": categories}) + decoded_cats = decode_msgpack(encoded_cats) + decoded_cats_val = decoded_cats["data"] if isinstance(decoded_cats, dict) else {} + + print_info(" Dict of string arrays:") + for cat, items in categories.items(): + print_info(f" {cat}: {items}") + print_info("") + print_info(" Round-trip:") + for cat, items in decoded_cats_val.items(): + print_info(f" {cat}: {list(items)}") + print_info("") + + print_success("Dict of arrays handled correctly") + + # Step 8: Nested Arrays (2D arrays) + print_step(8, "Nested Arrays (2D arrays)") + + print_info("Lists can contain other lists (2D arrays):") + print_info("") + + matrix = [ + [1, 2, 3], + [4, 5, 6], + [7, 8, 9], + ] + + encoded_matrix = encode_msgpack({"data": matrix}) + decoded_matrix = decode_msgpack(encoded_matrix) + decoded_matrix_val = decoded_matrix["data"] if isinstance(decoded_matrix, dict) else [] + + print_info(" Original matrix:") + for row in matrix: + print_info(f" {row}") + print_info("") + print_info(" Decoded matrix:") + for row in decoded_matrix_val: + print_info(f" {list(row)}") + print_info("") + + # Verify match + matrix_match = all(list(decoded_matrix_val[i]) == matrix[i] for i in range(len(matrix))) + print_info(f" Match: {matrix_match}") + print_info("") + + print_success("Nested arrays (2D) handled correctly") + + # Step 9: Complex Dataclass with Collections + print_step(9, "Complex Dataclass with Collections") + + print_info("Dataclasses can combine multiple collection types:") + print_info("") + + @dataclass + class AppConfig: + name: str = field(default="", metadata=wire("n")) + enabled_features: tuple[str, ...] = field(default=(), metadata=wire("ef")) + settings: dict[str, int] = field(default_factory=dict, metadata=wire("s")) + tags: tuple[str, ...] = field(default=(), metadata=wire("t")) + + config = AppConfig( + name="MyApp", + enabled_features=("auth", "logging", "metrics"), + settings={"timeout": 30, "retries": 3, "cache_size": 100}, + tags=("production", "v1"), + ) + + print_info(f" name: {config.name}") + print_info(f" enabled_features: {config.enabled_features}") + print_info(f" settings: {config.settings}") + print_info(f" tags: {config.tags}") + print_info("") + + wire_config = to_wire(config) + print_info(f" Wire format: {wire_config}") + print_info("") + + decoded_config = from_wire(AppConfig, wire_config) + print_info(f" Decoded name: {decoded_config.name}") + print_info(f" Decoded features: {decoded_config.enabled_features}") + print_info(f" Decoded settings: {decoded_config.settings}") + print_info(f" Decoded tags: {decoded_config.tags}") + print_info("") + + config_match = ( + decoded_config.name == config.name + and decoded_config.enabled_features == config.enabled_features + and decoded_config.settings == config.settings + and decoded_config.tags == config.tags + ) + print_info(f" Match: {config_match}") + + print_success("Complex dataclass with collections handled correctly") + + # Step 10: Round-Trip Verification Summary + print_step(10, "Round-Trip Verification Summary") + + print_info("Verifying round-trip for all composite types:") + print_info("") + + test_cases = [ + ("Number list", [1, 2, 3, 4, 5]), + ("String list", ["a", "b", "c"]), + ("Boolean list", [True, False, True]), + ("Large int list", [100, 200, 18446744073709551615]), + ("Empty list", []), + ("String->int dict", {"a": 1, "b": 2}), + ("String->str dict", {"name": "test", "type": "example"}), + ("Empty dict", {}), + ("2D array", [[1, 2], [3, 4]]), + ("Dict of arrays", {"x": [1, 2, 3], "y": [4, 5, 6]}), + ("Nested dict", {"outer": {"inner": "value"}}), + ] + + all_passed = True + for name, original in test_cases: + encoded = encode_msgpack({"v": original}) + decoded = decode_msgpack(encoded) + decoded_val = decoded["v"] if isinstance(decoded, dict) else None + + # Deep comparison for nested structures + def deep_equal(a: object, b: object) -> bool: + if isinstance(a, list) and isinstance(b, list | tuple): + return len(a) == len(b) and all(deep_equal(a[i], b[i]) for i in range(len(a))) + if isinstance(a, dict) and isinstance(b, dict): + return set(a.keys()) == set(b.keys()) and all(deep_equal(a[k], b[k]) for k in a) + return a == b + + passed = deep_equal(original, decoded_val) + status = "PASS" if passed else "FAIL" + print_info(f" [{status}] {name}") + if not passed: + all_passed = False + print_info(f" Original: {original}") + print_info(f" Decoded: {decoded_val}") + + print_info("") + if all_passed: + print_success("All round-trip verifications passed!") + + # Step 11: Summary + print_step(11, "Summary") + + print_info("Python composite type handling (vs TypeScript codecs):") + print_info("") + print_info(" Native Python types:") + print_info(" - list: Direct serialization (no ArrayCodec needed)") + print_info(" - dict: Direct serialization (no MapCodec/RecordCodec needed)") + print_info(" - tuple: Serializes as array in msgpack") + print_info("") + print_info(" Dataclass serde helpers:") + print_info(" - bytes_seq(alias) Sequences of byte arrays") + print_info(" - int_seq(alias) Sequences of integers") + print_info(" - addr_seq(alias) Sequences of addresses") + print_info(" - wire(alias) Generic field metadata") + print_info("") + print_info(" Key features:") + print_info(" - Native Python types work directly") + print_info(" - No need for explicit codec composition") + print_info(" - Nested structures (2D arrays, dict of arrays) work") + print_info(" - Round-trip encoding preserves all data") + print_info("") + print_info(" TypeScript comparison:") + print_info(" - TS needs ArrayCodec, MapCodec, RecordCodec") + print_info(" - Python uses native types + dataclass helpers") + print_info(" - Simpler, more Pythonic approach") + print_info("") + print_success("Composite Serde Example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/common/11_model_codecs.py b/examples/common/11_model_codecs.py new file mode 100644 index 00000000..5eea5c85 --- /dev/null +++ b/examples/common/11_model_codecs.py @@ -0,0 +1,488 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Model Serde (Object Model Serialization) + +This example demonstrates how to use dataclass-based serialization for complex +object structures with field metadata in Python. + +Note: Unlike the TypeScript SDK which uses ObjectModelCodec, PrimitiveModelCodec, +and ArrayModelCodec classes, the Python SDK uses dataclasses with field metadata +helpers. This is a more Pythonic approach that achieves the same goals. + +Topics covered: +- Defining dataclasses with field metadata using wire() +- Encoding format options: to_wire() produces dict for JSON or msgpack +- Handling optional fields with omit_if_none +- Field renaming with wire key aliases +- Nested dataclasses +- Round-trip encoding with to_wire() and from_wire() +- Default values and omission rules + +No LocalNet required - pure serde functions +""" + +from dataclasses import dataclass, field + +from shared import ( + format_hex, + print_header, + print_info, + print_step, + print_success, +) + +from algokit_common import ( + ZERO_ADDRESS, + addr, + address_from_public_key, + from_wire, + nested, + to_wire, + wire, +) +from algokit_transact.codec.msgpack import decode_msgpack, encode_msgpack + + +def main() -> None: + print_header("Model Serde Example") + + # Step 1: Introduction to Model Serde + print_step(1, "Introduction to Model Serde") + + print_info("Model serde provides structured serialization for domain objects.") + print_info("") + print_info("TypeScript approach:") + print_info(" - ObjectModelCodec with FieldMetadata definitions") + print_info(" - Explicit encode/decode methods") + print_info(" - PrimitiveModelCodec, ArrayModelCodec wrappers") + print_info("") + print_info("Python approach:") + print_info(" - Standard dataclasses with field metadata") + print_info(" - wire() helper for field configuration") + print_info(" - to_wire() / from_wire() for serialization") + print_info("") + print_info("Key features:") + print_info(" - Wire key aliases (property name -> wire format key)") + print_info(" - Optional fields (omit when None or default)") + print_info(" - Nested objects (dataclass containing dataclass)") + print_info(" - Custom encode/decode functions") + print_info("") + print_success("Dataclass-based model serde provides structured serialization") + + # Step 2: Basic Dataclass with wire() Metadata + print_step(2, "Basic Dataclass with wire() Metadata") + + print_info("wire() defines how each field is encoded/decoded:") + print_info("") + print_info(" wire(alias, # Wire format key name") + print_info(" encode=..., # Custom encoder function") + print_info(" decode=..., # Custom decoder function") + print_info(" omit_if_none=True, # Omit if value is None") + print_info(" keep_zero=False, # Keep 0 values (don't omit)") + print_info(" keep_false=False, # Keep False values") + print_info(" required=False) # Error if missing on decode") + print_info("") + + @dataclass + class Person: + name: str = field(default="", metadata=wire("n")) + age: int | None = field(default=None, metadata=wire("a")) + email: str | None = field(default=None, metadata=wire("e")) + + # Create a person + alice = Person(name="Alice", age=30, email="alice@example.com") + + print_info("Person dataclass: name, age?, email?") + print_info(f" Original: name={alice.name}, age={alice.age}, email={alice.email}") + print_info("") + + wire_data = to_wire(alice) + print_info(f" Wire format: {wire_data}") + print_info(" Note: 'name' -> 'n', 'age' -> 'a', 'email' -> 'e'") + print_info("") + + decoded_alice = from_wire(Person, wire_data) + print_info(f" Decoded: name={decoded_alice.name}, age={decoded_alice.age}, email={decoded_alice.email}") + + print_success("Dataclass fields mapped to wire keys via wire() metadata") + + # Step 3: Handling Optional Fields + print_step(3, "Handling Optional Fields") + + print_info("Optional fields are omitted when None or at default values:") + print_info("") + + # Person with only required fields + bob = Person(name="Bob") + print_info(f" Person with optional fields missing: name={bob.name}, age={bob.age}, email={bob.email}") + + bob_wire = to_wire(bob) + print_info(f" Wire format: {bob_wire}") + print_info(" Note: age and email not included (None values omitted)") + print_info("") + + bob_decoded = from_wire(Person, bob_wire) + print_info(f" Decoded: name={bob_decoded.name}, age={bob_decoded.age}, email={bob_decoded.email}") + print_info("") + + # Person with default-like values + @dataclass + class PersonWithDefaults: + name: str = field(default="", metadata=wire("n")) + age: int = field(default=0, metadata=wire("a")) + active: bool = field(default=False, metadata=wire("x")) + + charlie = PersonWithDefaults(name="", age=0, active=False) + print_info(f" Person with all defaults: name='{charlie.name}', age={charlie.age}, active={charlie.active}") + + charlie_wire = to_wire(charlie) + print_info(f" Wire format: {charlie_wire}") + print_info(" Note: Empty dict - all fields at defaults are omitted") + print_info("") + + charlie_decoded = from_wire(PersonWithDefaults, charlie_wire) + print_info(f" Decoded: name='{charlie_decoded.name}', age={charlie_decoded.age}, active={charlie_decoded.active}") + + print_success("Optional fields are omitted when empty or at default values") + + # Step 4: Keeping Zero/False Values + print_step(4, "Keeping Zero/False Values") + + print_info("Use keep_zero=True and keep_false=True to preserve default values:") + print_info("") + + @dataclass + class ExplicitDefaults: + name: str = field(default="", metadata=wire("n")) + count: int = field(default=0, metadata=wire("c", keep_zero=True)) + active: bool = field(default=False, metadata=wire("a", keep_false=True)) + + explicit = ExplicitDefaults(name="test", count=0, active=False) + print_info(f" Original: name={explicit.name}, count={explicit.count}, active={explicit.active}") + + explicit_wire = to_wire(explicit) + print_info(f" Wire format: {explicit_wire}") + print_info(" Note: 'count' and 'active' preserved due to keep_zero/keep_false") + print_info("") + + explicit_decoded = from_wire(ExplicitDefaults, explicit_wire) + decoded_name = explicit_decoded.name + decoded_count = explicit_decoded.count + decoded_active = explicit_decoded.active + print_info(f" Decoded: name={decoded_name}, count={decoded_count}, active={decoded_active}") + + print_success("keep_zero and keep_false preserve default values in wire format") + + # Step 5: Address Fields with addr() Helper + print_step(5, "Address Fields with addr() Helper") + + print_info("Use addr() helper for Algorand address fields:") + print_info("") + + @dataclass + class AssetInfo: + asset_id: int = field(default=0, metadata=wire("aid", keep_zero=True)) + name: str = field(default="", metadata=wire("nm")) + creator: str = field(default=ZERO_ADDRESS, metadata=addr("cr")) + metadata_bytes: bytes = field(default=b"", metadata=wire("md")) + + # Create an asset + creator_pk = bytes(range(32)) + creator_addr = address_from_public_key(creator_pk) + + asset = AssetInfo( + asset_id=12345, + name="Test Asset", + creator=creator_addr, + metadata_bytes=bytes([0x01, 0x02, 0x03]), + ) + + print_info(f" asset_id: {asset.asset_id}") + print_info(f" name: {asset.name}") + print_info(f" creator: {asset.creator[:20]}...") + print_info(f" metadata: {format_hex(asset.metadata_bytes)}") + print_info("") + + asset_wire = to_wire(asset) + print_info("Wire format:") + for key, value in asset_wire.items(): + if isinstance(value, bytes): + print_info(f" {key}: {format_hex(value[:8])}... ({len(value)} bytes)") + else: + print_info(f" {key}: {value}") + print_info("") + + asset_decoded = from_wire(AssetInfo, asset_wire) + print_info("Decoded:") + print_info(f" asset_id: {asset_decoded.asset_id}") + print_info(f" name: {asset_decoded.name}") + print_info(f" creator: {asset_decoded.creator[:20]}...") + print_info("") + + if asset_decoded.creator == asset.creator: + print_success("Address fields round-trip correctly via addr() helper") + + # Step 6: Nested Dataclasses + print_step(6, "Nested Dataclasses") + + print_info("Dataclasses can contain other dataclasses using nested():") + print_info("") + + @dataclass + class PostalAddress: + street: str = field(default="", metadata=wire("st")) + city: str = field(default="", metadata=wire("ct")) + postcode: int = field(default=0, metadata=wire("pc", keep_zero=True)) + country: str | None = field(default=None, metadata=wire("co")) + + @dataclass + class Company: + name: str = field(default="", metadata=wire("n")) + headquarters: PostalAddress | None = field(default=None, metadata=nested("hq", PostalAddress)) + founded: int | None = field(default=None, metadata=wire("f")) + + # Create a company with nested address + algorand = Company( + name="Algorand Foundation", + headquarters=PostalAddress( + street="1 Innovation Drive", + city="Boston", + postcode=12345, + country="USA", + ), + founded=2017, + ) + + print_info("Company with nested PostalAddress:") + print_info(f" name: {algorand.name}") + print_info(f" headquarters.street: {algorand.headquarters.street}") # type: ignore[union-attr] + print_info(f" headquarters.city: {algorand.headquarters.city}") # type: ignore[union-attr] + print_info(f" headquarters.postcode: {algorand.headquarters.postcode}") # type: ignore[union-attr] + print_info(f" headquarters.country: {algorand.headquarters.country}") # type: ignore[union-attr] + print_info(f" founded: {algorand.founded}") + print_info("") + + company_wire = to_wire(algorand) + print_info(f"Wire format: {company_wire}") + print_info(" Note: 'headquarters' encoded as 'hq', nested fields also renamed") + print_info("") + + company_decoded = from_wire(Company, company_wire) + print_info("Decoded:") + print_info(f" name: {company_decoded.name}") + print_info(f" headquarters.street: {company_decoded.headquarters.street}") # type: ignore[union-attr] + print_info(f" headquarters.city: {company_decoded.headquarters.city}") # type: ignore[union-attr] + print_info(f" founded: {company_decoded.founded}") + + print_success("Nested dataclasses preserve structure through encoding") + + # Step 7: Field Renaming with Wire Keys + print_step(7, "Field Renaming with Wire Keys") + + print_info("Wire key aliases map property names to different wire format keys:") + print_info("") + print_info(" Benefits:") + print_info(" - Reduce payload size (shorter keys)") + print_info(" - Match external API specifications") + print_info(" - Maintain backwards compatibility") + print_info("") + + @dataclass + class TransactionInfo: + transaction_id: str = field(default="", metadata=wire("txid")) + sender_address: str = field(default="", metadata=wire("snd")) + receiver_address: str = field(default="", metadata=wire("rcv")) + amount_in_micro_algos: int = field(default=0, metadata=wire("amt", keep_zero=True)) + note_field: str | None = field(default=None, metadata=wire("note")) + + txn = TransactionInfo( + transaction_id="ABC123...", + sender_address="SENDER...", + receiver_address="RECEIVER...", + amount_in_micro_algos=1000000, + note_field="Payment", + ) + + print_info("Property name -> wire key mapping:") + print_info(" transaction_id -> txid") + print_info(" sender_address -> snd") + print_info(" receiver_address -> rcv") + print_info(" amount_in_micro_algos -> amt") + print_info(" note_field -> note") + print_info("") + + txn_wire = to_wire(txn) + print_info(f"Wire format: {txn_wire}") + print_info("") + + # Size comparison + verbose_keys = ( + '{"transaction_id":"ABC123...","sender_address":"SENDER...",' + '"receiver_address":"RECEIVER...","amount_in_micro_algos":1000000,"note_field":"Payment"}' + ) + short_keys = '{"txid":"ABC123...","snd":"SENDER...","rcv":"RECEIVER...","amt":1000000,"note":"Payment"}' + + print_info("Size comparison:") + print_info(f" Without wire key renaming: {len(verbose_keys)} bytes") + print_info(f" With wire key renaming: {len(short_keys)} bytes") + savings = len(verbose_keys) - len(short_keys) + savings_pct = round((1 - len(short_keys) / len(verbose_keys)) * 100) + print_info(f" Savings: {savings} bytes ({savings_pct}%)") + + print_success("Wire key renaming reduces payload size") + + # Step 8: MessagePack Integration + print_step(8, "MessagePack Integration") + + print_info("to_wire() output can be directly encoded with msgpack:") + print_info("") + + simple = Person(name="Test", age=25, email="test@example.com") + + # to_wire -> msgpack encode -> msgpack decode -> from_wire + wire_dict = to_wire(simple) + msgpack_bytes = encode_msgpack(wire_dict) + decoded_dict = decode_msgpack(msgpack_bytes) + restored = from_wire(Person, decoded_dict) # type: ignore[arg-type] + + print_info(f" Original: name={simple.name}, age={simple.age}, email={simple.email}") + print_info(f" Wire dict: {wire_dict}") + print_info(f" Msgpack bytes: {len(msgpack_bytes)} bytes") + print_info(f" Decoded dict: {decoded_dict}") + print_info(f" Restored: name={restored.name}, age={restored.age}, email={restored.email}") + print_info("") + + match = restored.name == simple.name and restored.age == simple.age and restored.email == simple.email + if match: + print_success("Full round-trip: dataclass -> wire -> msgpack -> wire -> dataclass") + + # Step 9: Default Values + print_step(9, "Default Values") + + print_info("Dataclass defaults mirror TypeScript ObjectModelCodec.defaultValue():") + print_info("") + + @dataclass + class DefaultExample: + name: str = field(default="", metadata=wire("n")) + count: int = field(default=0, metadata=wire("c")) + active: bool = field(default=False, metadata=wire("a")) + tags: list[str] = field(default_factory=list, metadata=wire("t")) + + default_obj = DefaultExample() + d_name = default_obj.name + d_count = default_obj.count + d_active = default_obj.active + d_tags = default_obj.tags + print_info(f" Default object: name='{d_name}', count={d_count}, active={d_active}, tags={d_tags}") + print_info("") + + default_wire = to_wire(default_obj) + print_info(f" Wire format: {default_wire}") + print_info(" Note: Empty dict because all fields are at defaults") + print_info("") + + decoded_default = from_wire(DefaultExample, default_wire) + dd_name = decoded_default.name + dd_count = decoded_default.count + dd_active = decoded_default.active + dd_tags = decoded_default.tags + print_info(f" Decoded: name='{dd_name}', count={dd_count}, active={dd_active}, tags={dd_tags}") + + print_success("Dataclass defaults provide consistent initialization") + + # Step 10: Round-Trip Verification + print_step(10, "Round-Trip Verification") + + print_info("Verifying round-trip for model codecs:") + print_info("") + + # Test various dataclass scenarios + results = [] + + # Person with all fields + p1 = Person(name="Test", age=25, email="test@example.com") + p1_rt = from_wire(Person, to_wire(p1)) + results.append(("Person (all fields)", p1.name == p1_rt.name and p1.age == p1_rt.age and p1.email == p1_rt.email)) + + # Person with optional fields missing + p2 = Person(name="Bob") + p2_rt = from_wire(Person, to_wire(p2)) + results.append(("Person (name only)", p2.name == p2_rt.name and p2.age == p2_rt.age and p2.email == p2_rt.email)) + + # AssetInfo with address + a1 = AssetInfo(asset_id=999, name="Test Asset", creator=creator_addr, metadata_bytes=b"\x01\x02\x03") + a1_rt = from_wire(AssetInfo, to_wire(a1)) + a1_match = a1.asset_id == a1_rt.asset_id and a1.name == a1_rt.name and a1.creator == a1_rt.creator + results.append(("AssetInfo", a1_match)) + + # Nested Company + c1 = Company( + name="Test Corp", + headquarters=PostalAddress(street="123 Main", city="Anytown", postcode=99999), + founded=2020, + ) + c1_rt = from_wire(Company, to_wire(c1)) + results.append( + ( + "Company (nested)", + c1.name == c1_rt.name + and c1.headquarters.street == c1_rt.headquarters.street # type: ignore[union-attr] + and c1.headquarters.city == c1_rt.headquarters.city # type: ignore[union-attr] + and c1.founded == c1_rt.founded, + ) + ) + + # ExplicitDefaults + e1 = ExplicitDefaults(name="test", count=0, active=False) + e1_rt = from_wire(ExplicitDefaults, to_wire(e1)) + e1_match = e1.name == e1_rt.name and e1.count == e1_rt.count and e1.active == e1_rt.active + results.append(("ExplicitDefaults", e1_match)) + + all_passed = True + for name, passed in results: + status = "PASS" if passed else "FAIL" + print_info(f" [{status}] {name}") + if not passed: + all_passed = False + + print_info("") + if all_passed: + print_success("All round-trip verifications passed!") + + # Step 11: Summary + print_step(11, "Summary") + + print_info("Python model serde (vs TypeScript ObjectModelCodec):") + print_info("") + print_info(" Dataclass definition:") + print_info(" - @dataclass decorator for model classes") + print_info(" - field(default=..., metadata=wire(...)) for fields") + print_info(" - Native Python types (str, int, bool, bytes, list, dict)") + print_info("") + print_info(" Field metadata helpers:") + print_info(" - wire(alias, ...) Basic field configuration") + print_info(" - addr(alias, ...) Address string <-> bytes") + print_info(" - nested(alias, cls) Nested dataclass") + print_info(" - flatten(cls, ...) Merge nested fields into parent") + print_info("") + print_info(" Serialization functions:") + print_info(" - to_wire(obj) Dataclass -> wire dict") + print_info(" - from_wire(cls, d) Wire dict -> dataclass") + print_info("") + print_info(" Key options:") + print_info(" - omit_if_none=True Omit None values") + print_info(" - keep_zero=False Keep 0 values") + print_info(" - keep_false=False Keep False values") + print_info(" - required=False Error if missing") + print_info("") + print_info(" TypeScript comparison:") + print_info(" - TS: ObjectModelCodec, FieldMetadata, encode/decode methods") + print_info(" - Python: @dataclass, wire() metadata, to_wire/from_wire") + print_info(" - Python approach is more idiomatic and simpler") + print_info("") + print_success("Model Serde Example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/common/12_sourcemap.py b/examples/common/12_sourcemap.py new file mode 100644 index 00000000..6e00e8a8 --- /dev/null +++ b/examples/common/12_sourcemap.py @@ -0,0 +1,331 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Sourcemap for TEAL Debugging + +This example demonstrates how to use ProgramSourceMap for mapping TEAL +program counters (PC) to source locations for debugging purposes. + +Topics covered: +- ProgramSourceMap class construction from sourcemap data +- Sourcemap format: version, sources, mappings +- get_line_for_pc() to get source line for a specific PC +- get_pcs_for_line() to find PCs for a source line +- pc_to_line and line_to_pc dictionaries +- How sourcemaps enable TEAL debugging by mapping PC to source + +No LocalNet required - pure sourcemap parsing +""" + +from shared import ( + print_header, + print_info, + print_step, + print_success, +) + +from algokit_common import ( + ProgramSourceMap, + SourceMapVersionError, +) + + +def main() -> None: + print_header("Sourcemap Example") + + # Step 1: Introduction to Sourcemaps + print_step(1, "Introduction to Sourcemaps") + + print_info("Sourcemaps enable debugging by mapping compiled code to source code.") + print_info("") + print_info("In Algorand development:") + print_info(" - TEAL programs are compiled from higher-level languages (PyTeal, etc.)") + print_info(" - Program counter (PC) values identify positions in the compiled TEAL") + print_info(" - Sourcemaps map each PC back to the original source file location") + print_info(" - When errors occur, you can trace back to your original source code") + print_info("") + print_info("The ProgramSourceMap class parses standard source map v3 format.") + print_success("Sourcemaps bridge the gap between compiled TEAL and source code") + + # Step 2: Sourcemap Format + print_step(2, "Sourcemap Format") + + print_info("A sourcemap follows the standard v3 format with these fields:") + print_info("") + print_info(" version: int - Sourcemap version (must be 3)") + print_info(" sources: list[str] - List of source file names/paths") + print_info(" mappings: str - VLQ-encoded mapping data (semicolon-separated)") + print_info("") + print_info("The mappings string uses Base64 VLQ encoding:") + print_info(" - Each semicolon (;) represents one TEAL instruction (one PC value)") + print_info(" - Segments encode source location deltas") + print_info(" - Python SDK extracts line number from segment[2]") + print_info("") + print_success("Standard v3 sourcemap format enables interoperability with tools") + + # Step 3: Creating a Mock Sourcemap + print_step(3, "Creating a Mock Sourcemap") + + print_info("Let us create a mock sourcemap representing a simple TEAL program.") + print_info("") + print_info("Imagine this PyTeal source (pysource.py):") + print_info(" Line 0: from pyteal import *") + print_info(" Line 1: ") + print_info(" Line 2: def approval():") + print_info(" Line 3: return Approve()") + print_info(" Line 4: ") + print_info(" Line 5: print(compileTeal(approval()))") + print_info("") + print_info("Compiled to TEAL:") + print_info(" PC 0: #pragma version 10") + print_info(" PC 1: int 1") + print_info(" PC 2: return") + print_info("") + + # Create a mock sourcemap that maps: + # PC 0 -> Line 0 (version pragma from import) + # PC 1 -> Line 3 (the Approve() call) + # PC 2 -> Line 3 (the return statement) + # Note: VLQ encoding - each semicolon separates PC values + # AAAA encodes [0, 0, 0, 0] - source 0, line 0, col 0 + # AAGA encodes [0, 0, 3, 0] - delta of 3 lines + + mock_sourcemap = { + "version": 3, + "sources": ["pysource.py"], + "mappings": "AAAA;AAGA;AAAA", # PC0->line0, PC1->line3, PC2->line3 + } + + print_info(f"version: {mock_sourcemap['version']}") + print_info(f"sources: {mock_sourcemap['sources']}") + print_info(f'mappings: "{mock_sourcemap["mappings"]}"') + print_info("") + print_success("Mock sourcemap created representing a simple PyTeal program") + + # Step 4: Constructing ProgramSourceMap + print_step(4, "Constructing ProgramSourceMap") + + source_map = ProgramSourceMap(mock_sourcemap) + + print_info("ProgramSourceMap constructor takes a dict with:") + print_info(" { 'version': 3, 'sources': [...], 'mappings': '...' }") + print_info("") + print_info("After construction, the sourcemap properties are accessible:") + print_info(f" source_map.version: {source_map.version}") + print_info(f" source_map.sources: {source_map.sources}") + print_info(f' source_map.mappings: "{source_map.mappings}"') + print_info("") + print_info("The constructor parses the VLQ-encoded mappings and builds internal indexes.") + print_success("ProgramSourceMap constructed and mappings parsed") + + # Step 5: Accessing pc_to_line and line_to_pc Dictionaries + print_step(5, "pc_to_line and line_to_pc Dictionaries") + + print_info("ProgramSourceMap builds two useful dictionaries:") + print_info("") + + print_info("pc_to_line: Maps PC -> source line number") + for pc, line in sorted(source_map.pc_to_line.items()): + print_info(f" PC {pc} -> line {line}") + print_info("") + + print_info("line_to_pc: Maps source line -> list of PCs") + for line, pcs in sorted(source_map.line_to_pc.items()): + print_info(f" line {line} -> PCs {pcs}") + print_info("") + + print_success("Bidirectional PC <-> line mappings available") + + # Step 6: get_line_for_pc() - Get Source Line for a PC + print_step(6, "get_line_for_pc() - Get Source Line for a PC") + + print_info("get_line_for_pc(pc) returns the source line number for a given PC.") + print_info("") + + # Get line for each PC + for pc in range(4): # Check PCs 0-3 + line = source_map.get_line_for_pc(pc) + if line is not None: + print_info(f" PC {pc} -> line {line} ({source_map.sources[0]}:{line})") + else: + print_info(f" PC {pc} -> None (no mapping)") + print_info("") + + # Try a PC that doesn't exist + non_existent_pc = 999 + no_line = source_map.get_line_for_pc(non_existent_pc) + print_info(f" PC {non_existent_pc} (non-existent) -> {no_line}") + print_info("") + + print_success("get_line_for_pc() maps PC values to source lines") + + # Step 7: get_pcs_for_line() - Find PCs for a Source Line + print_step(7, "get_pcs_for_line() - Find PCs for a Source Line") + + print_info("get_pcs_for_line(line) returns all PCs for a source line.") + print_info("This is useful for setting breakpoints at a specific source line.") + print_info("") + + # Check each line + for line in range(6): + pcs = source_map.get_pcs_for_line(line) + if pcs: + print_info(f" Line {line}: PCs {pcs}") + else: + print_info(f" Line {line}: (no PCs mapped)") + print_info("") + + print_success("get_pcs_for_line() enables breakpoint setting and line-based debugging") + + # Step 8: Practical Debugging Example + print_step(8, "Practical Debugging Example") + + print_info("When a TEAL program fails, the error includes the PC where it failed.") + print_info("Sourcemaps let you trace back to your original source code.") + print_info("") + + # Simulate a runtime error scenario + failed_pc = 1 + error_line = source_map.get_line_for_pc(failed_pc) + + print_info("Simulated Runtime Error") + print_info(f" Error: Logic eval error at PC {failed_pc}: int 1 expected bytes") + print_info("") + + if error_line is not None: + source_file = source_map.sources[0] + + print_info("Mapped to Source") + print_info(f" File: {source_file}") + print_info(f" Line: {error_line}") + print_info("") + print_info(" This allows you to immediately find the source code location") + print_info(" that caused the error, rather than debugging raw TEAL opcodes.") + + print_success("Sourcemaps enable efficient debugging of compiled TEAL programs") + + # Step 9: Sourcemap with Multiple Sources + print_step(9, "Sourcemap with Multiple Sources") + + print_info("Sourcemaps can reference multiple source files.") + print_info("This is common when TEAL is generated from multiple modules.") + print_info("") + + # Create a multi-source sourcemap + # AAAA = source 0, line 0 + # ACAA = source delta +1 (source 1), line 0 + # ACAA = source delta +1 (source 2), line 0 + # AFAA = source delta -2 (source 0), line 0 + multi_source_map = ProgramSourceMap( + { + "version": 3, + "sources": ["main.py", "utils.py", "constants.py"], + "mappings": "AAAA;ACAA;ACAA;AFAA", + } + ) + + print_info(f"sources: {multi_source_map.sources}") + print_info("") + + print_info("PC to line mappings:") + for pc, line in sorted(multi_source_map.pc_to_line.items()): + # Note: Python SDK doesn't track source index per PC + # All PCs map to line numbers only + print_info(f" PC {pc} -> line {line}") + print_info("") + + print_info("Multiple source support allows tracing code back to the correct") + print_info("module in multi-file projects.") + print_success("Sourcemaps support multi-file projects") + + # Step 10: Version Validation + print_step(10, "Version Validation") + + print_info("ProgramSourceMap only supports version 3 sourcemaps.") + print_info("") + + try: + ProgramSourceMap( + { + "version": 2, # Invalid version + "sources": ["test.py"], + "mappings": "AAAA", + } + ) + print_info(" ERROR: Version 2 should have been rejected") + except SourceMapVersionError as e: + print_info(f' Creating version 2 sourcemap throws: "{e}"') + print_info("") + + print_success("Version validation ensures sourcemap compatibility") + + # Step 11: Real-World Sourcemap Example + print_step(11, "Real-World Sourcemap Example") + + print_info("Here's what a more realistic sourcemap might look like:") + print_info("") + + # A more complex example with multiple lines + real_world_map = ProgramSourceMap( + { + "version": 3, + "sources": ["approval.py"], + "mappings": "AAAA;AACA;AACA;AAGA;AACA;AACA;AAEA;AACA", + # This encodes a progression through source lines: + # PC 0 -> line 0, PC 1 -> line 1, PC 2 -> line 2 + # PC 3 -> line 5 (jump), PC 4 -> line 6, PC 5 -> line 7 + # PC 6 -> line 9 (jump), PC 7 -> line 10 + } + ) + + print_info("Realistic sourcemap for a PyTeal program:") + print_info(f" sources: {real_world_map.sources}") + print_info("") + print_info("PC -> Line mappings:") + for pc, line in sorted(real_world_map.pc_to_line.items()): + print_info(f" PC {pc:2d} -> line {line:2d}") + print_info("") + + print_info("This shows how the TEAL program counter progresses through") + print_info("the source code, sometimes jumping over blank/comment lines.") + + print_success("Real-world sourcemaps enable precise debugging") + + # Step 12: Summary - Debugging Workflow with Sourcemaps + print_step(12, "Summary - Debugging Workflow with Sourcemaps") + + print_info("Typical debugging workflow with sourcemaps:") + print_info("") + print_info(" 1. Compile your high-level code (PyTeal, etc.) to TEAL") + print_info(" 2. The compiler generates a sourcemap alongside the TEAL") + print_info(" 3. Load the sourcemap: ProgramSourceMap(sourcemap_data)") + print_info(" 4. When an error occurs, get the PC from the error message") + print_info(" 5. Map PC to line: source_map.get_line_for_pc(pc)") + print_info(" 6. Navigate to the source location to fix the issue") + print_info("") + print_info("For setting breakpoints:") + print_info(" 1. Identify the source file and line") + print_info(" 2. Get PCs: source_map.get_pcs_for_line(line)") + print_info(" 3. Set breakpoints at the returned PC values") + print_info("") + + print_info("Key Properties and Methods:") + print_info(" .version Sourcemap version (must be 3)") + print_info(" .sources List of source file names") + print_info(" .mappings Raw VLQ-encoded string") + print_info(" .pc_to_line Dict[int, int] - PC -> line") + print_info(" .line_to_pc Dict[int, list[int]] - line -> PCs") + print_info(" .get_line_for_pc(pc) Get line for a PC") + print_info(" .get_pcs_for_line(ln) Get PCs for a line") + print_info("") + + print_info("Related Classes:") + print_info(" SourceLocation (line, column) for source code position") + print_info(" PcLineLocation (pc, line) for PC-line mapping") + print_info(" SourceMapVersionError Exception for invalid version") + print_info("") + + print_success("ProgramSourceMap enables effective TEAL debugging!") + + +if __name__ == "__main__": + main() diff --git a/examples/common/verify-all.sh b/examples/common/verify-all.sh new file mode 100755 index 00000000..9e1412f0 --- /dev/null +++ b/examples/common/verify-all.sh @@ -0,0 +1,84 @@ +#!/bin/bash + +# verify-all.sh - Run all common examples and verify they work +# Exit with non-zero code if any example fails + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +cd "$SCRIPT_DIR" + +# Array of example files in order +EXAMPLES=( + "01_address_basics.py" + "02_address_encoding.py" + "03_array_utilities.py" + "04_constants.py" + "05_crypto_hash.py" + "06_logger.py" + "07_json_bigint.py" + "08_msgpack.py" + "09_primitive_codecs.py" + "10_composite_codecs.py" + "11_model_codecs.py" + "12_sourcemap.py" +) + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +NC='\033[0m' # No Color + +echo "========================================" +echo "Common Examples Verification Script" +echo "========================================" +echo "" + +if [ ${#EXAMPLES[@]} -eq 0 ]; then + echo "No examples to run yet." + echo "" + echo -e "${GREEN}Common examples suite passed (no examples)${NC}" + exit 0 +fi + +PASSED=0 +FAILED=0 +FAILED_EXAMPLES=() + +for example in "${EXAMPLES[@]}"; do + echo -n "Running $example... " + + if [ ! -f "$example" ]; then + echo -e "${RED}FAILED${NC} (file not found)" + FAILED=$((FAILED + 1)) + FAILED_EXAMPLES+=("$example") + continue + fi + + # Run the example and capture output/exit code + if OUTPUT=$(uv run python "$example" 2>&1); then + echo -e "${GREEN}PASSED${NC}" + PASSED=$((PASSED + 1)) + else + echo -e "${RED}FAILED${NC}" + echo "$OUTPUT" + FAILED=$((FAILED + 1)) + FAILED_EXAMPLES+=("$example") + fi +done + +echo "" +echo "========================================" +echo "Results: ${PASSED} passed, ${FAILED} failed" +echo "========================================" + +if [ $FAILED -gt 0 ]; then + echo "" + echo -e "${RED}Failed examples:${NC}" + for failed in "${FAILED_EXAMPLES[@]}"; do + echo " - $failed" + done + exit 1 +fi + +echo "" +echo -e "${GREEN}All Common examples passed!${NC}" +exit 0 diff --git a/examples/indexer_client/01_health_check.py b/examples/indexer_client/01_health_check.py new file mode 100644 index 00000000..7770b373 --- /dev/null +++ b/examples/indexer_client/01_health_check.py @@ -0,0 +1,100 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Indexer Health Check + +This example demonstrates how to check indexer health status using +the IndexerClient health_check() method. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from shared import ( + create_indexer_client, + print_error, + print_header, + print_info, + print_step, + print_success, +) + + +def main() -> None: + print_header("Indexer Health Check Example") + + # Create an Indexer client connected to LocalNet + indexer = create_indexer_client() + + # ========================================================================= + # Step 1: Perform Health Check + # ========================================================================= + print_step(1, "Checking indexer health with health_check()") + + try: + # health_check() returns a HealthCheck object with status information + health = indexer.health_check() + + print_success("Indexer is healthy!") + print_info("") + print_info("Health check response:") + print_info(f" - version: {health.version}") + print_info(f" - db_available: {health.db_available}") + print_info(f" - is_migrating: {health.is_migrating}") + print_info(f" - message: {health.message}") + print_info(f" - round: {health.round_}") + + # Display errors if any + if health.errors and len(health.errors) > 0: + errors_str = ", ".join(health.errors) + print_info(f" - errors: {errors_str}") + else: + print_info(" - errors: none") + + # ========================================================================= + # Step 2: Interpret the Health Check Results + # ========================================================================= + print_step(2, "Interpreting health check results") + + # Check if the database is available + if health.db_available: + print_success("Database is available and accessible") + else: + print_error("Database is NOT available") + + # Check if a migration is in progress + if health.is_migrating: + print_info("Note: Database migration is in progress") + print_info("Some queries may be slower or unavailable during migration") + else: + print_success("No database migration in progress") + + # Display current round + print_info(f"Indexer has processed blocks up to round {health.round_}") + except Exception as e: + print_error(f"Health check failed: {e}") + print_info("") + print_info("Common causes of health check failures:") + print_info(" - Indexer service is not running") + print_info(" - Network connectivity issues") + print_info(" - Incorrect indexer URL or port") + print_info("") + print_info("To start LocalNet, run: algokit localnet start") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. health_check() - Checks if the indexer service is healthy") + print_info("") + print_info("Health check response fields explained:") + print_info(" - version: The version of the indexer software") + print_info(" - db_available: Whether the database is accessible") + print_info(" - is_migrating: Whether a database migration is in progress") + print_info(" - message: A human-readable status message") + print_info(" - round: The latest block round the indexer has processed") + print_info(" - errors: Any error messages from the indexer") + + +if __name__ == "__main__": + main() diff --git a/examples/indexer_client/02_account_lookup.py b/examples/indexer_client/02_account_lookup.py new file mode 100644 index 00000000..ba108d1e --- /dev/null +++ b/examples/indexer_client/02_account_lookup.py @@ -0,0 +1,189 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Account Lookup + +This example demonstrates how to lookup account information using +the IndexerClient lookup_account_by_id() and search_for_accounts() methods. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from shared import ( + create_algorand_client, + create_indexer_client, + format_micro_algo, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + + +def main() -> None: + print_header("Account Lookup Example") + + # Create clients + indexer = create_indexer_client() + algorand = create_algorand_client() + + # ========================================================================= + # Step 1: Get a test account from LocalNet + # ========================================================================= + print_step(1, "Getting test account from LocalNet dispenser") + + try: + dispenser = algorand.account.localnet_dispenser() + test_account_address = dispenser.addr + print_success(f"Using dispenser account: {shorten_address(test_account_address)}") + except Exception as e: + print_error(f"Failed to get dispenser account: {e}") + print_info("") + print_info("Make sure LocalNet is running: algokit localnet start") + return + + # ========================================================================= + # Step 2: Lookup account by ID + # ========================================================================= + print_step(2, "Looking up account with lookup_account_by_id()") + + try: + # lookup_account_by_id() returns detailed account information + result = indexer.lookup_account_by_id(test_account_address) + account = result.account + + print_success("Account found!") + print_info("") + print_info("Account details:") + print_info(f" - address: {account.address}") + print_info(f" - amount: {format_micro_algo(account.amount)}") + print_info(f" - amount_without_pending_rewards: {format_micro_algo(account.amount_without_pending_rewards)}") + print_info(f" - min_balance: {format_micro_algo(account.min_balance)}") + print_info(f" - status: {account.status}") + print_info(f" - round: {account.round_}") + print_info("") + print_info("Additional account info:") + print_info(f" - pending_rewards: {format_micro_algo(account.pending_rewards)}") + print_info(f" - rewards: {format_micro_algo(account.rewards)}") + print_info(f" - total_apps_opted_in: {account.total_apps_opted_in}") + print_info(f" - total_assets_opted_in: {account.total_assets_opted_in}") + print_info(f" - total_created_apps: {account.total_created_apps}") + print_info(f" - total_created_assets: {account.total_created_assets}") + print_info("") + print_info(f"Query performed at round: {result.current_round}") + except Exception as e: + print_error(f"Account lookup failed: {e}") + + # ========================================================================= + # Step 3: Handle account not found + # ========================================================================= + print_step(3, "Handling account not found scenario") + + # Generate a random address that likely does not exist on LocalNet + random_account = algorand.account.random() + non_existent_address = random_account.addr + + print_info(f"Attempting to lookup non-existent account: {shorten_address(non_existent_address)}") + + try: + indexer.lookup_account_by_id(non_existent_address) + print_info("Account was unexpectedly found") + except Exception as e: + error_message = str(e) + + # Check if the error indicates account not found + error_lower = error_message.lower() + is_not_found_error = "no accounts found" in error_lower or "404" in error_message or "not found" in error_lower + if is_not_found_error: + print_success("Correctly received 'account not found' error") + print_info(f" Error: {error_message}") + else: + print_error(f"Unexpected error: {error_message}") + + # ========================================================================= + # Step 4: Search for accounts with filters + # ========================================================================= + print_step(4, "Searching for accounts with search_for_accounts()") + + try: + # search_for_accounts() allows searching with various filters + # Here we search for accounts with balance greater than 1 ALGO (1,000,000 µALGO) + search_result = indexer.search_for_accounts( + currency_greater_than=1_000_000, + limit=5, + ) + + print_success(f"Found {len(search_result.accounts)} account(s) with balance > 1 ALGO") + print_info("") + + if len(search_result.accounts) > 0: + print_info("Accounts found:") + for account in search_result.accounts: + addr_short = shorten_address(account.address) + amount_formatted = format_micro_algo(account.amount) + print_info(f" - {addr_short}: {amount_formatted} (status: {account.status})") + + print_info("") + print_info(f"Query performed at round: {search_result.current_round}") + + # Check if there are more results available + if search_result.next_token: + print_info(f"More results available (use next_token: {search_result.next_token})") + except Exception as e: + print_error(f"Account search failed: {e}") + + # ========================================================================= + # Step 5: Search with additional filters + # ========================================================================= + print_step(5, "Searching with additional filter options") + + try: + # Search for accounts that are online (participating in consensus) + # Note: On LocalNet, most accounts are typically offline + online_result = indexer.search_for_accounts( + auth_addr=None, # No specific auth address filter + limit=3, + ) + + print_info("Searching for accounts with default filters...") + print_info(f"Found {len(online_result.accounts)} account(s)") + + if len(online_result.accounts) > 0: + for account in online_result.accounts: + addr_short = shorten_address(account.address) + amount_formatted = format_micro_algo(account.amount) + print_info(f" - {addr_short}: {amount_formatted}") + else: + print_info(" No accounts found matching the criteria") + except Exception as e: + print_error(f"Account search failed: {e}") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. lookup_account_by_id(address) - Get detailed account information") + print_info(" 2. Handling 'account not found' errors gracefully") + print_info(" 3. search_for_accounts() - Search accounts with filters") + print_info("") + print_info("Key lookup_account_by_id() response fields:") + print_info(" - address: The account public key") + print_info(" - amount: Total MicroAlgos in the account") + print_info(" - amount_without_pending_rewards: Balance excluding pending rewards") + print_info(" - min_balance: Minimum balance required (based on assets/apps)") + print_info(" - status: Online, Offline, or NotParticipating") + print_info(" - round: The round for which this information is relevant") + print_info("") + print_info("Key search_for_accounts() filter parameters:") + print_info(" - currency_greater_than: Filter by minimum balance") + print_info(" - currency_less_than: Filter by maximum balance") + print_info(" - limit: Maximum number of results to return") + print_info(" - asset_id: Filter by accounts holding a specific asset") + print_info(" - application_id: Filter by accounts opted into an app") + + +if __name__ == "__main__": + main() diff --git a/examples/indexer_client/03_account_assets.py b/examples/indexer_client/03_account_assets.py new file mode 100644 index 00000000..3d248ecd --- /dev/null +++ b/examples/indexer_client/03_account_assets.py @@ -0,0 +1,277 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Account Assets + +This example demonstrates how to query account asset holdings using +the IndexerClient lookup_account_assets() and lookup_account_created_assets() methods. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from shared import ( + create_algorand_client, + create_indexer_client, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_utils import AssetCreateParams + + +def main() -> None: + print_header("Account Assets Example") + + # Create clients + indexer = create_indexer_client() + algorand = create_algorand_client() + + # ========================================================================= + # Step 1: Get a funded account from LocalNet + # ========================================================================= + print_step(1, "Getting a funded account from LocalNet") + + try: + dispenser = algorand.account.localnet_dispenser() + creator_address = dispenser.addr + print_success(f"Using dispenser account: {shorten_address(creator_address)}") + except Exception as e: + print_error(f"Failed to get dispenser account: {e}") + print_info("") + print_info("Make sure LocalNet is running: algokit localnet start") + print_info("If issues persist, try: algokit localnet reset") + return + + # ========================================================================= + # Step 2: Create test assets using AlgorandClient + # ========================================================================= + print_step(2, "Creating test assets for demonstration") + + try: + # Create first test asset + print_info("Creating first test asset: TestCoin (TC)...") + result1 = algorand.send.asset_create( + AssetCreateParams( + sender=creator_address, + total=1_000_000_000, + decimals=6, + asset_name="TestCoin", + unit_name="TC", + url="https://example.com/testcoin", + default_frozen=False, + ) + ) + asset_id_1 = result1.asset_id + print_success(f"Created TestCoin with Asset ID: {asset_id_1}") + + # Create second test asset + print_info("Creating second test asset: DemoCoin (DEMO)...") + result2 = algorand.send.asset_create( + AssetCreateParams( + sender=creator_address, + total=500_000, + decimals=3, + asset_name="DemoCoin", + unit_name="DEMO", + url="https://example.com/democoin", + default_frozen=False, + ) + ) + asset_id_2 = result2.asset_id + print_success(f"Created DemoCoin with Asset ID: {asset_id_2}") + print_info("") + except Exception as e: + print_error(f"Failed to create test assets: {e}") + print_info("") + print_info("If LocalNet errors occur, try: algokit localnet reset") + return + + # ========================================================================= + # Step 3: Lookup account assets with lookup_account_assets() + # ========================================================================= + print_step(3, "Looking up account asset holdings with lookup_account_assets()") + + try: + # lookup_account_assets() returns all assets held by an account + assets_result = indexer.lookup_account_assets(creator_address) + + print_success(f"Found {len(assets_result.assets or [])} asset holding(s) for account") + print_info("") + + if len(assets_result.assets or []) > 0: + print_info("Asset holdings:") + for holding in assets_result.assets or []: + print_info(f" Asset ID: {holding.asset_id}") + amount_formatted = f"{holding.amount:,}" + print_info(f" - amount: {amount_formatted}") + print_info(f" - is_frozen: {holding.is_frozen}") + if holding.opted_in_at_round is not None: + print_info(f" - opted_in_at_round: {holding.opted_in_at_round}") + print_info("") + + print_info(f"Query performed at round: {assets_result.current_round}") + except Exception as e: + print_error(f"lookup_account_assets failed: {e}") + + # ========================================================================= + # Step 4: Lookup account created assets with lookup_account_created_assets() + # ========================================================================= + print_step(4, "Looking up created assets with lookup_account_created_assets()") + + try: + # lookup_account_created_assets() returns assets created by an account + created_result = indexer.lookup_account_created_assets(creator_address) + + print_success(f"Found {len(created_result.assets or [])} asset(s) created by account") + print_info("") + + if len(created_result.assets or []) > 0: + print_info("Created assets:") + for asset in created_result.assets or []: + print_info(f" Asset ID: {asset.id_}") + if asset.params: + print_info(f" - creator: {shorten_address(asset.params.creator)}") + total_formatted = f"{asset.params.total:,}" + print_info(f" - total: {total_formatted}") + print_info(f" - decimals: {asset.params.decimals}") + asset_name = asset.params.name if asset.params.name else "(not set)" + print_info(f" - name: {asset_name}") + unit_name = asset.params.unit_name if asset.params.unit_name else "(not set)" + print_info(f" - unit_name: {unit_name}") + if asset.created_at_round is not None: + print_info(f" - created_at_round: {asset.created_at_round}") + print_info("") + + print_info(f"Query performed at round: {created_result.current_round}") + except Exception as e: + print_error(f"lookup_account_created_assets failed: {e}") + + # ========================================================================= + # Step 5: Demonstrate pagination with limit parameter + # ========================================================================= + print_step(5, "Demonstrating pagination with limit parameter") + + try: + # First query: get only 1 asset holding + print_info("Querying with limit=1...") + page1 = indexer.lookup_account_assets(creator_address, limit=1) + + print_info(f"Page 1: Retrieved {len(page1.assets or [])} asset(s)") + if len(page1.assets or []) > 0: + print_info(f" - Asset ID: {page1.assets[0].asset_id}") + + # Check if there are more results + if page1.next_token: + next_token_preview = str(page1.next_token)[:20] + print_info(f" - Next token available: {next_token_preview}...") + print_info("") + + # Second query: use the next token to get more results + print_info("Querying next page with next parameter...") + page2 = indexer.lookup_account_assets( + creator_address, + limit=1, + next_=page1.next_token, + ) + + print_info(f"Page 2: Retrieved {len(page2.assets or [])} asset(s)") + if len(page2.assets or []) > 0: + print_info(f" - Asset ID: {page2.assets[0].asset_id}") + + if page2.next_token: + print_info(" - More results available (next_token present)") + else: + print_info(" - No more results (no next_token)") + else: + print_info(" - No pagination needed (all results fit in one page)") + except Exception as e: + print_error(f"Pagination demo failed: {e}") + + # ========================================================================= + # Step 6: Query specific asset holding with asset_id filter + # ========================================================================= + print_step(6, "Querying specific asset holding with asset_id filter") + + try: + # You can filter lookup_account_assets by a specific asset_id + print_info(f"Querying holdings for Asset ID {asset_id_1} only...") + specific_result = indexer.lookup_account_assets( + creator_address, + asset_id=asset_id_1, + ) + + if len(specific_result.assets or []) > 0: + holding = specific_result.assets[0] + print_success(f"Found holding for Asset ID {asset_id_1}") + amount_formatted = f"{holding.amount:,}" + print_info(f" - amount: {amount_formatted}") + print_info(f" - is_frozen: {holding.is_frozen}") + else: + print_info(f"No holding found for Asset ID {asset_id_1}") + except Exception as e: + print_error(f"Specific asset query failed: {e}") + + # ========================================================================= + # Step 7: Query specific created asset with asset_id filter + # ========================================================================= + print_step(7, "Querying specific created asset with asset_id filter") + + try: + # You can also filter lookup_account_created_assets by a specific asset_id + print_info(f"Querying created asset with ID {asset_id_2} only...") + specific_created = indexer.lookup_account_created_assets( + creator_address, + asset_id=asset_id_2, + ) + + if len(specific_created.assets or []) > 0: + asset = specific_created.assets[0] + print_success(f"Found created asset with ID {asset_id_2}") + if asset.params: + asset_name = asset.params.name if asset.params.name else "(not set)" + print_info(f" - name: {asset_name}") + unit_name = asset.params.unit_name if asset.params.unit_name else "(not set)" + print_info(f" - unit_name: {unit_name}") + total_formatted = f"{asset.params.total:,}" + print_info(f" - total: {total_formatted}") + print_info(f" - decimals: {asset.params.decimals}") + else: + print_info(f"No created asset found with ID {asset_id_2}") + except Exception as e: + print_error(f"Specific created asset query failed: {e}") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. Creating test assets using AlgorandClient.send.asset_create()") + print_info(" 2. lookup_account_assets(address) - Get all assets held by an account") + print_info(" 3. lookup_account_created_assets(address) - Get assets created by an account") + print_info(" 4. Pagination using limit and next parameters") + print_info(" 5. Filtering by specific asset_id") + print_info("") + print_info("Key AssetHolding fields (from lookup_account_assets):") + print_info(" - asset_id: The asset identifier (int)") + print_info(" - amount: Number of units held (int)") + print_info(" - is_frozen: Whether the holding is frozen (bool)") + print_info(" - opted_in_at_round: Round when account opted into asset (optional int)") + print_info("") + print_info("Key Asset params fields (from lookup_account_created_assets):") + print_info(" - creator: Address that created the asset") + print_info(" - total: Total supply in base units (int)") + print_info(" - decimals: Number of decimal places (0-19)") + print_info(" - name: Full asset name (optional)") + print_info(" - unit_name: Short unit name like 'ALGO' (optional)") + print_info("") + print_info("Pagination parameters:") + print_info(" - limit: Maximum number of results per page") + print_info(" - next: Token from previous response to get next page") + + +if __name__ == "__main__": + main() diff --git a/examples/indexer_client/04_account_applications.py b/examples/indexer_client/04_account_applications.py new file mode 100644 index 00000000..96bdc97a --- /dev/null +++ b/examples/indexer_client/04_account_applications.py @@ -0,0 +1,357 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Account Applications + +This example demonstrates how to query account application relationships using +the IndexerClient lookup_account_created_applications() and lookup_account_app_local_states() methods. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from shared import ( + create_algorand_client, + create_indexer_client, + load_teal_source, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_transact import OnApplicationComplete +from algokit_utils.transactions.types import AppCallParams, AppCreateParams + + +def main() -> None: + print_header("Account Applications Example") + + # Create clients + indexer = create_indexer_client() + algorand = create_algorand_client() + + # ========================================================================= + # Step 1: Get a funded account from LocalNet + # ========================================================================= + print_step(1, "Getting a funded account from LocalNet") + + try: + creator = algorand.account.localnet_dispenser() + algorand.set_signer_from_account(creator) + creator_address = creator.addr + print_success(f"Using dispenser account: {shorten_address(creator_address)}") + except Exception as e: + print_error(f"Failed to get dispenser account: {e}") + print_info("") + print_info("Make sure LocalNet is running: algokit localnet start") + print_info("If issues persist, try: algokit localnet reset") + return + + # ========================================================================= + # Step 2: Deploy test applications using AlgorandClient + # ========================================================================= + print_step(2, "Deploying test applications for demonstration") + + try: + # Load TEAL programs from shared artifacts + approval_source = load_teal_source("approval-lifecycle-counter.teal") + clear_source = load_teal_source("clear-state-approve.teal") + print_info("Loaded TEAL source programs") + print_info("") + + # Create first application + print_info("Creating first test application: DemoApp1...") + result1 = algorand.send.app_create( + AppCreateParams( + sender=creator_address, + approval_program=approval_source, + clear_state_program=clear_source, + schema={ + "global_ints": 1, + "global_byte_slices": 0, + "local_ints": 1, + "local_byte_slices": 0, + }, + ) + ) + app_id_1 = result1.app_id + print_success(f"Created DemoApp1 with Application ID: {app_id_1}") + + # Create second application + print_info("Creating second test application: DemoApp2...") + result2 = algorand.send.app_create( + AppCreateParams( + sender=creator_address, + approval_program=approval_source, + clear_state_program=clear_source, + schema={ + "global_ints": 2, + "global_byte_slices": 1, + "local_ints": 2, + "local_byte_slices": 1, + }, + ) + ) + app_id_2 = result2.app_id + print_success(f"Created DemoApp2 with Application ID: {app_id_2}") + print_info("") + except Exception as e: + print_error(f"Failed to create test applications: {e}") + print_info("") + print_info("If LocalNet errors occur, try: algokit localnet reset") + return + + # ========================================================================= + # Step 3: Opt into an application to create local state + # ========================================================================= + print_step(3, "Opting into an application to create local state") + + try: + print_info(f"Opting into app {app_id_1}...") + + # Opt-in using the higher-level AlgorandClient API + algorand.send.app_call( + AppCallParams( + sender=creator_address, + app_id=app_id_1, + on_complete=OnApplicationComplete.OptIn, + ) + ) + + print_success(f"Successfully opted into app {app_id_1}") + print_info("") + except Exception as e: + print_error(f"Failed to opt into application: {e}") + # Continue anyway to demonstrate lookups + + # ========================================================================= + # Step 4: Lookup created applications with lookup_account_created_applications() + # ========================================================================= + print_step(4, "Looking up created applications with lookup_account_created_applications()") + + try: + # lookup_account_created_applications() returns applications created by an account + created_apps_result = indexer.lookup_account_created_applications(creator_address) + + print_success(f"Found {len(created_apps_result.applications or [])} application(s) created by account") + print_info("") + + if len(created_apps_result.applications or []) > 0: + print_info("Created applications:") + for app in created_apps_result.applications or []: + print_info(f" Application ID: {app.id_}") + if app.params: + if app.params.creator: + print_info(f" - creator: {shorten_address(app.params.creator)}") + if app.params.approval_program: + print_info(f" - approval_program: {len(app.params.approval_program)} bytes") + if app.params.clear_state_program: + print_info(f" - clear_state_program: {len(app.params.clear_state_program)} bytes") + if app.params.global_state_schema: + num_uints = app.params.global_state_schema.num_uints + num_bytes = app.params.global_state_schema.num_byte_slices + print_info(f" - global_state_schema: {num_uints} uints, {num_bytes} byte slices") + if app.params.local_state_schema: + num_uints = app.params.local_state_schema.num_uints + num_bytes = app.params.local_state_schema.num_byte_slices + print_info(f" - local_state_schema: {num_uints} uints, {num_bytes} byte slices") + if app.created_at_round is not None: + print_info(f" - created_at_round: {app.created_at_round}") + if app.params and app.params.global_state and len(app.params.global_state) > 0: + print_info(f" - global_state: {len(app.params.global_state)} key-value pair(s)") + print_info("") + + print_info(f"Query performed at round: {created_apps_result.current_round}") + except Exception as e: + print_error(f"lookup_account_created_applications failed: {e}") + + # ========================================================================= + # Step 5: Lookup account app local states with lookup_account_app_local_states() + # ========================================================================= + print_step(5, "Looking up app local states with lookup_account_app_local_states()") + + try: + # lookup_account_app_local_states() returns local state for applications the account has opted into + local_states_result = indexer.lookup_account_app_local_states(creator_address) + all_local_states = local_states_result.apps_local_states or [] + + print_success(f"Found {len(all_local_states)} app local state(s) for account") + print_info("") + + if len(all_local_states) > 0: + print_info("App local states:") + for local_state in all_local_states: + print_info(f" Application ID: {local_state.id_}") + if local_state.schema: + num_uints = local_state.schema.num_uints + num_bytes = local_state.schema.num_byte_slices + print_info(f" - schema: {num_uints} uints, {num_bytes} byte slices") + if local_state.opted_in_at_round is not None: + print_info(f" - opted_in_at_round: {local_state.opted_in_at_round}") + if local_state.key_value and len(local_state.key_value) > 0: + print_info(f" - key_value pairs: {len(local_state.key_value)}") + for kv in local_state.key_value: + # key is already bytes from deserialization + try: + key_str = kv.key.decode("utf-8") + except Exception: + key_str = str(kv.key) + # Value type_: 1 = bytes, 2 = uint + if kv.value.type_ == 2: + print_info(f' - "{key_str}": {kv.value.uint} (uint)') + else: + try: + value_str = kv.value.bytes_.decode("utf-8") + except Exception: + value_str = str(kv.value.bytes_) + print_info(f' - "{key_str}": "{value_str}" (bytes)') + else: + print_info(" - key_value: (empty)") + print_info("") + + print_info(f"Query performed at round: {local_states_result.current_round}") + except Exception as e: + print_error(f"lookup_account_app_local_states failed: {e}") + + # ========================================================================= + # Step 6: Demonstrate pagination with limit parameter + # ========================================================================= + print_step(6, "Demonstrating pagination with limit parameter") + + try: + # First query: get only 1 created application + print_info("Querying created applications with limit=1...") + page1 = indexer.lookup_account_created_applications(creator_address, limit=1) + + print_info(f"Page 1: Retrieved {len(page1.applications or [])} application(s)") + if len(page1.applications or []) > 0: + print_info(f" - Application ID: {page1.applications[0].id_}") + + # Check if there are more results + if page1.next_token: + next_token_preview = str(page1.next_token)[:20] + print_info(f" - Next token available: {next_token_preview}...") + print_info("") + + # Second query: use the next token to get more results + print_info("Querying next page with next parameter...") + page2 = indexer.lookup_account_created_applications( + creator_address, + limit=1, + next_=page1.next_token, + ) + + print_info(f"Page 2: Retrieved {len(page2.applications or [])} application(s)") + if len(page2.applications or []) > 0: + print_info(f" - Application ID: {page2.applications[0].id_}") + + if page2.next_token: + print_info(" - More results available (next_token present)") + else: + print_info(" - No more results (no next_token)") + else: + print_info(" - No pagination needed (all results fit in one page)") + except Exception as e: + print_error(f"Pagination demo failed: {e}") + + # ========================================================================= + # Step 7: Query specific application with application_id filter + # ========================================================================= + print_step(7, "Querying specific application with application_id filter") + + try: + # You can filter lookup_account_created_applications by a specific application_id + print_info(f"Querying created application with ID {app_id_1} only...") + specific_result = indexer.lookup_account_created_applications( + creator_address, + application_id=app_id_1, + ) + + if len(specific_result.applications or []) > 0: + app = specific_result.applications[0] + print_success(f"Found created application with ID {app_id_1}") + if app.params: + if app.params.global_state_schema: + num_uints = app.params.global_state_schema.num_uints + num_bytes = app.params.global_state_schema.num_byte_slices + print_info(f" - global_state_schema: {num_uints} uints, {num_bytes} byte slices") + if app.params.local_state_schema: + num_uints = app.params.local_state_schema.num_uints + num_bytes = app.params.local_state_schema.num_byte_slices + print_info(f" - local_state_schema: {num_uints} uints, {num_bytes} byte slices") + else: + print_info(f"No created application found with ID {app_id_1}") + except Exception as e: + print_error(f"Specific application query failed: {e}") + + # ========================================================================= + # Step 8: Query specific local state with application_id filter + # ========================================================================= + print_step(8, "Querying specific local state with application_id filter") + + try: + # You can also filter lookup_account_app_local_states by a specific application_id + print_info(f"Querying local state for application ID {app_id_1} only...") + specific_local_state = indexer.lookup_account_app_local_states( + creator_address, + application_id=app_id_1, + ) + + local_states = specific_local_state.apps_local_states or [] + if len(local_states) > 0: + local_state = local_states[0] + print_success(f"Found local state for application ID {app_id_1}") + if local_state.schema: + num_uints = local_state.schema.num_uints + num_bytes = local_state.schema.num_byte_slices + print_info(f" - schema: {num_uints} uints, {num_bytes} byte slices") + if local_state.key_value and len(local_state.key_value) > 0: + print_info(f" - key_value pairs: {len(local_state.key_value)}") + else: + print_info(f"No local state found for application ID {app_id_1}") + except Exception as e: + print_error(f"Specific local state query failed: {e}") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. Deploying test applications using TEAL compilation and AlgorandClient") + print_info(" 2. Opting into an application to create local state") + print_info(" 3. lookup_account_created_applications(address) - Get applications created by an account") + print_info(" 4. lookup_account_app_local_states(address) - Get application local states for an account") + print_info(" 5. Pagination using limit and next parameters") + print_info(" 6. Filtering by specific application_id") + print_info("") + print_info("Key Application fields (from lookup_account_created_applications):") + print_info(" - id: The application identifier (int)") + print_info(" - params.creator: Address that created the application") + print_info(" - params.approval_program: TEAL bytecode for approval logic (bytes)") + print_info(" - params.clear_state_program: TEAL bytecode for clear state logic (bytes)") + print_info(" - params.global_state_schema: {num_uint, num_byte_slice} for global storage") + print_info(" - params.local_state_schema: {num_uint, num_byte_slice} for per-user storage") + print_info(" - params.global_state: Array of TealKeyValue for current global state") + print_info(" - created_at_round: Round when application was created (optional int)") + print_info("") + print_info("Key ApplicationLocalState fields (from lookup_account_app_local_states):") + print_info(" - id: The application identifier (int)") + print_info(" - schema: {num_uint, num_byte_slice} for allocated local storage") + print_info(" - opted_in_at_round: Round when account opted in (optional int)") + print_info(" - key_value: Array of TealKeyValue for current local state") + print_info("") + print_info("TealKeyValue structure:") + print_info(" - key: The key as base64-encoded string") + print_info(" - value.type: 1 for bytes, 2 for uint") + print_info(" - value.bytes: Byte value as base64-encoded string") + print_info(" - value.uint: Integer value as int") + print_info("") + print_info("Pagination parameters:") + print_info(" - limit: Maximum number of results per page") + print_info(" - next: Token from previous response to get next page") + + +if __name__ == "__main__": + main() diff --git a/examples/indexer_client/05_account_transactions.py b/examples/indexer_client/05_account_transactions.py new file mode 100644 index 00000000..8ae85959 --- /dev/null +++ b/examples/indexer_client/05_account_transactions.py @@ -0,0 +1,447 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Account Transactions + +This example demonstrates how to query an account's transaction history using +the IndexerClient lookup_account_transactions() method. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import time +from datetime import datetime, timezone + +from shared import ( + create_algorand_client, + create_indexer_client, + format_micro_algo, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_utils import AlgoAmount, AssetCreateParams, AssetOptInParams, AssetTransferParams, PaymentParams + + +def main() -> None: + print_header("Account Transactions Example") + + # Create clients + indexer = create_indexer_client() + algorand = create_algorand_client() + + # ========================================================================= + # Step 1: Get a funded account from LocalNet + # ========================================================================= + print_step(1, "Getting a funded account from LocalNet") + + try: + sender = algorand.account.localnet_dispenser() + sender_address = sender.addr + algorand.set_signer_from_account(sender) + print_success(f"Using dispenser account: {shorten_address(sender_address)}") + except Exception as e: + print_error(f"Failed to get dispenser account: {e}") + print_info("") + print_info("Make sure LocalNet is running: algokit localnet start") + print_info("If issues persist, try: algokit localnet reset") + return + + # ========================================================================= + # Step 2: Create test transactions for demonstration + # ========================================================================= + print_step(2, "Creating test transactions for demonstration") + + try: + # Create a random receiver account + receiver = algorand.account.random() + receiver_address = receiver.addr + algorand.set_signer_from_account(receiver) + print_info(f"Created receiver account: {shorten_address(receiver_address)}") + + # Fund the receiver with some initial ALGO + print_info("Sending initial payment to receiver...") + algorand.send.payment( + PaymentParams( + sender=sender_address, + receiver=receiver_address, + amount=AlgoAmount.from_algo(10), + ) + ) + print_success("Initial payment sent: 10 ALGO") + + # Send a few more payments with different amounts + print_info("Sending additional payments...") + algorand.send.payment( + PaymentParams( + sender=sender_address, + receiver=receiver_address, + amount=AlgoAmount.from_algo(5), + ) + ) + print_success("Payment sent: 5 ALGO") + + algorand.send.payment( + PaymentParams( + sender=sender_address, + receiver=receiver_address, + amount=AlgoAmount.from_micro_algo(500_000), # 0.5 ALGO + ) + ) + print_success("Payment sent: 0.5 ALGO") + + # Create an asset + print_info("Creating a test asset...") + asset_create_result = algorand.send.asset_create( + AssetCreateParams( + sender=sender_address, + total=1_000_000, + decimals=6, + asset_name="TestToken", + unit_name="TEST", + ) + ) + asset_id = asset_create_result.asset_id + print_success(f"Created asset: TestToken (ID: {asset_id})") + + # Opt-in receiver to the asset + print_info("Opting receiver into asset...") + algorand.send.asset_opt_in( + AssetOptInParams( + sender=receiver_address, + asset_id=asset_id, + ) + ) + print_success("Receiver opted into asset") + + # Transfer some assets + print_info("Sending asset transfer...") + algorand.send.asset_transfer( + AssetTransferParams( + sender=sender_address, + receiver=receiver_address, + asset_id=asset_id, + amount=100_000, + ) + ) + print_success("Asset transfer sent: 100,000 TestToken (0.1 TEST)") + + # Small delay to allow indexer to catch up + print_info("Waiting for indexer to index transactions...") + time.sleep(3) + print_info("") + except Exception as e: + print_error(f"Failed to create test transactions: {e}") + print_info("") + print_info("If LocalNet errors occur, try: algokit localnet reset") + return + + # ========================================================================= + # Step 3: Lookup account transactions with lookup_account_transactions() + # ========================================================================= + print_step(3, "Looking up account transactions with lookup_account_transactions()") + + try: + # Note: Results are returned newest to oldest for account transactions + txns_result = indexer.lookup_account_transactions(sender_address) + + print_success(f"Found {len(txns_result.transactions or [])} transaction(s) for account") + print_info("Note: Results are returned newest to oldest") + print_info("") + + if len(txns_result.transactions or []) > 0: + print_info("Recent transactions:") + for tx in (txns_result.transactions or [])[:5]: + tx_id_short = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + print_info(f" Transaction ID: {tx_id_short}") + print_info(f" - tx_type: {tx.tx_type}") + print_info(f" - sender: {shorten_address(tx.sender)}") + print_info(f" - fee: {format_micro_algo(tx.fee)}") + if tx.confirmed_round is not None: + print_info(f" - confirmed_round: {tx.confirmed_round}") + if tx.round_time is not None: + date = datetime.fromtimestamp(tx.round_time, tz=timezone.utc) + print_info(f" - round_time: {date.isoformat()}") + # Show payment details if present + if tx.payment_transaction: + print_info(f" - receiver: {shorten_address(tx.payment_transaction.receiver)}") + print_info(f" - amount: {format_micro_algo(tx.payment_transaction.amount)}") + # Show asset transfer details if present + if tx.asset_transfer_transaction: + print_info(f" - asset_id: {tx.asset_transfer_transaction.asset_id}") + print_info(f" - amount: {tx.asset_transfer_transaction.amount}") + print_info(f" - receiver: {shorten_address(tx.asset_transfer_transaction.receiver)}") + # Show asset config details if present + if tx.asset_config_transaction: + acfg_asset_id = tx.asset_config_transaction.asset_id + asset_id_display = acfg_asset_id if acfg_asset_id else "new asset" + print_info(f" - asset_id: {asset_id_display}") + if tx.created_asset_id: + print_info(f" - created_asset_id: {tx.created_asset_id}") + print_info("") + + print_info(f"Query performed at round: {txns_result.current_round}") + except Exception as e: + print_error(f"lookup_account_transactions failed: {e}") + + # ========================================================================= + # Step 4: Filter by transaction type (pay, axfer, appl) + # ========================================================================= + print_step(4, "Filtering by transaction type (tx_type)") + + try: + # Filter for payment transactions only + print_info("Querying payment transactions (tx_type=pay)...") + pay_txns = indexer.lookup_account_transactions(sender_address, tx_type="pay") + print_success(f"Found {len(pay_txns.transactions or [])} payment transaction(s)") + + if len(pay_txns.transactions or []) > 0: + for tx in pay_txns.transactions[:3]: + tx_id_short = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + amount = tx.payment_transaction.amount if tx.payment_transaction else 0 + print_info(f" - {tx_id_short}: {format_micro_algo(amount)}") + print_info("") + + # Filter for asset transfer transactions + print_info("Querying asset transfer transactions (tx_type=axfer)...") + axfer_txns = indexer.lookup_account_transactions(sender_address, tx_type="axfer") + print_success(f"Found {len(axfer_txns.transactions or [])} asset transfer transaction(s)") + + if len(axfer_txns.transactions or []) > 0: + for tx in axfer_txns.transactions[:3]: + tx_id_short = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + asset_id_val = tx.asset_transfer_transaction.asset_id if tx.asset_transfer_transaction else "N/A" + amount = tx.asset_transfer_transaction.amount if tx.asset_transfer_transaction else "N/A" + print_info(f" - {tx_id_short}: asset_id={asset_id_val}, amount={amount}") + print_info("") + + # Filter for asset config transactions + print_info("Querying asset config transactions (tx_type=acfg)...") + acfg_txns = indexer.lookup_account_transactions(sender_address, tx_type="acfg") + print_success(f"Found {len(acfg_txns.transactions or [])} asset config transaction(s)") + + if len(acfg_txns.transactions or []) > 0: + for tx in acfg_txns.transactions[:3]: + tx_id_short = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + asset_id_display = tx.created_asset_id + if not asset_id_display and tx.asset_config_transaction: + asset_id_display = tx.asset_config_transaction.asset_id + if not asset_id_display: + asset_id_display = "N/A" + print_info(f" - {tx_id_short}: asset_id={asset_id_display}") + except Exception as e: + print_error(f"Transaction type filter failed: {e}") + + # ========================================================================= + # Step 5: Filter by round range (min_round, max_round) + # ========================================================================= + print_step(5, "Filtering by round range (min_round, max_round)") + + try: + # Get current round + all_txns = indexer.lookup_account_transactions(sender_address, limit=1) + current_round = all_txns.current_round + + # Filter to recent rounds only (last 100 rounds, but not negative) + min_round = current_round - 100 if current_round > 100 else 0 + print_info(f"Querying transactions from round {min_round} to {current_round}...") + + round_filtered_txns = indexer.lookup_account_transactions( + sender_address, + min_round=min_round, + max_round=current_round, + ) + + txn_count = len(round_filtered_txns.transactions or []) + print_success(f"Found {txn_count} transaction(s) in round range {min_round}-{current_round}") + + if len(round_filtered_txns.transactions or []) > 0: + rounds = [tx.confirmed_round for tx in round_filtered_txns.transactions if tx.confirmed_round is not None] + if rounds: + min_found_round = min(rounds) + max_found_round = max(rounds) + print_info(f" Rounds of found transactions: {min_found_round} to {max_found_round}") + except Exception as e: + print_error(f"Round filter failed: {e}") + + # ========================================================================= + # Step 6: Filter by time (before_time, after_time) + # ========================================================================= + print_step(6, "Filtering by time (before_time, after_time)") + + try: + # Get current time and a time window + now = datetime.now(tz=timezone.utc) + one_hour_ago = datetime.fromtimestamp(now.timestamp() - 60 * 60, tz=timezone.utc) + + # Format as RFC 3339 (ISO 8601 format that indexer expects) + after_time_str = one_hour_ago.isoformat() + before_time_str = now.isoformat() + + print_info(f"Querying transactions from {after_time_str} to {before_time_str}...") + + time_filtered_txns = indexer.lookup_account_transactions( + sender_address, + after_time=after_time_str, + before_time=before_time_str, + ) + + print_success(f"Found {len(time_filtered_txns.transactions or [])} transaction(s) in the last hour") + + if len(time_filtered_txns.transactions or []) > 0: + times = [tx.round_time for tx in time_filtered_txns.transactions if tx.round_time is not None] + if times: + min_time = min(times) + max_time = max(times) + print_info(" Time range of found transactions:") + print_info(f" - Earliest: {datetime.fromtimestamp(min_time, tz=timezone.utc).isoformat()}") + print_info(f" - Latest: {datetime.fromtimestamp(max_time, tz=timezone.utc).isoformat()}") + except Exception as e: + print_error(f"Time filter failed: {e}") + + # ========================================================================= + # Step 7: Filter by amount (currency_greater_than, currency_less_than) + # ========================================================================= + print_step(7, "Filtering by amount (currency_greater_than, currency_less_than)") + + try: + # Filter for transactions with amount greater than 1 ALGO (1,000,000 microAlgo) + min_amount = 1_000_000 + print_info(f"Querying transactions with amount > {format_micro_algo(min_amount)}...") + + large_amount_txns = indexer.lookup_account_transactions( + sender_address, + currency_greater_than=min_amount, + ) + + print_success(f"Found {len(large_amount_txns.transactions or [])} transaction(s) with amount > 1 ALGO") + + if len(large_amount_txns.transactions or []) > 0: + for tx in large_amount_txns.transactions[:3]: + tx_id_short = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + amount = 0 + if tx.payment_transaction: + amount = tx.payment_transaction.amount + elif tx.asset_transfer_transaction: + amount = tx.asset_transfer_transaction.amount + print_info(f" - {tx_id_short}: {tx.tx_type}, amount={amount}") + print_info("") + + # Filter for transactions with amount less than 5 ALGO (5,000,000 microAlgo) + max_amount = 5_000_000 + print_info(f"Querying transactions with amount < {format_micro_algo(max_amount)}...") + + small_amount_txns = indexer.lookup_account_transactions( + sender_address, + currency_less_than=max_amount, + ) + + print_success(f"Found {len(small_amount_txns.transactions or [])} transaction(s) with amount < 5 ALGO") + + if len(small_amount_txns.transactions or []) > 0: + for tx in small_amount_txns.transactions[:3]: + tx_id_short = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + amount = 0 + if tx.payment_transaction: + amount = tx.payment_transaction.amount + elif tx.asset_transfer_transaction: + amount = tx.asset_transfer_transaction.amount + print_info(f" - {tx_id_short}: {tx.tx_type}, amount={amount}") + print_info("") + + # Combine both filters to find transactions in a specific range + min_fmt = format_micro_algo(min_amount) + max_fmt = format_micro_algo(max_amount) + print_info(f"Querying transactions with amount between {min_fmt} and {max_fmt}...") + + range_amount_txns = indexer.lookup_account_transactions( + sender_address, + currency_greater_than=min_amount, + currency_less_than=max_amount, + ) + + print_success(f"Found {len(range_amount_txns.transactions or [])} transaction(s) with amount in range 1-5 ALGO") + except Exception as e: + print_error(f"Amount filter failed: {e}") + + # ========================================================================= + # Step 8: Pagination with limit and next + # ========================================================================= + print_step(8, "Demonstrating pagination with limit and next") + + try: + print_info("Querying transactions with limit=2...") + page1 = indexer.lookup_account_transactions(sender_address, limit=2) + + print_info(f"Page 1: Retrieved {len(page1.transactions or [])} transaction(s)") + for tx in page1.transactions or []: + tx_id_short = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + print_info(f" - {tx_id_short}: {tx.tx_type}") + + if page1.next_token: + next_token_preview = str(page1.next_token)[:20] + print_info(f" - Next token available: {next_token_preview}...") + print_info("") + + # Get next page + print_info("Querying next page...") + page2 = indexer.lookup_account_transactions( + sender_address, + limit=2, + next_=page1.next_token, + ) + + print_info(f"Page 2: Retrieved {len(page2.transactions or [])} transaction(s)") + for tx in page2.transactions or []: + tx_id_short = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + print_info(f" - {tx_id_short}: {tx.tx_type}") + + if page2.next_token: + print_info(" - More pages available (next_token present)") + else: + print_info(" - No more pages (no next_token)") + else: + print_info(" - No pagination needed (all results fit in one page)") + except Exception as e: + print_error(f"Pagination demo failed: {e}") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. lookup_account_transactions(address) - Get transaction history for an account") + print_info(" 2. Results are returned newest to oldest") + print_info(" 3. Filtering by tx_type (pay, axfer, acfg, appl, etc.)") + print_info(" 4. Filtering by round range (min_round, max_round)") + print_info(" 5. Filtering by time (before_time, after_time) using RFC 3339 format") + print_info(" 6. Filtering by amount (currency_greater_than, currency_less_than)") + print_info(" 7. Pagination using limit and next parameters") + print_info("") + print_info("Key Transaction fields:") + print_info(" - id: Transaction ID (string)") + print_info(" - tx_type: Transaction type (pay, keyreg, acfg, axfer, afrz, appl, stpf, hb)") + print_info(" - sender: Sender address (string)") + print_info(" - fee: Transaction fee in microAlgos (int)") + print_info(" - confirmed_round: Round when confirmed (int)") + print_info(" - round_time: Unix timestamp when confirmed (int)") + print_info(" - payment_transaction: Payment details (receiver, amount, close_remainder_to)") + print_info(" - asset_transfer_transaction: Asset transfer details (asset_id, amount, receiver)") + print_info(" - asset_config_transaction: Asset config details (asset_id, params)") + print_info(" - application_transaction: App call details (application_id, on_complete, etc.)") + print_info("") + print_info("Filter parameters:") + print_info(" - tx_type: Filter by transaction type") + print_info(" - min_round/max_round: Filter by round range") + print_info(" - before_time/after_time: Filter by time (RFC 3339 format)") + print_info(" - currency_greater_than/currency_less_than: Filter by amount") + print_info(" - asset_id: Filter by specific asset") + print_info(" - limit/next: Pagination controls") + + +if __name__ == "__main__": + main() diff --git a/examples/indexer_client/06_transaction_lookup.py b/examples/indexer_client/06_transaction_lookup.py new file mode 100644 index 00000000..6d0830e9 --- /dev/null +++ b/examples/indexer_client/06_transaction_lookup.py @@ -0,0 +1,366 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Transaction Lookup + +This example demonstrates how to lookup a single transaction by ID using +the IndexerClient lookup_transaction_by_id() method. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import base64 +import time +from datetime import datetime, timezone + +from shared import ( + create_algorand_client, + create_indexer_client, + format_micro_algo, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_utils import AlgoAmount, AssetCreateParams, AssetOptInParams, AssetTransferParams, PaymentParams + + +def main() -> None: + print_header("Transaction Lookup Example") + + # Create clients + indexer = create_indexer_client() + algorand = create_algorand_client() + + # ========================================================================= + # Step 1: Get a funded account from LocalNet + # ========================================================================= + print_step(1, "Getting a funded account from LocalNet") + + try: + sender = algorand.account.localnet_dispenser() + algorand.set_signer_from_account(sender) + sender_address = sender.addr + print_success(f"Using dispenser account: {shorten_address(sender_address)}") + except Exception as e: + print_error(f"Failed to get dispenser account: {e}") + print_info("") + print_info("Make sure LocalNet is running: algokit localnet start") + print_info("If issues persist, try: algokit localnet reset") + return + + # ========================================================================= + # Step 2: Create a test transaction and capture its txId + # ========================================================================= + print_step(2, "Creating a test transaction and capturing its txId") + + try: + # Create a random receiver account + receiver = algorand.account.random() + receiver_address = receiver.addr + algorand.set_signer_from_account(receiver) + print_info(f"Created receiver account: {shorten_address(receiver_address)}") + + # Send a payment transaction + print_info("Sending payment transaction...") + payment_result = algorand.send.payment( + PaymentParams( + sender=sender_address, + receiver=receiver_address, + amount=AlgoAmount.from_algo(5), + ) + ) + payment_tx_id = payment_result.tx_ids[0] + print_success(f"Payment transaction sent: {shorten_address(payment_tx_id, 8, 6)}") + print_info(f" Full txId: {payment_tx_id}") + + # Create an asset for asset transfer demonstration + print_info("Creating a test asset...") + asset_create_result = algorand.send.asset_create( + AssetCreateParams( + sender=sender_address, + total=1_000_000, + decimals=6, + asset_name="LookupToken", + unit_name="LOOK", + ) + ) + asset_id = asset_create_result.asset_id + print_success(f"Created asset: LookupToken (ID: {asset_id})") + + # Opt-in receiver to the asset + print_info("Opting receiver into asset...") + algorand.send.asset_opt_in( + AssetOptInParams( + sender=receiver_address, + asset_id=asset_id, + ) + ) + print_success("Receiver opted into asset") + + # Send an asset transfer transaction + print_info("Sending asset transfer transaction...") + asset_transfer_result = algorand.send.asset_transfer( + AssetTransferParams( + sender=sender_address, + receiver=receiver_address, + asset_id=asset_id, + amount=50_000, + ) + ) + asset_transfer_tx_id = asset_transfer_result.tx_ids[0] + print_success(f"Asset transfer transaction sent: {shorten_address(asset_transfer_tx_id, 8, 6)}") + print_info(f" Full txId: {asset_transfer_tx_id}") + + # Wait for indexer to catch up + print_info("Waiting for indexer to index transactions...") + time.sleep(3) + print_info("") + except Exception as e: + print_error(f"Failed to create test transactions: {e}") + print_info("") + print_info("If LocalNet errors occur, try: algokit localnet reset") + return + + # ========================================================================= + # Step 3: Lookup payment transaction by ID + # ========================================================================= + print_step(3, "Looking up payment transaction by ID") + + try: + txn_result = indexer.lookup_transaction_by_id(payment_tx_id) + tx = txn_result.transaction + + print_success("Transaction found!") + print_info("") + print_info("Common transaction fields:") + print_info(f" - id: {tx.id_}") + print_info(f" - tx_type: {tx.tx_type}") + print_info(f" - sender: {shorten_address(tx.sender)}") + print_info(f" - fee: {format_micro_algo(tx.fee)}") + print_info(f" - first_valid: {tx.first_valid}") + print_info(f" - last_valid: {tx.last_valid}") + print_info("") + + print_info("Confirmation info:") + if tx.confirmed_round is not None: + print_info(f" - confirmed_round: {tx.confirmed_round}") + if tx.round_time is not None: + date = datetime.fromtimestamp(tx.round_time, tz=timezone.utc) + print_info(f" - round_time: {date.isoformat()} (Unix: {tx.round_time})") + if tx.intra_round_offset is not None: + print_info(f" - intra_round_offset: {tx.intra_round_offset}") + print_info("") + + # Display payment-specific fields + if tx.payment_transaction: + print_info("Payment transaction details:") + print_info(f" - receiver: {shorten_address(tx.payment_transaction.receiver)}") + print_info(f" - amount: {format_micro_algo(tx.payment_transaction.amount)}") + if tx.payment_transaction.close_remainder_to: + print_info(f" - close_remainder_to: {shorten_address(tx.payment_transaction.close_remainder_to)}") + if tx.payment_transaction.close_amount is not None: + print_info(f" - close_amount: {format_micro_algo(tx.payment_transaction.close_amount)}") + + print_info("") + print_info(f"Query performed at round: {txn_result.current_round}") + except Exception as e: + print_error(f"lookup_transaction_by_id failed: {e}") + + # ========================================================================= + # Step 4: Lookup asset transfer transaction by ID + # ========================================================================= + print_step(4, "Looking up asset transfer transaction by ID") + + try: + txn_result = indexer.lookup_transaction_by_id(asset_transfer_tx_id) + tx = txn_result.transaction + + print_success("Transaction found!") + print_info("") + print_info("Common transaction fields:") + print_info(f" - id: {tx.id_}") + print_info(f" - tx_type: {tx.tx_type}") + print_info(f" - sender: {shorten_address(tx.sender)}") + print_info(f" - fee: {format_micro_algo(tx.fee)}") + print_info(f" - first_valid: {tx.first_valid}") + print_info(f" - last_valid: {tx.last_valid}") + print_info("") + + print_info("Confirmation info:") + if tx.confirmed_round is not None: + print_info(f" - confirmed_round: {tx.confirmed_round}") + if tx.round_time is not None: + date = datetime.fromtimestamp(tx.round_time, tz=timezone.utc) + print_info(f" - round_time: {date.isoformat()} (Unix: {tx.round_time})") + if tx.intra_round_offset is not None: + print_info(f" - intra_round_offset: {tx.intra_round_offset}") + print_info("") + + # Display asset transfer-specific fields + if tx.asset_transfer_transaction: + print_info("Asset transfer transaction details:") + print_info(f" - asset_id: {tx.asset_transfer_transaction.asset_id}") + print_info(f" - amount: {tx.asset_transfer_transaction.amount}") + print_info(f" - receiver: {shorten_address(tx.asset_transfer_transaction.receiver)}") + if tx.asset_transfer_transaction.sender: + print_info(f" - sender (clawback): {shorten_address(tx.asset_transfer_transaction.sender)}") + if tx.asset_transfer_transaction.close_to: + print_info(f" - close_to: {shorten_address(tx.asset_transfer_transaction.close_to)}") + if tx.asset_transfer_transaction.close_amount is not None: + print_info(f" - close_amount: {tx.asset_transfer_transaction.close_amount}") + + print_info("") + print_info(f"Query performed at round: {txn_result.current_round}") + except Exception as e: + print_error(f"lookup_transaction_by_id failed: {e}") + + # ========================================================================= + # Step 5: Handle transaction not found case + # ========================================================================= + print_step(5, "Handling transaction not found case") + + try: + # Use a fake transaction ID that doesn't exist (valid base32 format, 52 chars) + fake_tx_id = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + print_info(f"Attempting to lookup non-existent transaction: {shorten_address(fake_tx_id, 8, 6)}") + + indexer.lookup_transaction_by_id(fake_tx_id) + + # If we get here, the transaction was somehow found (shouldn't happen) + print_info("Transaction was unexpectedly found") + except Exception as e: + error_message = str(e) + if "not found" in error_message.lower() or "no transactions" in error_message.lower(): + print_success("Transaction not found - error handled correctly") + print_info(f" Error message: {error_message}") + else: + print_error(f"Unexpected error: {error_message}") + + # ========================================================================= + # Step 6: Display additional transaction fields (if available) + # ========================================================================= + print_step(6, "Displaying additional transaction fields") + + try: + txn_result = indexer.lookup_transaction_by_id(payment_tx_id) + tx = txn_result.transaction + + print_info("Additional fields (if present):") + + if tx.genesis_id: + print_info(f" - genesis_id: {tx.genesis_id}") + + if tx.genesis_hash: + if isinstance(tx.genesis_hash, bytes): + hash_b64 = base64.b64encode(tx.genesis_hash).decode() + else: + hash_b64 = tx.genesis_hash + hash_preview = hash_b64[:20] if len(hash_b64) > 20 else hash_b64 + print_info(f" - genesis_hash: {hash_preview}...") + + if tx.group: + group_b64 = base64.b64encode(tx.group).decode() if isinstance(tx.group, bytes) else tx.group + print_info(f" - group: {group_b64}") + + if tx.note: + try: + note_bytes = tx.note if isinstance(tx.note, bytes) else base64.b64decode(tx.note) + note_text = note_bytes.decode("utf-8") if note_bytes else "(empty)" + except Exception: + note_text = "(binary data)" + print_info(f" - note: {note_text}") + + if tx.lease: + lease_b64 = base64.b64encode(tx.lease).decode() if isinstance(tx.lease, bytes) else tx.lease + print_info(f" - lease: {lease_b64}") + + if tx.rekey_to: + print_info(f" - rekey_to: {tx.rekey_to}") + + if tx.sender_rewards is not None: + print_info(f" - sender_rewards: {format_micro_algo(tx.sender_rewards)}") + + if tx.receiver_rewards is not None: + print_info(f" - receiver_rewards: {format_micro_algo(tx.receiver_rewards)}") + + if tx.close_rewards is not None: + print_info(f" - close_rewards: {format_micro_algo(tx.close_rewards)}") + + if tx.closing_amount is not None: + print_info(f" - closing_amount: {format_micro_algo(tx.closing_amount)}") + + if tx.auth_addr: + print_info(f" - auth_addr: {tx.auth_addr}") + + if tx.signature: + print_info(" - signature: (present)") + if hasattr(tx.signature, "sig") and tx.signature.sig: + print_info(" - type: single signature") + if hasattr(tx.signature, "multisig") and tx.signature.multisig: + print_info(" - type: multisig") + if hasattr(tx.signature, "logicsig") and tx.signature.logicsig: + print_info(" - type: logic signature") + + # Check for created assets or applications + if tx.created_asset_id is not None: + print_info(f" - created_asset_id: {tx.created_asset_id}") + if tx.created_app_id is not None: + print_info(f" - created_app_id: {tx.created_app_id}") + + # Inner transactions (for app calls) + if tx.inner_txns and len(tx.inner_txns) > 0: + print_info(f" - inner_txns: {len(tx.inner_txns)} inner transaction(s)") + + # Logs (for app calls) + if tx.logs and len(tx.logs) > 0: + print_info(f" - logs: {len(tx.logs)} log entry(ies)") + + # State deltas (for app calls) + if tx.global_state_delta: + print_info(" - global_state_delta: (present)") + if tx.local_state_delta and len(tx.local_state_delta) > 0: + print_info(f" - local_state_delta: {len(tx.local_state_delta)} account(s) affected") + except Exception as e: + print_error(f"Failed to display additional fields: {e}") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. lookup_transaction_by_id(txId) - Get full transaction details by ID") + print_info(" 2. Displaying common transaction fields: id, tx_type, sender, fee, first_valid, last_valid") + print_info(" 3. Displaying confirmation info: confirmed_round, round_time, intra_round_offset") + print_info(" 4. Displaying payment-specific fields: receiver, amount, close_remainder_to") + print_info(" 5. Displaying asset transfer-specific fields: asset_id, amount, receiver") + print_info(" 6. Handling transaction not found errors") + print_info(" 7. Displaying additional fields: genesis_id, note, signature, etc.") + print_info("") + print_info("TransactionResponse structure:") + print_info(" - transaction: The full Transaction object") + print_info(" - current_round: Round at which the results were computed") + print_info("") + print_info("Key Transaction fields:") + print_info(" - id: Transaction ID (string)") + print_info(" - tx_type: Transaction type (pay, keyreg, acfg, axfer, afrz, appl, stpf, hb)") + print_info(" - sender: Sender address (string)") + print_info(" - fee: Transaction fee in microAlgos (int)") + print_info(" - first_valid: First valid round (int)") + print_info(" - last_valid: Last valid round (int)") + print_info(" - confirmed_round: Round when confirmed (int, optional)") + print_info(" - round_time: Unix timestamp when confirmed (int, optional)") + print_info(" - intra_round_offset: Position within the round (int, optional)") + print_info("") + print_info("Type-specific fields:") + print_info(" - payment_transaction: { receiver, amount, close_remainder_to, close_amount }") + print_info(" - asset_transfer_transaction: { asset_id, amount, receiver, sender, close_to, close_amount }") + print_info(" - asset_config_transaction: { asset_id, params }") + print_info(" - application_transaction: { application_id, on_complete, accounts, etc. }") + + +if __name__ == "__main__": + main() diff --git a/examples/indexer_client/07_transaction_search.py b/examples/indexer_client/07_transaction_search.py new file mode 100644 index 00000000..9a8ec120 --- /dev/null +++ b/examples/indexer_client/07_transaction_search.py @@ -0,0 +1,580 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Transaction Search + +This example demonstrates how to search for transactions with various filters using +the IndexerClient search_for_transactions() method. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import base64 +import time +from datetime import datetime, timezone + +from shared import ( + create_algod_client, + create_algorand_client, + create_indexer_client, + format_micro_algo, + load_teal_source, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, + wait_for_confirmation, +) + +from algokit_utils import AlgoAmount, AssetCreateParams, AssetOptInParams, AssetTransferParams, PaymentParams +from algokit_utils.transactions.types import AppCreateParams + + +def main() -> None: + print_header("Transaction Search Example") + + # Create clients + indexer = create_indexer_client() + algorand = create_algorand_client() + algod = create_algod_client() + + # ========================================================================= + # Step 1: Get a funded account from LocalNet + # ========================================================================= + print_step(1, "Getting a funded account from LocalNet") + + try: + sender_account = algorand.account.localnet_dispenser() + algorand.set_signer_from_account(sender_account) + sender_address = sender_account.addr + print_success(f"Using dispenser account: {shorten_address(sender_address)}") + except Exception as e: + print_error(f"Failed to get dispenser account: {e}") + print_info("") + print_info("Make sure LocalNet is running: algokit localnet start") + print_info("If issues persist, try: algokit localnet reset") + return + + # ========================================================================= + # Step 2: Create several different transaction types for setup + # ========================================================================= + print_step(2, "Creating several different transaction types for setup") + + try: + # Get the current round before creating transactions + status = algod.status() + start_round = status.last_round + + # Create a random receiver account + receiver_account = algorand.account.random() + receiver_address = receiver_account.addr + algorand.set_signer_from_account(receiver_account) + print_info(f"Created receiver account: {shorten_address(receiver_address)}") + + # 1. Payment transaction + print_info("Creating payment transaction...") + algorand.send.payment( + PaymentParams( + sender=sender_address, + receiver=receiver_address, + amount=AlgoAmount.from_algo(10), + ) + ) + print_success("Payment sent: 10 ALGO") + + # 2. Another payment with different amount + print_info("Creating another payment transaction...") + algorand.send.payment( + PaymentParams( + sender=sender_address, + receiver=receiver_address, + amount=AlgoAmount.from_algo(5), + ) + ) + print_success("Payment sent: 5 ALGO") + + # 3. Asset creation (acfg transaction) + print_info("Creating asset config transaction (asset creation)...") + asset_create_result = algorand.send.asset_create( + AssetCreateParams( + sender=sender_address, + total=1_000_000, + decimals=6, + asset_name="SearchTestToken", + unit_name="SRCH", + ) + ) + asset_id = asset_create_result.asset_id + print_success(f"Created asset: SearchTestToken (ID: {asset_id})") + + # 4. Asset opt-in (axfer to self with 0 amount) + print_info("Creating asset opt-in transaction...") + algorand.send.asset_opt_in( + AssetOptInParams( + sender=receiver_address, + asset_id=asset_id, + ) + ) + print_success("Receiver opted into asset") + + # 5. Asset transfer (axfer) + print_info("Creating asset transfer transaction...") + algorand.send.asset_transfer( + AssetTransferParams( + sender=sender_address, + receiver=receiver_address, + asset_id=asset_id, + amount=50_000, + ) + ) + print_success("Asset transfer sent: 50,000 units") + + # 6. Application creation (appl transaction) + print_info("Creating application transaction...") + # Load simple approval/clear programs from shared artifacts + approval_source = load_teal_source("clear-state-approve.teal") + clear_source = load_teal_source("clear-state-approve.teal") + + approval_result = algod.teal_compile(approval_source.encode()) + approval_program = base64.b64decode(approval_result.result) + + clear_result = algod.teal_compile(clear_source.encode()) + clear_program = base64.b64decode(clear_result.result) + + # Create the app transaction + txn = algorand.create_transaction.app_create( + AppCreateParams( + sender=sender_address, + approval_program=approval_program, + clear_state_program=clear_program, + schema={ + "global_ints": 0, + "global_byte_slices": 0, + "local_ints": 0, + "local_byte_slices": 0, + }, + ) + ) + + # Sign and send + signed_txn = sender_account.signer([txn], [0]) + result = algod.send_raw_transaction(signed_txn) + tx_id = result.tx_id + pending = wait_for_confirmation(algod, tx_id) + app_id = pending.app_id + print_success(f"Created application: ID {app_id}") + + # Small delay to allow indexer to catch up + print_info("Waiting for indexer to index transactions...") + time.sleep(3) + print_info("") + except Exception as e: + print_error(f"Failed to create test transactions: {e}") + print_info("") + print_info("If LocalNet errors occur, try: algokit localnet reset") + return + + # ========================================================================= + # Step 3: Search for transactions with default parameters + # ========================================================================= + print_step(3, "Searching for transactions with default parameters") + + try: + # Note: Results are returned oldest to newest (unless address filter is used) + txns_result = indexer.search_for_transactions(limit=10) + + print_success(f"Found {len(txns_result.transactions or [])} transaction(s)") + print_info("Note: Results are returned oldest to newest (except when using address filter)") + print_info("") + + if txns_result.transactions: + print_info("Recent transactions:") + for tx in (txns_result.transactions or [])[:5]: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + print_info(f" Transaction ID: {tx_id_display}") + print_info(f" - tx_type: {tx.tx_type}") + print_info(f" - sender: {shorten_address(tx.sender)}") + if tx.confirmed_round is not None: + print_info(f" - confirmed_round: {tx.confirmed_round}") + print_info("") + + print_info(f"Query performed at round: {txns_result.current_round}") + except Exception as e: + print_error(f"search_for_transactions failed: {e}") + + # ========================================================================= + # Step 4: Filter by tx_type to find specific transaction types + # ========================================================================= + print_step(4, "Filtering by tx_type to find specific transaction types") + + try: + # Transaction types: pay, keyreg, acfg, axfer, afrz, appl, stpf, hb + print_info("Available tx_type values: pay, keyreg, acfg, axfer, afrz, appl, stpf, hb") + print_info("") + + # Search for payment transactions + print_info("Searching for payment transactions (tx_type=pay)...") + pay_txns = indexer.search_for_transactions(tx_type="pay", limit=5) + print_success(f"Found {len(pay_txns.transactions or [])} payment transaction(s)") + if pay_txns.transactions: + for tx in (pay_txns.transactions or [])[:2]: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + amount = tx.payment_transaction.amount if tx.payment_transaction else 0 + print_info(f" - {tx_id_display}: {format_micro_algo(amount)}") + print_info("") + + # Search for asset transfer transactions + print_info("Searching for asset transfer transactions (tx_type=axfer)...") + axfer_txns = indexer.search_for_transactions(tx_type="axfer", limit=5) + print_success(f"Found {len(axfer_txns.transactions or [])} asset transfer transaction(s)") + if axfer_txns.transactions: + for tx in (axfer_txns.transactions or [])[:2]: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + axfer_asset_id = tx.asset_transfer_transaction.asset_id if tx.asset_transfer_transaction else "N/A" + print_info(f" - {tx_id_display}: asset_id={axfer_asset_id}") + print_info("") + + # Search for asset config transactions + print_info("Searching for asset config transactions (tx_type=acfg)...") + acfg_txns = indexer.search_for_transactions(tx_type="acfg", limit=5) + print_success(f"Found {len(acfg_txns.transactions or [])} asset config transaction(s)") + if acfg_txns.transactions: + for tx in (acfg_txns.transactions or [])[:2]: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + asset_id_display = tx.created_asset_id + if asset_id_display is None and tx.asset_config_transaction: + asset_id_display = tx.asset_config_transaction.asset_id + print_info(f" - {tx_id_display}: asset_id={asset_id_display}") + print_info("") + + # Search for application call transactions + print_info("Searching for application call transactions (tx_type=appl)...") + appl_txns = indexer.search_for_transactions(tx_type="appl", limit=5) + print_success(f"Found {len(appl_txns.transactions or [])} application call transaction(s)") + if appl_txns.transactions: + for tx in (appl_txns.transactions or [])[:2]: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + app_id_display = tx.created_app_id + if app_id_display is None and tx.application_transaction: + app_id_display = tx.application_transaction.application_id + print_info(f" - {tx_id_display}: app_id={app_id_display}") + except Exception as e: + print_error(f"tx_type filter failed: {e}") + + # ========================================================================= + # Step 5: Filter by sig_type (sig, msig, lsig) + # ========================================================================= + print_step(5, "Filtering by sig_type (sig, msig, lsig)") + + try: + # Signature types: + # - sig: Standard single signature + # - msig: Multisignature + # - lsig: Logic signature (smart signature) + print_info("Available sig_type values: sig, msig, lsig") + print_info("") + + # Search for standard signature transactions + print_info("Searching for standard signature transactions (sig_type=sig)...") + sig_txns = indexer.search_for_transactions(sig_type="sig", limit=5) + print_success(f"Found {len(sig_txns.transactions or [])} transaction(s) with standard signature") + if sig_txns.transactions: + for tx in (sig_txns.transactions or [])[:2]: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + print_info(f" - {tx_id_display}: {tx.tx_type}") + print_info("") + + # Note: msig and lsig transactions may not exist on LocalNet unless specifically created + print_info("Searching for multisig transactions (sig_type=msig)...") + msig_txns = indexer.search_for_transactions(sig_type="msig", limit=5) + print_success(f"Found {len(msig_txns.transactions or [])} multisig transaction(s)") + print_info("(Note: Multisig transactions require special setup and may not exist on LocalNet)") + print_info("") + + print_info("Searching for logic signature transactions (sig_type=lsig)...") + lsig_txns = indexer.search_for_transactions(sig_type="lsig", limit=5) + print_success(f"Found {len(lsig_txns.transactions or [])} logic signature transaction(s)") + print_info("(Note: Logic signature transactions require smart signatures and may not exist on LocalNet)") + except Exception as e: + print_error(f"sig_type filter failed: {e}") + + # ========================================================================= + # Step 6: Filter by address with address_role (sender, receiver) + # ========================================================================= + print_step(6, "Filtering by address with address_role (sender, receiver)") + + try: + # address_role can be: sender, receiver, freeze-target + # When using address filter, results are returned newest to oldest + print_info("Available address_role values: sender, receiver, freeze-target") + print_info("Note: When using address filter, results are returned newest to oldest") + print_info("") + + # Search for transactions where sender is the address + print_info(f"Searching for transactions where {shorten_address(sender_address)} is sender...") + sender_txns = indexer.search_for_transactions( + address=sender_address, + address_role="sender", + limit=5, + ) + print_success(f"Found {len(sender_txns.transactions or [])} transaction(s) as sender") + if sender_txns.transactions: + for tx in (sender_txns.transactions or [])[:3]: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + print_info(f" - {tx_id_display}: {tx.tx_type}") + print_info("") + + # Search for transactions where receiver is the address + print_info(f"Searching for transactions where {shorten_address(receiver_address)} is receiver...") + receiver_txns = indexer.search_for_transactions( + address=receiver_address, + address_role="receiver", + limit=5, + ) + print_success(f"Found {len(receiver_txns.transactions or [])} transaction(s) as receiver") + if receiver_txns.transactions: + for tx in (receiver_txns.transactions or [])[:3]: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + print_info(f" - {tx_id_display}: {tx.tx_type}") + print_info("") + + # Search for transactions involving an address in any role + print_info(f"Searching for all transactions involving {shorten_address(sender_address)} (no role filter)...") + any_role_txns = indexer.search_for_transactions( + address=sender_address, + limit=5, + ) + print_success(f"Found {len(any_role_txns.transactions or [])} transaction(s) involving address") + if any_role_txns.transactions: + for tx in (any_role_txns.transactions or [])[:3]: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + role = "sender" if tx.sender == sender_address else "other" + print_info(f" - {tx_id_display}: {tx.tx_type} (role: {role})") + except Exception as e: + print_error(f"address/address_role filter failed: {e}") + + # ========================================================================= + # Step 7: Filter by round range (min_round, max_round) + # ========================================================================= + print_step(7, "Filtering by round range (min_round, max_round)") + + try: + # Get current round + latest_txns = indexer.search_for_transactions(limit=1) + current_round = latest_txns.current_round + + print_info(f"Current round: {current_round}") + print_info(f"Transactions created starting from round: {start_round}") + print_info("") + + # Filter to recent rounds only + print_info(f"Searching for transactions from round {start_round} to {current_round}...") + round_filtered_txns = indexer.search_for_transactions( + min_round=start_round, + max_round=current_round, + limit=10, + ) + + print_success(f"Found {len(round_filtered_txns.transactions or [])} transaction(s) in round range") + if round_filtered_txns.transactions: + rounds = [ + tx.confirmed_round for tx in (round_filtered_txns.transactions or []) if tx.confirmed_round is not None + ] + if rounds: + min_found_round = min(rounds) + max_found_round = max(rounds) + print_info(f" Rounds of found transactions: {min_found_round} to {max_found_round}") + print_info("") + + # Single round query + print_info(f"Searching for transactions in round {current_round} only...") + single_round_txns = indexer.search_for_transactions( + round_=current_round, + limit=10, + ) + print_success(f"Found {len(single_round_txns.transactions or [])} transaction(s) in round {current_round}") + except Exception as e: + print_error(f"round filter failed: {e}") + + # ========================================================================= + # Step 8: Filter by time range (before_time, after_time) + # ========================================================================= + print_step(8, "Filtering by time range (before_time, after_time)") + + try: + # Time filters use RFC 3339 format (ISO 8601, e.g., "2026-01-26T10:00:00.000Z") + now = datetime.now(tz=timezone.utc) + one_hour_ago = datetime.fromtimestamp(now.timestamp() - 60 * 60, tz=timezone.utc) + + after_time_str = one_hour_ago.isoformat() + before_time_str = now.isoformat() + + print_info("Time filters use RFC 3339 format (ISO 8601)") + print_info(f" after_time: {after_time_str}") + print_info(f" before_time: {before_time_str}") + print_info("") + + print_info("Searching for transactions in the last hour...") + time_filtered_txns = indexer.search_for_transactions( + after_time=after_time_str, + before_time=before_time_str, + limit=10, + ) + + print_success(f"Found {len(time_filtered_txns.transactions or [])} transaction(s) in time range") + if time_filtered_txns.transactions: + times = [tx.round_time for tx in (time_filtered_txns.transactions or []) if tx.round_time is not None] + if times: + min_time = min(times) + max_time = max(times) + earliest = datetime.fromtimestamp(min_time, tz=timezone.utc).isoformat() + latest = datetime.fromtimestamp(max_time, tz=timezone.utc).isoformat() + print_info(" Time range of found transactions:") + print_info(f" - Earliest: {earliest}") + print_info(f" - Latest: {latest}") + except Exception as e: + print_error(f"time filter failed: {e}") + + # ========================================================================= + # Step 9: Filter by application_id to find app calls + # ========================================================================= + print_step(9, "Filtering by application_id to find app calls") + + try: + print_info(f"Searching for transactions involving application ID {app_id}...") + app_txns = indexer.search_for_transactions( + application_id=app_id, + limit=10, + ) + + print_success(f"Found {len(app_txns.transactions or [])} transaction(s) for app {app_id}") + if app_txns.transactions: + for tx in app_txns.transactions or []: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + print_info(f" - {tx_id_display}:") + print_info(f" tx_type: {tx.tx_type}") + if tx.created_app_id: + print_info(f" created_app_id: {tx.created_app_id}") + if tx.application_transaction and tx.application_transaction.on_completion is not None: + print_info(f" on_completion: {tx.application_transaction.on_completion}") + print_info("") + + # Note: You can combine application_id with other filters + print_info("Combining application_id filter with tx_type=appl...") + combined_app_txns = indexer.search_for_transactions( + application_id=app_id, + tx_type="appl", + limit=10, + ) + print_success(f"Found {len(combined_app_txns.transactions or [])} app call transaction(s) for app {app_id}") + except Exception as e: + print_error(f"application_id filter failed: {e}") + + # ========================================================================= + # Step 10: Combining multiple filters + # ========================================================================= + print_step(10, "Combining multiple filters") + + try: + print_info("You can combine multiple filters to narrow down results.") + print_info("") + + # Combine tx_type and address + print_info(f"Searching for payment transactions from {shorten_address(sender_address)}...") + combined_txns_1 = indexer.search_for_transactions( + tx_type="pay", + address=sender_address, + address_role="sender", + limit=5, + ) + print_success(f"Found {len(combined_txns_1.transactions or [])} payment transaction(s) from sender") + print_info("") + + # Combine round range and tx_type + print_info("Searching for asset transfers in recent rounds...") + latest_result = indexer.search_for_transactions(limit=1) + combined_txns_2 = indexer.search_for_transactions( + tx_type="axfer", + min_round=start_round, + max_round=latest_result.current_round, + limit=5, + ) + print_success(f"Found {len(combined_txns_2.transactions or [])} asset transfer(s) in recent rounds") + except Exception as e: + print_error(f"combined filters failed: {e}") + + # ========================================================================= + # Step 11: Pagination with limit and next + # ========================================================================= + print_step(11, "Demonstrating pagination with limit and next") + + try: + print_info("Using limit=2 to demonstrate pagination...") + page_1 = indexer.search_for_transactions(limit=2) + + print_info(f"Page 1: Retrieved {len(page_1.transactions or [])} transaction(s)") + for tx in page_1.transactions or []: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + print_info(f" - {tx_id_display}: {tx.tx_type}") + + if page_1.next_token: + token_preview = str(page_1.next_token)[:20] + print_info(f" - Next token available: {token_preview}...") + print_info("") + + print_info("Fetching next page...") + page_2 = indexer.search_for_transactions( + limit=2, + next_=page_1.next_token, + ) + + print_info(f"Page 2: Retrieved {len(page_2.transactions or [])} transaction(s)") + for tx in page_2.transactions or []: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + print_info(f" - {tx_id_display}: {tx.tx_type}") + + if page_2.next_token: + print_info(" - More pages available (next_token present)") + else: + print_info(" - No more pages (no next_token)") + else: + print_info(" - No pagination needed (all results fit in one page)") + except Exception as e: + print_error(f"pagination failed: {e}") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated search_for_transactions() with various filters:") + print_info("") + print_info("Key filter parameters:") + print_info(" - tx_type: Filter by transaction type (pay, keyreg, acfg, axfer, afrz, appl, stpf, hb)") + print_info(" - sig_type: Filter by signature type (sig, msig, lsig)") + print_info(" - address: Filter by address involvement") + print_info(" - address_role: Specify role (sender, receiver, freeze-target)") + print_info(" - min_round/max_round: Filter by round range") + print_info(" - round: Filter by specific round") + print_info(" - before_time/after_time: Filter by time (RFC 3339 format)") + print_info(" - application_id: Filter by application ID") + print_info(" - asset_id: Filter by asset ID") + print_info(" - currency_greater_than/currency_less_than: Filter by amount") + print_info(" - note_prefix: Filter by note prefix") + print_info(" - tx_id: Find specific transaction by ID") + print_info(" - group_id: Filter by group ID") + print_info(" - rekey_to: Filter for rekey transactions") + print_info(" - exclude_close_to: Exclude close-to transactions from results") + print_info("") + print_info("Result ordering:") + print_info(" - Default: Results are returned oldest to newest") + print_info(" - With address filter: Results are returned newest to oldest") + print_info("") + print_info("Pagination:") + print_info(" - limit: Maximum number of results per page") + print_info(" - next: Token from previous response to get next page") + + +if __name__ == "__main__": + main() diff --git a/examples/indexer_client/08_asset_lookup.py b/examples/indexer_client/08_asset_lookup.py new file mode 100644 index 00000000..0760dcbf --- /dev/null +++ b/examples/indexer_client/08_asset_lookup.py @@ -0,0 +1,331 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Asset Lookup + +This example demonstrates how to lookup and search for assets using +the IndexerClient lookup_asset_by_id() and search_for_assets() methods. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from shared import ( + create_algorand_client, + create_indexer_client, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_utils import AssetCreateParams + + +def main() -> None: + print_header("Asset Lookup Example") + + # Create clients + indexer = create_indexer_client() + algorand = create_algorand_client() + + # ========================================================================= + # Step 1: Get a funded account from LocalNet + # ========================================================================= + print_step(1, "Getting a funded account from LocalNet") + + try: + dispenser = algorand.account.localnet_dispenser() + algorand.set_signer_from_account(dispenser) + creator_address = dispenser.addr + print_success(f"Using dispenser account: {shorten_address(creator_address)}") + except Exception as e: + print_error(f"Failed to get dispenser account: {e}") + print_info("") + print_info("Make sure LocalNet is running: algokit localnet start") + print_info("If issues persist, try: algokit localnet reset") + return + + # ========================================================================= + # Step 2: Create test assets using AlgorandClient + # ========================================================================= + print_step(2, "Creating test assets for demonstration") + + try: + # Create first test asset with full configuration + print_info("Creating first test asset: AlphaToken (ALPHA)...") + result_1 = algorand.send.asset_create( + AssetCreateParams( + sender=creator_address, + total=1_000_000_000_000, # 1,000,000 units with 6 decimals + decimals=6, + asset_name="AlphaToken", + unit_name="ALPHA", + url="https://example.com/alpha", + default_frozen=False, + manager=creator_address, + reserve=creator_address, + freeze=creator_address, + clawback=creator_address, + ) + ) + asset_id_1 = result_1.asset_id + print_success(f"Created AlphaToken with Asset ID: {asset_id_1}") + + # Create second test asset with different unit name + print_info("Creating second test asset: BetaCoin (BETA)...") + result_2 = algorand.send.asset_create( + AssetCreateParams( + sender=creator_address, + total=500_000_000, # 500,000 units with 3 decimals + decimals=3, + asset_name="BetaCoin", + unit_name="BETA", + url="https://example.com/beta", + default_frozen=False, + ) + ) + asset_id_2 = result_2.asset_id + print_success(f"Created BetaCoin with Asset ID: {asset_id_2}") + print_info("") + except Exception as e: + print_error(f"Failed to create test assets: {e}") + print_info("") + print_info("If LocalNet errors occur, try: algokit localnet reset") + return + + # ========================================================================= + # Step 3: Lookup asset by ID with lookup_asset_by_id() + # ========================================================================= + print_step(3, "Looking up asset by ID with lookup_asset_by_id()") + + try: + # lookup_asset_by_id() returns detailed asset information + asset_result = indexer.lookup_asset_by_id(asset_id_1) + + print_success(f"Found asset with ID: {asset_result.asset.id_}") + print_info("") + + # Display asset params + params = asset_result.asset.params + print_info("Asset Parameters:") + print_info(f" - index: {asset_result.asset.id_}") + print_info(f" - creator: {shorten_address(params.creator)}") + print_info(f" - total: {params.total:,}") + print_info(f" - decimals: {params.decimals}") + print_info(f" - name: {params.name or '(not set)'}") + print_info(f" - unit_name: {params.unit_name or '(not set)'}") + print_info(f" - url: {params.url or '(not set)'}") + metadata_display = params.metadata_hash.hex() if params.metadata_hash else "(not set)" + print_info(f" - metadata_hash: {metadata_display}") + print_info(f" - default_frozen: {params.default_frozen or False}") + print_info("") + + # Display manager addresses + print_info("Manager Addresses:") + print_info(f" - manager: {shorten_address(params.manager) if params.manager else '(not set)'}") + print_info(f" - reserve: {shorten_address(params.reserve) if params.reserve else '(not set)'}") + print_info(f" - freeze: {shorten_address(params.freeze) if params.freeze else '(not set)'}") + print_info(f" - clawback: {shorten_address(params.clawback) if params.clawback else '(not set)'}") + print_info("") + + # Display creation/destruction info + if asset_result.asset.created_at_round is not None: + print_info(f"Created at round: {asset_result.asset.created_at_round}") + if asset_result.asset.destroyed_at_round is not None: + print_info(f"Destroyed at round: {asset_result.asset.destroyed_at_round}") + if asset_result.asset.deleted is not None: + print_info(f"Deleted: {asset_result.asset.deleted}") + + print_info(f"Query performed at round: {asset_result.current_round}") + except Exception as e: + print_error(f"lookup_asset_by_id failed: {e}") + + # ========================================================================= + # Step 4: Search for assets with search_for_assets() + # ========================================================================= + print_step(4, "Searching for assets with search_for_assets()") + + try: + # search_for_assets() returns a list of assets matching the criteria + search_result = indexer.search_for_assets(limit=10) + + print_success(f"Found {len(search_result.assets or [])} asset(s)") + print_info("") + + if search_result.assets: + print_info("Assets found:") + for asset in (search_result.assets or [])[:5]: + print_info(f" Asset ID: {asset.id_}") + print_info(f" - name: {asset.params.name or '(not set)'}") + print_info(f" - unit_name: {asset.params.unit_name or '(not set)'}") + print_info(f" - creator: {shorten_address(asset.params.creator)}") + print_info("") + if len(search_result.assets or []) > 5: + print_info(f" ... and {len(search_result.assets or []) - 5} more") + + print_info(f"Query performed at round: {search_result.current_round}") + except Exception as e: + print_error(f"search_for_assets failed: {e}") + + # ========================================================================= + # Step 5: Filter by name + # ========================================================================= + print_step(5, "Filtering assets by name") + + try: + # Search for assets with a specific name + print_info('Searching for assets with name "Alpha"...') + name_result = indexer.search_for_assets(name="Alpha") + + print_success(f'Found {len(name_result.assets or [])} asset(s) matching name "Alpha"') + if name_result.assets: + for asset in name_result.assets or []: + print_info(f" - Asset ID {asset.id_}: {asset.params.name} ({asset.params.unit_name})") + except Exception as e: + print_error(f"Filter by name failed: {e}") + + # ========================================================================= + # Step 6: Filter by unit name + # ========================================================================= + print_step(6, "Filtering assets by unit name") + + try: + # Search for assets with a specific unit name + print_info('Searching for assets with unit "BETA"...') + unit_result = indexer.search_for_assets(unit="BETA") + + print_success(f'Found {len(unit_result.assets or [])} asset(s) matching unit "BETA"') + if unit_result.assets: + for asset in unit_result.assets or []: + print_info(f" - Asset ID {asset.id_}: {asset.params.name} ({asset.params.unit_name})") + except Exception as e: + print_error(f"Filter by unit failed: {e}") + + # ========================================================================= + # Step 7: Filter by creator + # ========================================================================= + print_step(7, "Filtering assets by creator") + + try: + # Search for assets created by a specific account + print_info(f"Searching for assets created by {shorten_address(creator_address)}...") + creator_result = indexer.search_for_assets(creator=creator_address) + + print_success(f"Found {len(creator_result.assets or [])} asset(s) created by this account") + if creator_result.assets: + for asset in creator_result.assets or []: + name_display = asset.params.name or "(unnamed)" + unit_display = asset.params.unit_name or "N/A" + print_info(f" - Asset ID {asset.id_}: {name_display} ({unit_display})") + except Exception as e: + print_error(f"Filter by creator failed: {e}") + + # ========================================================================= + # Step 8: Filter by asset ID for exact match + # ========================================================================= + print_step(8, "Filtering by asset_id for exact match") + + try: + # Use asset_id parameter for exact matching + print_info(f"Searching for exact asset ID {asset_id_2}...") + exact_result = indexer.search_for_assets(asset_id=asset_id_2) + + if exact_result.assets: + asset = exact_result.assets[0] + print_success(f"Found exact match for Asset ID {asset_id_2}") + print_info(f" - name: {asset.params.name or '(not set)'}") + print_info(f" - unit_name: {asset.params.unit_name or '(not set)'}") + print_info(f" - total: {asset.params.total:,}") + else: + print_info(f"No asset found with ID {asset_id_2}") + except Exception as e: + print_error(f"Exact match search failed: {e}") + + # ========================================================================= + # Step 9: Handle asset not found + # ========================================================================= + print_step(9, "Handling asset not found") + + try: + # Try to look up a non-existent asset ID + non_existent_id = 999999999 + print_info(f"Looking up non-existent asset ID {non_existent_id}...") + + indexer.lookup_asset_by_id(non_existent_id) + print_info("Asset found (unexpected)") + except Exception as e: + message = str(e) + if "no asset found" in message.lower() or "not found" in message.lower() or "404" in message: + print_success("Asset not found error handled correctly") + print_info(f" Error message: {message}") + else: + print_error(f"Unexpected error: {message}") + + # ========================================================================= + # Step 10: Include deleted assets with include_all + # ========================================================================= + print_step(10, "Including deleted/destroyed assets with include_all") + + try: + # The include_all parameter includes assets that have been deleted/destroyed + print_info("Searching with include_all=True to include deleted assets...") + all_assets_result = indexer.search_for_assets( + creator=creator_address, + include_all=True, + ) + + print_success(f"Found {len(all_assets_result.assets or [])} asset(s) (including any deleted)") + for asset in all_assets_result.assets or []: + status = " [DELETED]" if asset.deleted else "" + name_display = asset.params.name or "(unnamed)" + print_info(f" - Asset ID {asset.id_}: {name_display}{status}") + except Exception as e: + print_error(f"Include all search failed: {e}") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. Creating test assets using algorand.send.asset_create()") + print_info(" 2. lookup_asset_by_id(asset_id) - Get detailed asset information") + print_info(" 3. search_for_assets() - Search for assets with various filters") + print_info(" 4. Filtering by name, unit, and creator") + print_info(" 5. Filtering by asset_id for exact match") + print_info(" 6. Handling asset not found errors") + print_info(" 7. Including deleted assets with include_all parameter") + print_info("") + print_info("Key Asset fields:") + print_info(" - index: Unique asset identifier (int)") + print_info(" - deleted: Whether asset is deleted (optional bool)") + print_info(" - created_at_round: Round when created (optional int)") + print_info(" - destroyed_at_round: Round when destroyed (optional int)") + print_info("") + print_info("Key AssetParams fields:") + print_info(" - creator: Address that created the asset") + print_info(" - total: Total supply in base units (int)") + print_info(" - decimals: Number of decimal places (0-19)") + print_info(" - name: Full asset name (optional)") + print_info(" - unit_name: Short unit name like 'ALGO' (optional)") + print_info(" - url: URL for more info (optional)") + print_info(" - metadata_hash: 32-byte metadata hash (optional)") + print_info("") + print_info("Manager address fields:") + print_info(" - manager: Can reconfigure or destroy the asset") + print_info(" - reserve: Holds non-minted units") + print_info(" - freeze: Can freeze/unfreeze holdings") + print_info(" - clawback: Can revoke holdings") + print_info("") + print_info("Search filter parameters:") + print_info(" - name: Filter by asset name (prefix match)") + print_info(" - unit: Filter by unit name (prefix match)") + print_info(" - creator: Filter by creator address") + print_info(" - asset_id: Filter by exact asset ID") + print_info(" - include_all: Include deleted/destroyed assets") + print_info(" - limit/next: Pagination parameters") + + +if __name__ == "__main__": + main() diff --git a/examples/indexer_client/09_asset_balances.py b/examples/indexer_client/09_asset_balances.py new file mode 100644 index 00000000..dedc5848 --- /dev/null +++ b/examples/indexer_client/09_asset_balances.py @@ -0,0 +1,353 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Asset Balances + +This example demonstrates how to lookup all holders of an asset using +the IndexerClient lookup_asset_balances() method. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import time + +from shared import ( + create_algorand_client, + create_indexer_client, + create_random_account, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_utils import AssetCreateParams, AssetOptInParams, AssetTransferParams + + +def main() -> None: + print_header("Asset Balances Example") + + # Create clients + indexer = create_indexer_client() + algorand = create_algorand_client() + + # ========================================================================= + # Step 1: Get a funded account and create additional accounts + # ========================================================================= + print_step(1, "Setting up accounts for demonstration") + + try: + # Get the dispenser account as the creator + dispenser = algorand.account.localnet_dispenser() + algorand.set_signer_from_account(dispenser) + creator_address = dispenser.addr + print_success(f"Creator account (dispenser): {shorten_address(creator_address)}") + + # Create additional accounts to hold the asset + holder_1 = create_random_account(algorand) + holder_1_address = holder_1.addr + print_success(f"Holder 1: {shorten_address(holder_1_address)}") + + holder_2 = create_random_account(algorand) + holder_2_address = holder_2.addr + print_success(f"Holder 2: {shorten_address(holder_2_address)}") + + holder_3 = create_random_account(algorand) + holder_3_address = holder_3.addr + print_success(f"Holder 3: {shorten_address(holder_3_address)}") + except Exception as e: + print_error(f"Failed to set up accounts: {e}") + print_info("") + print_info("Make sure LocalNet is running: algokit localnet start") + print_info("If issues persist, try: algokit localnet reset") + return + + # ========================================================================= + # Step 2: Create a test asset + # ========================================================================= + print_step(2, "Creating a test asset") + + try: + print_info("Creating test asset: BalanceToken (BAL)...") + result = algorand.send.asset_create( + AssetCreateParams( + sender=creator_address, + total=10_000_000, # 10,000 units with 3 decimals + decimals=3, + asset_name="BalanceToken", + unit_name="BAL", + url="https://example.com/balancetoken", + default_frozen=False, + ) + ) + asset_id = result.asset_id + print_success(f"Created BalanceToken with Asset ID: {asset_id}") + except Exception as e: + print_error(f"Failed to create test asset: {e}") + print_info("") + print_info("If LocalNet errors occur, try: algokit localnet reset") + return + + # ========================================================================= + # Step 3: Distribute asset to multiple accounts + # ========================================================================= + print_step(3, "Distributing asset to multiple accounts") + + try: + # Holder 1: Opt-in and receive 1000 BAL + print_info("Opting in Holder 1 and sending 1000 BAL...") + algorand.send.asset_opt_in( + AssetOptInParams( + sender=holder_1_address, + asset_id=asset_id, + ) + ) + algorand.send.asset_transfer( + AssetTransferParams( + sender=creator_address, + receiver=holder_1_address, + asset_id=asset_id, + amount=1_000_000, # 1000 BAL (with 3 decimals) + ) + ) + print_success("Holder 1 received 1000 BAL") + + # Holder 2: Opt-in and receive 500 BAL + print_info("Opting in Holder 2 and sending 500 BAL...") + algorand.send.asset_opt_in( + AssetOptInParams( + sender=holder_2_address, + asset_id=asset_id, + ) + ) + algorand.send.asset_transfer( + AssetTransferParams( + sender=creator_address, + receiver=holder_2_address, + asset_id=asset_id, + amount=500_000, # 500 BAL (with 3 decimals) + ) + ) + print_success("Holder 2 received 500 BAL") + + # Holder 3: Opt-in only (0 balance but still a holder) + print_info("Opting in Holder 3 (no transfer, will have 0 balance)...") + algorand.send.asset_opt_in( + AssetOptInParams( + sender=holder_3_address, + asset_id=asset_id, + ) + ) + print_success("Holder 3 opted in with 0 balance") + + print_info("") + print_info("Distribution summary:") + print_info(" - Creator: ~8500 BAL (remainder)") + print_info(" - Holder 1: 1000 BAL") + print_info(" - Holder 2: 500 BAL") + print_info(" - Holder 3: 0 BAL (opted-in only)") + except Exception as e: + print_error(f"Failed to distribute asset: {e}") + print_info("") + print_info("If LocalNet errors occur, try: algokit localnet reset") + return + + # Wait for indexer to sync after distribution + print_info("Waiting for indexer to sync...") + time.sleep(3) + + # ========================================================================= + # Step 4: Basic lookup_asset_balances() - Get all holders + # ========================================================================= + print_step(4, "Looking up all asset holders with lookup_asset_balances()") + + try: + # lookup_asset_balances() returns all accounts that hold (or have opted into) an asset + balances_result = indexer.lookup_asset_balances(asset_id) + + print_success(f"Found {len(balances_result.balances or [])} holder(s) for Asset ID {asset_id}") + print_info("") + + if balances_result.balances: + print_info("Asset balances:") + for balance in balances_result.balances or []: + print_info(f" Address: {shorten_address(balance.address)}") + print_info(f" - amount: {balance.amount:,}") + print_info(f" - is_frozen: {balance.is_frozen}") + if balance.opted_in_at_round is not None: + print_info(f" - opted_in_at_round: {balance.opted_in_at_round}") + print_info("") + + print_info(f"Query performed at round: {balances_result.current_round}") + except Exception as e: + print_error(f"lookup_asset_balances failed: {e}") + + # ========================================================================= + # Step 5: Filter by currency_greater_than + # ========================================================================= + print_step(5, "Filtering holders by currency_greater_than") + + try: + # Filter to only show accounts with more than 500 BAL (500,000 base units) + print_info("Querying holders with amount > 500,000 base units (> 500 BAL)...") + high_balance_result = indexer.lookup_asset_balances( + asset_id, + currency_greater_than=500_000, + ) + + print_success(f"Found {len(high_balance_result.balances or [])} holder(s) with balance > 500 BAL") + for balance in high_balance_result.balances or []: + print_info(f" {shorten_address(balance.address)}: {balance.amount:,} base units") + except Exception as e: + print_error(f"currency_greater_than query failed: {e}") + + # ========================================================================= + # Step 6: Filter by currency_less_than + # ========================================================================= + print_step(6, "Filtering holders by currency_less_than") + + try: + # Filter to only show accounts with less than 1,000,000 base units (< 1000 BAL) + print_info("Querying holders with amount < 1,000,000 base units (< 1000 BAL)...") + low_balance_result = indexer.lookup_asset_balances( + asset_id, + currency_less_than=1_000_000, + ) + + print_success(f"Found {len(low_balance_result.balances or [])} holder(s) with balance < 1000 BAL") + for balance in low_balance_result.balances or []: + print_info(f" {shorten_address(balance.address)}: {balance.amount:,} base units") + except Exception as e: + print_error(f"currency_less_than query failed: {e}") + + # ========================================================================= + # Step 7: Combine currency_greater_than and currency_less_than (range filter) + # ========================================================================= + print_step(7, "Filtering holders by balance range (combining currency filters)") + + try: + # Filter to show accounts with balance between 100 BAL and 2000 BAL + print_info("Querying holders with 100,000 < amount < 2,000,000 base units (100-2000 BAL)...") + range_result = indexer.lookup_asset_balances( + asset_id, + currency_greater_than=100_000, + currency_less_than=2_000_000, + ) + + print_success(f"Found {len(range_result.balances or [])} holder(s) with balance between 100 and 2000 BAL") + for balance in range_result.balances or []: + print_info(f" {shorten_address(balance.address)}: {balance.amount:,} base units") + except Exception as e: + print_error(f"Range filter query failed: {e}") + + # ========================================================================= + # Step 8: Using include_all to include 0 balance accounts + # ========================================================================= + print_step(8, "Using include_all to include accounts with 0 balance") + + try: + # By default, lookup_asset_balances may exclude accounts with 0 balance + # Use include_all=True to include opted-in accounts with no holdings + print_info("Querying with include_all=True to include all opted-in accounts...") + all_holders_result = indexer.lookup_asset_balances( + asset_id, + include_all=True, + ) + + print_success(f"Found {len(all_holders_result.balances or [])} holder(s) (including 0 balance)") + print_info("") + + zero_balance_count = len([b for b in (all_holders_result.balances or []) if b.amount == 0]) + non_zero_count = len([b for b in (all_holders_result.balances or []) if b.amount > 0]) + + print_info(f" - Accounts with balance > 0: {non_zero_count}") + print_info(f" - Accounts with balance = 0: {zero_balance_count}") + print_info("") + + print_info("All holders:") + for balance in all_holders_result.balances or []: + balance_str = "0 (opted-in only)" if balance.amount == 0 else f"{balance.amount:,}" + print_info(f" {shorten_address(balance.address)}: {balance_str}") + except Exception as e: + print_error(f"include_all query failed: {e}") + + # ========================================================================= + # Step 9: Demonstrate pagination + # ========================================================================= + print_step(9, "Demonstrating pagination for assets with many holders") + + try: + # First query: get only 2 holders + print_info("Querying with limit=2...") + page_1 = indexer.lookup_asset_balances( + asset_id, + limit=2, + include_all=True, + ) + + print_info(f"Page 1: Retrieved {len(page_1.balances or [])} holder(s)") + for balance in page_1.balances or []: + print_info(f" - {shorten_address(balance.address)}: {balance.amount:,}") + + # Check if there are more results + if page_1.next_token: + token_preview = str(page_1.next_token)[:20] + print_info(f" Next token available: {token_preview}...") + print_info("") + + # Second query: use the next token to get more results + print_info("Querying next page with next parameter...") + page_2 = indexer.lookup_asset_balances( + asset_id, + limit=2, + include_all=True, + next_=page_1.next_token, + ) + + print_info(f"Page 2: Retrieved {len(page_2.balances or [])} holder(s)") + for balance in page_2.balances or []: + print_info(f" - {shorten_address(balance.address)}: {balance.amount:,}") + + if page_2.next_token: + print_info(" More results available (next_token present)") + else: + print_info(" No more results (no next_token)") + else: + print_info(" No pagination needed (all results fit in one page)") + except Exception as e: + print_error(f"Pagination demo failed: {e}") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. Creating a test asset and distributing to multiple accounts") + print_info(" 2. lookup_asset_balances(asset_id) - Get all holders of an asset") + print_info(" 3. Balance fields: address, amount, is_frozen, opted_in_at_round") + print_info(" 4. Filtering with currency_greater_than (minimum balance)") + print_info(" 5. Filtering with currency_less_than (maximum balance)") + print_info(" 6. Combining currency filters for range queries") + print_info(" 7. Using include_all=True to include accounts with 0 balance") + print_info(" 8. Pagination using limit and next parameters") + print_info("") + print_info("Key MiniAssetHolding fields (from lookup_asset_balances):") + print_info(" - address: The account address holding the asset (str)") + print_info(" - amount: Number of base units held (int)") + print_info(" - is_frozen: Whether the holding is frozen (bool)") + print_info(" - opted_in_at_round: Round when account opted into asset (optional int)") + print_info("") + print_info("Filter parameters:") + print_info(" - currency_greater_than: Only return balances > this value (int)") + print_info(" - currency_less_than: Only return balances < this value (int)") + print_info(" - include_all: Include accounts with 0 balance (bool)") + print_info("") + print_info("Pagination parameters:") + print_info(" - limit: Maximum number of results per page") + print_info(" - next: Token from previous response to get next page") + + +if __name__ == "__main__": + main() diff --git a/examples/indexer_client/10_asset_transactions.py b/examples/indexer_client/10_asset_transactions.py new file mode 100644 index 00000000..5697aa22 --- /dev/null +++ b/examples/indexer_client/10_asset_transactions.py @@ -0,0 +1,600 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Asset Transactions + +This example demonstrates how to lookup transactions for a specific asset using +the IndexerClient lookup_asset_transactions() method. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import time +from datetime import datetime, timezone + +from shared import ( + create_algod_client, + create_algorand_client, + create_indexer_client, + create_random_account, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_utils import AssetConfigParams, AssetCreateParams, AssetFreezeParams, AssetOptInParams, AssetTransferParams + + +def main() -> None: + print_header("Asset Transactions Example") + + # Create clients + indexer = create_indexer_client() + algorand = create_algorand_client() + algod = create_algod_client() + + # ========================================================================= + # Step 1: Get a funded account and create additional accounts + # ========================================================================= + print_step(1, "Setting up accounts for demonstration") + + try: + # Get the dispenser account as the creator + dispenser = algorand.account.localnet_dispenser() + algorand.set_signer_from_account(dispenser) + creator_address = dispenser.addr + print_success(f"Creator account (dispenser): {shorten_address(creator_address)}") + + # Create additional accounts to hold the asset + holder_1 = create_random_account(algorand) + holder_1_address = holder_1.addr + print_success(f"Holder 1: {shorten_address(holder_1_address)}") + + holder_2 = create_random_account(algorand) + holder_2_address = holder_2.addr + print_success(f"Holder 2: {shorten_address(holder_2_address)}") + except Exception as e: + print_error(f"Failed to set up accounts: {e}") + print_info("") + print_info("Make sure LocalNet is running: algokit localnet start") + print_info("If issues persist, try: algokit localnet reset") + return + + # ========================================================================= + # Step 2: Create a test asset with freeze address + # ========================================================================= + print_step(2, "Creating a test asset with freeze address") + + try: + # Record the starting round for later filtering + status = algod.status() + start_round = status.last_round + + # Create asset with freeze address to enable freeze transactions + print_info("Creating test asset: TxnToken (TXN)...") + result = algorand.send.asset_create( + AssetCreateParams( + sender=creator_address, + total=10_000_000, # 10,000 units with 3 decimals + decimals=3, + asset_name="TxnToken", + unit_name="TXN", + url="https://example.com/txntoken", + default_frozen=False, + manager=creator_address, + reserve=creator_address, + freeze=creator_address, # Enable freeze functionality + clawback=creator_address, + ) + ) + asset_id = result.asset_id + print_success(f"Created TxnToken with Asset ID: {asset_id}") + print_info(f" - freeze address: {shorten_address(creator_address)} (enables freeze transactions)") + except Exception as e: + print_error(f"Failed to create test asset: {e}") + print_info("") + print_info("If LocalNet errors occur, try: algokit localnet reset") + return + + # ========================================================================= + # Step 3: Perform several asset transactions (opt-in, transfer, freeze) + # ========================================================================= + print_step(3, "Performing several asset transactions") + + try: + # 1. Holder 1: Opt-in (axfer to self with 0 amount) + print_info("Holder 1 opting into asset...") + algorand.send.asset_opt_in( + AssetOptInParams( + sender=holder_1_address, + asset_id=asset_id, + ) + ) + print_success("Holder 1 opted in (axfer)") + + # 2. Transfer to Holder 1 + print_info("Transferring 1000 TXN to Holder 1...") + algorand.send.asset_transfer( + AssetTransferParams( + sender=creator_address, + receiver=holder_1_address, + asset_id=asset_id, + amount=1_000_000, # 1000 TXN (with 3 decimals) + ) + ) + print_success("Transfer to Holder 1 complete (axfer)") + + # 3. Holder 2: Opt-in + print_info("Holder 2 opting into asset...") + algorand.send.asset_opt_in( + AssetOptInParams( + sender=holder_2_address, + asset_id=asset_id, + ) + ) + print_success("Holder 2 opted in (axfer)") + + # 4. Transfer to Holder 2 + print_info("Transferring 500 TXN to Holder 2...") + algorand.send.asset_transfer( + AssetTransferParams( + sender=creator_address, + receiver=holder_2_address, + asset_id=asset_id, + amount=500_000, # 500 TXN (with 3 decimals) + ) + ) + print_success("Transfer to Holder 2 complete (axfer)") + + # 5. Freeze Holder 1's account + print_info("Freezing Holder 1 account...") + algorand.send.asset_freeze( + AssetFreezeParams( + sender=creator_address, + asset_id=asset_id, + account=holder_1_address, + frozen=True, + ) + ) + print_success("Holder 1 account frozen (afrz)") + + # 6. Unfreeze Holder 1's account + print_info("Unfreezing Holder 1 account...") + algorand.send.asset_freeze( + AssetFreezeParams( + sender=creator_address, + asset_id=asset_id, + account=holder_1_address, + frozen=False, + ) + ) + print_success("Holder 1 account unfrozen (afrz)") + + # 7. Reconfigure asset (acfg) + print_info("Reconfiguring asset (updating manager)...") + algorand.send.asset_config( + AssetConfigParams( + sender=creator_address, + asset_id=asset_id, + manager=creator_address, + reserve=creator_address, + freeze=creator_address, + clawback=creator_address, + ) + ) + print_success("Asset reconfigured (acfg)") + + print_info("") + print_info("Transaction summary:") + print_info(" - 1 asset creation (acfg)") + print_info(" - 2 opt-ins (axfer with 0 amount)") + print_info(" - 2 transfers (axfer with positive amount)") + print_info(" - 2 freeze operations (afrz)") + print_info(" - 1 asset reconfiguration (acfg)") + + # Small delay to allow indexer to catch up + print_info("") + print_info("Waiting for indexer to index transactions...") + time.sleep(3) + except Exception as e: + print_error(f"Failed to create asset transactions: {e}") + print_info("") + print_info("If LocalNet errors occur, try: algokit localnet reset") + return + + # ========================================================================= + # Step 4: Basic lookup_asset_transactions() - Get all transactions for asset + # ========================================================================= + print_step(4, "Looking up all transactions for asset with lookup_asset_transactions()") + + try: + # lookup_asset_transactions() returns all transactions involving an asset + # Note: Results are returned oldest to newest + txns_result = indexer.lookup_asset_transactions(asset_id) + + print_success(f"Found {len(txns_result.transactions)} transaction(s) for Asset ID {asset_id}") + print_info("Note: Results are returned oldest to newest") + print_info("") + + if txns_result.transactions: + print_info("Asset transactions:") + for tx in txns_result.transactions: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + print_info(f" Transaction: {tx_id_display}") + print_info(f" - tx_type: {tx.tx_type}") + print_info(f" - sender: {shorten_address(tx.sender)}") + if tx.confirmed_round is not None: + print_info(f" - confirmed_round: {tx.confirmed_round}") + + # Show type-specific details + if tx.tx_type == "axfer" and tx.asset_transfer_transaction: + print_info(f" - receiver: {shorten_address(tx.asset_transfer_transaction.receiver)}") + print_info(f" - amount: {tx.asset_transfer_transaction.amount:,}") + elif tx.tx_type == "afrz" and tx.asset_freeze_transaction: + print_info(f" - frozen_address: {shorten_address(tx.asset_freeze_transaction.address)}") + print_info(f" - new_freeze_status: {tx.asset_freeze_transaction.new_freeze_status}") + elif tx.tx_type == "acfg": + if tx.created_asset_id: + print_info(f" - created_asset_id: {tx.created_asset_id} (asset creation)") + elif tx.asset_config_transaction: + print_info(f" - asset_id: {tx.asset_config_transaction.asset_id} (reconfiguration)") + print_info("") + + print_info(f"Query performed at round: {txns_result.current_round}") + except Exception as e: + print_error(f"lookup_asset_transactions failed: {e}") + + # ========================================================================= + # Step 5: Filter by address and address_role - Sender + # ========================================================================= + print_step(5, "Filtering by address with address_role=sender") + + try: + # address_role can be: sender, receiver, freeze-target + print_info("Available address_role values: sender, receiver, freeze-target") + print_info("") + + print_info(f"Searching for transactions where {shorten_address(creator_address)} is sender...") + sender_txns = indexer.lookup_asset_transactions( + asset_id, + address=creator_address, + address_role="sender", + ) + + print_success(f"Found {len(sender_txns.transactions)} transaction(s) where creator is sender") + if sender_txns.transactions: + for tx in sender_txns.transactions[:5]: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + print_info(f" - {tx_id_display}: {tx.tx_type}") + except Exception as e: + print_error(f"address_role=sender filter failed: {e}") + + # ========================================================================= + # Step 6: Filter by address and address_role - Receiver + # ========================================================================= + print_step(6, "Filtering by address with address_role=receiver") + + try: + print_info(f"Searching for transactions where {shorten_address(holder_1_address)} is receiver...") + receiver_txns = indexer.lookup_asset_transactions( + asset_id, + address=holder_1_address, + address_role="receiver", + ) + + print_success(f"Found {len(receiver_txns.transactions)} transaction(s) where Holder 1 is receiver") + if receiver_txns.transactions: + for tx in receiver_txns.transactions: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + if tx.asset_transfer_transaction: + print_info(f" - {tx_id_display}: {tx.tx_type}, amount: {tx.asset_transfer_transaction.amount:,}") + else: + print_info(f" - {tx_id_display}: {tx.tx_type}") + except Exception as e: + print_error(f"address_role=receiver filter failed: {e}") + + # ========================================================================= + # Step 7: Filter by address and address_role - Freeze-target + # ========================================================================= + print_step(7, "Filtering by address with address_role=freeze-target") + + try: + # freeze-target filters for accounts that were the target of freeze operations + print_info(f"Searching for freeze transactions targeting {shorten_address(holder_1_address)}...") + freeze_target_txns = indexer.lookup_asset_transactions( + asset_id, + address=holder_1_address, + address_role="freeze-target", + ) + + print_success(f"Found {len(freeze_target_txns.transactions)} freeze transaction(s) targeting Holder 1") + if freeze_target_txns.transactions: + for tx in freeze_target_txns.transactions: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + if tx.asset_freeze_transaction: + frozen = tx.asset_freeze_transaction.new_freeze_status + print_info(f" - {tx_id_display}: {tx.tx_type}, new_freeze_status: {frozen}") + print_info("") + print_info("Note: freeze-target is specifically for afrz transactions targeting an account") + except Exception as e: + print_error(f"address_role=freeze-target filter failed: {e}") + + # ========================================================================= + # Step 8: Filter by tx_type - Asset Transfer (axfer) + # ========================================================================= + print_step(8, "Filtering by tx_type for specific asset operations") + + try: + # tx_type values relevant to assets: acfg (config), axfer (transfer), afrz (freeze) + print_info("Asset-related tx_type values: acfg (config), axfer (transfer), afrz (freeze)") + print_info("") + + # Search for asset transfers only + print_info("Searching for asset transfer transactions (tx_type=axfer)...") + axfer_txns = indexer.lookup_asset_transactions(asset_id, tx_type="axfer") + print_success(f"Found {len(axfer_txns.transactions)} asset transfer transaction(s)") + if axfer_txns.transactions: + for tx in axfer_txns.transactions[:4]: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + amount = tx.asset_transfer_transaction.amount if tx.asset_transfer_transaction else 0 + amount_str = "0 (opt-in)" if amount == 0 else f"{amount:,}" + print_info(f" - {tx_id_display}: amount={amount_str}") + print_info("") + + # Search for asset freeze transactions + print_info("Searching for asset freeze transactions (tx_type=afrz)...") + afrz_txns = indexer.lookup_asset_transactions(asset_id, tx_type="afrz") + print_success(f"Found {len(afrz_txns.transactions)} asset freeze transaction(s)") + if afrz_txns.transactions: + for tx in afrz_txns.transactions: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + frozen = tx.asset_freeze_transaction.new_freeze_status if tx.asset_freeze_transaction else False + print_info(f" - {tx_id_display}: frozen={frozen}") + print_info("") + + # Search for asset config transactions + print_info("Searching for asset config transactions (tx_type=acfg)...") + acfg_txns = indexer.lookup_asset_transactions(asset_id, tx_type="acfg") + print_success(f"Found {len(acfg_txns.transactions)} asset config transaction(s)") + if acfg_txns.transactions: + for tx in acfg_txns.transactions: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + if tx.created_asset_id: + print_info(f" - {tx_id_display}: asset creation") + else: + print_info(f" - {tx_id_display}: asset reconfiguration") + except Exception as e: + print_error(f"tx_type filter failed: {e}") + + # ========================================================================= + # Step 9: Filter by round range (min_round, max_round) + # ========================================================================= + print_step(9, "Filtering by round range (min_round, max_round)") + + try: + # Get current round + latest_txns = indexer.lookup_asset_transactions(asset_id, limit=1) + current_round = latest_txns.current_round + + print_info(f"Transactions created starting from round: {start_round}") + print_info(f"Current round: {current_round}") + print_info("") + + # Filter by round range + print_info(f"Searching for transactions from round {start_round} to {current_round}...") + round_filtered_txns = indexer.lookup_asset_transactions( + asset_id, + min_round=start_round, + max_round=current_round, + ) + + print_success(f"Found {len(round_filtered_txns.transactions)} transaction(s) in round range") + if round_filtered_txns.transactions: + rounds = [tx.confirmed_round for tx in round_filtered_txns.transactions if tx.confirmed_round is not None] + if rounds: + min_found_round = min(rounds) + max_found_round = max(rounds) + print_info(f" Rounds of found transactions: {min_found_round} to {max_found_round}") + except Exception as e: + print_error(f"round filter failed: {e}") + + # ========================================================================= + # Step 10: Filter by time range (before_time, after_time) + # ========================================================================= + print_step(10, "Filtering by time range (before_time, after_time)") + + try: + # Time filters use RFC 3339 format (ISO 8601, e.g., "2026-01-26T10:00:00.000Z") + now = datetime.now(tz=timezone.utc) + one_hour_ago = datetime.fromtimestamp(now.timestamp() - 60 * 60, tz=timezone.utc) + + after_time_str = one_hour_ago.isoformat() + before_time_str = now.isoformat() + + print_info("Time filters use RFC 3339 format (ISO 8601)") + print_info(f" after_time: {after_time_str}") + print_info(f" before_time: {before_time_str}") + print_info("") + + print_info("Searching for transactions in the last hour...") + time_filtered_txns = indexer.lookup_asset_transactions( + asset_id, + after_time=after_time_str, + before_time=before_time_str, + ) + + print_success(f"Found {len(time_filtered_txns.transactions)} transaction(s) in time range") + if time_filtered_txns.transactions: + times = [tx.round_time for tx in time_filtered_txns.transactions if tx.round_time is not None] + if times: + min_time = min(times) + max_time = max(times) + earliest = datetime.fromtimestamp(min_time, tz=timezone.utc).isoformat() + latest = datetime.fromtimestamp(max_time, tz=timezone.utc).isoformat() + print_info(" Time range of found transactions:") + print_info(f" - Earliest: {earliest}") + print_info(f" - Latest: {latest}") + except Exception as e: + print_error(f"time filter failed: {e}") + + # ========================================================================= + # Step 11: Filter by currency amount + # ========================================================================= + print_step(11, "Filtering by currency amount (currency_greater_than, currency_less_than)") + + try: + # currency_greater_than/currency_less_than filter by transaction amount + print_info("Searching for transfers with amount > 0 (excludes opt-ins)...") + non_zero_txns = indexer.lookup_asset_transactions( + asset_id, + tx_type="axfer", + currency_greater_than=0, + ) + + print_success(f"Found {len(non_zero_txns.transactions)} transfer(s) with amount > 0") + if non_zero_txns.transactions: + for tx in non_zero_txns.transactions: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + amount = tx.asset_transfer_transaction.amount if tx.asset_transfer_transaction else 0 + print_info(f" - {tx_id_display}: amount={amount:,}") + print_info("") + + # Filter for large transfers only + print_info("Searching for transfers with amount > 500,000 (> 500 TXN)...") + large_txns = indexer.lookup_asset_transactions( + asset_id, + tx_type="axfer", + currency_greater_than=500_000, + ) + + print_success(f"Found {len(large_txns.transactions)} large transfer(s)") + if large_txns.transactions: + for tx in large_txns.transactions: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + amount = tx.asset_transfer_transaction.amount if tx.asset_transfer_transaction else 0 + print_info(f" - {tx_id_display}: amount={amount:,}") + except Exception as e: + print_error(f"currency filter failed: {e}") + + # ========================================================================= + # Step 12: Combining multiple filters + # ========================================================================= + print_step(12, "Combining multiple filters") + + try: + print_info("You can combine multiple filters to narrow down results.") + print_info("") + + # Combine tx_type and address + print_info(f"Searching for asset transfers TO {shorten_address(holder_1_address)}...") + combined_txns_1 = indexer.lookup_asset_transactions( + asset_id, + tx_type="axfer", + address=holder_1_address, + address_role="receiver", + ) + print_success(f"Found {len(combined_txns_1.transactions)} transfer(s) to Holder 1") + for tx in combined_txns_1.transactions: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + amount = tx.asset_transfer_transaction.amount if tx.asset_transfer_transaction else 0 + print_info(f" - {tx_id_display}: amount={amount:,}") + print_info("") + + # Combine round range and tx_type + print_info("Searching for freeze transactions in recent rounds...") + latest_result = indexer.lookup_asset_transactions(asset_id, limit=1) + combined_txns_2 = indexer.lookup_asset_transactions( + asset_id, + tx_type="afrz", + min_round=start_round, + max_round=latest_result.current_round, + ) + print_success(f"Found {len(combined_txns_2.transactions)} freeze transaction(s) in recent rounds") + for tx in combined_txns_2.transactions: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + frozen = tx.asset_freeze_transaction.new_freeze_status if tx.asset_freeze_transaction else False + print_info(f" - {tx_id_display}: frozen={frozen}, round={tx.confirmed_round}") + except Exception as e: + print_error(f"combined filters failed: {e}") + + # ========================================================================= + # Step 13: Pagination with limit and next + # ========================================================================= + print_step(13, "Demonstrating pagination with limit and next") + + try: + print_info("Using limit=3 to demonstrate pagination...") + page_1 = indexer.lookup_asset_transactions(asset_id, limit=3) + + print_info(f"Page 1: Retrieved {len(page_1.transactions)} transaction(s)") + for tx in page_1.transactions: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + print_info(f" - {tx_id_display}: {tx.tx_type}") + + if page_1.next_token: + token_preview = page_1.next_token[:20] + print_info(f" Next token available: {token_preview}...") + print_info("") + + print_info("Fetching next page...") + page_2 = indexer.lookup_asset_transactions( + asset_id, + limit=3, + next_=page_1.next_token, + ) + + print_info(f"Page 2: Retrieved {len(page_2.transactions)} transaction(s)") + for tx in page_2.transactions: + tx_id_display = shorten_address(tx.id_, 8, 6) if tx.id_ else "N/A" + print_info(f" - {tx_id_display}: {tx.tx_type}") + + if page_2.next_token: + print_info(" More pages available (next_token present)") + else: + print_info(" No more pages (no next_token)") + else: + print_info(" No pagination needed (all results fit in one page)") + except Exception as e: + print_error(f"pagination failed: {e}") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated lookup_asset_transactions() with various filters:") + print_info("") + print_info("Key characteristics:") + print_info(" - Results are returned oldest to newest") + print_info(" - Returns all transaction types involving the asset (acfg, axfer, afrz)") + print_info("") + print_info("Transaction types for assets:") + print_info(" - acfg: Asset configuration (create, reconfigure, destroy)") + print_info(" - axfer: Asset transfer (opt-in with 0 amount, transfers, close-out)") + print_info(" - afrz: Asset freeze (freeze/unfreeze account holdings)") + print_info("") + print_info("Address filtering with address_role:") + print_info(" - sender: Transactions where address is the sender") + print_info(" - receiver: Transactions where address is the receiver") + print_info(" - freeze-target: Freeze transactions targeting the address") + print_info("") + print_info("Other filter parameters:") + print_info(" - tx_type: Filter by transaction type (acfg, axfer, afrz)") + print_info(" - min_round/max_round: Filter by round range") + print_info(" - before_time/after_time: Filter by time (RFC 3339 format)") + print_info(" - currency_greater_than/currency_less_than: Filter by amount") + print_info(" - sig_type: Filter by signature type (sig, msig, lsig)") + print_info(" - note_prefix: Filter by note prefix") + print_info(" - tx_id: Find specific transaction by ID") + print_info(" - exclude_close_to: Exclude close-to transactions") + print_info(" - rekey_to: Filter for rekey transactions") + print_info("") + print_info("Pagination:") + print_info(" - limit: Maximum number of results per page") + print_info(" - next: Token from previous response to get next page") + + +if __name__ == "__main__": + main() diff --git a/examples/indexer_client/11_application_lookup.py b/examples/indexer_client/11_application_lookup.py new file mode 100644 index 00000000..ed5f7898 --- /dev/null +++ b/examples/indexer_client/11_application_lookup.py @@ -0,0 +1,483 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Application Lookup + +This example demonstrates how to lookup and search for applications using +the IndexerClient lookup_application_by_id() and search_for_applications() methods. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import base64 +import time + +from shared import ( + create_algod_client, + create_algorand_client, + create_indexer_client, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, + wait_for_confirmation, +) + +from algokit_utils.transactions.types import AppCreateParams, AppDeleteParams + + +def main() -> None: + print_header("Application Lookup Example") + + # Create clients + indexer = create_indexer_client() + algorand = create_algorand_client() + algod = create_algod_client() + + # ========================================================================= + # Step 1: Get a funded account from LocalNet + # ========================================================================= + print_step(1, "Getting a funded account from LocalNet") + + try: + creator_account = algorand.account.localnet_dispenser() + algorand.set_signer_from_account(creator_account) + creator_address = creator_account.addr + print_success(f"Using dispenser account: {shorten_address(creator_address)}") + except Exception as e: + print_error(f"Failed to get dispenser account: {e}") + print_info("") + print_info("Make sure LocalNet is running: algokit localnet start") + print_info("If issues persist, try: algokit localnet reset") + return + + # ========================================================================= + # Step 2: Deploy test applications using AlgorandClient + # ========================================================================= + print_step(2, "Deploying test applications for demonstration") + + try: + # Simple approval program that stores a counter in global state + approval_source = """#pragma version 10 +// Simple smart contract for demonstration +txn ApplicationID +int 0 +== +bnz handle_creation + +txn OnCompletion +int NoOp +== +bnz handle_noop + +txn OnCompletion +int DeleteApplication +== +bnz handle_delete + +int 0 +return + +handle_creation: + byte "counter" + int 0 + app_global_put + byte "name" + byte "DemoApp" + app_global_put + int 1 + return + +handle_noop: + byte "counter" + app_global_get + int 1 + + + byte "counter" + swap + app_global_put + int 1 + return + +handle_delete: + int 1 + return +""" + + clear_source = """#pragma version 10 +int 1 +return +""" + + # Compile TEAL programs + print_info("Compiling TEAL programs...") + approval_result = algod.teal_compile(approval_source.encode()) + approval_program = base64.b64decode(approval_result.result) + + clear_result = algod.teal_compile(clear_source.encode()) + clear_program = base64.b64decode(clear_result.result) + + print_info(f"Approval program: {len(approval_program)} bytes") + print_info(f"Clear state program: {len(clear_program)} bytes") + print_info("") + + # Create first application + print_info("Creating first test application: DemoApp1...") + txn_1 = algorand.create_transaction.app_create( + AppCreateParams( + sender=creator_address, + approval_program=approval_program, + clear_state_program=clear_program, + schema={ + "global_ints": 1, + "global_byte_slices": 1, + "local_ints": 0, + "local_byte_slices": 0, + }, + ) + ) + signed_txn_1 = creator_account.signer([txn_1], [0]) + result_1 = algod.send_raw_transaction(signed_txn_1) + tx_id_1 = result_1.tx_id + pending_1 = wait_for_confirmation(algod, tx_id_1) + app_id_1 = pending_1.app_id + print_success(f"Created DemoApp1 with Application ID: {app_id_1}") + + # Create second application with different schema + print_info("Creating second test application: DemoApp2...") + txn_2 = algorand.create_transaction.app_create( + AppCreateParams( + sender=creator_address, + approval_program=approval_program, + clear_state_program=clear_program, + schema={ + "global_ints": 2, + "global_byte_slices": 2, + "local_ints": 1, + "local_byte_slices": 1, + }, + ) + ) + signed_txn_2 = creator_account.signer([txn_2], [0]) + result_2 = algod.send_raw_transaction(signed_txn_2) + tx_id_2 = result_2.tx_id + pending_2 = wait_for_confirmation(algod, tx_id_2) + app_id_2 = pending_2.app_id + print_success(f"Created DemoApp2 with Application ID: {app_id_2}") + + # Small delay to allow indexer to catch up + print_info("Waiting for indexer to index applications...") + time.sleep(3) + print_info("") + except Exception as e: + print_error(f"Failed to create test applications: {e}") + print_info("") + print_info("If LocalNet errors occur, try: algokit localnet reset") + return + + # ========================================================================= + # Step 3: Lookup application by ID with lookup_application_by_id() + # ========================================================================= + print_step(3, "Looking up application by ID with lookup_application_by_id()") + + try: + # lookup_application_by_id() returns detailed information about a single application + app_result = indexer.lookup_application_by_id(app_id_1) + + if app_result.application: + app = app_result.application + print_success(f"Found application with ID: {app.id_}") + print_info("") + + # Display application params + print_info("Application params:") + print_info(f" - id: {app.id_}") + if app.params.creator: + print_info(f" - creator: {shorten_address(app.params.creator)}") + if app.params.approval_program: + print_info(f" - approval_program: {len(app.params.approval_program)} bytes") + if app.params.clear_state_program: + print_info(f" - clear_state_program: {len(app.params.clear_state_program)} bytes") + if app.params.extra_program_pages is not None: + print_info(f" - extra_program_pages: {app.params.extra_program_pages}") + print_info("") + + # Display state schema + print_info("State schema:") + if app.params.global_state_schema: + gss = app.params.global_state_schema + print_info(f" - global_state_schema: {gss.num_uints} uints, {gss.num_byte_slices} byte slices") + if app.params.local_state_schema: + lss = app.params.local_state_schema + print_info(f" - local_state_schema: {lss.num_uints} uints, {lss.num_byte_slices} byte slices") + print_info("") + + # Display global state key-value pairs if present + if app.params.global_state and len(app.params.global_state) > 0: + print_info("Global state key-value pairs:") + for kv in app.params.global_state: + # Decode the key from bytes to string + key_bytes = base64.b64decode(kv.key) if isinstance(kv.key, str) else kv.key + key_str = key_bytes.decode("utf-8") + # Value type: 1 = bytes, 2 = uint + if kv.value.type_ == 2: + print_info(f' - "{key_str}": {kv.value.uint} (uint)') + else: + kv_bytes = kv.value.bytes_ + value_bytes = base64.b64decode(kv_bytes) if isinstance(kv_bytes, str) else kv_bytes + value_str = value_bytes.decode("utf-8") if value_bytes else "(empty)" + print_info(f' - "{key_str}": "{value_str}" (bytes)') + else: + print_info("Global state: (empty or not set)") + print_info("") + + # Display additional metadata + if app.created_at_round is not None: + print_info(f"Created at round: {app.created_at_round}") + if app.deleted is not None: + print_info(f"Deleted: {app.deleted}") + if app.deleted_at_round is not None: + print_info(f"Deleted at round: {app.deleted_at_round}") + else: + print_info("Application not found in response") + + print_info(f"Query performed at round: {app_result.current_round}") + except Exception as e: + print_error(f"lookup_application_by_id failed: {e}") + + # ========================================================================= + # Step 4: Lookup second application to compare + # ========================================================================= + print_step(4, "Looking up second application to compare schemas") + + try: + app_result_2 = indexer.lookup_application_by_id(app_id_2) + + if app_result_2.application: + app = app_result_2.application + print_success(f"Found application with ID: {app.id_}") + print_info("") + + print_info("State schema (different from first app):") + if app.params.global_state_schema: + gss = app.params.global_state_schema + print_info(f" - global_state_schema: {gss.num_uints} uints, {gss.num_byte_slices} byte slices") + if app.params.local_state_schema: + lss = app.params.local_state_schema + print_info(f" - local_state_schema: {lss.num_uints} uints, {lss.num_byte_slices} byte slices") + except Exception as e: + print_error(f"lookup_application_by_id failed: {e}") + + # ========================================================================= + # Step 5: Search for applications with search_for_applications() + # ========================================================================= + print_step(5, "Searching for applications with search_for_applications()") + + try: + # search_for_applications() returns a list of applications matching the criteria + search_result = indexer.search_for_applications() + + print_success(f"Found {len(search_result.applications)} application(s)") + print_info("") + + if search_result.applications: + print_info("Applications found:") + # Show first 5 applications to avoid too much output + apps_to_show = search_result.applications[:5] + for app in apps_to_show: + print_info(f" Application ID: {app.id_}") + if app.params.creator: + print_info(f" - creator: {shorten_address(app.params.creator)}") + if app.deleted: + print_info(f" - deleted: {app.deleted}") + print_info("") + if len(search_result.applications) > 5: + print_info(f" ... and {len(search_result.applications) - 5} more") + + print_info(f"Query performed at round: {search_result.current_round}") + except Exception as e: + print_error(f"search_for_applications failed: {e}") + + # ========================================================================= + # Step 6: Filter applications by creator address + # ========================================================================= + print_step(6, "Filtering applications by creator address") + + try: + # Filter applications by creator + print_info(f"Searching for applications created by: {shorten_address(creator_address)}") + filtered_result = indexer.search_for_applications(creator=creator_address) + + print_success(f"Found {len(filtered_result.applications)} application(s) by this creator") + print_info("") + + if filtered_result.applications: + print_info("Applications by this creator:") + for app in filtered_result.applications: + print_info(f" Application ID: {app.id_}") + if app.params.global_state_schema: + gss = app.params.global_state_schema + print_info(f" - global_state_schema: {gss.num_uints} uints, {gss.num_byte_slices} byte slices") + except Exception as e: + print_error(f"search_for_applications by creator failed: {e}") + + # ========================================================================= + # Step 7: Delete an application and demonstrate include_all parameter + # ========================================================================= + print_step(7, "Deleting an application to demonstrate include_all parameter") + + try: + # Delete the second application + print_info(f"Deleting application {app_id_2}...") + delete_txn = algorand.create_transaction.app_delete( + AppDeleteParams( + sender=creator_address, + app_id=app_id_2, + ) + ) + signed_delete = creator_account.signer([delete_txn], [0]) + delete_result = algod.send_raw_transaction(signed_delete) + delete_tx_id = delete_result.tx_id + wait_for_confirmation(algod, delete_tx_id) + print_success(f"Deleted application {app_id_2}") + print_info("") + + # Wait for indexer to catch up + time.sleep(2) + + # Search without include_all (should not include deleted apps) + print_info("Searching for applications by creator (without include_all)...") + without_deleted = indexer.search_for_applications( + creator=creator_address, + include_all=False, + ) + print_info(f"Found {len(without_deleted.applications)} application(s) (excludes deleted)") + + # Search with include_all to include deleted applications + print_info("Searching for applications by creator (with include_all: True)...") + with_deleted = indexer.search_for_applications( + creator=creator_address, + include_all=True, + ) + print_info(f"Found {len(with_deleted.applications)} application(s) (includes deleted)") + print_info("") + + # Show deleted application details + deleted_app = next((app for app in with_deleted.applications if app.id_ == app_id_2), None) + if deleted_app: + print_info(f"Deleted application (ID: {deleted_app.id_}):") + print_info(f" - deleted: {deleted_app.deleted}") + if deleted_app.deleted_at_round is not None: + print_info(f" - deleted_at_round: {deleted_app.deleted_at_round}") + except Exception as e: + print_error(f"Delete/include_all demo failed: {e}") + + # ========================================================================= + # Step 8: Handle case where application is not found + # ========================================================================= + print_step(8, "Handling case where application is not found") + + try: + # Try to lookup a non-existent application + non_existent_app_id = 999999999 + print_info(f"Attempting to lookup non-existent application ID: {non_existent_app_id}") + + result = indexer.lookup_application_by_id(non_existent_app_id) + + # The response may have application as None for non-existent apps + if result.application: + print_info(f"Unexpectedly found application: {result.application.id_}") + else: + print_info("Application field is None in response (application not found)") + except Exception as e: + # Some indexers throw an error for non-existent applications + print_info(f"Application not found (caught error): {e}") + + # ========================================================================= + # Step 9: Demonstrate pagination with limit and next parameters + # ========================================================================= + print_step(9, "Demonstrating pagination with limit and next parameters") + + try: + # First page with limit + print_info("Fetching first page of applications (limit: 1)...") + page_1 = indexer.search_for_applications(limit=1) + + print_info(f"Page 1: Retrieved {len(page_1.applications)} application(s)") + if page_1.applications: + print_info(f" - Application ID: {page_1.applications[0].id_}") + + # Check if there are more results + if page_1.next_token: + token_preview = page_1.next_token[:20] + print_info(f" - Next token available: {token_preview}...") + print_info("") + + # Fetch second page using next token + print_info("Fetching second page using next token...") + page_2 = indexer.search_for_applications( + limit=1, + next_=page_1.next_token, + ) + + print_info(f"Page 2: Retrieved {len(page_2.applications)} application(s)") + if page_2.applications: + print_info(f" - Application ID: {page_2.applications[0].id_}") + + if page_2.next_token: + print_info(" - More results available (next_token present)") + else: + print_info(" - No more results (no next_token)") + else: + print_info(" - No pagination needed (all results fit in one page)") + except Exception as e: + print_error(f"Pagination demo failed: {e}") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. Deploying test applications using TEAL compilation") + print_info(" 2. lookup_application_by_id(app_id) - Get detailed info about a single application") + print_info(" 3. Display application params: id, creator, approval_program, clear_state_program") + print_info(" 4. Display state schema: global_state_schema, local_state_schema") + print_info(" 5. Display global state key-value pairs") + print_info(" 6. search_for_applications() - Search for applications") + print_info(" 7. Filtering by creator address") + print_info(" 8. Using include_all to include deleted applications") + print_info(" 9. Handling case where application is not found") + print_info(" 10. Pagination with limit and next parameters") + print_info("") + print_info("Key lookup_application_by_id response fields:") + print_info(" - application: The Application object (may be None if not found)") + print_info(" - current_round: Round at which results were computed") + print_info("") + print_info("Key Application fields:") + print_info(" - id: Application identifier (int)") + print_info(" - deleted: Whether app is deleted (bool, optional)") + print_info(" - created_at_round: Round when created (int, optional)") + print_info(" - deleted_at_round: Round when deleted (int, optional)") + print_info(" - params: ApplicationParams object") + print_info("") + print_info("Key ApplicationParams fields:") + print_info(" - creator: Address that created the application") + print_info(" - approval_program: TEAL bytecode for approval logic (bytes)") + print_info(" - clear_state_program: TEAL bytecode for clear state logic (bytes)") + print_info(" - global_state_schema: {num_uint, num_byte_slice} for global storage") + print_info(" - local_state_schema: {num_uint, num_byte_slice} for per-user storage") + print_info(" - global_state: Array of TealKeyValue for current global state") + print_info(" - extra_program_pages: Extra program pages (int, optional)") + print_info("") + print_info("search_for_applications() filter parameters:") + print_info(" - application_id: Filter by specific app ID") + print_info(" - creator: Filter by creator address") + print_info(" - include_all: Include deleted applications (default: False)") + print_info(" - limit: Maximum results per page") + print_info(" - next: Pagination token from previous response") + + +if __name__ == "__main__": + main() diff --git a/examples/indexer_client/12_application_logs.py b/examples/indexer_client/12_application_logs.py new file mode 100644 index 00000000..10a27df0 --- /dev/null +++ b/examples/indexer_client/12_application_logs.py @@ -0,0 +1,424 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Application Logs Lookup + +This example demonstrates how to lookup application logs using +the IndexerClient lookup_application_logs_by_id() method. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import base64 +import time + +from shared import ( + create_algod_client, + create_algorand_client, + create_indexer_client, + load_teal_source, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, + wait_for_confirmation, +) + +from algokit_utils import AlgoAmount, PaymentParams +from algokit_utils.transactions.types import AppCallParams, AppCreateParams + + +def decode_log_entry(log_bytes: bytes) -> str: + """ + Decode log bytes to string if possible, otherwise show hex. + """ + try: + # Try to decode as UTF-8 string + decoded = log_bytes.decode("utf-8") + # Check if it's printable ASCII/UTF-8 + if all(0x20 <= ord(c) <= 0x7E or c in "\t\n\r" for c in decoded): + return f'"{decoded}"' + except (UnicodeDecodeError, AttributeError): + pass + + # Display as hex for binary data + hex_str = log_bytes.hex() + return f"0x{hex_str} ({len(log_bytes)} bytes)" + + +def main() -> None: + print_header("Application Logs Lookup Example") + + # Create clients + indexer = create_indexer_client() + algorand = create_algorand_client() + algod = create_algod_client() + + # ========================================================================= + # Step 1: Get funded accounts from LocalNet + # ========================================================================= + print_step(1, "Getting funded accounts from LocalNet") + + try: + creator_account = algorand.account.localnet_dispenser() + algorand.set_signer_from_account(creator_account) + creator_address = creator_account.addr + print_success(f"Using dispenser account as creator: {shorten_address(creator_address)}") + + # Create a separate caller account for sender filtering demo + caller_account = algorand.account.kmd.get_or_create_wallet_account("caller-account") + algorand.set_signer_from_account(caller_account) + caller_address = caller_account.addr + print_success(f"Using caller account: {shorten_address(caller_address)}") + + # Fund the caller account + algorand.send.payment( + PaymentParams( + sender=creator_address, + receiver=caller_address, + amount=AlgoAmount.from_algo(1), + ) + ) + print_info("Funded caller account with 1 ALGO") + except Exception as e: + print_error(f"Failed to get accounts: {e}") + print_info("") + print_info("Make sure LocalNet is running: algokit localnet start") + print_info("If issues persist, try: algokit localnet reset") + return + + # ========================================================================= + # Step 2: Deploy an application that emits logs + # ========================================================================= + print_step(2, "Deploying an application that emits logs") + + try: + # Load TEAL programs from shared artifacts + approval_source = load_teal_source("approval-logging.teal") + clear_source = load_teal_source("clear-state-logging.teal") + + # Compile TEAL programs + print_info("Compiling TEAL programs...") + approval_result = algod.teal_compile(approval_source.encode()) + approval_program = base64.b64decode(approval_result.result) + + clear_result = algod.teal_compile(clear_source.encode()) + clear_state_program = base64.b64decode(clear_result.result) + + print_info(f"Approval program: {len(approval_program)} bytes") + print_info(f"Clear state program: {len(clear_state_program)} bytes") + print_info("") + + # Create application + print_info("Creating application...") + create_txn = algorand.create_transaction.app_create( + AppCreateParams( + sender=creator_address, + approval_program=approval_program, + clear_state_program=clear_state_program, + schema={ + "global_ints": 0, + "global_byte_slices": 0, + "local_ints": 0, + "local_byte_slices": 0, + }, + ) + ) + + signed_create_txn = creator_account.signer([create_txn], [0]) + result = algod.send_raw_transaction(signed_create_txn) + tx_id = result.tx_id + pending_info = wait_for_confirmation(algod, tx_id) + app_id = pending_info.app_id + print_success(f"Created application with ID: {app_id}") + print_info(f"Creation transaction ID: {tx_id}") + print_info("") + except Exception as e: + print_error(f"Failed to create application: {e}") + print_info("") + print_info("If LocalNet errors occur, try: algokit localnet reset") + return + + # ========================================================================= + # Step 3: Call the application multiple times to generate logs + # ========================================================================= + print_step(3, "Calling the application multiple times to generate logs") + + call_tx_ids: list[str] = [] + first_call_round: int = 0 + last_call_round: int = 0 + + try: + # Make several calls from the creator account using the high-level send API + for i in range(3): + call_result = algorand.send.app_call( + AppCallParams( + sender=creator_address, + app_id=app_id, + note=f"log call {i + 1}".encode(), + ) + ) + + call_tx_id = call_result.tx_ids[0] + call_tx_ids.append(call_tx_id) + + confirmed_round = call_result.confirmation.confirmed_round + if first_call_round == 0: + first_call_round = confirmed_round + last_call_round = confirmed_round + + tx_id_preview = call_tx_id[:12] + print_info(f"Call {i + 1}: txId={tx_id_preview}..., round={confirmed_round}") + + # Make a call from the caller account (different sender) + caller_call_result = algorand.send.app_call( + AppCallParams( + sender=caller_address, + app_id=app_id, + note=b"log call from caller", + ) + ) + + caller_tx_id = caller_call_result.tx_ids[0] + call_tx_ids.append(caller_tx_id) + last_call_round = caller_call_result.confirmation.confirmed_round + + tx_id_preview = caller_tx_id[:12] + print_info(f"Call 4 (from caller): txId={tx_id_preview}..., round={last_call_round}") + print_success("Made 4 application calls (3 from creator, 1 from caller)") + print_info("") + except Exception as e: + print_error(f"Failed to call application: {e}") + return + + # ========================================================================= + # Step 4: Lookup application logs with lookup_application_logs_by_id() + # ========================================================================= + print_step(4, "Looking up application logs with lookup_application_logs_by_id()") + + # Wait for indexer to catch up with algod + print_info("Waiting for indexer to sync...") + time.sleep(3) + + try: + # lookup_application_logs_by_id() returns all logs for an application + logs_result = indexer.lookup_application_logs_by_id(app_id) + + print_success(f"Retrieved logs for application {logs_result.application_id}") + print_info(f"Query performed at round: {logs_result.current_round}") + print_info("") + + if logs_result.log_data and len(logs_result.log_data) > 0: + print_info(f"Found {len(logs_result.log_data)} transaction(s) with logs:") + print_info("") + + for log_entry in logs_result.log_data: + print_info(f"Transaction: {log_entry.tx_id}") + print_info(f" Logs ({len(log_entry.logs)} entries):") + for i, log in enumerate(log_entry.logs): + # Handle both bytes and base64-encoded strings + log_bytes = base64.b64decode(log) if isinstance(log, str) else log + decoded = decode_log_entry(log_bytes) + print_info(f" [{i}] {decoded}") + print_info("") + else: + print_info("No logs found for this application") + + if logs_result.next_token: + token_preview = logs_result.next_token[:20] + print_info(f"More results available (nextToken: {token_preview}...)") + except Exception as e: + print_error(f"lookup_application_logs_by_id failed: {e}") + + # ========================================================================= + # Step 5: Filter logs by txId to get logs from a specific transaction + # ========================================================================= + print_step(5, "Filtering logs by txId") + + try: + specific_tx_id = call_tx_ids[0] + tx_id_preview = specific_tx_id[:20] + print_info(f"Filtering logs for specific transaction: {tx_id_preview}...") + + filtered_result = indexer.lookup_application_logs_by_id( + app_id, + txid=specific_tx_id, + ) + + if filtered_result.log_data and len(filtered_result.log_data) > 0: + print_success(f"Found {len(filtered_result.log_data)} log entry for transaction") + for log_entry in filtered_result.log_data: + print_info(f"Transaction: {log_entry.tx_id}") + print_info(f" Logs ({len(log_entry.logs)} entries):") + for i, log in enumerate(log_entry.logs): + log_bytes = base64.b64decode(log) if isinstance(log, str) else log + decoded = decode_log_entry(log_bytes) + print_info(f" [{i}] {decoded}") + else: + print_info("No logs found for this transaction") + except Exception as e: + print_error(f"txId filtering failed: {e}") + + # ========================================================================= + # Step 6: Filter logs by min_round and max_round + # ========================================================================= + print_step(6, "Filtering logs by min_round and max_round") + + try: + print_info(f"Filtering logs between rounds {first_call_round} and {last_call_round}") + + # Filter by min_round + print_info("") + print_info(f"Logs with min_round={first_call_round}:") + min_round_result = indexer.lookup_application_logs_by_id( + app_id, + min_round=first_call_round, + ) + if min_round_result.log_data: + print_info(f" Found {len(min_round_result.log_data)} transaction(s) with logs") + + # Filter by max_round + print_info("") + print_info(f"Logs with max_round={first_call_round}:") + max_round_result = indexer.lookup_application_logs_by_id( + app_id, + max_round=first_call_round, + ) + if max_round_result.log_data: + print_info(f" Found {len(max_round_result.log_data)} transaction(s) with logs") + + # Filter by range (min_round and max_round combined) + print_info("") + print_info(f"Logs with min_round={first_call_round} and max_round={last_call_round}:") + range_result = indexer.lookup_application_logs_by_id( + app_id, + min_round=first_call_round, + max_round=last_call_round, + ) + if range_result.log_data: + print_info(f" Found {len(range_result.log_data)} transaction(s) with logs") + for log_entry in range_result.log_data: + tx_preview = log_entry.tx_id[:20] + print_info(f" - {tx_preview}... ({len(log_entry.logs)} log entries)") + except Exception as e: + print_error(f"Round filtering failed: {e}") + + # ========================================================================= + # Step 7: Filter logs by sender_address + # ========================================================================= + print_step(7, "Filtering logs by sender_address") + + try: + # Filter logs by creator address + print_info(f"Filtering logs by sender: {shorten_address(creator_address)}") + creator_logs_result = indexer.lookup_application_logs_by_id( + app_id, + sender_address=creator_address, + ) + if creator_logs_result.log_data: + print_success(f"Found {len(creator_logs_result.log_data)} transaction(s) from creator") + + # Filter logs by caller address + print_info("") + print_info(f"Filtering logs by sender: {shorten_address(caller_address)}") + caller_logs_result = indexer.lookup_application_logs_by_id( + app_id, + sender_address=caller_address, + ) + if caller_logs_result.log_data: + print_success(f"Found {len(caller_logs_result.log_data)} transaction(s) from caller") + for log_entry in caller_logs_result.log_data: + tx_preview = log_entry.tx_id[:20] + print_info(f" Transaction: {tx_preview}...") + for i, log in enumerate(log_entry.logs): + log_bytes = base64.b64decode(log) if isinstance(log, str) else log + decoded = decode_log_entry(log_bytes) + print_info(f" [{i}] {decoded}") + except Exception as e: + print_error(f"sender_address filtering failed: {e}") + + # ========================================================================= + # Step 8: Demonstrate pagination for applications with many log entries + # ========================================================================= + print_step(8, "Demonstrating pagination with limit and next parameters") + + try: + # First page with limit of 2 + print_info("Fetching first page of logs (limit: 2)...") + page1 = indexer.lookup_application_logs_by_id(app_id, limit=2) + + if page1.log_data: + print_info(f"Page 1: Retrieved {len(page1.log_data)} transaction(s) with logs") + for log_entry in page1.log_data: + tx_preview = log_entry.tx_id[:20] + print_info(f" - {tx_preview}...") + + # Check if there are more results + if page1.next_token: + token_preview = page1.next_token[:20] + print_info(f" Next token available: {token_preview}...") + print_info("") + + # Fetch second page using next token + print_info("Fetching second page using next token...") + page2 = indexer.lookup_application_logs_by_id( + app_id, + limit=2, + next_=page1.next_token, + ) + + if page2.log_data: + print_info(f"Page 2: Retrieved {len(page2.log_data)} transaction(s) with logs") + for log_entry in page2.log_data: + tx_preview = log_entry.tx_id[:20] + print_info(f" - {tx_preview}...") + + if page2.next_token: + print_info(" More results available (nextToken present)") + else: + print_info(" No more results (no nextToken)") + else: + print_info(" No pagination needed (all results fit in one page)") + except Exception as e: + print_error(f"Pagination demo failed: {e}") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. Deploying an application that emits logs using the `log` opcode") + print_info(" 2. Calling the application to generate log entries") + print_info(" 3. lookup_application_logs_by_id(app_id) - Get all logs for an application") + print_info(" 4. Displaying log entry fields: tx_id and logs (decoded from bytes)") + print_info(" 5. Filtering by txid to get logs from a specific transaction") + print_info(" 6. Filtering by min_round and max_round for round range queries") + print_info(" 7. Filtering by sender_address to get logs from a specific caller") + print_info(" 8. Pagination with limit and next parameters") + print_info("") + print_info("Key lookup_application_logs_by_id response fields:") + print_info(" - application_id: The application identifier (int)") + print_info(" - current_round: Round at which results were computed (int)") + print_info(" - log_data: Array of ApplicationLogData objects") + print_info(" - next_token: Pagination token for next page (optional)") + print_info("") + print_info("Key ApplicationLogData fields:") + print_info(" - tx_id: Transaction ID that generated the logs") + print_info(" - logs: Array of bytes, each containing a log entry") + print_info("") + print_info("Filter parameters:") + print_info(" - txid: Filter by specific transaction ID") + print_info(" - min_round: Only include logs from this round onwards") + print_info(" - max_round: Only include logs up to this round") + print_info(" - sender_address: Filter by the address that called the application") + print_info(" - limit: Maximum results per page") + print_info(" - next: Pagination token from previous response") + print_info("") + print_info("Note: The `log` opcode in TEAL emits log entries that are stored") + print_info("in the transaction result and indexed by the indexer.") + + +if __name__ == "__main__": + main() diff --git a/examples/indexer_client/13_application_boxes.py b/examples/indexer_client/13_application_boxes.py new file mode 100644 index 00000000..074c8a8e --- /dev/null +++ b/examples/indexer_client/13_application_boxes.py @@ -0,0 +1,457 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Application Boxes Lookup + +This example demonstrates how to query application boxes using +the IndexerClient search_for_application_boxes() and lookup_application_box_by_id_and_name() methods. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import base64 +import time + +from shared import ( + create_algod_client, + create_algorand_client, + create_indexer_client, + load_teal_source, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_common import get_application_address +from algokit_transact import BoxReference +from algokit_utils import AlgoAmount, PaymentParams +from algokit_utils.transactions.types import AppCallParams, AppCreateParams + + +def decode_box_name(name_bytes: bytes) -> str: + """ + Decode box name bytes to a displayable string. + Shows as a UTF-8 string if printable, otherwise as hex. + """ + try: + decoded = name_bytes.decode("utf-8") + # Check if it's printable ASCII/UTF-8 + if all(0x20 <= ord(c) <= 0x7E or c in "\t\n\r" for c in decoded): + return f'"{decoded}"' + except (UnicodeDecodeError, AttributeError): + pass + + # Display as hex for binary data + hex_str = name_bytes.hex() + return f"0x{hex_str} ({len(name_bytes)} bytes)" + + +def decode_box_value(value_bytes: bytes) -> str: + """ + Decode box value bytes to a displayable string. + Shows as a UTF-8 string if printable, otherwise as hex. + """ + try: + decoded = value_bytes.decode("utf-8") + # Check if it's printable ASCII/UTF-8 + if all(0x20 <= ord(c) <= 0x7E or c in "\t\n\r" for c in decoded): + return f'"{decoded}"' + except (UnicodeDecodeError, AttributeError): + pass + + # Display as hex for binary data + hex_str = value_bytes.hex() + return f"0x{hex_str} ({len(value_bytes)} bytes)" + + +def main() -> None: + print_header("Application Boxes Lookup Example") + + # Create clients + indexer = create_indexer_client() + algorand = create_algorand_client() + algod = create_algod_client() + + # ========================================================================= + # Step 1: Get a funded account from LocalNet + # ========================================================================= + print_step(1, "Getting a funded account from LocalNet") + + try: + creator_account = algorand.account.localnet_dispenser() + algorand.set_signer_from_account(creator_account) + creator_address = creator_account.addr + print_success(f"Using dispenser account: {shorten_address(creator_address)}") + except Exception as e: + print_error(f"Failed to get dispenser account: {e}") + print_info("") + print_info("Make sure LocalNet is running: algokit localnet start") + print_info("If issues persist, try: algokit localnet reset") + return + + # ========================================================================= + # Step 2: Deploy an application that uses box storage + # ========================================================================= + print_step(2, "Deploying an application that uses box storage") + + try: + # Load approval program from shared artifacts + approval_source = load_teal_source("approval-box-ops.teal") + clear_source = load_teal_source("clear-state-approve.teal") + + # Compile TEAL programs + print_info("Compiling TEAL programs...") + approval_result = algod.teal_compile(approval_source.encode()) + approval_program = base64.b64decode(approval_result.result) + + clear_result = algod.teal_compile(clear_source.encode()) + clear_state_program = base64.b64decode(clear_result.result) + + print_info(f"Approval program: {len(approval_program)} bytes") + print_info(f"Clear state program: {len(clear_state_program)} bytes") + print_info("") + + # Create application using AlgorandClient's high-level API + print_info("Creating application...") + result = algorand.send.app_create( + AppCreateParams( + sender=creator_address, + approval_program=approval_program, + clear_state_program=clear_state_program, + schema={ + "global_ints": 0, + "global_byte_slices": 0, + "local_ints": 0, + "local_byte_slices": 0, + }, + ) + ) + + app_id = result.app_id + print_success(f"Created application with ID: {app_id}") + + # Fund the application account for box storage MBR + app_address = get_application_address(app_id) + print_info(f"Funding application account: {shorten_address(app_address)}") + algorand.send.payment( + PaymentParams( + sender=creator_address, + receiver=app_address, + amount=AlgoAmount.from_algo(1), + ) + ) + print_success("Funded application account with 1 ALGO for box storage") + print_info("") + except Exception as e: + print_error(f"Failed to create application: {e}") + print_info("") + print_info("If LocalNet errors occur, try: algokit localnet reset") + return + + # ========================================================================= + # Step 3: Handle case where application has no boxes + # ========================================================================= + print_step(3, "Handling case where application has no boxes") + + try: + # search_for_application_boxes() returns an empty array when no boxes exist + empty_result = indexer.search_for_application_boxes(app_id) + + print_info(f"Application ID: {empty_result.application_id}") + print_info(f"Number of boxes: {len(empty_result.boxes or [])}") + + if len(empty_result.boxes or []) == 0: + print_success("Correctly returned empty boxes array for new application") + print_info("Applications start with no boxes - boxes are created via app calls") + except Exception as e: + print_error(f"search_for_application_boxes failed: {e}") + + # ========================================================================= + # Step 4: Create several boxes with different names and values + # ========================================================================= + print_step(4, "Creating several boxes with different names and values") + + # Box data to create + box_data = [ + {"name": "user_count", "value": "42"}, + {"name": "settings", "value": '{"theme":"dark","lang":"en"}'}, + {"name": "metadata", "value": "v1.0.0-production"}, + {"name": "box_alpha", "value": "First box in alphabetical order"}, + {"name": "box_beta", "value": "Second box in alphabetical order"}, + {"name": "box_gamma", "value": "Third box in alphabetical order"}, + ] + + try: + for box in box_data: + box_name_bytes = box["name"].encode("utf-8") + box_value_bytes = box["value"].encode("utf-8") + + algorand.send.app_call( + AppCallParams( + sender=creator_address, + app_id=app_id, + args=[b"create_box", box_name_bytes, box_value_bytes], + box_references=[BoxReference(app_id=app_id, name=box_name_bytes)], + ) + ) + + print_info(f'Created box "{box["name"]}" with value: "{box["value"]}"') + print_success(f"Created {len(box_data)} boxes for demonstration") + print_info("") + except Exception as e: + print_error(f"Failed to create boxes: {e}") + return + + # ========================================================================= + # Step 5: Search for application boxes with search_for_application_boxes() + # ========================================================================= + print_step(5, "Searching for application boxes with search_for_application_boxes()") + + # Wait for the indexer to catch up with the algod transactions + print_info("Waiting for indexer to sync...") + time.sleep(3) + + try: + # search_for_application_boxes() returns all box names for an application + boxes_result = indexer.search_for_application_boxes(app_id) + + print_success(f"Retrieved boxes for application {boxes_result.application_id}") + print_info(f"Total boxes found: {len(boxes_result.boxes or [])}") + print_info("") + + if len(boxes_result.boxes or []) > 0: + print_info("Box names (sorted lexicographically):") + for i, box_descriptor in enumerate(boxes_result.boxes or []): + # Handle both bytes and base64-encoded strings + name_bytes = ( + base64.b64decode(box_descriptor.name) + if isinstance(box_descriptor.name, str) + else box_descriptor.name + ) + name_display = decode_box_name(name_bytes) + print_info(f" [{i}] {name_display}") + print_info("") + print_info("Note: search_for_application_boxes returns only box names (BoxDescriptor[]),") + print_info("not the values. Use lookup_application_box_by_id_and_name to get values.") + + if boxes_result.next_token: + token_preview = boxes_result.next_token[:20] + print_info(f"More results available (nextToken: {token_preview}...)") + except Exception as e: + print_error(f"search_for_application_boxes failed: {e}") + + # ========================================================================= + # Step 6: Lookup specific box by name with lookup_application_box_by_id_and_name() + # ========================================================================= + print_step(6, "Looking up specific box values with lookup_application_box_by_id_and_name()") + + try: + # lookup_application_box_by_id_and_name() requires the box name as a string + # Use the b64: prefix to pass base64-encoded box name + box_name_bytes = b"settings" + box_name_str = "b64:" + base64.b64encode(box_name_bytes).decode() + + print_info('Looking up box with name "settings"...') + print_info(f"Box name encoded: {box_name_str}") + print_info("") + + box_result = indexer.lookup_application_box_by_id_and_name(app_id, box_name_str) + + print_success("Retrieved box details:") + print_info(f" Round: {box_result.round_}") + + # Handle both bytes and base64-encoded strings for name and value + name_bytes = base64.b64decode(box_result.name) if isinstance(box_result.name, str) else box_result.name + value_bytes = base64.b64decode(box_result.value) if isinstance(box_result.value, str) else box_result.value + + print_info(f" Name: {decode_box_name(name_bytes)}") + print_info(f" Value: {decode_box_value(value_bytes)}") + print_info(f" Value size: {len(value_bytes)} bytes") + print_info("") + + # Try parsing as JSON since we know this box contains JSON + value_str = value_bytes.decode("utf-8") + if value_str.startswith("{"): + import json + + try: + parsed = json.loads(value_str) + print_info("Parsed as JSON:") + for key, val in parsed.items(): + print_info(f" {key}: {json.dumps(val)}") + except json.JSONDecodeError: + pass + except Exception as e: + print_error(f"lookup_application_box_by_id_and_name failed: {e}") + + # ========================================================================= + # Step 7: Show how to properly encode box names using bytes + # ========================================================================= + print_step(7, "Demonstrating box name encoding with bytes") + + try: + print_info("Box names use the 'b64:' or 'str:' format for the indexer API.") + print_info("") + + # Example 1: String to b64-encoded name + string_name = "user_count" + string_name_encoded = "b64:" + base64.b64encode(string_name.encode("utf-8")).decode() + print_info(f'1. String "{string_name}" encoded for API:') + print_info(f' "b64:" + base64.b64encode("{string_name}".encode("utf-8")).decode()') + print_info(f" Result: {string_name_encoded}") + print_info("") + + # Lookup this box + box1 = indexer.lookup_application_box_by_id_and_name(app_id, string_name_encoded) + value1 = base64.b64decode(box1.value) if isinstance(box1.value, str) else box1.value + print_info(f" Box value: {decode_box_value(value1)}") + print_info("") + + # Example 2: Direct bytes encoded as b64 + print_info("2. Direct bytes encoded as b64:") + direct_bytes = bytes([109, 101, 116, 97, 100, 97, 116, 97]) # "metadata" + direct_encoded = "b64:" + base64.b64encode(direct_bytes).decode() + print_info(f" bytes([{', '.join(str(b) for b in direct_bytes)}])") + print_info(f' Decodes to: "{direct_bytes.decode("utf-8")}"') + print_info(f" Encoded: {direct_encoded}") + + box2 = indexer.lookup_application_box_by_id_and_name(app_id, direct_encoded) + value2 = base64.b64decode(box2.value) if isinstance(box2.value, str) else box2.value + print_info(f" Box value: {decode_box_value(value2)}") + print_info("") + + # Example 3: Hex string to bytes to b64 + print_info("3. Hex string to bytes to b64 (for binary box names):") + hex_str = "73657474696e6773" # "settings" in hex + hex_bytes = bytes.fromhex(hex_str) + hex_encoded = "b64:" + base64.b64encode(hex_bytes).decode() + print_info(f' Hex "{hex_str}" to bytes') + print_info(f' Decodes to: "{hex_bytes.decode("utf-8")}"') + print_info(f" Encoded: {hex_encoded}") + + box3 = indexer.lookup_application_box_by_id_and_name(app_id, hex_encoded) + value3 = base64.b64decode(box3.value) if isinstance(box3.value, str) else box3.value + print_info(f" Box value: {decode_box_value(value3)}") + except Exception as e: + print_error(f"Box name encoding demo failed: {e}") + + # ========================================================================= + # Step 8: Handle case where box is not found + # ========================================================================= + print_step(8, "Handling case where box is not found") + + try: + non_existent_name = "b64:" + base64.b64encode(b"does_not_exist").decode() + print_info('Attempting to lookup non-existent box "does_not_exist"...') + + indexer.lookup_application_box_by_id_and_name(app_id, non_existent_name) + + # If we get here, the box was found (unexpected) + print_info("Box was found (unexpected)") + except Exception as e: + print_success("Correctly caught error for non-existent box") + print_info(f"Error message: {e}") + print_info("") + print_info("Always handle the case where a box may not exist.") + print_info("The indexer throws an error when the box is not found.") + + # ========================================================================= + # Step 9: Demonstrate pagination for applications with many boxes + # ========================================================================= + print_step(9, "Demonstrating pagination with limit and next parameters") + + try: + # First page with limit of 2 + print_info("Fetching first page of boxes (limit: 2)...") + page1 = indexer.search_for_application_boxes(app_id, limit=2) + + print_info(f"Page 1: Retrieved {len(page1.boxes or [])} box(es)") + for box in page1.boxes or []: + name_bytes = base64.b64decode(box.name) if isinstance(box.name, str) else box.name + print_info(f" - {decode_box_name(name_bytes)}") + + # Check if there are more results + if page1.next_token: + token_preview = page1.next_token[:20] + print_info(f"Next token available: {token_preview}...") + print_info("") + + # Fetch second page using next token + print_info("Fetching second page using next token...") + page2 = indexer.search_for_application_boxes( + app_id, + limit=2, + next_=page1.next_token, + ) + + print_info(f"Page 2: Retrieved {len(page2.boxes or [])} box(es)") + for box in page2.boxes or []: + name_bytes = base64.b64decode(box.name) if isinstance(box.name, str) else box.name + print_info(f" - {decode_box_name(name_bytes)}") + + if page2.next_token: + print_info("More results available (nextToken present)") + print_info("") + + # Fetch remaining boxes + print_info("Fetching remaining boxes...") + page3 = indexer.search_for_application_boxes( + app_id, + limit=10, + next_=page2.next_token, + ) + + print_info(f"Page 3: Retrieved {len(page3.boxes or [])} box(es)") + for box in page3.boxes or []: + name_bytes = base64.b64decode(box.name) if isinstance(box.name, str) else box.name + print_info(f" - {decode_box_name(name_bytes)}") + + if not page3.next_token: + print_info("No more results (no nextToken)") + else: + print_info("No more results (no nextToken)") + else: + print_info("No pagination needed (all results fit in one page)") + except Exception as e: + print_error(f"Pagination demo failed: {e}") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. Deploying an application that uses box storage") + print_info(" 2. Creating several boxes via app calls") + print_info(" 3. Handling the case where application has no boxes") + print_info(" 4. search_for_application_boxes(app_id) - List all box names") + print_info(" 5. lookup_application_box_by_id_and_name(app_id, box_name) - Get specific box value") + print_info(" 6. Properly encoding box names using bytes") + print_info(" 7. Displaying box values after decoding from bytes") + print_info(" 8. Handling the case where box is not found") + print_info(" 9. Pagination with limit and next parameters") + print_info("") + print_info("Key search_for_application_boxes response fields (BoxesResponse):") + print_info(" - application_id: The application identifier (int)") + print_info(" - boxes: Array of BoxDescriptor objects (just names, not values)") + print_info(" - next_token: Pagination token for next page (optional)") + print_info("") + print_info("Key BoxDescriptor fields:") + print_info(" - name: Box name as bytes (raw bytes)") + print_info("") + print_info("Key lookup_application_box_by_id_and_name response fields (Box):") + print_info(" - round: Round at which box was retrieved (int)") + print_info(" - name: Box name as bytes") + print_info(" - value: Box value as bytes") + print_info("") + print_info("search_for_application_boxes() filter parameters:") + print_info(" - limit: Maximum results per page") + print_info(" - next: Pagination token from previous response") + print_info("") + print_info("Note: Box names are returned sorted lexicographically by the indexer.") + + +if __name__ == "__main__": + main() diff --git a/examples/indexer_client/14_block_lookup.py b/examples/indexer_client/14_block_lookup.py new file mode 100644 index 00000000..71d61180 --- /dev/null +++ b/examples/indexer_client/14_block_lookup.py @@ -0,0 +1,423 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Block Lookup + +This example demonstrates how to lookup block information using +the IndexerClient lookup_block() method. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import time +from datetime import datetime, timezone + +from shared import ( + create_algorand_client, + create_indexer_client, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_utils import AlgoAmount, PaymentParams + + +def format_bytes_hex(data: bytes) -> str: + """Format a bytes array as a hex string.""" + return data.hex() + + +def format_timestamp(timestamp: int) -> str: + """Format a Unix timestamp to a human-readable date.""" + return datetime.fromtimestamp(timestamp, tz=timezone.utc).isoformat() + + +def main() -> None: + print_header("Block Lookup Example") + + # Create clients + indexer = create_indexer_client() + algorand = create_algorand_client() + + # ========================================================================= + # Step 1: Get the current round from the indexer to find a recent block + # ========================================================================= + print_step(1, "Getting a recent block round from the indexer") + + try: + # Use health check to get the current round + health = indexer.health_check() + recent_round = health.round_ + print_success(f"Current indexer round: {recent_round}") + print_info("") + + # Use a block that's a few rounds back to ensure it's fully indexed + if recent_round > 5: + recent_round = recent_round - 3 + print_info(f"Using block {recent_round} (a few rounds back for stability)") + except Exception as e: + print_error(f"Failed to get current round: {e}") + print_info("") + print_info("Make sure LocalNet is running: algokit localnet start") + print_info("If issues persist, try: algokit localnet reset") + return + + # ========================================================================= + # Step 2: Lookup block with lookup_block() to get full block details + # ========================================================================= + print_step(2, "Looking up block with lookup_block(round_number)") + + try: + block = indexer.lookup_block(recent_round) + + print_success(f"Retrieved block {block.round_}") + print_info("") + + # Display basic block fields + print_info("Basic Block Fields:") + print_info(f" Round: {block.round_}") + print_info(f" Timestamp: {block.timestamp} ({format_timestamp(block.timestamp)})") + print_info(f" Genesis ID: {block.genesis_id}") + + # Handle genesis_hash which may be bytes or base64-encoded string + genesis_hash = block.genesis_hash + if isinstance(genesis_hash, str): + import base64 + + genesis_hash = base64.b64decode(genesis_hash) + print_info(f" Genesis Hash: {format_bytes_hex(genesis_hash)}") + + # Handle previous_block_hash which may be bytes or base64-encoded string + previous_block_hash = block.previous_block_hash + if isinstance(previous_block_hash, str): + import base64 + + previous_block_hash = base64.b64decode(previous_block_hash) + print_info(f" Previous Block Hash: {format_bytes_hex(previous_block_hash)}") + print_info("") + + # Display optional proposer info (may not be present on all networks) + if hasattr(block, "proposer") and block.proposer: + print_info("Proposer Information:") + print_info(f" Proposer: {shorten_address(str(block.proposer))}") + if hasattr(block, "fees_collected") and block.fees_collected is not None: + print_info(f" Fees Collected: {block.fees_collected} µALGO") + if hasattr(block, "bonus") and block.bonus is not None: + print_info(f" Bonus: {block.bonus} µALGO") + if hasattr(block, "proposer_payout") and block.proposer_payout is not None: + print_info(f" Proposer Payout: {block.proposer_payout} µALGO") + print_info("") + + # Display transaction counter + if hasattr(block, "txn_counter") and block.txn_counter is not None: + print_info(f"Transaction Counter: {block.txn_counter} (total txns committed in ledger up to this block)") + print_info("") + except Exception as e: + print_error(f"lookup_block failed: {e}") + + # ========================================================================= + # Step 3: Display block header info - seed, txnCommitments, participationUpdates + # ========================================================================= + print_step(3, "Displaying block header information") + + try: + block = indexer.lookup_block(recent_round) + + import base64 + + print_info("Seed and Transaction Commitments:") + seed = block.seed + if isinstance(seed, str): + seed = base64.b64decode(seed) + print_info(f" Seed (Sortition): {format_bytes_hex(seed)}") + + transactions_root = block.transactions_root + if isinstance(transactions_root, str): + transactions_root = base64.b64decode(transactions_root) + print_info(f" Transactions Root: {format_bytes_hex(transactions_root)}") + + if hasattr(block, "transactions_root_sha256") and block.transactions_root_sha256: + txn_root_sha256 = block.transactions_root_sha256 + if isinstance(txn_root_sha256, str): + txn_root_sha256 = base64.b64decode(txn_root_sha256) + print_info(f" Txn Root SHA256: {format_bytes_hex(txn_root_sha256)}") + print_info("") + + # Display participation updates + print_info("Participation Updates:") + updates = block.participation_updates + if hasattr(updates, "absent_participation_accounts") and updates.absent_participation_accounts: + absent_count = len(updates.absent_participation_accounts) + print_info(f" Absent Accounts: {absent_count} account(s)") + for account in updates.absent_participation_accounts[:3]: + print_info(f" - {shorten_address(str(account))}") + if absent_count > 3: + print_info(f" ... and {absent_count - 3} more") + else: + print_info(" Absent Accounts: None") + if hasattr(updates, "expired_participation_accounts") and updates.expired_participation_accounts: + expired_count = len(updates.expired_participation_accounts) + print_info(f" Expired Accounts: {expired_count} account(s)") + for account in updates.expired_participation_accounts[:3]: + print_info(f" - {shorten_address(str(account))}") + if expired_count > 3: + print_info(f" ... and {expired_count - 3} more") + else: + print_info(" Expired Accounts: None") + print_info("") + + # Display rewards info + print_info("Block Rewards:") + print_info(f" Fee Sink: {shorten_address(str(block.rewards.fee_sink))}") + print_info(f" Rewards Pool: {shorten_address(str(block.rewards.rewards_pool))}") + print_info(f" Rewards Level: {block.rewards.rewards_level}") + print_info(f" Rewards Rate: {block.rewards.rewards_rate}") + print_info(f" Rewards Residue: {block.rewards.rewards_residue}") + print_info(f" Rewards Calc Round: {block.rewards.rewards_calculation_round}") + print_info("") + + # Display upgrade state + print_info("Upgrade State:") + print_info(f" Current Protocol: {block.upgrade_state.current_protocol}") + if hasattr(block.upgrade_state, "next_protocol") and block.upgrade_state.next_protocol: + print_info(f" Next Protocol: {block.upgrade_state.next_protocol}") + if hasattr(block.upgrade_state, "next_protocol_vote_before"): + print_info(f" Next Protocol Vote: {block.upgrade_state.next_protocol_vote_before}") + if hasattr(block.upgrade_state, "next_protocol_switch_on"): + print_info(f" Next Protocol Switch: {block.upgrade_state.next_protocol_switch_on}") + if hasattr(block.upgrade_state, "next_protocol_approvals"): + print_info(f" Next Protocol Approvals: {block.upgrade_state.next_protocol_approvals}") + else: + print_info(" Next Protocol: None (no upgrade pending)") + + # Display upgrade vote if present + if hasattr(block, "upgrade_vote") and block.upgrade_vote: + print_info("") + print_info("Upgrade Vote:") + if hasattr(block.upgrade_vote, "upgrade_propose") and block.upgrade_vote.upgrade_propose: + print_info(f" Proposed Protocol: {block.upgrade_vote.upgrade_propose}") + if hasattr(block.upgrade_vote, "upgrade_delay") and block.upgrade_vote.upgrade_delay is not None: + print_info(f" Upgrade Delay: {block.upgrade_vote.upgrade_delay}") + upgrade_approve = getattr(block.upgrade_vote, "upgrade_approve", False) + print_info(f" Upgrade Approve: {upgrade_approve}") + print_info("") + + # Display state proof tracking if present + if hasattr(block, "state_proof_tracking") and block.state_proof_tracking: + print_info("State Proof Tracking:") + for tracking in block.state_proof_tracking: + print_info(f" Type: {tracking.type_}") + if hasattr(tracking, "next_round") and tracking.next_round is not None: + print_info(f" Next Round: {tracking.next_round}") + if hasattr(tracking, "online_total_weight") and tracking.online_total_weight is not None: + print_info(f" Online Weight: {tracking.online_total_weight}") + if hasattr(tracking, "voters_commitment") and tracking.voters_commitment: + voters = tracking.voters_commitment + if isinstance(voters, str): + voters = base64.b64decode(voters) + print_info(f" Voters Commitment: {format_bytes_hex(voters)}") + print_info("") + except Exception as e: + print_error(f"Failed to display block header: {e}") + + # ========================================================================= + # Step 4: Show transactions included in the block if any + # ========================================================================= + print_step(4, "Showing transactions included in the block") + + try: + block = indexer.lookup_block(recent_round) + + print_info(f"Block {block.round_} contains {len(block.transactions or [])} transaction(s)") + print_info("") + + if len(block.transactions or []) > 0: + print_info("Transactions in this block:") + # Show up to 5 transactions for brevity + txns_to_show = (block.transactions or [])[:5] + for i, txn in enumerate(txns_to_show): + print_info(f" [{i}] ID: {txn.id_}") + print_info(f" Type: {txn.tx_type}") + print_info(f" Sender: {shorten_address(str(txn.sender))}") + print_info(f" Fee: {txn.fee} µALGO") + if hasattr(txn, "payment_transaction") and txn.payment_transaction: + pt = txn.payment_transaction + print_info(f" Receiver: {shorten_address(str(pt.receiver))}") + print_info(f" Amount: {pt.amount} µALGO") + if hasattr(txn, "asset_transfer_transaction") and txn.asset_transfer_transaction: + att = txn.asset_transfer_transaction + print_info(f" Asset ID: {att.asset_id}") + print_info(f" Receiver: {shorten_address(str(att.receiver))}") + print_info(f" Amount: {att.amount}") + print_info("") + if len(block.transactions or []) > 5: + print_info(f" ... and {len(block.transactions or []) - 5} more transaction(s)") + print_info("") + else: + print_info("This block has no transactions (empty block).") + print_info("Empty blocks are common on LocalNet when there is no activity.") + print_info("") + except Exception as e: + print_error(f"Failed to show transactions: {e}") + + # ========================================================================= + # Step 5: Create some transactions to have blocks with transactions + # ========================================================================= + print_step(5, "Creating transactions to demonstrate blocks with transactions") + + block_with_txns: int | None = None + + try: + # Get a funded account + dispenser = algorand.account.localnet_dispenser() + algorand.set_signer_from_account(dispenser) + dispenser_address = dispenser.addr + print_info(f"Using dispenser: {shorten_address(dispenser_address)}") + + # Create a few transactions + print_info("Creating 3 payment transactions...") + receiver = algorand.account.random() + + for i in range(3): + algorand.send.payment( + PaymentParams( + sender=dispenser_address, + receiver=receiver.addr, + amount=AlgoAmount.from_micro_algo(100000), + note=f"Block lookup example payment {i + 1}".encode(), + ) + ) + + print_success("Created 3 transactions") + + # Wait a moment for indexer to catch up + print_info("Waiting for indexer to index the transactions...") + time.sleep(2) + + # Get the current round which should contain our transactions + health = indexer.health_check() + block_with_txns = health.round_ + print_info(f"Current round after transactions: {block_with_txns}") + print_info("") + + # Look up a recent block that might contain our transactions + # Check a few recent blocks to find one with transactions + for r in range(block_with_txns, max(block_with_txns - 5, 0), -1): + block = indexer.lookup_block(r) + if len(block.transactions or []) > 0: + block_with_txns = r + print_success(f"Found block {r} with {len(block.transactions or [])} transaction(s)") + print_info("") + + # Show the transactions + print_info("Transactions in this block:") + for i, txn in enumerate((block.transactions or [])[:3]): + txn_id = txn.id_ if txn.id_ else "unknown" + print_info(f" [{i}] {txn_id[:20]}... ({txn.tx_type})") + if len(block.transactions or []) > 3: + print_info(f" ... and {len(block.transactions or []) - 3} more") + break + except Exception as e: + print_error(f"Failed to create transactions: {e}") + print_info("This step requires LocalNet - continuing with other demonstrations...") + print_info("") + + # ========================================================================= + # Step 6: Demonstrate header_only parameter to get only block header + # ========================================================================= + print_step(6, "Demonstrating header_only parameter") + + try: + round_to_lookup = block_with_txns if block_with_txns else recent_round + + print_info(f"Looking up block {round_to_lookup} with header_only=False (default):") + full_block = indexer.lookup_block(round_to_lookup) + print_info(f" Transactions included: {len(full_block.transactions or [])}") + print_info("") + + print_info(f"Looking up block {round_to_lookup} with header_only=True:") + header_only = indexer.lookup_block(round_to_lookup, header_only=True) + print_info(f" Transactions included: {len(header_only.transactions or [])}") + print_info("") + + if len(full_block.transactions or []) > 0 and len(header_only.transactions or []) == 0: + print_success("header_only=True correctly excludes transactions from the response") + elif len(full_block.transactions or []) == 0: + print_info("This block has no transactions, so header_only has no visible effect") + print_info("header_only=True is useful to reduce response size for blocks with many transactions") + + print_info("") + print_info("header_only parameter:") + print_info(" - False (default): Returns full block including all transactions") + print_info(" - True: Returns only block header without transactions array") + print_info(" - Use header_only=True when you only need block metadata for better performance") + except Exception as e: + print_error(f"header_only demo failed: {e}") + + # ========================================================================= + # Step 7: Handle the case where block is not found + # ========================================================================= + print_step(7, "Handling the case where block is not found") + + try: + # Try to look up a block from the far future + future_round = 999999999999 + print_info(f"Attempting to lookup block {future_round} (far future)...") + + indexer.lookup_block(future_round) + + # If we get here, the block was found (unexpected) + print_info("Block was found (unexpected)") + except Exception as e: + print_success("Correctly caught error for non-existent block") + print_info(f"Error message: {e}") + print_info("") + print_info("Always handle the case where a block may not exist yet.") + print_info("The indexer throws an error when the block round has not been reached.") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. Getting a recent block round from the indexer health check") + print_info(" 2. lookup_block(round_number) - Get full block details") + print_info(" 3. Block header info: seed, transaction commitments, participation updates") + print_info(" 4. Displaying transactions included in a block") + print_info(" 5. Creating transactions to populate blocks") + print_info(" 6. header_only parameter - Get block header without transactions") + print_info(" 7. Handling the case where block is not found") + print_info("") + print_info("Key Block fields:") + print_info(" - round: Block round number (int)") + print_info(" - timestamp: Unix timestamp in seconds") + print_info(" - genesis_id: Genesis block identifier string") + print_info(" - genesis_hash: 32-byte hash of genesis block (bytes)") + print_info(" - previous_block_hash: 32-byte hash of previous block (bytes)") + print_info(" - seed: 32-byte sortition seed (bytes)") + print_info(" - transactions_root: Merkle root of transactions (bytes)") + print_info(" - transactions: Array of Transaction objects") + print_info(" - participation_updates: Participation account updates") + print_info(" - rewards: Block rewards info (fee_sink, rewards_pool, etc.)") + print_info(" - upgrade_state: Protocol upgrade state") + print_info("") + print_info("Optional Block fields:") + print_info(" - proposer: Block proposer address (newer blocks)") + print_info(" - fees_collected: Total fees collected in block") + print_info(" - bonus: Bonus payout for block") + print_info(" - proposer_payout: Amount paid to proposer") + print_info(" - txn_counter: Cumulative transaction count") + print_info(" - state_proof_tracking: State proof tracking info") + print_info(" - upgrade_vote: Protocol upgrade vote") + print_info("") + print_info("lookup_block() parameters:") + print_info(" - round_number: Block round to lookup (required)") + print_info(" - header_only: If true, exclude transactions from response (optional)") + + +if __name__ == "__main__": + main() diff --git a/examples/indexer_client/15_block_headers.py b/examples/indexer_client/15_block_headers.py new file mode 100644 index 00000000..c10e6f5e --- /dev/null +++ b/examples/indexer_client/15_block_headers.py @@ -0,0 +1,427 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Block Headers Search + +This example demonstrates how to search for block headers using +the IndexerClient search_for_block_headers() method. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import time +from datetime import datetime, timezone + +from shared import ( + create_algorand_client, + create_indexer_client, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_utils import AlgoAmount, PaymentParams + + +def format_timestamp(timestamp: int) -> str: + """Format a Unix timestamp to a human-readable date.""" + return datetime.fromtimestamp(timestamp, tz=timezone.utc).isoformat() + + +def main() -> None: + print_header("Block Headers Search Example") + + # Create clients + indexer = create_indexer_client() + algorand = create_algorand_client() + + # ========================================================================= + # Step 1: Basic search_for_block_headers() call + # ========================================================================= + print_step(1, "Basic search_for_block_headers() call") + + try: + # Search for recent block headers with a limit + result = indexer.search_for_block_headers(limit=5) + + print_success(f"Retrieved {len(result.blocks or [])} block header(s)") + print_info(f"Current round: {result.current_round}") + print_info("") + + print_info("Block headers (results are returned in ascending round order):") + for block in result.blocks or []: + print_info(f" Round {block.round_}:") + print_info(f" Timestamp: {block.timestamp} ({format_timestamp(block.timestamp)})") + if hasattr(block, "proposer") and block.proposer: + print_info(f" Proposer: {shorten_address(str(block.proposer))}") + else: + print_info(" Proposer: (not available)") + print_info("") + + print_info("Note: Results are returned in ascending round order (oldest first)") + except Exception as e: + print_error(f"search_for_block_headers failed: {e}") + print_info("") + print_info("Make sure LocalNet is running: algokit localnet start") + print_info("If issues persist, try: algokit localnet reset") + return + + # ========================================================================= + # Step 2: Get the current round to define search ranges + # ========================================================================= + print_step(2, "Getting current round for search range examples") + + try: + health = indexer.health_check() + current_round = health.round_ + print_success(f"Current indexer round: {current_round}") + print_info("") + except Exception as e: + print_error(f"Failed to get current round: {e}") + return + + # ========================================================================= + # Step 3: Filter by min_round and max_round + # ========================================================================= + print_step(3, "Filtering by min_round and max_round") + + try: + # Search for blocks in a specific round range + min_round = current_round - 10 if current_round > 10 else 1 + max_round = current_round - 5 if current_round > 5 else current_round + + print_info(f"Searching for blocks between round {min_round} and {max_round}...") + + result = indexer.search_for_block_headers( + min_round=min_round, + max_round=max_round, + limit=10, + ) + + print_success(f"Found {len(result.blocks or [])} block(s) in range") + print_info("") + + if len(result.blocks or []) > 0: + print_info("Block rounds found:") + for block in result.blocks or []: + print_info(f" Round {block.round_} - {format_timestamp(block.timestamp)}") + print_info("") + + print_info("min_round and max_round parameters:") + print_info(" - min_round: Only include blocks at or after this round") + print_info(" - max_round: Only include blocks at or before this round") + except Exception as e: + print_error(f"Round range search failed: {e}") + + # ========================================================================= + # Step 4: Filter by before_time and after_time + # ========================================================================= + print_step(4, "Filtering by before_time and after_time") + + try: + # Get a timestamp from a recent block to use as a reference + recent_blocks = indexer.search_for_block_headers(limit=1) + + if len(recent_blocks.blocks or []) > 0: + ref_timestamp = recent_blocks.blocks[0].timestamp + + # Search for blocks in a time window (before the reference time) + # Create a time 1 hour before the reference + before_date = datetime.fromtimestamp(ref_timestamp, tz=timezone.utc) + after_date = datetime.fromtimestamp(ref_timestamp - 3600, tz=timezone.utc) # 1 hour before + + print_info("Searching for blocks between:") + print_info(f" After: {after_date.isoformat()}") + print_info(f" Before: {before_date.isoformat()}") + print_info("") + + result = indexer.search_for_block_headers( + after_time=after_date.isoformat(), + before_time=before_date.isoformat(), + limit=5, + ) + + print_success(f"Found {len(result.blocks or [])} block(s) in time range") + print_info("") + + if len(result.blocks or []) > 0: + print_info("Blocks found:") + for block in result.blocks or []: + print_info(f" Round {block.round_} - {format_timestamp(block.timestamp)}") + print_info("") + + print_info("Time filter parameters (RFC 3339 / ISO 8601 format):") + print_info(" - after_time: Only include blocks created after this timestamp") + print_info(" - before_time: Only include blocks created before this timestamp") + print_info(' - Example format: "2026-01-26T10:00:00.000Z"') + except Exception as e: + print_error(f"Time range search failed: {e}") + + # ========================================================================= + # Step 5: Create transactions to have blocks with a known proposer + # ========================================================================= + print_step(5, "Creating transactions to populate blocks with proposer info") + + proposer_address: str | None = None + + try: + # Get a funded account + dispenser = algorand.account.localnet_dispenser() + algorand.set_signer_from_account(dispenser) + dispenser_address = dispenser.addr + print_info(f"Using dispenser: {shorten_address(dispenser_address)}") + + # Create a few transactions to generate activity + print_info("Creating 3 payment transactions...") + receiver = algorand.account.random() + + for i in range(3): + algorand.send.payment( + PaymentParams( + sender=dispenser_address, + receiver=receiver.addr, + amount=AlgoAmount.from_micro_algo(100000), + note=f"Block headers example payment {i + 1}".encode(), + ) + ) + + print_success("Created 3 transactions") + + # Wait a moment for indexer to catch up + print_info("Waiting for indexer to index the transactions...") + time.sleep(2) + + # Get recent block headers to find a proposer + recent_headers = indexer.search_for_block_headers(limit=10) + + # Find a block with a proposer + for block in recent_headers.blocks or []: + if hasattr(block, "proposer") and block.proposer: + proposer_address = str(block.proposer) + print_success(f"Found block with proposer: {shorten_address(proposer_address)}") + print_info(f" Block round: {block.round_}") + break + + if not proposer_address: + print_info("No blocks with proposer info found (proposer may not be set on LocalNet)") + print_info("") + except Exception as e: + print_error(f"Failed to create transactions: {e}") + print_info("This step requires LocalNet - continuing with other demonstrations...") + print_info("") + + # ========================================================================= + # Step 6: Filter by proposers array to find blocks by specific accounts + # ========================================================================= + print_step(6, "Filtering by proposers array") + + try: + if proposer_address: + print_info(f"Searching for blocks proposed by: {shorten_address(proposer_address)}") + + result = indexer.search_for_block_headers( + proposers=[proposer_address], + limit=5, + ) + + print_success(f"Found {len(result.blocks or [])} block(s) proposed by this account") + print_info("") + + if len(result.blocks or []) > 0: + print_info("Blocks found:") + for block in result.blocks or []: + proposer_str = ( + shorten_address(str(block.proposer)) + if hasattr(block, "proposer") and block.proposer + else "(unknown)" + ) + print_info(f" Round {block.round_} - Proposer: {proposer_str}") + else: + print_info("No proposer address available to demonstrate filtering") + print_info("On MainNet/TestNet, you would use a known validator address") + print_info("") + + print_info("proposers parameter:") + print_info(" - Array of addresses to filter by block proposer") + print_info(" - Find all blocks proposed by specific validator accounts") + print_info(" - Useful for analyzing validator participation") + except Exception as e: + print_error(f"Proposers filter search failed: {e}") + + # ========================================================================= + # Step 7: Demonstrate additional filters (expired and absent) + # ========================================================================= + print_step(7, "Demonstrating expired and absent participation filters") + + try: + print_info("The search_for_block_headers() method also supports:") + print_info("") + print_info("expired parameter:") + print_info(" - Array of addresses to filter by expired participation accounts") + print_info(" - Finds blocks where specified accounts had their participation keys expire") + print_info("") + print_info("absent parameter:") + print_info(" - Array of addresses to filter by absent participation accounts") + print_info(" - Finds blocks where specified accounts were marked absent") + print_info(" - Absent accounts are those that failed to participate in consensus") + print_info("") + + # Try searching with these filters (likely no results on LocalNet) + if proposer_address: + expired_result = indexer.search_for_block_headers( + expired=[proposer_address], + limit=5, + ) + print_info(f"Blocks with expired participation for this address: {len(expired_result.blocks or [])}") + + absent_result = indexer.search_for_block_headers( + absent=[proposer_address], + limit=5, + ) + print_info(f"Blocks with absent status for this address: {len(absent_result.blocks or [])}") + print_info("") + + print_info("Note: On LocalNet, these filters typically return no results") + print_info("as participation tracking is primarily relevant on MainNet/TestNet") + except Exception as e: + print_error(f"Participation filter search failed: {e}") + + # ========================================================================= + # Step 8: Demonstrate pagination for fetching multiple block headers + # ========================================================================= + print_step(8, "Demonstrating pagination") + + try: + print_info("Fetching block headers with pagination (3 per page)...") + print_info("") + + next_token: str | None = None + page_count = 0 + total_blocks = 0 + max_pages = 3 + + while True: + result = indexer.search_for_block_headers( + limit=3, + next_=next_token, + ) + + page_count += 1 + total_blocks += len(result.blocks or []) + + print_info(f"Page {page_count}: Retrieved {len(result.blocks or [])} block(s)") + for block in result.blocks or []: + print_info(f" Round {block.round_} - {format_timestamp(block.timestamp)}") + + if result.next_token: + token_preview = str(result.next_token)[:30] + print_info(f" Next token: {token_preview}...") + else: + print_info(" No more pages") + + print_info("") + + next_token = result.next_token + + if not next_token or page_count >= max_pages: + break + + print_success(f"Retrieved {total_blocks} total block(s) across {page_count} page(s)") + print_info("") + + print_info("Pagination parameters:") + print_info(" - limit: Maximum number of results per page") + print_info(" - next: Token from previous response to get next page") + print_info(" - Response includes next_token if more results are available") + except Exception as e: + print_error(f"Pagination demo failed: {e}") + + # ========================================================================= + # Step 9: Combining multiple filters + # ========================================================================= + print_step(9, "Combining multiple filters") + + try: + # Combine round range with limit + min_round = current_round - 20 if current_round > 20 else 1 + max_round = current_round + + print_info("Combining filters: round range + limit") + print_info(f" min_round: {min_round}") + print_info(f" max_round: {max_round}") + print_info(" limit: 5") + print_info("") + + result = indexer.search_for_block_headers( + min_round=min_round, + max_round=max_round, + limit=5, + ) + + print_success(f"Found {len(result.blocks or [])} block(s)") + print_info("") + + if len(result.blocks or []) > 0: + print_info("Blocks found:") + for block in result.blocks or []: + proposer_str = ( + shorten_address(str(block.proposer)) + if hasattr(block, "proposer") and block.proposer + else "(unknown)" + ) + print_info(f" Round {block.round_} - Proposer: {proposer_str}") + print_info("") + + print_info("Multiple filters can be combined:") + print_info(" - Round range (min_round, max_round) + time range (before_time, after_time)") + print_info(" - Proposers filter + round/time range") + print_info(" - Any combination to narrow down results") + except Exception as e: + print_error(f"Combined filters search failed: {e}") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. Basic search_for_block_headers() call") + print_info(" 2. Getting current round for search ranges") + print_info(" 3. Filtering by min_round and max_round") + print_info(" 4. Filtering by before_time and after_time (RFC 3339 format)") + print_info(" 5. Creating transactions to populate blocks") + print_info(" 6. Filtering by proposers array") + print_info(" 7. Additional filters: expired and absent participation") + print_info(" 8. Pagination with limit and next parameters") + print_info(" 9. Combining multiple filters") + print_info("") + print_info("search_for_block_headers() parameters:") + print_info(" - limit: Maximum number of results to return") + print_info(" - next: Pagination token from previous response") + print_info(" - min_round: Only include blocks at or after this round") + print_info(" - max_round: Only include blocks at or before this round") + print_info(" - before_time: Only include blocks created before this timestamp (RFC 3339)") + print_info(" - after_time: Only include blocks created after this timestamp (RFC 3339)") + print_info(" - proposers: Array of addresses to filter by block proposer") + print_info(" - expired: Array of addresses to filter by expired participation") + print_info(" - absent: Array of addresses to filter by absent participation") + print_info("") + print_info("BlockHeadersResponse fields:") + print_info(" - current_round: Round at which results were computed (int)") + print_info(" - next_token: Pagination token for next page (optional string)") + print_info(" - blocks: Array of Block objects") + print_info("") + print_info("Key Block header fields:") + print_info(" - round: Block round number (int)") + print_info(" - timestamp: Unix timestamp in seconds (int)") + print_info(" - proposer: Block proposer address (optional, newer blocks)") + print_info(" - genesis_id: Genesis block identifier (string)") + print_info(" - genesis_hash: Hash of genesis block (bytes)") + print_info("") + print_info("Note: Results are returned in ascending round order (oldest first)") + + +if __name__ == "__main__": + main() diff --git a/examples/indexer_client/16_pagination.py b/examples/indexer_client/16_pagination.py new file mode 100644 index 00000000..5ffe3731 --- /dev/null +++ b/examples/indexer_client/16_pagination.py @@ -0,0 +1,630 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Pagination + +This example demonstrates how to properly handle pagination across multiple +indexer endpoints using limit and next parameters. It includes a generic +pagination helper function and shows iteration through all pages of results. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import time +from collections.abc import Callable +from dataclasses import dataclass + +from shared import ( + create_algorand_client, + create_indexer_client, + format_micro_algo, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_utils import AlgoAmount, AssetCreateParams, PaymentParams + +# ============================================================================ +# Generic Pagination Helper Function +# ============================================================================ + + +@dataclass +class PaginationOptions: + """Generic pagination options for fetch function.""" + + limit: int | None = None + next: str | None = None + + +@dataclass +class PaginatedResponse: + """Generic response type for paginated endpoints.""" + + items: list + next_token: str | None + current_round: int + + +@dataclass +class PaginateAllOptions: + """Options for the paginate_all helper.""" + + page_size: int = 100 + max_items: int | None = None + on_page: Callable[[list, int], bool | None] | None = None + stop_when: Callable[[object, int], bool] | None = None + + +@dataclass +class PaginateAllResult: + """Result from paginate_all helper.""" + + items: list + total_pages: int + stopped_early: bool + + +async def paginate_all( + fetch_page: Callable[[PaginationOptions], PaginatedResponse], + options: PaginateAllOptions | None = None, +) -> PaginateAllResult: + """ + Generic pagination helper that iterates through all pages of results. + + This function provides a reusable pattern for paginating through any + indexer endpoint that supports limit and next parameters. + + Args: + fetch_page: Function that fetches a page of results + options: Pagination options including page_size, max_items, callbacks + + Returns: + All items collected across all pages + """ + if options is None: + options = PaginateAllOptions() + + page_size = options.page_size + max_items = options.max_items + on_page = options.on_page + stop_when = options.stop_when + + all_items: list = [] + next_token: str | None = None + page_number = 0 + stopped_early = False + + while True: + page_number += 1 + + # Fetch the next page + response = fetch_page(PaginationOptions(limit=page_size, next=next_token)) + + # Process items and check for early termination + for item in response.items: + # Check stop condition + if stop_when and stop_when(item, len(all_items)): + stopped_early = True + break + + all_items.append(item) + + # Check max items limit + if max_items and len(all_items) >= max_items: + stopped_early = True + break + + # Call page callback if provided + if on_page: + continue_iteration = on_page(response.items, page_number) + if continue_iteration is False: + stopped_early = True + break + + # Check if we should stop + if stopped_early: + break + + next_token = response.next_token + if not next_token: + break + + return PaginateAllResult(items=all_items, total_pages=page_number, stopped_early=stopped_early) + + +def main() -> None: + print_header("Pagination Example") + + # Create clients + indexer = create_indexer_client() + algorand = create_algorand_client() + + # ========================================================================= + # Step 1: Get a funded account and create some test data + # ========================================================================= + print_step(1, "Setting up test data for pagination") + + try: + sender_account = algorand.account.localnet_dispenser() + algorand.set_signer_from_account(sender_account) + sender_address = sender_account.addr + print_success(f"Using dispenser account: {shorten_address(sender_address)}") + + # Create several random accounts and send them funds to generate transactions + print_info("Creating test transactions for pagination demo...") + receiver_accounts: list[str] = [] + + for _i in range(5): + receiver = algorand.account.random() + receiver_accounts.append(receiver.addr) + + algorand.send.payment( + PaymentParams( + sender=sender_address, + receiver=receiver.addr, + amount=AlgoAmount.from_algo(1), + ) + ) + + print_success(f"Created {len(receiver_accounts)} payment transactions") + + # Create a test asset + print_info("Creating test asset...") + asset_result = algorand.send.asset_create( + AssetCreateParams( + sender=sender_address, + total=1_000_000, + decimals=0, + asset_name="PaginationTestToken", + unit_name="PAGE", + ) + ) + print_success(f"Created asset: PaginationTestToken (ID: {asset_result.asset_id})") + + # Wait for indexer to catch up + print_info("Waiting for indexer to index transactions...") + time.sleep(3) + print_info("") + except Exception as e: + print_error(f"Failed to set up test data: {e}") + print_info("") + print_info("Make sure LocalNet is running: algokit localnet start") + print_info("If issues persist, try: algokit localnet reset") + return + + # ========================================================================= + # Step 2: Demonstrate pagination with search_for_transactions() + # ========================================================================= + print_step(2, "Paginating through search_for_transactions()") + + try: + print_info("Manually iterating through transaction pages...") + print_info("Settings: page_size=2 (small for demo purposes)") + print_info("") + + all_transactions: list = [] + next_token: str | None = None + page_number = 0 + max_pages = 5 + + while page_number < max_pages: + page_number += 1 + + result = indexer.search_for_transactions( + limit=2, + next_=next_token, + ) + + all_transactions.extend(result.transactions or []) + print_info(f" Page {page_number}: Retrieved {len(result.transactions or [])} transaction(s)") + + next_token = result.next_token + if not next_token: + break + + print_success(f"Total transactions fetched: {len(all_transactions)}") + print_info(f"Total pages fetched: {page_number}") + print_info("") + + # Display first few transactions + if len(all_transactions) > 0: + print_info("First 3 transactions:") + for tx in all_transactions[:3]: + tx_id = tx.id_ if tx.id_ else "N/A" + print_info(f" - {shorten_address(tx_id, 8, 6)}: {tx.tx_type}") + except Exception as e: + print_error(f"search_for_transactions pagination failed: {e}") + + # ========================================================================= + # Step 3: Demonstrate pagination with search_for_accounts() + # ========================================================================= + print_step(3, "Paginating through search_for_accounts()") + + try: + print_info("Fetching all accounts with balance > 0 using pagination...") + print_info("Settings: page_size=3") + print_info("") + + all_accounts: list = [] + next_token = None + page_number = 0 + max_items = 15 + + while len(all_accounts) < max_items: + page_number += 1 + + result = indexer.search_for_accounts( + currency_greater_than=0, + limit=3, + next_=next_token, + ) + + for account in result.accounts or []: + if len(all_accounts) >= max_items: + break + all_accounts.append(account) + + print_info(f" Page {page_number}: Retrieved {len(result.accounts or [])} account(s)") + + next_token = result.next_token + if not next_token: + break + + print_success(f"Total accounts fetched: {len(all_accounts)}") + print_info(f"Total pages fetched: {page_number}") + print_info("") + + # Display accounts with their balances + if len(all_accounts) > 0: + print_info("Accounts found:") + for account in all_accounts[:5]: + print_info(f" - {shorten_address(account.address)}: {format_micro_algo(account.amount)}") + if len(all_accounts) > 5: + print_info(f" ... and {len(all_accounts) - 5} more") + except Exception as e: + print_error(f"search_for_accounts pagination failed: {e}") + + # ========================================================================= + # Step 4: Demonstrate pagination with search_for_assets() + # ========================================================================= + print_step(4, "Paginating through search_for_assets()") + + try: + print_info("Fetching all assets using pagination...") + print_info("Settings: page_size=2") + print_info("") + + all_assets: list = [] + next_token = None + page_number = 0 + max_items = 10 + + while len(all_assets) < max_items: + page_number += 1 + + result = indexer.search_for_assets( + limit=2, + next_=next_token, + ) + + for asset in result.assets or []: + if len(all_assets) >= max_items: + break + all_assets.append(asset) + + print_info(f" Page {page_number}: Retrieved {len(result.assets or [])} asset(s)") + + next_token = result.next_token + if not next_token: + break + + print_success(f"Total assets fetched: {len(all_assets)}") + print_info(f"Total pages fetched: {page_number}") + print_info("") + + # Display assets + if len(all_assets) > 0: + print_info("Assets found:") + for asset in all_assets[:5]: + name = asset.params.name if asset.params.name else "Unnamed" + unit_name = asset.params.unit_name if asset.params.unit_name else "N/A" + asset_id = asset.id_ + print_info(f" - ID {asset_id}: {name} ({unit_name})") + if len(all_assets) > 5: + print_info(f" ... and {len(all_assets) - 5} more") + else: + print_info("No assets found on LocalNet") + except Exception as e: + print_error(f"search_for_assets pagination failed: {e}") + + # ========================================================================= + # Step 5: Display total count of items across all pages + # ========================================================================= + print_step(5, "Counting total items across all pages") + + try: + print_info("Counting all transactions without fetching full data...") + print_info("") + + total_transactions = 0 + page_count = 0 + next_token = None + + # Simple counting loop using limit and next + while True: + page_count += 1 + result = indexer.search_for_transactions( + limit=100, # Use larger page size for counting + next_=next_token, + ) + + total_transactions += len(result.transactions or []) + next_token = result.next_token + + # Safety limit for demo + if page_count >= 10: + print_info(" (stopping after 10 pages for demo purposes)") + break + + if not next_token: + break + + print_success(f"Total transactions counted: {total_transactions}") + print_info(f"Pages scanned: {page_count}") + print_info("") + + # Also count accounts + print_info("Counting all accounts...") + total_accounts = 0 + page_count = 0 + next_token = None + + while True: + page_count += 1 + result = indexer.search_for_accounts( + currency_greater_than=0, + limit=100, + next_=next_token, + ) + + total_accounts += len(result.accounts or []) + next_token = result.next_token + + if page_count >= 10: + break + if not next_token: + break + + print_success(f"Total accounts with balance > 0: {total_accounts}") + print_info(f"Pages scanned: {page_count}") + except Exception as e: + print_error(f"Counting failed: {e}") + + # ========================================================================= + # Step 6: Demonstrate early termination when a condition is met + # ========================================================================= + print_step(6, "Demonstrating early termination") + + try: + print_info("Searching for transactions until we find a payment transaction...") + print_info("") + + all_transactions = [] + next_token = None + page_number = 0 + found_payment = False + + while True: + page_number += 1 + result = indexer.search_for_transactions( + limit=5, + next_=next_token, + ) + + print_info(f" Page {page_number}: Checking {len(result.transactions or [])} transaction(s)...") + + for tx in result.transactions or []: + if tx.tx_type == "pay": + tx_id = tx.id_ if tx.id_ else "N/A" + idx = len(all_transactions) + print_info(f" Found payment transaction at index {idx}: {shorten_address(tx_id, 8, 6)}") + found_payment = True + break + all_transactions.append(tx) + + if found_payment: + break + + next_token = result.next_token + if not next_token: + break + + print_success(f"Stopped early: {found_payment}") + print_info(f"Total transactions before stopping: {len(all_transactions)}") + print_info(f"Pages checked: {page_number}") + print_info("") + + # Another example: stop after finding an account with specific balance + print_info("Searching for an account with balance > 1000 ALGO...") + + found_whale = False + all_accounts = [] + next_token = None + + while True: + result = indexer.search_for_accounts( + currency_greater_than=0, + limit=5, + next_=next_token, + ) + + for account in result.accounts or []: + # Stop when we find an account with > 1000 ALGO (1,000,000,000,000 microAlgos) + if account.amount > 1_000_000_000_000: + found_whale = True + print_info( + f" Found whale account: {shorten_address(account.address)} " + f"with {format_micro_algo(account.amount)}" + ) + break + all_accounts.append(account) + + if found_whale: + break + + next_token = result.next_token + if not next_token: + break + + if found_whale: + print_success("Found an account with > 1000 ALGO!") + else: + print_info("No account found with > 1000 ALGO (searched all accounts)") + except Exception as e: + print_error(f"Early termination demo failed: {e}") + + # ========================================================================= + # Step 7: Handle the case where there are no results + # ========================================================================= + print_step(7, "Handling empty results") + + try: + print_info("Searching for assets with a name that does not exist...") + print_info("") + + all_assets = [] + next_token = None + page_number = 0 + + while True: + page_number += 1 + result = indexer.search_for_assets( + name="ThisAssetNameShouldNotExist12345", + limit=10, + next_=next_token, + ) + + print_info(f" Page {page_number}: Retrieved {len(result.assets or [])} item(s)") + all_assets.extend(result.assets or []) + + next_token = result.next_token + if not next_token: + break + + if len(all_assets) == 0: + print_success("Correctly handled empty results (no assets found)") + print_info(f"Total pages: {page_number}") + print_info("Note: Empty results return an empty array, not an error") + else: + print_info(f"Unexpectedly found {len(all_assets)} asset(s)") + print_info("") + + # Also demonstrate with accounts + print_info("Searching for accounts with impossibly high balance...") + + all_accounts = [] + next_token = None + + while True: + # Search for accounts with balance > max supply (would never exist) + result = indexer.search_for_accounts( + currency_greater_than=10_000_000_000_000_000, # > 10 billion ALGO + limit=10, + next_=next_token, + ) + + all_accounts.extend(result.accounts or []) + + next_token = result.next_token + if not next_token: + break + + if len(all_accounts) == 0: + print_success("Correctly handled empty results (no accounts with such high balance)") + else: + print_info(f"Found {len(all_accounts)} account(s)") + except Exception as e: + print_error(f"Empty results handling failed: {e}") + + # ========================================================================= + # Step 8: Manual pagination without helper + # ========================================================================= + print_step(8, "Manual pagination pattern (without helper)") + + try: + print_info("Sometimes you may want to control pagination manually...") + print_info("") + + # Manual pagination loop + all_transactions: list = [] + next_token: str | None = None + page_num = 0 + + while True: + page_num += 1 + page = indexer.search_for_transactions( + limit=3, + next_=next_token, + ) + + all_transactions.extend(page.transactions or []) + next_token = page.next_token + + print_info( + f" Page {page_num}: {len(page.transactions or [])} transactions (total: {len(all_transactions)})" + ) + + # Limit for demo + if page_num >= 3: + print_info(" (stopping after 3 pages for demo)") + break + + if not next_token: + break + + print_success(f"Manual pagination complete: {len(all_transactions)} transactions in {page_num} pages") + print_info("") + + print_info("Key pagination fields:") + print_info(" - limit: Maximum items per page (request parameter)") + print_info(" - next_token: Token from response to fetch next page") + print_info(" - When next_token is None/missing, no more pages exist") + except Exception as e: + print_error(f"Manual pagination failed: {e}") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated pagination patterns for indexer endpoints:") + print_info("") + print_info("Pagination basics:") + print_info(" - Use `limit` parameter to control page size") + print_info(" - Use `next` parameter with `next_token` from response to get next page") + print_info(" - When `next_token` is None, there are no more pages") + print_info("") + print_info("Generic pagination helper (paginate_all):") + print_info(" - Reusable across all paginated endpoints") + print_info(" - Supports page_size, max_items limits") + print_info(" - Supports on_page callback for progress tracking") + print_info(" - Supports stop_when condition for early termination") + print_info("") + print_info("Endpoints demonstrated:") + print_info(" - search_for_transactions() - paginate through transactions") + print_info(" - search_for_accounts() - paginate through accounts") + print_info(" - search_for_assets() - paginate through assets") + print_info("") + print_info("Best practices:") + print_info(" - Use larger page sizes (50-100) for production to reduce API calls") + print_info(" - Implement max_items limit to prevent unbounded queries") + print_info(" - Use early termination when searching for specific items") + print_info(" - Handle empty results gracefully (empty array, not error)") + + +if __name__ == "__main__": + main() diff --git a/examples/indexer_client/verify-all.sh b/examples/indexer_client/verify-all.sh new file mode 100755 index 00000000..ebed238e --- /dev/null +++ b/examples/indexer_client/verify-all.sh @@ -0,0 +1,88 @@ +#!/bin/bash + +# verify-all.sh - Run all indexer_client examples and verify they work +# Exit with non-zero code if any example fails + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +cd "$SCRIPT_DIR" + +# Array of example files in order +EXAMPLES=( + "01_health_check.py" + "02_account_lookup.py" + "03_account_assets.py" + "04_account_applications.py" + "05_account_transactions.py" + "06_transaction_lookup.py" + "07_transaction_search.py" + "08_asset_lookup.py" + "09_asset_balances.py" + "10_asset_transactions.py" + "11_application_lookup.py" + "12_application_logs.py" + "13_application_boxes.py" + "14_block_lookup.py" + "15_block_headers.py" + "16_pagination.py" +) + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +NC='\033[0m' # No Color + +echo "========================================" +echo "Indexer Client Examples Verification Script" +echo "========================================" +echo "" + +if [ ${#EXAMPLES[@]} -eq 0 ]; then + echo "No examples to run yet." + echo "" + echo -e "${GREEN}Indexer Client examples suite passed (no examples)${NC}" + exit 0 +fi + +PASSED=0 +FAILED=0 +FAILED_EXAMPLES=() + +for example in "${EXAMPLES[@]}"; do + echo -n "Running $example... " + + if [ ! -f "$example" ]; then + echo -e "${RED}FAILED${NC} (file not found)" + FAILED=$((FAILED + 1)) + FAILED_EXAMPLES+=("$example") + continue + fi + + # Run the example and capture output/exit code + if OUTPUT=$(uv run python "$example" 2>&1); then + echo -e "${GREEN}PASSED${NC}" + PASSED=$((PASSED + 1)) + else + echo -e "${RED}FAILED${NC}" + echo "$OUTPUT" + FAILED=$((FAILED + 1)) + FAILED_EXAMPLES+=("$example") + fi +done + +echo "" +echo "========================================" +echo "Results: ${PASSED} passed, ${FAILED} failed" +echo "========================================" + +if [ $FAILED -gt 0 ]; then + echo "" + echo -e "${RED}Failed examples:${NC}" + for failed in "${FAILED_EXAMPLES[@]}"; do + echo " - $failed" + done + exit 1 +fi + +echo "" +echo -e "${GREEN}All Indexer Client examples passed!${NC}" +exit 0 diff --git a/examples/kmd_client/01_version.py b/examples/kmd_client/01_version.py new file mode 100644 index 00000000..d64b6203 --- /dev/null +++ b/examples/kmd_client/01_version.py @@ -0,0 +1,74 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: KMD Version Information + +This example demonstrates how to retrieve version information from the KMD +(Key Management Daemon) server using the version() method. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import sys + +from shared import ( + create_kmd_client, + print_error, + print_header, + print_info, + print_step, + print_success, +) + + +def main() -> None: + print_header("KMD Version Information Example") + + # Create a KMD client connected to LocalNet + kmd = create_kmd_client() + + # ========================================================================= + # Step 1: Get Version Information + # ========================================================================= + print_step(1, "Getting KMD version information with version()") + + try: + version_response = kmd.version() + version_info = version_response.versions + + print_success("Version information retrieved successfully!") + print_info("") + print_info("Supported API versions:") + + if len(version_info) == 0: + print_info(" (No versions reported)") + else: + for version in version_info: + print_info(f" - {version}") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. version() - Retrieves KMD server version information") + print_info("") + print_info("Key fields in version response:") + print_info(" - versions: Array of supported API version strings") + print_info("") + print_info("The KMD (Key Management Daemon) is responsible for:") + print_info(" - Managing wallets and their keys") + print_info(" - Signing transactions securely") + print_info(" - Storing keys in encrypted wallet files") + except Exception as e: + print_error(f"Failed to get version information: {e}") + print_info("") + print_info("Troubleshooting:") + print_info(" - Ensure LocalNet is running: algokit localnet start") + print_info(" - Check that KMD is accessible on port 4002") + print_info(" - Verify the KMD token is correct") + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/examples/kmd_client/02_wallet_management.py b/examples/kmd_client/02_wallet_management.py new file mode 100644 index 00000000..bf2f48ed --- /dev/null +++ b/examples/kmd_client/02_wallet_management.py @@ -0,0 +1,182 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Wallet Creation and Listing + +This example demonstrates how to create, list, rename, and get info about wallets +using the KMD (Key Management Daemon) client. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) + +Covered operations: +- create_wallet() - Create a new wallet +- list_wallets() - List all available wallets +- wallet_info() - Get detailed wallet information (requires wallet handle) +- rename_wallet() - Rename an existing wallet +""" + +import sys +import time + +from shared import ( + cleanup_test_wallet, + create_kmd_client, + print_error, + print_header, + print_info, + print_step, + print_success, +) + +from algokit_kmd_client.models import ( + CreateWalletRequest, + InitWalletHandleTokenRequest, + RenameWalletRequest, + WalletInfoRequest, +) + + +def main() -> None: + print_header("KMD Wallet Management Example") + + kmd = create_kmd_client() + test_wallet_name = f"test-wallet-{int(time.time() * 1000)}" + test_wallet_password = "test-password-123" + wallet_id = "" + wallet_handle_token = "" + + try: + # ========================================================================= + # Step 1: Create a New Wallet + # ========================================================================= + print_step(1, "Creating a new wallet with create_wallet()") + + create_result = kmd.create_wallet( + CreateWalletRequest( + wallet_name=test_wallet_name, + wallet_password=test_wallet_password, + wallet_driver_name="sqlite", + ) + ) + + wallet = create_result.wallet + wallet_id = wallet.id_ + + print_success("Wallet created successfully!") + print_info("") + print_info("Wallet fields from create_wallet response:") + print_info(f" - id: {wallet.id_}") + print_info(f" - name: {wallet.name}") + print_info(f" - driver_name: {wallet.driver_name}") + print_info(f" - supported_txs: [{', '.join(str(t) for t in wallet.supported_txs)}]") + print_info(f" - mnemonic_ux: {wallet.mnemonic_ux}") + + # ========================================================================= + # Step 2: List All Wallets + # ========================================================================= + print_step(2, "Listing all wallets with list_wallets()") + + list_result = kmd.list_wallets() + wallets = list_result.wallets + + print_success(f"Found {len(wallets)} wallet(s)") + print_info("") + print_info("Available wallets:") + + for index, w in enumerate(wallets): + print_info(f" {index + 1}. id: {w.id_}") + print_info(f" name: {w.name}") + + # ========================================================================= + # Step 3: Get Wallet Info (requires wallet handle) + # ========================================================================= + print_step(3, "Getting wallet info with wallet_info() (requires handle)") + + # First, we need to init a wallet handle to get detailed info + init_result = kmd.init_wallet_handle( + InitWalletHandleTokenRequest(wallet_id=wallet_id, wallet_password=test_wallet_password) + ) + wallet_handle_token = init_result.wallet_handle_token + print_info(f"Wallet handle token obtained: {wallet_handle_token[:16]}...") + + info_result = kmd.wallet_info(WalletInfoRequest(wallet_handle_token=wallet_handle_token)) + + print_success("Wallet info retrieved successfully!") + print_info("") + print_info("wallet_info() response fields:") + print_info(f" expires_seconds: {info_result.wallet_handle.expires_seconds}") + print_info(f" wallet.id: {info_result.wallet_handle.wallet.id_}") + print_info(f" wallet.name: {info_result.wallet_handle.wallet.name}") + + # ========================================================================= + # Step 4: Rename the Wallet + # ========================================================================= + print_step(4, "Renaming the wallet with rename_wallet()") + + new_wallet_name = f"{test_wallet_name}-renamed" + + rename_result = kmd.rename_wallet( + RenameWalletRequest( + wallet_id=wallet_id, + wallet_password=test_wallet_password, + wallet_name=new_wallet_name, + ) + ) + + print_success("Wallet renamed successfully!") + print_info("") + print_info("rename_wallet() response fields:") + print_info(f" - id: {rename_result.wallet.id_}") + print_info(f" - name: {rename_result.wallet.name} (was: {test_wallet_name})") + + # Verify the rename by checking wallet info again + verify_info = kmd.wallet_info(WalletInfoRequest(wallet_handle_token=wallet_handle_token)) + + print_info("") + print_info(f'Verified: wallet name is now "{verify_info.wallet_handle.wallet.name}"') + + # ========================================================================= + # Step 5: Clean Up (release wallet handle) + # ========================================================================= + print_step(5, "Cleaning up: releasing wallet handle") + + cleanup_test_wallet(kmd, wallet_handle_token) + wallet_handle_token = "" # Mark as cleaned up + + print_success("Wallet handle released") + print_info("") + print_info("Note: KMD does not support deleting wallets via API.") + print_info("The test wallet will remain in KMD storage.") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated:") + print_info(" 1. create_wallet() - Create a new wallet with name and password") + print_info(" 2. list_wallets() - List all available wallets") + print_info(" 3. wallet_info() - Get detailed wallet info (requires handle)") + print_info(" 4. rename_wallet() - Rename an existing wallet") + print_info("") + print_info("Key concepts:") + print_info(" - Wallets are collections of keys managed by KMD") + print_info(" - A wallet handle token is required for most operations") + print_info(" - Wallet handles expire and should be released when done") + print_info(" - The 'sqlite' driver is the standard driver for wallet storage") + except Exception as e: + print_error(f"Error: {e}") + print_info("") + print_info("Troubleshooting:") + print_info(" - Ensure LocalNet is running: algokit localnet start") + print_info(" - If LocalNet issues occur: algokit localnet reset") + print_info(" - Check that KMD is accessible on port 4002") + + # Cleanup on error + if wallet_handle_token: + cleanup_test_wallet(kmd, wallet_handle_token) + + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/examples/kmd_client/03_wallet_sessions.py b/examples/kmd_client/03_wallet_sessions.py new file mode 100644 index 00000000..d23dea1d --- /dev/null +++ b/examples/kmd_client/03_wallet_sessions.py @@ -0,0 +1,197 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Wallet Session Management + +This example demonstrates how to manage wallet sessions using KMD handle tokens. +Handle tokens are used to unlock wallets and perform operations on them. +They have an expiration time and should be released when no longer needed. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) + +Covered operations: +- init_wallet_handle() - Unlock a wallet and get a handle token +- wallet_info() - Check token expiration time (expires_seconds) +- renew_wallet_handle() - Extend token validity +- release_wallet_handle() - Invalidate the token +""" + +import sys +import time + +from shared import ( + cleanup_test_wallet, + create_kmd_client, + print_error, + print_header, + print_info, + print_step, + print_success, +) + +from algokit_kmd_client.models import ( + CreateWalletRequest, + InitWalletHandleTokenRequest, + ReleaseWalletHandleTokenRequest, + RenewWalletHandleTokenRequest, + WalletInfoRequest, +) + + +def main() -> None: + print_header("KMD Wallet Session Management Example") + + kmd = create_kmd_client() + test_wallet_name = f"session-test-wallet-{int(time.time() * 1000)}" + test_wallet_password = "session-test-password" + wallet_id = "" + wallet_handle_token = "" + + try: + # ========================================================================= + # Step 1: Create a Test Wallet + # ========================================================================= + print_step(1, "Creating a test wallet for session demonstration") + + create_result = kmd.create_wallet( + CreateWalletRequest( + wallet_name=test_wallet_name, + wallet_password=test_wallet_password, + wallet_driver_name="sqlite", + ) + ) + + wallet_id = create_result.wallet.id_ + print_success(f"Test wallet created: {test_wallet_name}") + print_info(f"Wallet ID: {wallet_id}") + + # ========================================================================= + # Step 2: Unlock Wallet with init_wallet_handle() + # ========================================================================= + print_step(2, "Unlocking wallet with init_wallet_handle()") + + init_result = kmd.init_wallet_handle( + InitWalletHandleTokenRequest(wallet_id=wallet_id, wallet_password=test_wallet_password) + ) + wallet_handle_token = init_result.wallet_handle_token + + print_success("Wallet unlocked successfully!") + print_info("") + print_info("init_wallet_handle() response:") + print_info(f" wallet_handle_token: {wallet_handle_token}") + print_info("") + print_info("The handle token is used to authenticate operations on this wallet.") + print_info("It has an expiration time and must be renewed or released when done.") + + # ========================================================================= + # Step 3: Check Token Expiration with wallet_info() + # ========================================================================= + print_step(3, "Checking token expiration with wallet_info()") + + info_result = kmd.wallet_info(WalletInfoRequest(wallet_handle_token=wallet_handle_token)) + + print_success("Wallet info retrieved!") + print_info("") + print_info("wallet_info() token expiration info:") + expires = info_result.wallet_handle.expires_seconds + print_info(f" expires_seconds: {expires}") + print_info("") + print_info(f"The token will expire in {expires} seconds.") + print_info("After expiration, the token becomes invalid and must be re-initialized.") + + # Store the initial expiration for comparison + initial_expiration = expires + + # ========================================================================= + # Step 4: Renew Token with renew_wallet_handle() + # ========================================================================= + print_step(4, "Extending token validity with renew_wallet_handle()") + + renew_result = kmd.renew_wallet_handle_token( + RenewWalletHandleTokenRequest(wallet_handle_token=wallet_handle_token) + ) + + renewed_expires = renew_result.wallet_handle.expires_seconds + print_success("Token renewed successfully!") + print_info("") + print_info("renew_wallet_handle() response:") + print_info(f" expires_seconds: {renewed_expires}") + print_info("") + print_info(f"Previous expiration: {initial_expiration} seconds") + print_info(f"New expiration: {renewed_expires} seconds") + print_info("") + print_info("The token expiration has been reset. Use this to keep sessions alive") + print_info("during long-running operations.") + + # Verify the renewal worked by calling wallet_info again + verify_info = kmd.wallet_info(WalletInfoRequest(wallet_handle_token=wallet_handle_token)) + print_info("") + print_info(f"Verified: token now expires in {verify_info.wallet_handle.expires_seconds} seconds") + + # ========================================================================= + # Step 5: Release Token with release_wallet_handle() + # ========================================================================= + print_step(5, "Invalidating token with release_wallet_handle()") + + kmd.release_wallet_handle_token(ReleaseWalletHandleTokenRequest(wallet_handle_token=wallet_handle_token)) + + print_success("Token released successfully!") + print_info("") + print_info("The wallet handle token has been invalidated.") + print_info("Any subsequent operations using this token will fail.") + + # ========================================================================= + # Step 6: Verify Token is Invalid + # ========================================================================= + print_step(6, "Verifying token is no longer valid") + + try: + kmd.wallet_info(WalletInfoRequest(wallet_handle_token=wallet_handle_token)) + print_error("Token should have been invalid but operation succeeded!") + except Exception as e: + print_success("Token correctly invalidated!") + print_info("") + print_info("Attempting to use the released token resulted in an error:") + print_info(f" {e}") + print_info("") + print_info("This confirms the token was properly released and is no longer usable.") + + # Mark as cleaned up since we already released the token + wallet_handle_token = "" + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated wallet session management:") + print_info("") + print_info(" 1. init_wallet_handle() - Unlock a wallet and get a handle token") + print_info(" 2. wallet_info() - Check token expiration (expires_seconds)") + print_info(" 3. renew_wallet_handle() - Extend token validity before expiration") + print_info(" 4. release_wallet_handle() - Invalidate token when done") + print_info("") + print_info("Key concepts:") + print_info(" - Handle tokens authenticate wallet operations") + print_info(" - Tokens expire automatically after a timeout (default: 60 seconds)") + print_info(" - Renew tokens during long operations to prevent expiration") + print_info(" - Always release tokens when done to free resources") + print_info(" - Released tokens cannot be used for any operations") + print_info("") + print_info("Note: The test wallet remains in KMD (wallets cannot be deleted via API).") + except Exception as e: + print_error(f"Error: {e}") + print_info("") + print_info("Troubleshooting:") + print_info(" - Ensure LocalNet is running: algokit localnet start") + print_info(" - If LocalNet issues occur: algokit localnet reset") + print_info(" - Check that KMD is accessible on port 4002") + + # Cleanup on error + if wallet_handle_token: + cleanup_test_wallet(kmd, wallet_handle_token) + + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/examples/kmd_client/04_key_generation.py b/examples/kmd_client/04_key_generation.py new file mode 100644 index 00000000..3eb09560 --- /dev/null +++ b/examples/kmd_client/04_key_generation.py @@ -0,0 +1,166 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Key Generation + +This example demonstrates how to generate new keys in a wallet using the +KMD generate_key() method. Keys are generated deterministically from the +wallet's master derivation key, which means they can be recovered if you +have the wallet's mnemonic or master derivation key. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) + +Covered operations: +- generate_key() - Generate a new key in the wallet +- list_keys() - List all keys in the wallet +""" + +import sys + +from shared import ( + cleanup_test_wallet, + create_kmd_client, + create_test_wallet, + print_error, + print_header, + print_info, + print_step, + print_success, +) + +from algokit_kmd_client.models import GenerateKeyRequest, ListKeysRequest + + +def main() -> None: + print_header("KMD Key Generation Example") + + kmd = create_kmd_client() + wallet_handle_token = "" + + try: + # ========================================================================= + # Step 1: Create a Test Wallet + # ========================================================================= + print_step(1, "Creating a test wallet for key generation") + + test_wallet = create_test_wallet(kmd, "test-password") + wallet_handle_token = test_wallet["wallet_handle_token"] + + print_success(f"Test wallet created: {test_wallet['wallet_name']}") + print_info(f"Wallet ID: {test_wallet['wallet_id']}") + + # ========================================================================= + # Step 2: Generate a Single Key + # ========================================================================= + print_step(2, "Generating a new key with generate_key()") + + key_address = kmd.generate_key(GenerateKeyRequest(wallet_handle_token=wallet_handle_token)).address + + print_success("Key generated successfully!") + print_info("") + print_info("generate_key() response:") + print_info(f" address: {key_address}") + print_info("") + print_info("The address is the public key (account address) for the generated key.") + print_info("The corresponding private key is stored securely in the wallet.") + + # ========================================================================= + # Step 3: Generate Multiple Keys (Deterministic Derivation) + # ========================================================================= + print_step(3, "Generating multiple keys to demonstrate deterministic derivation") + + generated_addresses: list[str] = [key_address] + + print_info("Generating 4 more keys...") + print_info("") + + for i in range(4): + address = kmd.generate_key(GenerateKeyRequest(wallet_handle_token=wallet_handle_token)).address + generated_addresses.append(address) + print_info(f" Key {i + 2}: {address}") + + print_success(f"Generated {len(generated_addresses)} keys total") + print_info("") + print_info("Each key is derived from the master derivation key (MDK) using a") + print_info("deterministic sequence. This means if you create a new wallet with") + print_info("the same MDK (or mnemonic), you can regenerate these same keys") + print_info("in the same order.") + + # ========================================================================= + # Step 4: List All Keys in the Wallet + # ========================================================================= + print_step(4, "Listing all keys in the wallet with list_keys()") + + list_result = kmd.list_keys_in_wallet(ListKeysRequest(wallet_handle_token=wallet_handle_token)).addresses + + print_success(f"Found {len(list_result)} keys in wallet") + print_info("") + print_info("All keys in the wallet:") + + for index, address in enumerate(list_result): + print_info(f" {index + 1}. {address}") + + # ========================================================================= + # Step 5: Verify Generated Keys Match Listed Keys + # ========================================================================= + print_step(5, "Verifying generated keys match listed keys") + + listed_addresses = list_result + all_found = all(addr in listed_addresses for addr in generated_addresses) + + if all_found: + print_success("All generated keys are present in the wallet!") + else: + print_error("Some generated keys are missing from the wallet list") + + # ========================================================================= + # Cleanup + # ========================================================================= + print_step(6, "Cleaning up test wallet") + + cleanup_test_wallet(kmd, wallet_handle_token) + wallet_handle_token = "" # Mark as cleaned up + + print_success("Test wallet handle released") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated key generation in KMD:") + print_info("") + print_info(" 1. generate_key() - Generate a new key, returns the public address") + print_info(" 2. list_keys() - List all keys (addresses) in the wallet") + print_info("") + print_info("Key concepts:") + print_info(" - Keys are generated deterministically from the master derivation key") + print_info(" - Each generate_key() call creates the next key in the sequence") + print_info(" - Generated keys can be recovered by restoring the wallet from its") + print_info(" mnemonic or master derivation key") + print_info(" - The private keys are stored securely in the wallet, only public") + print_info(" addresses are returned") + print_info("") + print_info("Recovery note:") + print_info(" If you need to recover generated keys, you can:") + print_info(" 1. Create a new wallet with the same master derivation key") + print_info(" 2. Call generate_key() the same number of times") + print_info(" 3. The same addresses will be generated in the same order") + print_info("") + print_info("Note: The test wallet remains in KMD (wallets cannot be deleted via API).") + except Exception as e: + print_error(f"Error: {e}") + print_info("") + print_info("Troubleshooting:") + print_info(" - Ensure LocalNet is running: algokit localnet start") + print_info(" - If LocalNet issues occur: algokit localnet reset") + print_info(" - Check that KMD is accessible on port 4002") + + # Cleanup on error + if wallet_handle_token: + cleanup_test_wallet(kmd, wallet_handle_token) + + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/examples/kmd_client/05_key_import_export.py b/examples/kmd_client/05_key_import_export.py new file mode 100644 index 00000000..b7172ac6 --- /dev/null +++ b/examples/kmd_client/05_key_import_export.py @@ -0,0 +1,233 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Key Import and Export + +This example demonstrates how to import and export keys using the KMD +import_key() and export_key() methods. + +Key concepts: +- Importing externally generated keys into a wallet +- Exporting private keys from a wallet +- Understanding that imported keys are NOT backed up by the master derivation key + +Prerequisites: +- LocalNet running (via `algokit localnet start`) + +Covered operations: +- import_key() - Import an external private key into the wallet +- export_key() - Export a private key from the wallet +""" + +import secrets +import sys + +from nacl.signing import SigningKey +from shared import ( + cleanup_test_wallet, + create_kmd_client, + create_test_wallet, + print_error, + print_header, + print_info, + print_step, + print_success, +) + +from algokit_kmd_client.models import ExportKeyRequest, ImportKeyRequest, ListKeysRequest + + +def format_bytes_for_display(data: bytes, show_first: int = 4, show_last: int = 4) -> str: + """Format a byte array for display, showing first and last few bytes for security.""" + hex_str = data.hex() + if len(data) <= show_first + show_last: + return hex_str + first_bytes = hex_str[: show_first * 2] + last_bytes = hex_str[-(show_last * 2) :] + return f"{first_bytes}...{last_bytes}" + + +def main() -> None: + print_header("KMD Key Import and Export Example") + + kmd = create_kmd_client() + wallet_handle_token = "" + wallet_password = "test-password" + + try: + # ========================================================================= + # Step 1: Create a Test Wallet + # ========================================================================= + print_step(1, "Creating a test wallet for key import/export") + + test_wallet = create_test_wallet(kmd, wallet_password) + wallet_handle_token = test_wallet["wallet_handle_token"] + + print_success(f"Test wallet created: {test_wallet['wallet_name']}") + print_info(f"Wallet ID: {test_wallet['wallet_id']}") + + # ========================================================================= + # Step 2: Create a Random Account Using nacl + # ========================================================================= + print_step(2, "Creating a random account to get a private key") + + # Generate a random ed25519 keypair using PyNaCl + # - public_key: 32 bytes (used to derive the Algorand address) + # - private_key: 64 bytes (32-byte seed + 32-byte public key) + seed = secrets.token_bytes(32) + signing_key = SigningKey(seed) + public_key = bytes(signing_key.verify_key) + # The full private key is seed (32 bytes) + public key (32 bytes) = 64 bytes + original_private_key = seed + public_key + + print_success("Random keypair generated!") + print_info("") + print_info("Keypair details:") + print_info(f" Public key (32 bytes): {format_bytes_for_display(public_key)}") + print_info(f" Private key (64 bytes): {format_bytes_for_display(original_private_key)}") + print_info("") + print_info("Note: The ed25519 private key is 64 bytes because it contains") + print_info(" both the 32-byte private seed AND the 32-byte public key.") + + # ========================================================================= + # Step 3: Import the Private Key into the Wallet + # ========================================================================= + print_step(3, "Importing the private key with import_key()") + + imported_address = kmd.import_key( + ImportKeyRequest(wallet_handle_token=wallet_handle_token, private_key=original_private_key) + ).address + + print_success("Key imported successfully!") + print_info("") + print_info("import_key() response:") + print_info(f" address: {imported_address}") + print_info("") + print_info("The imported address is derived from the public key portion") + print_info("of the private key that was imported.") + + # ========================================================================= + # Step 4: Verify the Key is in the Wallet + # ========================================================================= + print_step(4, "Verifying the key is in the wallet") + + list_result = kmd.list_keys_in_wallet(ListKeysRequest(wallet_handle_token=wallet_handle_token)).addresses + + key_found = imported_address in list_result + + if key_found: + print_success("Imported key found in wallet!") + else: + print_error("Imported key not found in wallet list") + + print_info(f"Wallet contains {len(list_result)} key(s)") + + # ========================================================================= + # Step 5: Export the Private Key + # ========================================================================= + print_step(5, "Exporting the private key with export_key()") + + exported_private_key = kmd.export_key( + ExportKeyRequest( + wallet_handle_token=wallet_handle_token, + wallet_password=wallet_password, + address=imported_address, + ) + ).private_key + + print_success("Key exported successfully!") + print_info("") + print_info("export_key() response:") + print_info(f" privateKey (64 bytes): {format_bytes_for_display(exported_private_key)}") + print_info("") + print_info("Note: Exporting private keys requires the wallet password for security.") + + # ========================================================================= + # Step 6: Verify the Exported Key Matches the Original + # ========================================================================= + print_step(6, "Verifying the exported key matches the original") + + keys_match = original_private_key == exported_private_key + + if keys_match: + print_success("Exported key matches the original key!") + print_info("") + print_info("Verification details:") + print_info(f" Original key length: {len(original_private_key)} bytes") + print_info(f" Exported key length: {len(exported_private_key)} bytes") + print_info(" Keys are identical: true") + else: + print_error("Keys do not match!") + print_info("") + print_info(f"Original key: {format_bytes_for_display(original_private_key)}") + print_info(f"Exported key: {format_bytes_for_display(exported_private_key)}") + + # ========================================================================= + # Important Note About Imported Keys + # ========================================================================= + print_step(7, "Important note about imported keys") + + print_info("") + print_info("IMPORTANT: Imported keys are NOT backed up by the master derivation key!") + print_info("") + print_info("When you import a key:") + print_info(" - The key is stored in the wallet database") + print_info(" - It can be used for signing transactions") + print_info(" - It can be exported using export_key()") + print_info("") + print_info("However, imported keys CANNOT be recovered by:") + print_info(" - Restoring the wallet from its mnemonic/MDK") + print_info(" - Using generate_key() (which only regenerates derived keys)") + print_info("") + print_info("To backup imported keys, you must either:") + print_info(" 1. Export the key and store it securely") + print_info(" 2. Backup the entire wallet database file") + + # ========================================================================= + # Cleanup + # ========================================================================= + print_step(8, "Cleaning up test wallet") + + cleanup_test_wallet(kmd, wallet_handle_token) + wallet_handle_token = "" # Mark as cleaned up + + print_success("Test wallet handle released") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated key import and export in KMD:") + print_info("") + print_info(" 1. import_key() - Import an external private key into a wallet") + print_info(" Parameters: wallet_handle_token, private_key (64-byte bytes)") + print_info(" Returns: address of the imported key") + print_info("") + print_info(" 2. export_key() - Export a private key from a wallet") + print_info(" Parameters: wallet_handle_token, wallet_password, address") + print_info(" Returns: private_key (64-byte bytes)") + print_info("") + print_info("Key takeaways:") + print_info(" - Private keys are 64 bytes (32-byte seed + 32-byte public key)") + print_info(" - Importing returns the corresponding Algorand address") + print_info(" - Exporting requires the wallet password for security") + print_info(" - Imported keys are NOT protected by the wallet mnemonic/MDK") + print_info(" - Always backup imported keys separately!") + print_info("") + print_info("Note: The test wallet remains in KMD (wallets cannot be deleted via API).") + except Exception as e: + print_error(f"Error: {e}") + print_info("") + print_info("Troubleshooting:") + print_info(" - Ensure LocalNet is running: algokit localnet start") + print_info(" - If LocalNet issues occur: algokit localnet reset") + print_info(" - Check that KMD is accessible on port 4002") + + # Cleanup on error + if wallet_handle_token: + cleanup_test_wallet(kmd, wallet_handle_token) + + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/examples/kmd_client/06_key_listing_deletion.py b/examples/kmd_client/06_key_listing_deletion.py new file mode 100644 index 00000000..30401009 --- /dev/null +++ b/examples/kmd_client/06_key_listing_deletion.py @@ -0,0 +1,207 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Key Listing and Deletion + +This example demonstrates how to list all keys in a wallet and delete +specific keys using the KMD list_keys() and delete_key() methods. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) + +Covered operations: +- list_keys() - List all keys (addresses) in a wallet +- delete_key() - Delete a specific key from the wallet +""" + +import sys + +from shared import ( + cleanup_test_wallet, + create_kmd_client, + create_test_wallet, + print_error, + print_header, + print_info, + print_step, + print_success, +) + +from algokit_kmd_client.models import DeleteKeyRequest, GenerateKeyRequest, ListKeysRequest + + +def main() -> None: + print_header("KMD Key Listing and Deletion Example") + + kmd = create_kmd_client() + wallet_password = "test-password" + wallet_handle_token = "" + + try: + # ========================================================================= + # Step 1: Create a Test Wallet + # ========================================================================= + print_step(1, "Creating a test wallet") + + test_wallet = create_test_wallet(kmd, wallet_password) + wallet_handle_token = test_wallet["wallet_handle_token"] + + print_success(f"Test wallet created: {test_wallet['wallet_name']}") + print_info(f"Wallet ID: {test_wallet['wallet_id']}") + + # ========================================================================= + # Step 2: Generate Several Keys + # ========================================================================= + print_step(2, "Generating several keys in the wallet") + + generated_addresses: list[str] = [] + + print_info("Generating 5 keys...") + print_info("") + + for i in range(5): + address = kmd.generate_key(GenerateKeyRequest(wallet_handle_token=wallet_handle_token)).address + generated_addresses.append(address) + print_info(f" Key {i + 1}: {address}") + + print_success(f"Generated {len(generated_addresses)} keys") + + # ========================================================================= + # Step 3: List All Keys with list_keys() + # ========================================================================= + print_step(3, "Listing all keys with list_keys()") + + list_result = kmd.list_keys_in_wallet(ListKeysRequest(wallet_handle_token=wallet_handle_token)).addresses + + print_success(f"Found {len(list_result)} keys in wallet") + print_info("") + print_info("list_keys() response:") + print_info(" Returns a list of address strings") + print_info("") + print_info("All keys in the wallet:") + + for index, address in enumerate(list_result): + print_info(f" {index + 1}. {address}") + + # ========================================================================= + # Step 4: Delete One Key with delete_key() + # ========================================================================= + print_step(4, "Deleting the first key with delete_key()") + + key_to_delete = generated_addresses[0] + print_info(f"Key to delete: {key_to_delete}") + print_info("") + + kmd.delete_key( + DeleteKeyRequest( + wallet_handle_token=wallet_handle_token, wallet_password=wallet_password, address=key_to_delete + ) + ) + + print_success("Key deleted successfully!") + print_info("") + print_info("delete_key() parameters:") + print_info(" wallet_handle_token: The handle token from init_wallet_handle()") + print_info(" wallet_password: The wallet password (required for security)") + print_info(" address: The public address of the key to delete") + print_info("") + print_info("Note: delete_key() returns None on success (no response body).") + + # ========================================================================= + # Step 5: Verify Deletion by Listing Keys Again + # ========================================================================= + print_step(5, "Verifying deletion by listing keys again") + + list_after_delete = kmd.list_keys_in_wallet(ListKeysRequest(wallet_handle_token=wallet_handle_token)).addresses + + print_info(f"Keys before deletion: {len(list_result)}") + print_info(f"Keys after deletion: {len(list_after_delete)}") + print_info("") + + deleted_key_present = key_to_delete in list_after_delete + + if not deleted_key_present: + print_success(f"Confirmed: Key {key_to_delete[:8]}... is no longer in the wallet") + else: + print_error("Key still present in wallet after deletion!") + + print_info("") + print_info("Remaining keys:") + for index, address in enumerate(list_after_delete): + print_info(f" {index + 1}. {address}") + + # ========================================================================= + # Step 6: Handle Deleting a Non-Existent Key + # ========================================================================= + print_step(6, "Handling deletion of a non-existent key") + + print_info("Attempting to delete the already-deleted key again...") + print_info("") + + # Note: KMD does NOT throw an error when deleting a non-existent key. + # The operation silently succeeds even if the key doesn't exist. + kmd.delete_key( + DeleteKeyRequest( + wallet_handle_token=wallet_handle_token, wallet_password=wallet_password, address=key_to_delete + ) + ) + + print_success("delete_key() completed (no error thrown)") + print_info("") + print_info("Important: KMD does NOT throw an error when deleting a non-existent key!") + print_info("The operation silently succeeds even if:") + print_info(" - The key does not exist in the wallet") + print_info(" - The address was never part of this wallet") + print_info(" - The key was already deleted") + print_info("") + print_info("This means you should always verify key existence before deletion") + print_info("if you need to confirm the key was actually removed.") + + # ========================================================================= + # Cleanup + # ========================================================================= + print_step(7, "Cleaning up test wallet") + + cleanup_test_wallet(kmd, wallet_handle_token) + wallet_handle_token = "" # Mark as cleaned up + + print_success("Test wallet handle released") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated key listing and deletion in KMD:") + print_info("") + print_info(" 1. list_keys() - List all keys (addresses) in a wallet") + print_info(" Takes: wallet_handle_token") + print_info(" Returns: list of address strings") + print_info("") + print_info(" 2. delete_key() - Delete a specific key from the wallet") + print_info(" Takes: wallet_handle_token, wallet_password, address") + print_info(" Returns: None (no response body)") + print_info(" Requires wallet password for security") + print_info("") + print_info("Important notes:") + print_info(" - Deleted keys cannot be recovered unless you have a backup") + print_info(" - Generated keys can be re-derived from the master derivation key") + print_info(" - Imported keys are permanently lost if deleted without backup") + print_info(" - Deleting a non-existent key does NOT throw an error (silent success)") + print_info("") + print_info("Note: The test wallet remains in KMD (wallets cannot be deleted via API).") + except Exception as e: + print_error(f"Error: {e}") + print_info("") + print_info("Troubleshooting:") + print_info(" - Ensure LocalNet is running: algokit localnet start") + print_info(" - If LocalNet issues occur: algokit localnet reset") + print_info(" - Check that KMD is accessible on port 4002") + + # Cleanup on error + if wallet_handle_token: + cleanup_test_wallet(kmd, wallet_handle_token) + + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/examples/kmd_client/07_master_key_export.py b/examples/kmd_client/07_master_key_export.py new file mode 100644 index 00000000..77cbfa29 --- /dev/null +++ b/examples/kmd_client/07_master_key_export.py @@ -0,0 +1,228 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Master Key Export + +This example demonstrates how to export the master derivation key (MDK) +for wallet backup using the KMD export_master_key() method. + +Key concepts: +- The master derivation key (MDK) is the root key used to deterministically + generate all keys in the wallet +- With the MDK, you can recreate a wallet and regenerate all derived keys +- Imported keys CANNOT be recovered from the MDK +- The MDK should be stored securely as it can regenerate all wallet keys + +Prerequisites: +- LocalNet running (via `algokit localnet start`) + +Covered operations: +- export_master_key() - Export the master derivation key from a wallet +""" + +import sys + +from shared import ( + cleanup_test_wallet, + create_kmd_client, + create_test_wallet, + print_error, + print_header, + print_info, + print_step, + print_success, +) + +from algokit_kmd_client.models import ExportMasterKeyRequest, GenerateKeyRequest, ListKeysRequest + + +def format_bytes_for_display(data: bytes, show_first: int = 4, show_last: int = 4) -> str: + """Format a byte array for display, showing first and last few bytes for security.""" + hex_str = data.hex() + if len(data) <= show_first + show_last: + return hex_str + first_bytes = hex_str[: show_first * 2] + last_bytes = hex_str[-(show_last * 2) :] + return f"{first_bytes}...{last_bytes}" + + +def main() -> None: + print_header("KMD Master Key Export Example") + + kmd = create_kmd_client() + wallet_handle_token = "" + wallet_password = "test-password" + + try: + # ========================================================================= + # Step 1: Create a Test Wallet + # ========================================================================= + print_step(1, "Creating a test wallet") + + test_wallet = create_test_wallet(kmd, wallet_password) + wallet_handle_token = test_wallet["wallet_handle_token"] + + print_success(f"Test wallet created: {test_wallet['wallet_name']}") + print_info(f"Wallet ID: {test_wallet['wallet_id']}") + + # ========================================================================= + # Step 2: Generate Several Keys in the Wallet + # ========================================================================= + print_step(2, "Generating several keys in the wallet") + + generated_addresses: list[str] = [] + num_keys = 3 + + for i in range(1, num_keys + 1): + address = kmd.generate_key(GenerateKeyRequest(wallet_handle_token=wallet_handle_token)).address + generated_addresses.append(address) + print_info(f"Key {i}: {address}") + + print_success(f"Generated {num_keys} keys in the wallet") + print_info("") + print_info("These keys are deterministically derived from the master derivation key.") + print_info("They can be regenerated by creating a new wallet with the same MDK.") + + # ========================================================================= + # Step 3: Export the Master Derivation Key + # ========================================================================= + print_step(3, "Exporting the master derivation key with export_master_key()") + + master_key = kmd.export_master_key( + ExportMasterKeyRequest(wallet_handle_token=wallet_handle_token, wallet_password=wallet_password) + ).master_derivation_key + + print_success("Master derivation key exported successfully!") + print_info("") + print_info("export_master_key() response:") + key_display = format_bytes_for_display(master_key) + print_info(f" master_derivation_key ({len(master_key)} bytes): {key_display}") + print_info("") + print_info("Note: The wallet password is required to export the master key for security.") + + # ========================================================================= + # Step 4: Explain What the Master Key Is + # ========================================================================= + print_step(4, "Understanding the master derivation key") + + print_info("") + print_info("What is the Master Derivation Key (MDK)?") + print_info("-" * 40) + print_info("") + print_info("The MDK is the cryptographic root of your wallet. It is used to:") + print_info("") + print_info(" 1. BACKUP/RECOVERY: Store this key to recover your wallet") + print_info(" - Create a new wallet with the MDK to restore it") + print_info(" - Call generate_key() the same number of times to recover keys") + print_info(f" - In this example, calling generate_key() {num_keys} times would") + print_info(" regenerate the exact same addresses") + print_info("") + print_info(" 2. DETERMINISTIC DERIVATION: Keys are derived in sequence") + print_info(" - First generate_key() call always produces the same address") + print_info(" - Second call produces the same second address, etc.") + print_info(" - This sequence is reproducible with the same MDK") + + # ========================================================================= + # Step 5: Important Limitations + # ========================================================================= + print_step(5, "Important limitations - Imported keys") + + print_info("") + print_info("IMPORTANT: Imported keys CANNOT be recovered from the MDK!") + print_info("-" * 40) + print_info("") + print_info("The MDK only protects keys generated with generate_key().") + print_info("") + print_info("Keys imported with import_key():") + print_info(" - Are stored in the wallet database") + print_info(" - Can be used for transactions while the wallet exists") + print_info(" - CANNOT be regenerated from the MDK") + print_info(" - Must be backed up separately using export_key()") + print_info("") + print_info("To fully backup a wallet with imported keys:") + print_info(" 1. Export and store the MDK (for generated keys)") + print_info(" 2. Export and store each imported key separately") + print_info(" 3. Or backup the entire wallet database file") + + # ========================================================================= + # Step 6: Security Implications + # ========================================================================= + print_step(6, "Security implications") + + print_info("") + print_info("SECURITY WARNING: Handle the MDK with extreme care!") + print_info("-" * 40) + print_info("") + print_info("Anyone with access to your MDK can:") + print_info(" - Recreate your entire wallet") + print_info(" - Generate all your derived keys") + print_info(" - Sign transactions and move your funds") + print_info("") + print_info("Best practices for MDK storage:") + print_info(" - Never store it in plain text on your computer") + print_info(" - Use hardware security modules (HSM) for production") + print_info(" - Consider splitting the key using Shamir Secret Sharing") + print_info(" - Store backups in secure, offline locations") + print_info(" - Never transmit the MDK over insecure channels") + print_info("") + print_info("The MDK in this example is for demonstration only.") + print_info("In production, implement proper key management practices.") + + # ========================================================================= + # Step 7: Verify Keys Can Be Listed + # ========================================================================= + print_step(7, "Verifying wallet state") + + list_result = kmd.list_keys_in_wallet(ListKeysRequest(wallet_handle_token=wallet_handle_token)).addresses + + print_success(f"Wallet contains {len(list_result)} key(s)") + print_info("") + print_info("Generated addresses (would be recoverable from MDK):") + for i, addr in enumerate(list_result): + print_info(f" {i + 1}. {addr}") + + # ========================================================================= + # Cleanup + # ========================================================================= + print_step(8, "Cleaning up test wallet") + + cleanup_test_wallet(kmd, wallet_handle_token) + wallet_handle_token = "" # Mark as cleaned up + + print_success("Test wallet handle released") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated master key export in KMD:") + print_info("") + print_info(" export_master_key()") + print_info(" Parameters: wallet_handle_token, wallet_password") + print_info(f" Returns: master_derivation_key ({len(master_key)}-byte bytes)") + print_info("") + print_info("Key takeaways:") + print_info(" - The MDK is the root key for deterministic key derivation") + print_info(f" - MDK is {len(master_key)} bytes (256 bits) for ed25519") + print_info(" - Wallet password is required to export the MDK") + print_info(" - Generated keys can be recovered with the MDK") + print_info(" - Imported keys CANNOT be recovered with the MDK") + print_info(" - The MDK must be stored securely - it controls all funds!") + print_info("") + print_info("Note: The test wallet remains in KMD (wallets cannot be deleted via API).") + except Exception as e: + print_error(f"Error: {e}") + print_info("") + print_info("Troubleshooting:") + print_info(" - Ensure LocalNet is running: algokit localnet start") + print_info(" - If LocalNet issues occur: algokit localnet reset") + print_info(" - Check that KMD is accessible on port 4002") + + # Cleanup on error + if wallet_handle_token: + cleanup_test_wallet(kmd, wallet_handle_token) + + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/examples/kmd_client/08_multisig_setup.py b/examples/kmd_client/08_multisig_setup.py new file mode 100644 index 00000000..974b5365 --- /dev/null +++ b/examples/kmd_client/08_multisig_setup.py @@ -0,0 +1,288 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Multisig Account Setup + +This example demonstrates how to create multisig accounts using the KMD +import_multisig() method. + +Key concepts: +- A multisig account requires M-of-N signatures to authorize transactions +- The threshold (M) is the minimum number of signatures required +- The public keys (N) are the participants who can sign +- The multisig version parameter (currently always 1) defines the format +- The resulting multisig address is deterministically derived from the + public keys, threshold, and version + +Prerequisites: +- LocalNet running (via `algokit localnet start`) + +Covered operations: +- generate_key() - Generate keys to use as multisig participants +- import_multisig() - Create a multisig account from public keys +""" + +import sys + +from shared import ( + cleanup_test_wallet, + create_kmd_client, + create_test_wallet, + print_error, + print_header, + print_info, + print_step, + print_success, +) + +from algokit_common import public_key_from_address +from algokit_kmd_client.models import GenerateKeyRequest, ImportMultisigRequest, ListMultisigRequest + + +def format_bytes_for_display(data: bytes, show_first: int = 4, show_last: int = 4) -> str: + """Format a byte array for display, showing first and last few bytes.""" + hex_str = data.hex() + if len(data) <= show_first + show_last: + return hex_str + first_bytes = hex_str[: show_first * 2] + last_bytes = hex_str[-(show_last * 2) :] + return f"{first_bytes}...{last_bytes}" + + +def main() -> None: + print_header("KMD Multisig Account Setup Example") + + kmd = create_kmd_client() + wallet_handle_token = "" + wallet_password = "test-password" + + try: + # ========================================================================= + # Step 1: Create a Test Wallet + # ========================================================================= + print_step(1, "Creating a test wallet") + + test_wallet = create_test_wallet(kmd, wallet_password) + wallet_handle_token = test_wallet["wallet_handle_token"] + + print_success(f"Test wallet created: {test_wallet['wallet_name']}") + print_info(f"Wallet ID: {test_wallet['wallet_id']}") + + # ========================================================================= + # Step 2: Generate 3 Keys for Multisig Participants + # ========================================================================= + print_step(2, "Generating 3 keys to use as multisig participants") + + participant_addresses: list[str] = [] + num_participants = 3 + + for i in range(1, num_participants + 1): + address = kmd.generate_key(GenerateKeyRequest(wallet_handle_token=wallet_handle_token)).address + participant_addresses.append(address) + print_info(f"Participant {i}: {address}") + + print_success(f"Generated {num_participants} participant keys") + print_info("") + print_info("These addresses will be used to create a 2-of-3 multisig account.") + + # ========================================================================= + # Step 3: Convert Addresses to Public Keys + # ========================================================================= + print_step(3, "Converting addresses to public keys") + + public_keys: list[bytes] = [] + for addr in participant_addresses: + pk = public_key_from_address(addr) + public_keys.append(pk) + + print_info("Public keys extracted from addresses:") + for i, pk in enumerate(public_keys): + pk_display = format_bytes_for_display(pk) + print_info(f" Participant {i + 1}: {pk_display} ({len(pk)} bytes)") + + print_info("") + print_info("Note: Each Algorand address encodes a 32-byte public key.") + print_info("The address also includes a 4-byte checksum for error detection.") + + # ========================================================================= + # Step 4: Create the Multisig Account with import_multisig() + # ========================================================================= + print_step(4, "Creating a 2-of-3 multisig account with import_multisig()") + + threshold = 2 # Minimum signatures required + multisig_version = 1 # Multisig format version + + multisig_address = kmd.import_multisig( + ImportMultisigRequest( + wallet_handle_token=wallet_handle_token, + multisig_version=multisig_version, + threshold=threshold, + public_keys=public_keys, + ) + ).address + + print_success("Multisig account created successfully!") + print_info("") + print_info("import_multisig() response:") + print_info(f" address: {multisig_address}") + print_info("") + print_info("Parameters used:") + print_info(f" public_keys: {num_participants} participant keys") + print_info(f" threshold: {threshold} (minimum signatures required)") + print_info(f" multisig_version: {multisig_version}") + + # ========================================================================= + # Step 5: Explain the Threshold Parameter + # ========================================================================= + print_step(5, "Understanding the threshold parameter") + + print_info("") + print_info("What is the threshold?") + print_info("-" * 40) + print_info("") + print_info(f"The threshold ({threshold}) is the minimum number of signatures required") + print_info("to authorize any transaction from this multisig account.") + print_info("") + print_info(f"With a {threshold}-of-{num_participants} configuration:") + print_info(f" - {num_participants} participants can potentially sign") + print_info(f" - At least {threshold} signatures are required") + msg = f" - Any {threshold} of the {num_participants} participants can authorize a transaction" + print_info(msg) + print_info("") + print_info("Common use cases:") + print_info(" - 2-of-3: Standard security (recover if one key is lost)") + print_info(" - 2-of-2: Joint control (both parties must agree)") + print_info(" - 3-of-5: Committee/board decisions") + print_info(" - 1-of-N: Any participant can act alone (hot wallet backup)") + + # ========================================================================= + # Step 6: Explain the Multisig Version Parameter + # ========================================================================= + print_step(6, "Understanding the multisig version parameter") + + print_info("") + print_info("What is the multisig version?") + print_info("-" * 40) + print_info("") + msg = f"The multisig version ({multisig_version}) specifies the format of the multisig account." + print_info(msg) + print_info("") + print_info("Currently, version 1 is the only supported version on Algorand.") + print_info("This parameter exists for future compatibility if the multisig") + print_info("format is ever updated.") + print_info("") + print_info("Always use version 1 unless Algorand documentation specifies otherwise.") + + # ========================================================================= + # Step 7: Show Relationship Between Keys and Address + # ========================================================================= + print_step(7, "Relationship between public keys and multisig address") + + print_info("") + print_info("How is the multisig address derived?") + print_info("-" * 40) + print_info("") + print_info("The multisig address is deterministically computed from:") + print_info(" 1. The multisig version") + print_info(" 2. The threshold value") + print_info(" 3. The ordered list of public keys") + print_info("") + print_info("Important properties:") + print_info(" - Same inputs always produce the same multisig address") + print_info(" - Changing the order of public keys changes the address") + print_info(" - Changing the threshold changes the address") + print_info(" - The address encodes the complete multisig configuration") + print_info("") + print_info("Multisig address structure:") + print_info(f" {multisig_address}") + print_info("") + print_info("Participant addresses (order matters!):") + for i, addr in enumerate(participant_addresses): + print_info(f" {i + 1}. {addr}") + + # ========================================================================= + # Step 8: Verify Multisig is Listed + # ========================================================================= + print_step(8, "Verifying the multisig account is in the wallet") + + list_result = kmd.list_multisig(ListMultisigRequest(wallet_handle_token=wallet_handle_token)).addresses + + print_success(f"Wallet contains {len(list_result)} multisig address(es)") + print_info("") + print_info("Multisig addresses in wallet:") + for i, addr in enumerate(list_result): + marker = " (our new multisig)" if addr == multisig_address else "" + print_info(f" {i + 1}. {addr}{marker}") + + # ========================================================================= + # Step 9: Summary of Multisig Operations + # ========================================================================= + print_step(9, "What you can do with the multisig account") + + print_info("") + print_info("Now that the multisig is imported, you can:") + print_info("") + print_info(" 1. RECEIVE FUNDS: Send Algo or ASAs to the multisig address") + print_info(f" Address: {multisig_address}") + print_info("") + print_info(" 2. SIGN TRANSACTIONS: Use sign_multisig_transaction() to add") + print_info(" signatures from participants whose keys are in this wallet") + print_info("") + print_info(" 3. EXPORT CONFIGURATION: Use export_multisig() to get the") + print_info(" full multisig parameters (keys, threshold, version)") + print_info("") + print_info(" 4. DELETE: Use delete_multisig() to remove from the wallet") + print_info(" (does not affect the blockchain account or funds)") + print_info("") + print_info("Note: To fully authorize a transaction, collect signatures from") + print_info(f"at least {threshold} participants, then combine and submit.") + + # ========================================================================= + # Cleanup + # ========================================================================= + print_step(10, "Cleaning up test wallet") + + cleanup_test_wallet(kmd, wallet_handle_token) + wallet_handle_token = "" # Mark as cleaned up + + print_success("Test wallet handle released") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated multisig account setup in KMD:") + print_info("") + print_info(" import_multisig()") + print_info(" Parameters:") + print_info(" - wallet_handle_token: Session token for the wallet") + print_info(" - multisig_version: Format version (always 1)") + print_info(" - threshold: Minimum signatures required (M in M-of-N)") + print_info(" - public_keys: List of participant public keys (bytes)") + print_info(" Returns:") + print_info(" - address: The generated multisig address string") + print_info("") + print_info("Key takeaways:") + print_info(" - Multisig requires M-of-N signatures to authorize transactions") + print_info(" - The address is derived from version + threshold + ordered keys") + print_info(" - Same configuration always produces the same address") + print_info(" - Public keys are extracted from addresses using public_key_from_address()") + print_info(" - multisig_version should always be 1 (current Algorand standard)") + print_info("") + print_info("Note: The test wallet remains in KMD (wallets cannot be deleted via API).") + except Exception as e: + print_error(f"Error: {e}") + print_info("") + print_info("Troubleshooting:") + print_info(" - Ensure LocalNet is running: algokit localnet start") + print_info(" - If LocalNet issues occur: algokit localnet reset") + print_info(" - Check that KMD is accessible on port 4002") + + # Cleanup on error + if wallet_handle_token: + cleanup_test_wallet(kmd, wallet_handle_token) + + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/examples/kmd_client/09_multisig_management.py b/examples/kmd_client/09_multisig_management.py new file mode 100644 index 00000000..27e21847 --- /dev/null +++ b/examples/kmd_client/09_multisig_management.py @@ -0,0 +1,326 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Multisig Account Management + +This example demonstrates how to manage multisig accounts using KMD: +- list_multisig() - List all multisig accounts in a wallet +- export_multisig() - Get the multisig preimage information +- delete_multisig() - Remove a multisig account from the wallet + +Key concepts: +- Multisig accounts can be listed to see all multisigs in a wallet +- The multisig preimage contains the original parameters: publicKeys, threshold, version +- Deleting a multisig only removes it from the wallet, not from the blockchain +- Funds in a deleted multisig address remain on the blockchain + +Prerequisites: +- LocalNet running (via `algokit localnet start`) + +Covered operations: +- generate_key() - Generate keys to use as multisig participants +- import_multisig() - Create a multisig account from public keys +- list_multisig() - List all multisig accounts in the wallet +- export_multisig() - Export the multisig preimage (configuration) +- delete_multisig() - Delete a multisig account from the wallet +""" + +import sys + +from shared import ( + cleanup_test_wallet, + create_kmd_client, + create_test_wallet, + print_error, + print_header, + print_info, + print_step, + print_success, +) + +from algokit_common import public_key_from_address +from algokit_kmd_client.models import ( + DeleteMultisigRequest, + ExportMultisigRequest, + GenerateKeyRequest, + ImportMultisigRequest, + ListMultisigRequest, +) + + +def format_bytes_for_display(data: bytes, show_first: int = 4, show_last: int = 4) -> str: + """Format a byte array for display, showing first and last few bytes.""" + hex_str = data.hex() + if len(data) <= show_first + show_last: + return hex_str + first_bytes = hex_str[: show_first * 2] + last_bytes = hex_str[-(show_last * 2) :] + return f"{first_bytes}...{last_bytes}" + + +def main() -> None: + print_header("KMD Multisig Account Management Example") + + kmd = create_kmd_client() + wallet_handle_token = "" + wallet_password = "test-password" + + try: + # ========================================================================= + # Step 1: Create a Test Wallet + # ========================================================================= + print_step(1, "Creating a test wallet") + + test_wallet = create_test_wallet(kmd, wallet_password) + wallet_handle_token = test_wallet["wallet_handle_token"] + + print_success(f"Test wallet created: {test_wallet['wallet_name']}") + print_info(f"Wallet ID: {test_wallet['wallet_id']}") + + # ========================================================================= + # Step 2: Generate 3 Keys for Multisig Participants + # ========================================================================= + print_step(2, "Generating 3 keys to use as multisig participants") + + participant_addresses: list[str] = [] + num_participants = 3 + + for i in range(1, num_participants + 1): + address = kmd.generate_key(GenerateKeyRequest(wallet_handle_token=wallet_handle_token)).address + participant_addresses.append(address) + print_info(f"Participant {i}: {address}") + + print_success(f"Generated {num_participants} participant keys") + + # ========================================================================= + # Step 3: Create a 2-of-3 Multisig Account + # ========================================================================= + print_step(3, "Creating a 2-of-3 multisig account") + + public_keys: list[bytes] = [] + for addr in participant_addresses: + pk = public_key_from_address(addr) + public_keys.append(pk) + + threshold = 2 + multisig_version = 1 + + multisig_address = kmd.import_multisig( + ImportMultisigRequest( + wallet_handle_token=wallet_handle_token, + multisig_version=multisig_version, + threshold=threshold, + public_keys=public_keys, + ) + ).address + + print_success("Multisig account created!") + print_info(f"Multisig address: {multisig_address}") + print_info(f"Configuration: {threshold}-of-{num_participants}") + + # ========================================================================= + # Step 4: List All Multisig Accounts with list_multisig() + # ========================================================================= + print_step(4, "Listing all multisig accounts with list_multisig()") + + list_result = kmd.list_multisig(ListMultisigRequest(wallet_handle_token=wallet_handle_token)).addresses + + print_success(f"Found {len(list_result)} multisig address(es) in wallet") + print_info("") + print_info("list_multisig() response:") + print_info(f" Returns a list of {len(list_result)} address string(s)") + print_info("") + print_info("Multisig addresses in wallet:") + for i, addr in enumerate(list_result): + print_info(f" {i + 1}. {addr}") + + print_info("") + print_info("Note: list_multisig() returns all multisig addresses currently") + print_info("imported in the wallet. Each address represents a unique multisig") + print_info("configuration (different participants, threshold, or version).") + + # ========================================================================= + # Step 5: Export Multisig Preimage with export_multisig() + # ========================================================================= + print_step(5, "Exporting multisig preimage with export_multisig()") + + export_result = kmd.export_multisig( + ExportMultisigRequest( + address=multisig_address, + wallet_handle_token=wallet_handle_token, + ) + ) + + print_success("Multisig preimage exported successfully!") + print_info("") + print_info("export_multisig() response fields:") + print_info(f" multisig_version: {export_result.multisig_version}") + print_info(f" threshold: {export_result.threshold}") + print_info(f" public_keys: List of {len(export_result.public_keys)} public key(s)") + print_info("") + print_info("Exported multisig configuration:") + print_info(f" Version: {export_result.multisig_version}") + print_info(f" Threshold: {export_result.threshold} (minimum signatures required)") + print_info(" Public Keys:") + for i, pk in enumerate(export_result.public_keys): + pk_display = format_bytes_for_display(pk) + print_info(f" {i + 1}. {pk_display} ({len(pk)} bytes)") + + print_info("") + print_info("What is the multisig preimage?") + print_info("-" * 40) + print_info("The preimage contains the original parameters used to create") + print_info("the multisig address:") + print_info(" - multisig_version: The format version (always 1)") + print_info(" - threshold: Minimum signatures required") + print_info(" - public_keys: The ordered list of participant public keys") + print_info("") + print_info("This information is needed to:") + print_info(" - Reconstruct the multisig address") + print_info(" - Import the multisig into another wallet") + print_info(" - Verify the configuration of an existing multisig") + + # ========================================================================= + # Step 6: Verify Exported Info Matches Original + # ========================================================================= + print_step(6, "Verifying exported info matches original parameters") + + version_matches = export_result.multisig_version == multisig_version + threshold_matches = export_result.threshold == threshold + key_count_matches = len(export_result.public_keys) == len(public_keys) + + # Check if all public keys match + all_keys_match = key_count_matches + if key_count_matches: + for i, original_key in enumerate(public_keys): + exported_key = export_result.public_keys[i] + if original_key != exported_key: + all_keys_match = False + break + + print_info("Verification results:") + version_str = f"expected: {multisig_version}, got: {export_result.multisig_version}" + print_info(f" Version matches: {'Yes' if version_matches else 'No'} ({version_str})") + threshold_str = f"expected: {threshold}, got: {export_result.threshold}" + print_info(f" Threshold matches: {'Yes' if threshold_matches else 'No'} ({threshold_str})") + key_count_str = f"expected: {len(public_keys)}, got: {len(export_result.public_keys)}" + print_info(f" Key count matches: {'Yes' if key_count_matches else 'No'} ({key_count_str})") + print_info(f" All keys match: {'Yes' if all_keys_match else 'No'}") + + if version_matches and threshold_matches and all_keys_match: + print_success("All exported information matches the original parameters!") + + # ========================================================================= + # Step 7: Delete the Multisig Account with delete_multisig() + # ========================================================================= + print_step(7, "Deleting the multisig account with delete_multisig()") + + print_info(f"Deleting multisig: {multisig_address}") + + kmd.delete_multisig( + DeleteMultisigRequest( + address=multisig_address, + wallet_handle_token=wallet_handle_token, + wallet_password=wallet_password, + ) + ) + + print_success("Multisig account deleted from wallet!") + print_info("") + print_info("delete_multisig() parameters:") + print_info(" - wallet_handle_token: Session token for the wallet") + print_info(" - wallet_password: Wallet password (required for security)") + print_info(" - address: The multisig address to delete") + print_info("") + print_info("Important notes about delete_multisig():") + print_info(" - Only removes the multisig from the local KMD wallet") + print_info(" - Does NOT affect the blockchain account") + print_info(" - Any funds at the multisig address remain accessible") + print_info(" - To spend funds, re-import the multisig with the same parameters") + + # ========================================================================= + # Step 8: Verify Deletion by Listing Multisig Accounts Again + # ========================================================================= + print_step(8, "Verifying deletion by listing multisig accounts") + + list_after_delete = kmd.list_multisig(ListMultisigRequest(wallet_handle_token=wallet_handle_token)).addresses + + print_info("Multisig accounts after deletion:") + if len(list_after_delete) == 0: + print_success("No multisig accounts remaining in wallet") + else: + print_info(f"Found {len(list_after_delete)} multisig address(es):") + for i, addr in enumerate(list_after_delete): + print_info(f" {i + 1}. {addr}") + + # Check if the deleted address is still present + deleted_address_still_present = multisig_address in list_after_delete + + if deleted_address_still_present: + print_error("The deleted multisig address is still present (unexpected)") + else: + print_success(f"Confirmed: {multisig_address[:8]}... is no longer in the wallet") + + # ========================================================================= + # Cleanup + # ========================================================================= + print_step(9, "Cleaning up test wallet") + + cleanup_test_wallet(kmd, wallet_handle_token) + wallet_handle_token = "" # Mark as cleaned up + + print_success("Test wallet handle released") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated multisig account management in KMD:") + print_info("") + print_info(" list_multisig()") + print_info(" Parameters:") + print_info(" - wallet_handle_token: Session token for the wallet") + print_info(" Returns:") + print_info(" - List of multisig address strings") + print_info("") + print_info(" export_multisig()") + print_info(" Parameters:") + print_info(" - wallet_handle_token: Session token for the wallet") + print_info(" - address: The multisig address to export") + print_info(" Returns:") + print_info(" - multisig_version: Multisig format version (1)") + print_info(" - threshold: Minimum signatures required") + print_info(" - public_keys: List of participant public keys (bytes)") + print_info("") + print_info(" delete_multisig()") + print_info(" Parameters:") + print_info(" - wallet_handle_token: Session token for the wallet") + print_info(" - wallet_password: Wallet password (required)") + print_info(" - address: The multisig address to delete") + print_info(" Returns:") + print_info(" - None") + print_info("") + print_info("Key takeaways:") + print_info(" - list_multisig() shows all multisig accounts in the wallet") + print_info(" - export_multisig() retrieves the original configuration (preimage)") + print_info(" - delete_multisig() removes from wallet only, not blockchain") + print_info(" - Wallet password is required for delete_multisig() for security") + print_info(" - Deleted multisigs can be re-imported with the same parameters") + print_info("") + print_info("Note: The test wallet remains in KMD (wallets cannot be deleted via API).") + except Exception as e: + print_error(f"Error: {e}") + print_info("") + print_info("Troubleshooting:") + print_info(" - Ensure LocalNet is running: algokit localnet start") + print_info(" - If LocalNet issues occur: algokit localnet reset") + print_info(" - Check that KMD is accessible on port 4002") + + # Cleanup on error + if wallet_handle_token: + cleanup_test_wallet(kmd, wallet_handle_token) + + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/examples/kmd_client/10_transaction_signing.py b/examples/kmd_client/10_transaction_signing.py new file mode 100644 index 00000000..d7f9fe4b --- /dev/null +++ b/examples/kmd_client/10_transaction_signing.py @@ -0,0 +1,291 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Transaction Signing with KMD + +This example demonstrates how to sign transactions using the KMD +sign_transaction() method. It shows the complete workflow of creating +a wallet, generating a key, funding it, signing a transaction, and +submitting it to the network. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) + +Covered operations: +- sign_transaction() - Sign a transaction using a key from the wallet +""" + +import sys + +from shared import ( + cleanup_test_wallet, + create_algod_client, + create_algorand_client, + create_kmd_client, + create_test_wallet, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, + wait_for_confirmation, +) + +from algokit_kmd_client.models import GenerateKeyRequest, SignTxnRequest +from algokit_transact import PaymentTransactionFields, Transaction, TransactionType, assign_fee, encode_transaction_raw +from algokit_utils import AlgoAmount +from algokit_utils.transactions.types import PaymentParams + + +def format_bytes_for_display(data: bytes, show_first: int = 8, show_last: int = 8) -> str: + """Format a byte array for display, showing first and last few bytes.""" + hex_str = data.hex() + if len(data) <= show_first + show_last: + return hex_str + first_bytes = hex_str[: show_first * 2] + last_bytes = hex_str[-(show_last * 2) :] + return f"{first_bytes}...{last_bytes}" + + +def format_micro_algo(micro_algo: int) -> str: + """Format microAlgos to a human-readable string.""" + algo_value = micro_algo / 1_000_000 + return f"{micro_algo:,} microALGO ({algo_value:.6f} ALGO)" + + +def main() -> None: + print_header("KMD Transaction Signing Example") + + kmd = create_kmd_client() + algod = create_algod_client() + algorand = create_algorand_client() + wallet_handle_token = "" + wallet_password = "test-password" + + try: + # ========================================================================= + # Step 1: Create a Test Wallet + # ========================================================================= + print_step(1, "Creating a test wallet for transaction signing") + + test_wallet = create_test_wallet(kmd, wallet_password) + wallet_handle_token = test_wallet["wallet_handle_token"] + + print_success(f"Test wallet created: {test_wallet['wallet_name']}") + print_info(f"Wallet ID: {test_wallet['wallet_id']}") + + # ========================================================================= + # Step 2: Generate a Key in the Wallet + # ========================================================================= + print_step(2, "Generating a key in the wallet") + + generate_key_response = kmd.generate_key( + GenerateKeyRequest( + wallet_handle_token=wallet_handle_token, + ) + ) + sender_address = generate_key_response.address + + print_success(f"Key generated: {sender_address}") + + # ========================================================================= + # Step 3: Fund the Generated Key Using the Dispenser + # ========================================================================= + print_step(3, "Funding the generated key using the dispenser") + + dispenser = algorand.account.localnet_dispenser() + print_info(f"Dispenser address: {shorten_address(dispenser.addr)}") + + # Fund the generated key with 1 ALGO + fund_amount = AlgoAmount.from_algo(1) + algorand.send.payment( + PaymentParams( + sender=dispenser.addr, + receiver=sender_address, + amount=fund_amount, + ) + ) + + # Verify funding + account_info = algod.account_information(sender_address) + print_success(f"Account funded: {format_micro_algo(account_info.amount)}") + + fund_amount_micro_algo = fund_amount.micro_algo + + # ========================================================================= + # Step 4: Create a Payment Transaction + # ========================================================================= + print_step(4, "Creating a payment transaction using algod suggestedParams") + + # Get suggested transaction parameters from algod + suggested_params = algod.suggested_params() + + print_info("Suggested Parameters:") + print_info(f" First Valid Round: {suggested_params.first_valid:,}") + print_info(f" Last Valid Round: {suggested_params.last_valid:,}") + print_info(f" Genesis ID: {suggested_params.genesis_id}") + print_info(f" Min Fee: {format_micro_algo(suggested_params.min_fee)}") + print_info("") + + # Create a receiver (we'll send a small amount back to the dispenser) + receiver_address = dispenser.addr + payment_amount = 100_000 # 0.1 ALGO + + # Create the transaction using Transaction and PaymentTransactionFields from algokit-transact + transaction_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=sender_address, + first_valid=suggested_params.first_valid, + last_valid=suggested_params.last_valid, + genesis_hash=suggested_params.genesis_hash, + genesis_id=suggested_params.genesis_id, + payment=PaymentTransactionFields( + receiver=receiver_address, + amount=payment_amount, + ), + ) + + # Assign the fee using suggested params + transaction = assign_fee( + transaction_without_fee, + fee_per_byte=suggested_params.fee, + min_fee=suggested_params.min_fee, + ) + + tx_id = transaction.tx_id() + + print_success("Transaction created!") + print_info("") + print_info("Transaction Details:") + print_info(f" Transaction ID: {tx_id}") + print_info(f" Sender: {shorten_address(sender_address)}") + print_info(f" Receiver: {shorten_address(receiver_address)}") + print_info(f" Amount: {format_micro_algo(payment_amount)}") + print_info(f" Fee: {format_micro_algo(transaction.fee or 0)}") + + # ========================================================================= + # Step 5: Sign the Transaction Using sign_transaction() + # ========================================================================= + print_step(5, "Signing the transaction with sign_transaction()") + + tx_bytes = encode_transaction_raw(transaction) + signed_txn_response = kmd.sign_transaction( + SignTxnRequest( + transaction=tx_bytes, + wallet_handle_token=wallet_handle_token, + wallet_password=wallet_password, + ) + ) + signed_txn = signed_txn_response.signed_transaction + + print_success("Transaction signed successfully!") + print_info("") + print_info("sign_transaction() return value:") + print_info(f" signed_transaction: bytes ({len(signed_txn)} bytes)") + print_info("") + print_info("Signed transaction bytes (abbreviated):") + print_info(f" {format_bytes_for_display(signed_txn)}") + print_info("") + print_info("The sign_transaction() method:") + print_info(" - Takes wallet_handle_token, wallet_password, and transaction") + print_info(" - Finds the private key matching the sender in the wallet") + print_info(" - Signs the transaction and returns the signed bytes") + + # ========================================================================= + # Step 6: Submit the Signed Transaction to the Network + # ========================================================================= + print_step(6, "Submitting the signed transaction to the network using algod") + + submit_response = algod.send_raw_transaction(signed_txn) + + print_success("Transaction submitted!") + print_info(f"Transaction ID: {submit_response.tx_id}") + + # ========================================================================= + # Step 7: Wait for Confirmation + # ========================================================================= + print_step(7, "Waiting for confirmation") + + # On LocalNet in dev mode, transactions confirm immediately + pending_info = wait_for_confirmation(algod, tx_id) + + confirmed_round = pending_info.confirmed_round or 0 + if confirmed_round > 0: + print_success(f"Transaction confirmed in round {confirmed_round:,}") + else: + print_error("Transaction not confirmed within expected rounds") + + # ========================================================================= + # Step 8: Verify the Transaction + # ========================================================================= + print_step(8, "Verifying the transaction was successful") + + # Check sender's balance (should be reduced by payment + fee) + sender_info = algod.account_information(sender_address) + print_info(f"Sender balance after: {format_micro_algo(sender_info.amount)}") + + expected_balance = fund_amount_micro_algo - payment_amount - (transaction.fee or suggested_params.min_fee) + print_info(f"Expected balance: ~{format_micro_algo(expected_balance)}") + print_info("") + + if sender_info.amount <= fund_amount_micro_algo - payment_amount: + print_success("Transaction verified! Balance reduced as expected.") + + # ========================================================================= + # Cleanup + # ========================================================================= + print_step(9, "Cleaning up test wallet") + + cleanup_test_wallet(kmd, wallet_handle_token) + wallet_handle_token = "" # Mark as cleaned up + + print_success("Test wallet handle released") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated transaction signing with KMD:") + print_info("") + print_info(" sign_transaction() - Sign a transaction using a wallet key") + print_info(" Parameters:") + print_info(" - wallet_handle_token: The wallet session token") + print_info(" - wallet_password: The wallet password for security") + print_info(" - transaction: The Transaction object to sign") + print_info(" Returns:") + print_info(" - signed_transaction: bytes of signed transaction") + print_info("") + print_info("Complete workflow:") + print_info(" 1. Create/unlock a wallet and get wallet_handle_token") + print_info(" 2. Generate a key in the wallet (or import one)") + print_info(" 3. Fund the key using the dispenser or another source") + print_info(" 4. Create a Transaction using suggested params from algod") + print_info(" 5. Sign with kmd.sign_transaction()") + print_info(" 6. Submit with algod.send_raw_transaction()") + print_info(" 7. Wait for confirmation with pending_transaction_info()") + print_info("") + print_info("Key points:") + print_info(" - The wallet password is required to sign transactions") + print_info(" - The sender address in the transaction must match a key in the wallet") + print_info(" - The signed transaction can be submitted to any algod node") + print_info(" - KMD keeps private keys secure; only signed bytes are returned") + print_info("") + print_info("Note: The test wallet remains in KMD (wallets cannot be deleted via API).") + except Exception as e: + print_error(f"Error: {e}") + print_info("") + print_info("Troubleshooting:") + print_info(" - Ensure LocalNet is running: algokit localnet start") + print_info(" - If LocalNet issues occur: algokit localnet reset") + print_info(" - Check that KMD is accessible on port 4002") + print_info(" - Check that Algod is accessible on port 4001") + + # Cleanup on error + if wallet_handle_token: + cleanup_test_wallet(kmd, wallet_handle_token) + + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/examples/kmd_client/11_multisig_signing.py b/examples/kmd_client/11_multisig_signing.py new file mode 100644 index 00000000..8c5f5129 --- /dev/null +++ b/examples/kmd_client/11_multisig_signing.py @@ -0,0 +1,461 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Multisig Transaction Signing with KMD + +This example demonstrates how to sign multisig transactions using the KMD +sign_multisig_transaction() method. It shows: + - Creating a multisig account with 2-of-3 threshold + - Funding the multisig account via the dispenser + - Creating a payment transaction from the multisig account + - Signing with the first participant (partial signature) + - Signing with the second participant (completing the multisig) + - Submitting the fully signed transaction to the network + +Prerequisites: +- LocalNet running (via `algokit localnet start`) + +Covered operations: +- sign_multisig_transaction() - Sign a multisig transaction with a participant key +""" + +import sys + +import msgpack +from shared import ( + cleanup_test_wallet, + create_algod_client, + create_algorand_client, + create_kmd_client, + create_test_wallet, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, + wait_for_confirmation, +) + +from algokit_common import address_from_public_key, public_key_from_address +from algokit_kmd_client.models import ( + GenerateKeyRequest, + ImportMultisigRequest, + MultisigSig, + MultisigSubsig, + SignMultisigTxnRequest, +) +from algokit_transact import ( + PaymentTransactionFields, + Transaction, + TransactionType, + assign_fee, + encode_signed_transaction, + encode_transaction_raw, +) +from algokit_transact.models.signed_transaction import SignedTransaction +from algokit_transact.signing.types import MultisigSignature, MultisigSubsignature +from algokit_utils import AlgoAmount +from algokit_utils.transactions.types import PaymentParams + + +def format_micro_algo(micro_algo: int) -> str: + """Format microAlgos to a human-readable string.""" + algo_value = micro_algo / 1_000_000 + return f"{micro_algo:,} microALGO ({algo_value:.6f} ALGO)" + + +def decode_kmd_multisig_response(multisig_bytes: bytes) -> dict: + """ + Decode the KMD multisig response bytes into a MultisigSig structure. + + The KMD API returns msgpack-encoded MultisigSig with wire keys: + - 'subsig' -> subsignatures array + - 'thr' -> threshold + - 'v' -> version + Each subsig has: + - 'pk' -> publicKey + - 's' -> signature (optional) + """ + decoded = msgpack.unpackb(multisig_bytes, strict_map_key=False) + + subsig_array = decoded.get("subsig", []) + threshold = decoded.get("thr", 0) + version = decoded.get("v", 0) + + subsignatures = [] + for subsig in subsig_array: + public_key = subsig.get("pk") + signature = subsig.get("s") + subsignatures.append({"public_key": public_key, "signature": signature}) + + return {"subsignatures": subsignatures, "threshold": threshold, "version": version} + + +def kmd_multisig_to_transact_multisig(kmd_msig: dict) -> MultisigSignature: + """Convert a KMD MultisigSig to the transact MultisigSignature format.""" + return MultisigSignature( + version=kmd_msig["version"], + threshold=kmd_msig["threshold"], + subsigs=[ + MultisigSubsignature(public_key=subsig["public_key"], sig=subsig["signature"]) + for subsig in kmd_msig["subsignatures"] + ], + ) + + +def count_signatures(msig: dict) -> int: + """Count the number of signatures in a KMD MultisigSig.""" + return sum(1 for subsig in msig["subsignatures"] if subsig["signature"] is not None) + + +def main() -> None: + print_header("KMD Multisig Transaction Signing Example") + + kmd = create_kmd_client() + algod = create_algod_client() + algorand = create_algorand_client() + wallet_handle_token = "" + wallet_password = "test-password" + + try: + # ========================================================================= + # Step 1: Create a Test Wallet + # ========================================================================= + print_step(1, "Creating a test wallet for multisig signing") + + test_wallet = create_test_wallet(kmd, wallet_password) + wallet_handle_token = test_wallet["wallet_handle_token"] + + print_success(f"Test wallet created: {test_wallet['wallet_name']}") + print_info(f"Wallet ID: {test_wallet['wallet_id']}") + + # ========================================================================= + # Step 2: Generate 3 Keys for Multisig Participants + # ========================================================================= + print_step(2, "Generating 3 keys to use as multisig participants") + + participant_addresses: list[str] = [] + public_keys: list[bytes] = [] + num_participants = 3 + + for i in range(1, num_participants + 1): + generate_key_response = kmd.generate_key( + GenerateKeyRequest( + wallet_handle_token=wallet_handle_token, + ) + ) + address = generate_key_response.address + participant_addresses.append(address) + pk = public_key_from_address(address) + public_keys.append(pk) + print_info(f"Participant {i}: {shorten_address(address)}") + + print_success(f"Generated {num_participants} participant keys") + + # ========================================================================= + # Step 3: Create a 2-of-3 Multisig Account + # ========================================================================= + print_step(3, "Creating a 2-of-3 multisig account") + + threshold = 2 # Minimum signatures required + multisig_version = 1 # Multisig format version + + import_multisig_response = kmd.import_multisig( + ImportMultisigRequest( + multisig_version=multisig_version, + public_keys=public_keys, + threshold=threshold, + wallet_handle_token=wallet_handle_token, + ) + ) + multisig_address = import_multisig_response.address + + print_success("Multisig account created!") + print_info(f"Multisig Address: {multisig_address}") + print_info(f"Threshold: {threshold}-of-{num_participants}") + + # ========================================================================= + # Step 4: Fund the Multisig Account Using the Dispenser + # ========================================================================= + print_step(4, "Funding the multisig account using the dispenser") + + dispenser = algorand.account.localnet_dispenser() + print_info(f"Dispenser address: {shorten_address(dispenser.addr)}") + + # Fund the multisig account with 1 ALGO + fund_amount = AlgoAmount.from_algo(1) + algorand.send.payment( + PaymentParams( + sender=dispenser.addr, + receiver=multisig_address, + amount=fund_amount, + ) + ) + + # Verify funding + account_info = algod.account_information(multisig_address) + print_success(f"Multisig funded: {format_micro_algo(account_info.amount)}") + + # ========================================================================= + # Step 5: Create a Payment Transaction from the Multisig Account + # ========================================================================= + print_step(5, "Creating a payment transaction from the multisig account") + + suggested_params = algod.suggested_params() + + print_info("Suggested Parameters:") + print_info(f" First Valid Round: {suggested_params.first_valid:,}") + print_info(f" Last Valid Round: {suggested_params.last_valid:,}") + print_info(f" Genesis ID: {suggested_params.genesis_id}") + print_info("") + + # Create a payment back to the dispenser + receiver_address = dispenser.addr + payment_amount = 100_000 # 0.1 ALGO + + transaction_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=multisig_address, + first_valid=suggested_params.first_valid, + last_valid=suggested_params.last_valid, + genesis_hash=suggested_params.genesis_hash, + genesis_id=suggested_params.genesis_id, + payment=PaymentTransactionFields( + receiver=receiver_address, + amount=payment_amount, + ), + ) + + # Assign the fee + transaction = assign_fee( + transaction_without_fee, + fee_per_byte=suggested_params.fee, + min_fee=suggested_params.min_fee, + ) + + tx_id = transaction.tx_id() + + print_success("Transaction created!") + print_info(f"Transaction ID: {tx_id}") + print_info(f"Sender: {shorten_address(multisig_address)} (multisig)") + print_info(f"Receiver: {shorten_address(receiver_address)}") + print_info(f"Amount: {format_micro_algo(payment_amount)}") + print_info(f"Fee: {format_micro_algo(transaction.fee or 0)}") + + # ========================================================================= + # Step 6: Sign with the First Participant (Partial Signature) + # ========================================================================= + print_step(6, "Signing with the first participant (partial signature)") + + print_info(f"First signer: {shorten_address(participant_addresses[0])}") + print_info("") + + tx_bytes = encode_transaction_raw(transaction) + + first_result = kmd.sign_multisig_transaction( + SignMultisigTxnRequest( + public_key=public_keys[0], + transaction=tx_bytes, + wallet_handle_token=wallet_handle_token, + wallet_password=wallet_password, + ) + ) + first_sign_result = first_result.multisig + + print_success("First signature obtained!") + print_info("") + print_info("sign_multisig_transaction() response fields:") + print_info(f" multisig: bytes ({len(first_sign_result)} bytes)") + print_info("") + + # Decode and display the partial multisig signature + partial_kmd_multisig = decode_kmd_multisig_response(first_sign_result) + sig_count_1 = count_signatures(partial_kmd_multisig) + + print_info("Partial Multisig Signature:") + print_info(f" version: {partial_kmd_multisig['version']}") + print_info(f" threshold: {partial_kmd_multisig['threshold']}") + print_info(f" subsigs: {len(partial_kmd_multisig['subsignatures'])} participants") + print_info(f" Signatures collected: {sig_count_1} of {threshold} required") + print_info("") + print_info("Subsignature details:") + for i, subsig in enumerate(partial_kmd_multisig["subsignatures"]): + has_sig = subsig["signature"] is not None + status = "SIGNED" if has_sig else "pending" + addr = address_from_public_key(subsig["public_key"]) + print_info(f" {i + 1}. {shorten_address(addr)} - {status}") + + print_info("") + print_info("Note: With only 1 signature, the transaction cannot yet be submitted.") + print_info(f" We need {threshold} signatures ({threshold - sig_count_1} more required).") + + # ========================================================================= + # Step 7: Sign with the Second Participant (Complete the Multisig) + # ========================================================================= + print_step(7, "Signing with the second participant (completing the signature)") + + print_info(f"Second signer: {shorten_address(participant_addresses[1])}") + print_info("") + print_info("Passing the partial multisig from Step 6 to collect the second signature...") + print_info("") + + # Convert decoded dict to MultisigSig for passing back to KMD + partial_msig_obj = MultisigSig( + version=partial_kmd_multisig["version"], + threshold=partial_kmd_multisig["threshold"], + subsignatures=[ + MultisigSubsig(public_key=s["public_key"], signature=s["signature"]) + for s in partial_kmd_multisig["subsignatures"] + ], + ) + + second_result = kmd.sign_multisig_transaction( + SignMultisigTxnRequest( + public_key=public_keys[1], + transaction=tx_bytes, + wallet_handle_token=wallet_handle_token, + wallet_password=wallet_password, + partial_multisig=partial_msig_obj, + ) + ) + second_sign_result = second_result.multisig + + print_success("Second signature obtained!") + print_info("") + + # Decode and display the completed multisig signature + completed_kmd_multisig = decode_kmd_multisig_response(second_sign_result) + sig_count_2 = count_signatures(completed_kmd_multisig) + + print_info("Completed Multisig Signature:") + print_info(f" version: {completed_kmd_multisig['version']}") + print_info(f" threshold: {completed_kmd_multisig['threshold']}") + print_info(f" Signatures collected: {sig_count_2} of {threshold} required") + print_info("") + print_info("Subsignature details:") + for i, subsig in enumerate(completed_kmd_multisig["subsignatures"]): + has_sig = subsig["signature"] is not None + status = "SIGNED" if has_sig else "pending" + addr = address_from_public_key(subsig["public_key"]) + print_info(f" {i + 1}. {shorten_address(addr)} - {status}") + + print_info("") + print_success(f"Threshold met! {sig_count_2} >= {threshold} signatures collected.") + print_info("The transaction is now fully authorized and ready for submission.") + + # ========================================================================= + # Step 8: Construct and Submit the Signed Transaction + # ========================================================================= + print_step(8, "Constructing and submitting the multisig-signed transaction") + + # Convert KMD MultisigSig to transact's MultisigSignature for the SignedTransaction + completed_multisig = kmd_multisig_to_transact_multisig(completed_kmd_multisig) + + # Build the signed transaction with the multisig signature + signed_txn = SignedTransaction( + txn=transaction, + msig=completed_multisig, + ) + + # Encode and submit + encoded_signed_txn = encode_signed_transaction(signed_txn) + print_info(f"Encoded signed transaction: {len(encoded_signed_txn)} bytes") + print_info("") + + submit_response = algod.send_raw_transaction(encoded_signed_txn) + + print_success("Transaction submitted!") + print_info(f"Transaction ID: {submit_response.tx_id}") + + # ========================================================================= + # Step 9: Wait for Confirmation + # ========================================================================= + print_step(9, "Waiting for confirmation") + + pending_info = wait_for_confirmation(algod, tx_id) + + confirmed_round = pending_info.confirmed_round or 0 + if confirmed_round > 0: + print_success(f"Transaction confirmed in round {confirmed_round:,}") + else: + print_error("Transaction not confirmed within expected rounds") + + # ========================================================================= + # Step 10: Verify the Transaction + # ========================================================================= + print_step(10, "Verifying the transaction was successful") + + # Check multisig account balance + multisig_info = algod.account_information(multisig_address) + expected_deduction = payment_amount + (transaction.fee or suggested_params.min_fee) + expected_balance = fund_amount.micro_algo - expected_deduction + + print_info(f"Multisig balance before: {format_micro_algo(fund_amount.micro_algo)}") + print_info(f"Multisig balance after: {format_micro_algo(multisig_info.amount)}") + print_info(f"Expected balance: ~{format_micro_algo(expected_balance)}") + print_info("") + + if multisig_info.amount <= fund_amount.micro_algo - payment_amount: + print_success("Transaction verified! Balance reduced as expected.") + + # ========================================================================= + # Cleanup + # ========================================================================= + print_step(11, "Cleaning up test wallet") + + cleanup_test_wallet(kmd, wallet_handle_token) + wallet_handle_token = "" # Mark as cleaned up + + print_success("Test wallet handle released") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated multisig transaction signing with KMD:") + print_info("") + print_info(" sign_multisig_transaction() - Sign a multisig transaction") + print_info(" Parameters:") + print_info(" - wallet_handle_token: The wallet session token") + print_info(" - wallet_password: The wallet password") + print_info(" - transaction: The Transaction object to sign") + print_info(" - public_key: The public key of the signer (must be in wallet)") + print_info(" - partial_multisig: (optional) Existing partial signature to add to") + print_info(" Returns:") + print_info(" - multisig: bytes of the multisig signature (msgpack encoded)") + print_info("") + print_info("Multisig signing workflow:") + print_info(" 1. Create a multisig account with import_multisig()") + print_info(" 2. Fund the multisig account") + print_info(" 3. Create a transaction with the multisig address as sender") + print_info(" 4. Sign with first participant (returns partial multisig signature)") + print_info(" 5. Sign with additional participants, passing the partial signature") + print_info(" 6. Once threshold is met, construct SignedTransaction with msig field") + print_info(" 7. Encode and submit the signed transaction") + print_info("") + print_info("Key points:") + print_info(" - Each signer adds their signature to the multisig structure") + print_info(" - The partial_multisig parameter chains signatures together") + print_info(" - The response contains a msgpack-encoded MultisigSignature") + print_info(" - Transaction is valid once threshold signatures are collected") + print_info(" - Any 2 of the 3 participants could have signed (2-of-3 threshold)") + print_info("") + print_info("Note: The test wallet remains in KMD (wallets cannot be deleted via API).") + except Exception as e: + print_error(f"Error: {e}") + print_info("") + print_info("Troubleshooting:") + print_info(" - Ensure LocalNet is running: algokit localnet start") + print_info(" - If LocalNet issues occur: algokit localnet reset") + print_info(" - Check that KMD is accessible on port 4002") + print_info(" - Check that Algod is accessible on port 4001") + + # Cleanup on error + if wallet_handle_token: + cleanup_test_wallet(kmd, wallet_handle_token) + + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/examples/kmd_client/12_program_signing.py b/examples/kmd_client/12_program_signing.py new file mode 100644 index 00000000..eab39954 --- /dev/null +++ b/examples/kmd_client/12_program_signing.py @@ -0,0 +1,298 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Program Signing (Delegated Logic Signatures) with KMD + +This example demonstrates how to sign programs/contracts using the KMD +sign_program() method. It shows: + - Creating a simple TEAL program (logic signature) + - Compiling the TEAL program using algod's teal_compile + - Signing the compiled program bytes with sign_program() + - Understanding the resulting signature for delegated logic signatures + - How to use the signature with a LogicSigAccount + +What is Program Signing? +Program signing creates a "delegated logic signature" (delegated lsig). +This allows an account holder to authorize a smart contract (TEAL program) +to sign transactions on their behalf. When you sign a program: + 1. You're attesting that you authorize this program to act for your account + 2. Transactions signed by this delegated lsig will be authorized by your account + 3. The program logic determines which transactions are approved + +Use cases for delegated logic signatures: + - Recurring payments (program checks amount and frequency) + - Subscription services (program validates payment recipients) + - Limited spending authorizations (program enforces constraints) + - Conditional transfers (program checks external conditions) + +Prerequisites: +- LocalNet running (via `algokit localnet start`) + +Covered operations: +- sign_program() - Sign a compiled TEAL program with a wallet key +""" + +import base64 +import sys + +from shared import ( + cleanup_test_wallet, + create_algod_client, + create_kmd_client, + create_test_wallet, + load_teal_source, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_kmd_client.models import GenerateKeyRequest, SignProgramRequest +from algokit_transact import LogicSigAccount + + +def format_bytes_for_display(data: bytes, show_first: int = 8, show_last: int = 8) -> str: + """Format a byte array for display, showing first and last few bytes.""" + hex_str = data.hex() + if len(data) <= show_first + show_last: + return hex_str + first_bytes = hex_str[: show_first * 2] + last_bytes = hex_str[-(show_last * 2) :] + return f"{first_bytes}...{last_bytes}" + + +def main() -> None: + print_header("KMD Program Signing Example") + + kmd = create_kmd_client() + algod = create_algod_client() + wallet_handle_token = "" + wallet_password = "test-password" + + try: + # ========================================================================= + # Step 1: Create a Test Wallet + # ========================================================================= + print_step(1, "Creating a test wallet for program signing") + + test_wallet = create_test_wallet(kmd, wallet_password) + wallet_handle_token = test_wallet["wallet_handle_token"] + + print_success(f"Test wallet created: {test_wallet['wallet_name']}") + print_info(f"Wallet ID: {test_wallet['wallet_id']}") + + # ========================================================================= + # Step 2: Generate a Key in the Wallet + # ========================================================================= + print_step(2, "Generating a key in the wallet") + + generate_key_response = kmd.generate_key( + GenerateKeyRequest( + wallet_handle_token=wallet_handle_token, + ) + ) + signer_address = generate_key_response.address + + print_success("Key generated!") + print_info(f"Address: {signer_address}") + print_info(f"Shortened: {shorten_address(signer_address)}") + + # ========================================================================= + # Step 3: Create a Simple TEAL Program + # ========================================================================= + print_step(3, "Creating a simple TEAL program") + + # Load the delegated payment limit TEAL program from shared artifacts + # This program approves payment transactions up to 1 ALGO + teal_source = load_teal_source("delegated-payment-limit.teal") + + print_info("TEAL Program Source:") + print_info("") + for line in teal_source.split("\n"): + print_info(f" {line}") + print_info("") + print_info("This program approves payment transactions up to 1 ALGO.") + print_info("When signed by an account, it creates a 'delegated logic signature'") + print_info("that can authorize small payments on behalf of that account.") + + # ========================================================================= + # Step 4: Compile the TEAL Program + # ========================================================================= + print_step(4, "Compiling the TEAL program using algod teal_compile") + + compile_result = algod.teal_compile(teal_source) + + # Decode base64 result to bytes + program_bytes = base64.b64decode(compile_result.result) + + print_success("TEAL program compiled successfully!") + print_info("") + print_info("Compilation Result:") + print_info(f" Hash (address): {compile_result.hash_}") + print_info(f" Compiled size: {len(program_bytes)} bytes") + print_info(f" Compiled bytes: {format_bytes_for_display(program_bytes)}") + print_info("") + print_info("The hash is the 'contract address' - the address of the logic signature") + print_info("when used in non-delegated mode (without a signature).") + + # ========================================================================= + # Step 5: Sign the Program with sign_program() + # ========================================================================= + print_step(5, "Signing the program with sign_program()") + + print_info(f"Signer: {shorten_address(signer_address)}") + print_info("") + + sign_program_response = kmd.sign_program( + SignProgramRequest( + address=signer_address, + program=program_bytes, + wallet_handle_token=wallet_handle_token, + wallet_password=wallet_password, + ) + ) + signature = sign_program_response.sig + + print_success("Program signed successfully!") + print_info("") + print_info("sign_program() return value:") + print_info(f" sig: bytes ({len(signature)} bytes)") + print_info("") + print_info("Signature Details:") + print_info(f" Signature: {format_bytes_for_display(signature)}") + print_info(f" Signature length: {len(signature)} bytes (ed25519 signature)") + print_info("") + print_info("This signature attests that the signer authorizes this program") + print_info("to sign transactions on their behalf.") + + # ========================================================================= + # Step 6: Create a LogicSigAccount with the Signature + # ========================================================================= + print_step(6, "Creating a LogicSigAccount with the signature") + + print_info("A LogicSigAccount combines:") + print_info(" 1. The compiled program (logic)") + print_info(" 2. The signature (delegation proof)") + print_info(" 3. The delegator address (who authorized it)") + print_info("") + + # First, get the program address (hash of "Program" + logic) + # This is what the address would be in non-delegated mode + non_delegated_lsig = LogicSigAccount(logic=program_bytes) + program_address = non_delegated_lsig.address + + # Create a LogicSigAccount for delegation + lsig_account = LogicSigAccount(logic=program_bytes, _address=signer_address, sig=signature) + + print_success("LogicSigAccount created!") + print_info("") + print_info("LogicSigAccount properties:") + print_info(f" Program address: {shorten_address(program_address)}") + print_info(f" Delegator address: {shorten_address(signer_address)}") + print_info(f" Has signature: {lsig_account.sig is not None}") + print_info(f" Logic size: {len(lsig_account.logic)} bytes") + print_info("") + + # Show that the lsig_account's addr is the delegator, not the program + print_info("Important distinction:") + print_info(f" - Program address: {shorten_address(program_address)}") + print_info(" Hash of the logic - this is the 'contract account' in non-delegated mode") + print_info("") + print_info(f" - lsig_account.addr: {shorten_address(lsig_account.addr)}") + print_info(" This is the DELEGATOR - the account authorizing the program") + print_info("") + print_info("When using this delegated lsig, transactions will be authorized") + print_info(f"as if signed by {shorten_address(signer_address)} (the delegator).") + + # ========================================================================= + # Step 7: Demonstrate How to Use the LogicSigAccount + # ========================================================================= + print_step(7, "Understanding how to use the delegated LogicSigAccount") + + print_info("To use this delegated logic signature in a transaction:") + print_info("") + print_info(" 1. Create a Transaction with sender = delegator address") + print_info("") + print_info(" 2. Use the LogicSigAccount.signer to sign the transaction:") + print_info("") + print_info(" signed_txns = lsig_account.signer([txn], [0])") + print_info("") + print_info(" 3. The signed transaction will include:") + print_info(" - lsig.logic: The compiled TEAL program") + print_info(" - lsig.sig: The delegation signature from sign_program()") + print_info("") + print_info(" 4. When submitted, the network validates:") + print_info(" - The signature is valid for the program + delegator") + print_info(" - The program logic approves the transaction") + print_info("") + print_info("Example use case - a subscription payment service:") + print_info(" - User signs a program allowing monthly $10 payments to service") + print_info(" - Service can execute payments without additional user approval") + print_info(" - Program logic ensures payments stay within authorized limits") + + # ========================================================================= + # Cleanup + # ========================================================================= + print_step(8, "Cleaning up test wallet") + + cleanup_test_wallet(kmd, wallet_handle_token) + wallet_handle_token = "" # Mark as cleaned up + + print_success("Test wallet handle released") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated program signing with KMD:") + print_info("") + print_info(" sign_program() - Sign a TEAL program for delegation") + print_info(" Parameters:") + print_info(" - wallet_handle_token: The wallet session token") + print_info(" - wallet_password: The wallet password") + print_info(" - address: The account that will delegate authority") + print_info(" - program: The compiled TEAL program bytes") + print_info(" Returns:") + print_info(" - sig: bytes (64-byte ed25519 signature)") + print_info("") + print_info("Program signing workflow:") + print_info(" 1. Write a TEAL program with the desired authorization logic") + print_info(" 2. Compile the program using algod.teal_compile()") + print_info(" 3. Sign the program bytes using kmd.sign_program()") + print_info(" 4. Create a LogicSigAccount with the program, signature, and delegator") + print_info(" 5. Use the LogicSigAccount.signer to sign authorized transactions") + print_info("") + print_info("Key concepts:") + print_info(" - Delegated vs Non-delegated Logic Signatures:") + print_info(" - Non-delegated: Program itself is the 'account', no signature needed") + print_info(" - Delegated: Program acts on behalf of a real account (requires signature)") + print_info("") + print_info(" - The signature proves the delegator authorized the program") + print_info(" - The program logic controls which transactions are approved") + print_info(" - Anyone with the lsig can submit transactions (if program approves)") + print_info("") + print_info("Security considerations:") + print_info(" - Write program logic carefully - it controls your account!") + print_info(" - Always limit amounts, recipients, or other transaction fields") + print_info(" - Consider adding time bounds or counters for recurring payments") + print_info("") + print_info("Note: The test wallet remains in KMD (wallets cannot be deleted via API).") + except Exception as e: + print_error(f"Error: {e}") + print_info("") + print_info("Troubleshooting:") + print_info(" - Ensure LocalNet is running: algokit localnet start") + print_info(" - If LocalNet issues occur: algokit localnet reset") + print_info(" - Check that KMD is accessible on port 4002") + print_info(" - Check that Algod is accessible on port 4001") + + # Cleanup on error + if wallet_handle_token: + cleanup_test_wallet(kmd, wallet_handle_token) + + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/examples/kmd_client/13_multisig_program_signing.py b/examples/kmd_client/13_multisig_program_signing.py new file mode 100644 index 00000000..dd983272 --- /dev/null +++ b/examples/kmd_client/13_multisig_program_signing.py @@ -0,0 +1,472 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915 +""" +Example: Multisig Program Signing (Delegated Multisig Logic Signatures) with KMD + +This example demonstrates how to sign programs with multisig using the KMD +sign_multisig_program() method. It shows: + - Creating a 2-of-3 multisig account + - Creating a simple TEAL program (logic signature) + - Compiling the TEAL program using algod teal_compile + - Signing the program with the first participant (partial signature) + - Signing the program with the second participant (completing the multisig) + - Understanding delegated multisig logic signatures + +What is Multisig Program Signing? +Multisig program signing creates a "delegated multisig logic signature". +This combines two powerful concepts: + 1. Multisig: Requiring multiple parties to approve + 2. Delegated Logic Signatures: Authorizing a program to act on behalf of an account + +With a delegated multisig lsig: + - The multisig account authorizes a program to sign transactions + - Multiple parties must sign the program (meeting the threshold) + - Once signed, the program can authorize transactions within its logic + - No further interaction needed from the multisig participants + +Use cases for delegated multisig logic signatures: + - Multi-party controlled recurring payments + - Joint account automation (e.g., business partners authorizing limit) + - Escrow with automated release conditions + - DAO treasury with programmatic spending rules + +Prerequisites: +- LocalNet running (via `algokit localnet start`) + +Covered operations: +- sign_multisig_program() - Sign a compiled TEAL program with a multisig participant +""" + +import base64 +import sys + +import msgpack +from shared import ( + cleanup_test_wallet, + create_algod_client, + create_kmd_client, + create_test_wallet, + load_teal_source, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_common import address_from_public_key, public_key_from_address +from algokit_kmd_client.models import ( + GenerateKeyRequest, + ImportMultisigRequest, + MultisigSig, + MultisigSubsig, + SignProgramMultisigRequest, +) +from algokit_transact import LogicSigAccount +from algokit_transact.signing.types import MultisigSignature, MultisigSubsignature + + +def format_bytes_for_display(data: bytes, show_first: int = 8, show_last: int = 8) -> str: + """Format a byte array for display, showing first and last few bytes.""" + hex_str = data.hex() + if len(data) <= show_first + show_last: + return hex_str + first_bytes = hex_str[: show_first * 2] + last_bytes = hex_str[-(show_last * 2) :] + return f"{first_bytes}...{last_bytes}" + + +def decode_kmd_multisig_response(multisig_bytes: bytes) -> dict: + """ + Decode the KMD multisig response bytes into a MultisigSig structure. + + The KMD API returns msgpack-encoded MultisigSig with wire keys: + - 'subsig' -> subsignatures array + - 'thr' -> threshold + - 'v' -> version + Each subsig has: + - 'pk' -> publicKey + - 's' -> signature (optional) + """ + decoded = msgpack.unpackb(multisig_bytes, strict_map_key=False) + + subsig_array = decoded.get(b"subsig", []) + threshold = decoded.get(b"thr", 0) + version = decoded.get(b"v", 0) + + subsignatures = [] + for subsig in subsig_array: + public_key = subsig.get(b"pk") + signature = subsig.get(b"s") + subsignatures.append({"public_key": public_key, "signature": signature}) + + return {"subsignatures": subsignatures, "threshold": threshold, "version": version} + + +def kmd_multisig_to_transact_multisig(kmd_msig: dict) -> MultisigSignature: + """Convert a KMD MultisigSig to the transact MultisigSignature format.""" + return MultisigSignature( + version=kmd_msig["version"], + threshold=kmd_msig["threshold"], + subsigs=[ + MultisigSubsignature(public_key=subsig["public_key"], sig=subsig["signature"]) + for subsig in kmd_msig["subsignatures"] + ], + ) + + +def count_signatures(msig: dict) -> int: + """Count the number of signatures in a KMD MultisigSig.""" + return sum(1 for subsig in msig["subsignatures"] if subsig["signature"] is not None) + + +def main() -> None: + print_header("KMD Multisig Program Signing Example") + + kmd = create_kmd_client() + algod = create_algod_client() + wallet_handle_token = "" + wallet_password = "test-password" + + try: + # ========================================================================= + # Step 1: Create a Test Wallet + # ========================================================================= + print_step(1, "Creating a test wallet for multisig program signing") + + test_wallet = create_test_wallet(kmd, wallet_password) + wallet_handle_token = test_wallet["wallet_handle_token"] + + print_success(f"Test wallet created: {test_wallet['wallet_name']}") + print_info(f"Wallet ID: {test_wallet['wallet_id']}") + + # ========================================================================= + # Step 2: Generate 3 Keys for Multisig Participants + # ========================================================================= + print_step(2, "Generating 3 keys to use as multisig participants") + + participant_addresses: list[str] = [] + public_keys: list[bytes] = [] + num_participants = 3 + + for i in range(1, num_participants + 1): + generate_key_response = kmd.generate_key( + GenerateKeyRequest( + wallet_handle_token=wallet_handle_token, + ) + ) + address = generate_key_response.address + participant_addresses.append(address) + pk = public_key_from_address(address) + public_keys.append(pk) + print_info(f"Participant {i}: {shorten_address(address)}") + + print_success(f"Generated {num_participants} participant keys") + + # ========================================================================= + # Step 3: Create a 2-of-3 Multisig Account + # ========================================================================= + print_step(3, "Creating a 2-of-3 multisig account") + + threshold = 2 # Minimum signatures required + multisig_version = 1 # Multisig format version + + import_multisig_response = kmd.import_multisig( + ImportMultisigRequest( + multisig_version=multisig_version, + public_keys=public_keys, + threshold=threshold, + wallet_handle_token=wallet_handle_token, + ) + ) + multisig_address = import_multisig_response.address + + print_success("Multisig account created!") + print_info(f"Multisig Address: {multisig_address}") + print_info(f"Threshold: {threshold}-of-{num_participants}") + print_info("") + print_info("This multisig address will be used as the delegator for the logic signature.") + + # ========================================================================= + # Step 4: Create a Simple TEAL Program + # ========================================================================= + print_step(4, "Creating a simple TEAL program") + + # Load TEAL logic signature from shared artifacts + # This program approves payment transactions up to 1 ALGO + # In production, you'd have more sophisticated logic + teal_source = load_teal_source("delegated-payment-limit.teal") + + print_info("TEAL Program Source:") + print_info("") + for line in teal_source.split("\n"): + print_info(f" {line}") + print_info("") + print_info("This program approves payment transactions up to 1 ALGO.") + print_info("When signed by a multisig account, it creates a 'delegated multisig lsig'.") + + # ========================================================================= + # Step 5: Compile the TEAL Program + # ========================================================================= + print_step(5, "Compiling the TEAL program using algod teal_compile") + + compile_result = algod.teal_compile(teal_source) + + # Decode base64 result to bytes + program_bytes = base64.b64decode(compile_result.result) + + print_success("TEAL program compiled successfully!") + print_info("") + print_info("Compilation Result:") + print_info(f" Hash (program address): {compile_result.hash_}") + print_info(f" Compiled size: {len(program_bytes)} bytes") + print_info(f" Compiled bytes: {format_bytes_for_display(program_bytes)}") + + # ========================================================================= + # Step 6: Sign with the First Participant (Partial Signature) + # ========================================================================= + print_step(6, "Signing the program with the first participant") + + print_info(f"First signer: {shorten_address(participant_addresses[0])}") + print_info("") + + first_result = kmd.sign_multisig_program( + SignProgramMultisigRequest( + address=multisig_address, + program=program_bytes, + public_key=public_keys[0], + wallet_handle_token=wallet_handle_token, + wallet_password=wallet_password, + ) + ) + first_sign_result = first_result.multisig + + print_success("First signature obtained!") + print_info("") + print_info("sign_multisig_program() response fields:") + print_info(f" multisig: bytes ({len(first_sign_result)} bytes)") + print_info("") + + # Decode and display the partial multisig signature + partial_kmd_multisig = decode_kmd_multisig_response(first_sign_result) + sig_count_1 = count_signatures(partial_kmd_multisig) + + print_info("Partial Multisig Signature:") + print_info(f" version: {partial_kmd_multisig['version']}") + print_info(f" threshold: {partial_kmd_multisig['threshold']}") + print_info(f" subsigs: {len(partial_kmd_multisig['subsignatures'])} participants") + print_info(f" Signatures collected: {sig_count_1} of {threshold} required") + print_info("") + print_info("Subsignature details:") + for i, subsig in enumerate(partial_kmd_multisig["subsignatures"]): + has_sig = subsig["signature"] is not None + status = "SIGNED" if has_sig else "pending" + addr = address_from_public_key(subsig["public_key"]) + print_info(f" {i + 1}. {shorten_address(addr)} - {status}") + + print_info("") + print_info("Note: With only 1 signature, the multisig lsig is not yet valid.") + print_info(f" We need {threshold} signatures ({threshold - sig_count_1} more required).") + + # ========================================================================= + # Step 7: Sign with the Second Participant (Complete the Multisig) + # ========================================================================= + print_step(7, "Signing the program with the second participant") + + print_info(f"Second signer: {shorten_address(participant_addresses[1])}") + print_info("") + print_info("Passing the partial multisig from Step 6 to collect the second signature...") + print_info("") + + # Convert decoded dict to MultisigSig for passing back to KMD + partial_msig_obj = MultisigSig( + version=partial_kmd_multisig["version"], + threshold=partial_kmd_multisig["threshold"], + subsignatures=[ + MultisigSubsig(public_key=s["public_key"], signature=s["signature"]) + for s in partial_kmd_multisig["subsignatures"] + ], + ) + + second_result = kmd.sign_multisig_program( + SignProgramMultisigRequest( + address=multisig_address, + program=program_bytes, + public_key=public_keys[1], + wallet_handle_token=wallet_handle_token, + wallet_password=wallet_password, + partial_multisig=partial_msig_obj, + ) + ) + second_sign_result = second_result.multisig + + print_success("Second signature obtained!") + print_info("") + + # Decode and display the completed multisig signature + completed_kmd_multisig = decode_kmd_multisig_response(second_sign_result) + sig_count_2 = count_signatures(completed_kmd_multisig) + + print_info("Completed Multisig Signature:") + print_info(f" version: {completed_kmd_multisig['version']}") + print_info(f" threshold: {completed_kmd_multisig['threshold']}") + print_info(f" Signatures collected: {sig_count_2} of {threshold} required") + print_info("") + print_info("Subsignature details:") + for i, subsig in enumerate(completed_kmd_multisig["subsignatures"]): + has_sig = subsig["signature"] is not None + status = "SIGNED" if has_sig else "pending" + addr = address_from_public_key(subsig["public_key"]) + print_info(f" {i + 1}. {shorten_address(addr)} - {status}") + + print_info("") + print_success(f"Threshold met! {sig_count_2} >= {threshold} signatures collected.") + print_info("The delegated multisig logic signature is now fully authorized.") + + # ========================================================================= + # Step 8: Create a LogicSigAccount with the Multisig Signature + # ========================================================================= + print_step(8, "Creating a LogicSigAccount with the multisig signature") + + print_info("A delegated multisig LogicSigAccount combines:") + print_info(" 1. The compiled program (logic)") + print_info(" 2. The multisig signature (delegation proof from multiple parties)") + print_info(" 3. The multisig delegator address") + print_info("") + + # Get the program address (hash of "Program" + logic) + non_delegated_lsig = LogicSigAccount(logic=program_bytes) + program_address = non_delegated_lsig.address + + # Create a LogicSigAccount for delegation + completed_multisig = kmd_multisig_to_transact_multisig(completed_kmd_multisig) + lsig_account = LogicSigAccount(logic=program_bytes, _address=multisig_address, msig=completed_multisig) + + print_success("LogicSigAccount created with multisig signature!") + print_info("") + print_info("LogicSigAccount properties:") + print_info(f" Program address: {shorten_address(program_address)}") + print_info(f" Delegator address: {shorten_address(multisig_address)} (multisig)") + print_info(f" Has msig: {lsig_account.msig is not None}") + print_info(f" Logic size: {len(lsig_account.logic)} bytes") + print_info("") + + # Show the distinction between program address and delegator + print_info("Important distinction:") + print_info(f" - Program address: {shorten_address(program_address)}") + print_info(" Hash of the logic - this is the 'contract account' in non-delegated mode") + print_info("") + print_info(f" - lsig_account.addr: {shorten_address(lsig_account.addr)}") + print_info(" This is the DELEGATOR - the multisig account authorizing the program") + print_info("") + print_info("When using this delegated multisig lsig, transactions will be authorized") + print_info(f"as if signed by the multisig account {shorten_address(multisig_address)}.") + + # ========================================================================= + # Step 9: Explain How Delegated Multisig Logic Signatures Work + # ========================================================================= + print_step(9, "Understanding delegated multisig logic signatures") + + print_info("Delegated Multisig Logic Signatures combine two concepts:") + print_info("") + print_info("1. MULTISIG AUTHORIZATION:") + print_info(" - Multiple parties (2-of-3 in this example) must approve") + print_info(" - Each party signs the program bytes with their key") + print_info(" - Signatures are collected via partial_multisig parameter") + print_info(" - Once threshold is met, the authorization is complete") + print_info("") + print_info("2. DELEGATED LOGIC SIGNATURE:") + print_info(" - The program defines the rules for transactions") + print_info(" - The multisig signature authorizes the program") + print_info(" - Anyone with the lsig can submit transactions (if program approves)") + print_info(" - No further interaction from the multisig signers needed") + print_info("") + print_info("Key differences from regular multisig transactions:") + print_info(" - Multisig Txn: Signers approve EACH transaction") + print_info(" - Multisig Lsig: Signers approve the PROGRAM once, then") + print_info(" the program approves transactions automatically") + print_info("") + print_info("Example workflow for using the delegated multisig lsig:") + print_info("") + print_info(" 1. Create a Transaction with sender = multisig address") + print_info("") + print_info(" 2. Use the LogicSigAccount.signer to sign:") + print_info("") + print_info(" signed_txns = lsig_account.signer([txn], [0])") + print_info("") + print_info(" 3. The signed transaction includes:") + print_info(" - lsig.logic: The compiled TEAL program") + print_info(" - lsig.msig: The multisig delegation signature") + print_info("") + print_info(" 4. When submitted, the network validates:") + print_info(" - The multisig signature is valid (threshold met)") + print_info(" - The program logic approves the transaction") + + # ========================================================================= + # Cleanup + # ========================================================================= + print_step(10, "Cleaning up test wallet") + + cleanup_test_wallet(kmd, wallet_handle_token) + wallet_handle_token = "" # Mark as cleaned up + + print_success("Test wallet handle released") + + # ========================================================================= + # Summary + # ========================================================================= + print_header("Summary") + print_info("This example demonstrated multisig program signing with KMD:") + print_info("") + print_info(" sign_multisig_program() - Sign a TEAL program with multisig") + print_info(" Parameters:") + print_info(" - wallet_handle_token: The wallet session token") + print_info(" - wallet_password: The wallet password") + print_info(" - address: The multisig account address (delegator)") + print_info(" - program: The compiled TEAL program bytes") + print_info(" - public_key: The public key of the signer (must be in wallet)") + print_info(" - partial_multisig: (optional) Existing partial signature to add to") + print_info(" Returns:") + print_info(" - multisig: bytes (msgpack-encoded MultisigSig)") + print_info("") + print_info("Multisig program signing workflow:") + print_info(" 1. Create a multisig account with import_multisig()") + print_info(" 2. Write a TEAL program with the desired authorization logic") + print_info(" 3. Compile the program using algod.teal_compile()") + print_info(" 4. Sign with first participant using sign_multisig_program()") + print_info(" 5. Sign with additional participants, passing partial_multisig") + print_info(" 6. Once threshold is met, create LogicSigAccount with msig") + print_info(" 7. Use LogicSigAccount.signer to sign authorized transactions") + print_info("") + print_info("Key points:") + print_info(" - Each participant signs the PROGRAM (not transactions)") + print_info(" - The partial_multisig parameter chains signatures together") + print_info(" - The response contains msgpack-encoded MultisigSignature") + print_info(" - Unlike sign_multisig_transaction, program signing is done ONCE") + print_info(" - The resulting lsig can sign unlimited transactions (per program logic)") + print_info("") + print_info("Security considerations:") + print_info(" - Write program logic carefully - it controls your multisig account!") + print_info(" - Multiple parties review and sign the program code") + print_info(" - Consider time bounds, amount limits, and recipient restrictions") + print_info(" - The delegated lsig grants ongoing authorization until program expires") + print_info("") + print_info("Note: The test wallet remains in KMD (wallets cannot be deleted via API).") + except Exception as e: + print_error(f"Error: {e}") + print_info("") + print_info("Troubleshooting:") + print_info(" - Ensure LocalNet is running: algokit localnet start") + print_info(" - If LocalNet issues occur: algokit localnet reset") + print_info(" - Check that KMD is accessible on port 4002") + print_info(" - Check that Algod is accessible on port 4001") + + # Cleanup on error + if wallet_handle_token: + cleanup_test_wallet(kmd, wallet_handle_token) + + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/examples/kmd_client/verify-all.sh b/examples/kmd_client/verify-all.sh new file mode 100755 index 00000000..b56d7854 --- /dev/null +++ b/examples/kmd_client/verify-all.sh @@ -0,0 +1,85 @@ +#!/bin/bash + +# verify-all.sh - Run all kmd_client examples and verify they work +# Exit with non-zero code if any example fails + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +cd "$SCRIPT_DIR" + +# Array of example files in order +EXAMPLES=( + "01_version.py" + "02_wallet_management.py" + "03_wallet_sessions.py" + "04_key_generation.py" + "05_key_import_export.py" + "06_key_listing_deletion.py" + "07_master_key_export.py" + "08_multisig_setup.py" + "09_multisig_management.py" + "10_transaction_signing.py" + "11_multisig_signing.py" + "12_program_signing.py" + "13_multisig_program_signing.py" +) + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +NC='\033[0m' # No Color + +echo "========================================" +echo "KMD Client Examples Verification Script" +echo "========================================" +echo "" + +if [ ${#EXAMPLES[@]} -eq 0 ]; then + echo "No examples to run yet." + echo "" + echo -e "${GREEN}KMD Client examples suite passed (no examples)${NC}" + exit 0 +fi + +PASSED=0 +FAILED=0 +FAILED_EXAMPLES=() + +for example in "${EXAMPLES[@]}"; do + echo -n "Running $example... " + + if [ ! -f "$example" ]; then + echo -e "${RED}FAILED${NC} (file not found)" + FAILED=$((FAILED + 1)) + FAILED_EXAMPLES+=("$example") + continue + fi + + # Run the example and capture output/exit code + if OUTPUT=$(uv run python "$example" 2>&1); then + echo -e "${GREEN}PASSED${NC}" + PASSED=$((PASSED + 1)) + else + echo -e "${RED}FAILED${NC}" + echo "$OUTPUT" + FAILED=$((FAILED + 1)) + FAILED_EXAMPLES+=("$example") + fi +done + +echo "" +echo "========================================" +echo "Results: ${PASSED} passed, ${FAILED} failed" +echo "========================================" + +if [ $FAILED -gt 0 ]; then + echo "" + echo -e "${RED}Failed examples:${NC}" + for failed in "${FAILED_EXAMPLES[@]}"; do + echo " - $failed" + done + exit 1 +fi + +echo "" +echo -e "${GREEN}All KMD Client examples passed!${NC}" +exit 0 diff --git a/examples/pyproject.toml b/examples/pyproject.toml new file mode 100644 index 00000000..1d644fc3 --- /dev/null +++ b/examples/pyproject.toml @@ -0,0 +1,25 @@ +[project] +name = "algokit-examples" +version = "0.0.0" +requires-python = ">=3.10" +dependencies = [ + "algokit-utils", + "keyring", + "boto3", + "python-dotenv>=1.2.2", +] + +[build-system] +requires = ["hatchling"] +build-backend = "hatchling.build" + +[tool.hatch.build.targets.wheel] +packages = ["shared"] + +[tool.uv.sources] +algokit-utils = { path = "..", editable = true } + +[dependency-groups] +dev = [ + "mypy>=1.20.1", +] diff --git a/examples/shared/__init__.py b/examples/shared/__init__.py new file mode 100644 index 00000000..7e52c332 --- /dev/null +++ b/examples/shared/__init__.py @@ -0,0 +1,77 @@ +""" +Shared utilities for AlgoKit examples. + +This module provides common utilities for LocalNet configuration, +console output, formatting, client creation, and account management. +""" + +from .constants import ( + ALGOD_PORT, + ALGOD_SERVER, + ALGOD_TOKEN, + INDEXER_PORT, + INDEXER_SERVER, + INDEXER_TOKEN, + KMD_PORT, + KMD_SERVER, + KMD_TOKEN, +) +from .mock_keyring import KeyringProtocol, get_keyring +from .utils import ( + cleanup_test_wallet, + create_algod_client, + create_algorand_client, + create_indexer_client, + create_kmd_client, + create_random_account, + create_test_wallet, + format_algo, + format_bytes, + format_hex, + format_micro_algo, + get_account_balance, + get_funded_account, + load_teal_source, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, + wait_for_confirmation, +) + +__all__ = [ + "ALGOD_PORT", + "ALGOD_SERVER", + "ALGOD_TOKEN", + "INDEXER_PORT", + "INDEXER_SERVER", + "INDEXER_TOKEN", + "KMD_PORT", + "KMD_SERVER", + "KMD_TOKEN", + "KeyringProtocol", + "cleanup_test_wallet", + "create_algod_client", + "create_algorand_client", + "create_indexer_client", + "create_kmd_client", + "create_random_account", + "create_test_wallet", + "format_algo", + "format_bytes", + "format_hex", + "format_micro_algo", + "get_account_balance", + "get_funded_account", + "get_keyring", + "load_teal_source", + "print_error", + "print_header", + "print_info", + "print_step", + "print_success", + "shorten_address", + "wait_for_confirmation", +] diff --git a/examples/shared/artifacts/__init__.py b/examples/shared/artifacts/__init__.py new file mode 100644 index 00000000..2c946b31 --- /dev/null +++ b/examples/shared/artifacts/__init__.py @@ -0,0 +1,5 @@ +""" +Shared TEAL artifacts for examples. + +This directory contains TEAL source files that can be used across multiple examples. +""" diff --git a/examples/shared/artifacts/always-approve.teal b/examples/shared/artifacts/always-approve.teal new file mode 100644 index 00000000..6a0fb3c5 --- /dev/null +++ b/examples/shared/artifacts/always-approve.teal @@ -0,0 +1,5 @@ +#pragma version 10 +// Simple logic sig that always approves +// WARNING: In production, you should add conditions! +int 1 +return diff --git a/examples/shared/artifacts/approval-always-reject.teal b/examples/shared/artifacts/approval-always-reject.teal new file mode 100644 index 00000000..1228ba4e --- /dev/null +++ b/examples/shared/artifacts/approval-always-reject.teal @@ -0,0 +1,14 @@ +#pragma version 10 +// App that always rejects non-creation calls with err opcode + +txn ApplicationID +int 0 +== +bnz handle_creation + +// Always reject non-creation calls with a specific error +err + +handle_creation: + int 1 + return diff --git a/examples/shared/artifacts/approval-box-ops.teal b/examples/shared/artifacts/approval-box-ops.teal new file mode 100644 index 00000000..0f1c734c --- /dev/null +++ b/examples/shared/artifacts/approval-box-ops.teal @@ -0,0 +1,54 @@ +#pragma version 10 +txn ApplicationID +bz create + +// Check if we're being called with "create_box" as first arg +txn NumAppArgs +int 0 +== +bnz just_succeed + +txna ApplicationArgs 0 +byte "create_box" +== +bnz handle_create_box + +txna ApplicationArgs 0 +byte "delete_box" +== +bnz handle_delete_box + +// Default: just succeed +b just_succeed + +handle_create_box: +// Create or replace a box with the given name and value +// Args: [0] = "create_box", [1] = box_name, [2] = box_value +txna ApplicationArgs 1 +txna ApplicationArgs 2 +len +box_create +pop +txna ApplicationArgs 1 +int 0 +txna ApplicationArgs 2 +box_replace +int 1 +return + +handle_delete_box: +// Delete a box with the given name +// Args: [0] = "delete_box", [1] = box_name +txna ApplicationArgs 1 +box_del +pop +int 1 +return + +just_succeed: +int 1 +return + +create: +int 1 +return diff --git a/examples/shared/artifacts/approval-box-storage.teal b/examples/shared/artifacts/approval-box-storage.teal new file mode 100644 index 00000000..b7cdb171 --- /dev/null +++ b/examples/shared/artifacts/approval-box-storage.teal @@ -0,0 +1,138 @@ +#pragma version 10 +// Stateful app with global state, local state, and box storage +// - Create: Initializes global counter, message, and creator +// - NoOp with "increment": Increments counter +// - NoOp with "set_box": Creates/updates a box with provided name and value +// - OptIn: Initializes local user_score and opted_in_round +// - CloseOut: Allows close out +// - Update: Allows updating the application code +// - Delete: Allows deleting the application + +// Check if this is app creation +txn ApplicationID +int 0 +== +bnz handle_creation + +// Check OnComplete action +txn OnCompletion +int NoOp +== +bnz handle_noop + +txn OnCompletion +int OptIn +== +bnz handle_optin + +txn OnCompletion +int CloseOut +== +bnz handle_closeout + +txn OnCompletion +int UpdateApplication +== +bnz handle_update + +txn OnCompletion +int DeleteApplication +== +bnz handle_delete + +// Reject other operations +int 0 +return + +handle_creation: + // Initialize global counter to 0 + byte "counter" + int 0 + app_global_put + // Store a message + byte "message" + byte "Hello from AppManager!" + app_global_put + // Store creator address + byte "creator" + txn Sender + app_global_put + int 1 + return + +handle_noop: + // Check if first arg is "increment" + txn NumAppArgs + int 0 + == + bnz noop_default + + txna ApplicationArgs 0 + byte "increment" + == + bnz handle_increment + + txna ApplicationArgs 0 + byte "set_box" + == + bnz handle_set_box + + // Default: just approve + noop_default: + int 1 + return + +handle_increment: + // Increment global counter only + byte "counter" + app_global_get + int 1 + + + byte "counter" + swap + app_global_put + int 1 + return + +handle_set_box: + // Expects: arg[0]="set_box", arg[1]=box_name, arg[2]=box_value + txn NumAppArgs + int 3 + >= + assert + + // Create or replace box with name from arg[1] and value from arg[2] + txna ApplicationArgs 1 + dup + box_del + pop // Ignore result of delete (may not exist) + txna ApplicationArgs 2 + box_put + int 1 + return + +handle_optin: + // Initialize local score for this user + txn Sender + byte "user_score" + int 0 + app_local_put + // Store opt-in timestamp (round number) + txn Sender + byte "opted_in_round" + global Round + app_local_put + int 1 + return + +handle_closeout: + int 1 + return + +handle_update: + int 1 + return + +handle_delete: + int 1 + return diff --git a/examples/shared/artifacts/approval-counter-message.teal b/examples/shared/artifacts/approval-counter-message.teal new file mode 100644 index 00000000..db75d4dc --- /dev/null +++ b/examples/shared/artifacts/approval-counter-message.teal @@ -0,0 +1,26 @@ +#pragma version 10 +txn ApplicationID +bz create +// On call: increment counter +byte "counter" +app_global_get +int 1 ++ +byte "counter" +swap +app_global_put +byte "message" +byte "Hello, Algorand!" +app_global_put +int 1 +return +create: +// On create: initialize counter to 0 +byte "counter" +int 0 +app_global_put +byte "message" +byte "Hello, Algorand!" +app_global_put +int 1 +return diff --git a/examples/shared/artifacts/approval-counter-simple.teal b/examples/shared/artifacts/approval-counter-simple.teal new file mode 100644 index 00000000..23a19875 --- /dev/null +++ b/examples/shared/artifacts/approval-counter-simple.teal @@ -0,0 +1,42 @@ +#pragma version 10 +// Simple counter app: create, noop increment, delete + +txn ApplicationID +int 0 +== +bnz handle_creation + +txn OnCompletion +int NoOp +== +bnz handle_noop + +txn OnCompletion +int DeleteApplication +== +bnz handle_delete + +int 0 +return + +handle_creation: + byte "counter" + int 0 + app_global_put + int 1 + return + +handle_noop: + byte "counter" + app_global_get + int 1 + + + byte "counter" + swap + app_global_put + int 1 + return + +handle_delete: + int 1 + return diff --git a/examples/shared/artifacts/approval-counter.teal b/examples/shared/artifacts/approval-counter.teal new file mode 100644 index 00000000..71a68684 --- /dev/null +++ b/examples/shared/artifacts/approval-counter.teal @@ -0,0 +1,72 @@ +#pragma version 10 +// Simple smart contract for demonstration + +// Check if this is app creation +txn ApplicationID +int 0 +== +bnz handle_creation + +// Check OnComplete action +txn OnCompletion +int NoOp +== +bnz handle_noop + +txn OnCompletion +int OptIn +== +bnz handle_optin + +txn OnCompletion +int DeleteApplication +== +bnz handle_delete + +// Reject other operations +int 0 +return + +handle_creation: + // Initialize global counter to 0 + byte "counter" + int 0 + app_global_put + int 1 + return + +handle_noop: + // Increment global counter + byte "counter" + app_global_get + int 1 + + + byte "counter" + swap + app_global_put + + // If any app args provided, log the first one + txn NumAppArgs + int 0 + > + bz noop_end + txna ApplicationArgs 0 + log + + noop_end: + int 1 + return + +handle_optin: + // Initialize local counter for this user + txn Sender + byte "user_counter" + int 0 + app_local_put + int 1 + return + +handle_delete: + // Allow deletion + int 1 + return diff --git a/examples/shared/artifacts/approval-error-triggers.teal b/examples/shared/artifacts/approval-error-triggers.teal new file mode 100644 index 00000000..71cc82a8 --- /dev/null +++ b/examples/shared/artifacts/approval-error-triggers.teal @@ -0,0 +1,69 @@ +#pragma version 10 +// App that triggers various errors based on arguments +// Used for testing error transformers + +txn ApplicationID +int 0 +== +bnz handle_creation + +// Handle deletion +txn OnCompletion +int DeleteApplication +== +bnz handle_delete + +// Check if we have at least one argument +txn NumAppArgs +int 0 +> +bnz check_action + +// No arguments - reject +err + +check_action: + // Get the first argument + txna ApplicationArgs 0 + byte "approve" + == + bnz do_approve + + txna ApplicationArgs 0 + byte "reject_division" + == + bnz do_division_error + + txna ApplicationArgs 0 + byte "reject_assert" + == + bnz do_assert_error + + // Unknown action - reject + err + +do_approve: + int 1 + return + +handle_delete: + int 1 + return + +do_division_error: + // Intentional division by zero error + int 1 + int 0 + / + return + +do_assert_error: + // Intentional assertion failure + int 0 + assert + int 1 + return + +handle_creation: + int 1 + return diff --git a/examples/shared/artifacts/approval-lifecycle-counter.teal b/examples/shared/artifacts/approval-lifecycle-counter.teal new file mode 100644 index 00000000..3646e815 --- /dev/null +++ b/examples/shared/artifacts/approval-lifecycle-counter.teal @@ -0,0 +1,54 @@ +#pragma version 10 +// Simple smart contract for demonstration +txn ApplicationID +int 0 +== +bnz handle_creation + +txn OnCompletion +int NoOp +== +bnz handle_noop + +txn OnCompletion +int OptIn +== +bnz handle_optin + +txn OnCompletion +int DeleteApplication +== +bnz handle_delete + +int 0 +return + +handle_creation: + byte "counter" + int 0 + app_global_put + int 1 + return + +handle_noop: + byte "counter" + app_global_get + int 1 + + + byte "counter" + swap + app_global_put + int 1 + return + +handle_optin: + txn Sender + byte "user_visits" + int 1 + app_local_put + int 1 + return + +handle_delete: + int 1 + return diff --git a/examples/shared/artifacts/approval-lifecycle-full-v2.teal b/examples/shared/artifacts/approval-lifecycle-full-v2.teal new file mode 100644 index 00000000..91dbdb3c --- /dev/null +++ b/examples/shared/artifacts/approval-lifecycle-full-v2.teal @@ -0,0 +1,90 @@ +#pragma version 10 +// Full lifecycle app V2 - increments counter by 2 instead of 1 +// Used for demonstrating app updates + +// Check if this is app creation +txn ApplicationID +int 0 +== +bnz handle_creation + +// Check OnComplete action +txn OnCompletion +int NoOp +== +bnz handle_noop + +txn OnCompletion +int OptIn +== +bnz handle_optin + +txn OnCompletion +int CloseOut +== +bnz handle_closeout + +txn OnCompletion +int UpdateApplication +== +bnz handle_update + +txn OnCompletion +int DeleteApplication +== +bnz handle_delete + +// Reject other operations +int 0 +return + +handle_creation: + byte "counter" + int 0 + app_global_put + byte "message" + byte "Hello, World!" + app_global_put + int 1 + return + +handle_noop: + // V2: Increment global counter by 2 instead of 1 + byte "counter" + app_global_get + int 2 + + + byte "counter" + swap + app_global_put + + txn NumAppArgs + int 0 + > + bz noop_end + txna ApplicationArgs 0 + log + + noop_end: + int 1 + return + +handle_optin: + txn Sender + byte "user_visits" + int 0 + app_local_put + int 1 + return + +handle_closeout: + int 1 + return + +handle_update: + int 1 + return + +handle_delete: + int 1 + return diff --git a/examples/shared/artifacts/approval-lifecycle-full.teal b/examples/shared/artifacts/approval-lifecycle-full.teal new file mode 100644 index 00000000..7d9c5b23 --- /dev/null +++ b/examples/shared/artifacts/approval-lifecycle-full.teal @@ -0,0 +1,103 @@ +#pragma version 10 +// Full lifecycle app with counter, message, OptIn, CloseOut, Update, Delete +// - Create: Initializes global counter to 0 and message +// - NoOp: Increments counter, logs first arg if provided +// - OptIn: Initializes local user_visits to 0 +// - CloseOut: Allows close out (local state will be removed) +// - ClearState: Always approves (cannot reject) +// - Update: Allows updating the application code +// - Delete: Allows deleting the application + +// Check if this is app creation +txn ApplicationID +int 0 +== +bnz handle_creation + +// Check OnComplete action +txn OnCompletion +int NoOp +== +bnz handle_noop + +txn OnCompletion +int OptIn +== +bnz handle_optin + +txn OnCompletion +int CloseOut +== +bnz handle_closeout + +txn OnCompletion +int UpdateApplication +== +bnz handle_update + +txn OnCompletion +int DeleteApplication +== +bnz handle_delete + +// Reject other operations +int 0 +return + +handle_creation: + // Initialize global counter to 0 + byte "counter" + int 0 + app_global_put + // Store a message + byte "message" + byte "Hello, World!" + app_global_put + int 1 + return + +handle_noop: + // Increment global counter + byte "counter" + app_global_get + int 1 + + + byte "counter" + swap + app_global_put + + // If any app args provided, log the first one + txn NumAppArgs + int 0 + > + bz noop_end + txna ApplicationArgs 0 + log + + noop_end: + int 1 + return + +handle_optin: + // Initialize local counter for this user + txn Sender + byte "user_visits" + int 0 + app_local_put + int 1 + return + +handle_closeout: + // Allow close out (local state will be removed) + int 1 + return + +handle_update: + // Allow updates (in production, add access control!) + int 1 + return + +handle_delete: + // Allow deletion (in production, add access control!) + int 1 + return diff --git a/examples/shared/artifacts/approval-logging.teal b/examples/shared/artifacts/approval-logging.teal new file mode 100644 index 00000000..312271e4 --- /dev/null +++ b/examples/shared/artifacts/approval-logging.teal @@ -0,0 +1,48 @@ +#pragma version 10 +// Application that emits logs for demonstration + +txn ApplicationID +int 0 +== +bnz handle_creation + +// On any call (NoOp), emit some logs +txn OnCompletion +int NoOp +== +bnz handle_call + +txn OnCompletion +int DeleteApplication +== +bnz handle_delete + +int 0 +return + +handle_creation: + // Log a creation message + byte "App created!" + log + int 1 + return + +handle_call: + // Emit multiple log entries + byte "Log entry 1: Hello from the app" + log + byte "Log entry 2: Call processed" + log + // Log the sender address + byte "Sender: " + txn Sender + concat + log + int 1 + return + +handle_delete: + byte "App deleted!" + log + int 1 + return diff --git a/examples/shared/artifacts/clear-state-approve.teal b/examples/shared/artifacts/clear-state-approve.teal new file mode 100644 index 00000000..c960bf86 --- /dev/null +++ b/examples/shared/artifacts/clear-state-approve.teal @@ -0,0 +1,3 @@ +#pragma version 10 +int 1 +return diff --git a/examples/shared/artifacts/clear-state-logging.teal b/examples/shared/artifacts/clear-state-logging.teal new file mode 100644 index 00000000..4e7dbfb1 --- /dev/null +++ b/examples/shared/artifacts/clear-state-logging.teal @@ -0,0 +1,5 @@ +#pragma version 10 +byte "Clear state called" +log +int 1 +return diff --git a/examples/shared/artifacts/complex-approve.teal b/examples/shared/artifacts/complex-approve.teal new file mode 100644 index 00000000..e8af8fb3 --- /dev/null +++ b/examples/shared/artifacts/complex-approve.teal @@ -0,0 +1,17 @@ +#pragma version 10 +// Simple smart contract that: +// - Always approves application creation +// - Always approves application calls +// - Always approves clear state + +txn ApplicationID +bz create + +// Not creation, approve all calls +int 1 +return + +create: +// On create, just approve +int 1 +return diff --git a/examples/shared/artifacts/counter-init.teal b/examples/shared/artifacts/counter-init.teal new file mode 100644 index 00000000..e48cc751 --- /dev/null +++ b/examples/shared/artifacts/counter-init.teal @@ -0,0 +1,7 @@ +#pragma version 10 +// Counter program +byte "counter" +int 0 +app_global_put +int 1 +return diff --git a/examples/shared/artifacts/delegated-payment-limit.teal b/examples/shared/artifacts/delegated-payment-limit.teal new file mode 100644 index 00000000..5b5ec3bd --- /dev/null +++ b/examples/shared/artifacts/delegated-payment-limit.teal @@ -0,0 +1,16 @@ +#pragma version 8 +// Delegated Logic Signature Example +// This program approves payment transactions up to 1 ALGO + +// Check that this is a payment transaction +txn TypeEnum +int pay +== + +// Check that the amount is <= 1 ALGO (1,000,000 microALGOs) +txn Amount +int 1000000 +<= + +// Both conditions must be true +&& diff --git a/examples/shared/artifacts/simple-approve.teal b/examples/shared/artifacts/simple-approve.teal new file mode 100644 index 00000000..a9e8b17d --- /dev/null +++ b/examples/shared/artifacts/simple-approve.teal @@ -0,0 +1,2 @@ +#pragma version 10 +int 1 diff --git a/examples/shared/artifacts/teal-template-basic.teal b/examples/shared/artifacts/teal-template-basic.teal new file mode 100644 index 00000000..3bd98a39 --- /dev/null +++ b/examples/shared/artifacts/teal-template-basic.teal @@ -0,0 +1,12 @@ +#pragma version 10 +// Template with replaceable parameters +// TMPL_INT_VALUE will be replaced with an integer +// TMPL_BYTES_VALUE will be replaced with bytes + +// Push template values +int TMPL_INT_VALUE +byte TMPL_BYTES_VALUE +pop +pop +int 1 +return diff --git a/examples/shared/artifacts/teal-template-deploy-control.teal b/examples/shared/artifacts/teal-template-deploy-control.teal new file mode 100644 index 00000000..2fa1c2d1 --- /dev/null +++ b/examples/shared/artifacts/teal-template-deploy-control.teal @@ -0,0 +1,35 @@ +#pragma version 10 +// AlgoKit deploy-time control template +// Uses TMPL_UPDATABLE and TMPL_DELETABLE for controlling app lifecycle + +txn ApplicationID +int 0 +== +bnz handle_creation + +txn OnCompletion +int UpdateApplication +== +bnz handle_update + +txn OnCompletion +int DeleteApplication +== +bnz handle_delete + +int 1 +return + +handle_creation: + int 1 + return + +handle_update: + // Check if updates are allowed + int TMPL_UPDATABLE + return + +handle_delete: + // Check if deletion is allowed + int TMPL_DELETABLE + return diff --git a/examples/shared/artifacts/teal-template-versioned.teal b/examples/shared/artifacts/teal-template-versioned.teal new file mode 100644 index 00000000..4595465b --- /dev/null +++ b/examples/shared/artifacts/teal-template-versioned.teal @@ -0,0 +1,78 @@ +#pragma version 10 +// Versioned App - Version TMPL_VERSION +// This comment changes bytecode when version changes + +txn ApplicationID +int 0 +== +bnz handle_creation + +txn OnCompletion +int NoOp +== +bnz handle_noop + +txn OnCompletion +int OptIn +== +bnz handle_optin + +txn OnCompletion +int CloseOut +== +bnz handle_closeout + +txn OnCompletion +int UpdateApplication +== +bnz handle_update + +txn OnCompletion +int DeleteApplication +== +bnz handle_delete + +int 0 +return + +handle_creation: + // Store the version in global state + byte "version" + int TMPL_VERSION + app_global_put + // Initialize a counter + byte "counter" + int 0 + app_global_put + int 1 + return + +handle_noop: + // Increment counter on each call + byte "counter" + app_global_get + int 1 + + + byte "counter" + swap + app_global_put + int 1 + return + +handle_optin: + int 1 + return + +handle_closeout: + int 1 + return + +handle_update: + // Check if updates are allowed via deploy-time control + int TMPL_UPDATABLE + return + +handle_delete: + // Check if deletion is allowed via deploy-time control + int TMPL_DELETABLE + return diff --git a/examples/shared/constants.py b/examples/shared/constants.py new file mode 100644 index 00000000..585c4983 --- /dev/null +++ b/examples/shared/constants.py @@ -0,0 +1,20 @@ +""" +LocalNet configuration constants for examples. + +These constants provide default configuration for connecting to an AlgoKit LocalNet instance. +""" + +# Algod configuration +ALGOD_SERVER = "http://localhost" +ALGOD_PORT = 4001 +ALGOD_TOKEN = "a" * 64 # Default LocalNet token + +# KMD configuration +KMD_SERVER = "http://localhost" +KMD_PORT = 4002 +KMD_TOKEN = "a" * 64 # Default LocalNet token + +# Indexer configuration +INDEXER_SERVER = "http://localhost" +INDEXER_PORT = 8980 +INDEXER_TOKEN = "a" * 64 # Default LocalNet token diff --git a/examples/shared/mock_keyring.py b/examples/shared/mock_keyring.py new file mode 100644 index 00000000..6559d106 --- /dev/null +++ b/examples/shared/mock_keyring.py @@ -0,0 +1,76 @@ +# ruff: noqa: S105, S106 +""" +Mock keyring implementation for CI/testing environments. + +This module provides a mock keyring that stores secrets in memory using a +dictionary. It's automatically used when running in GitHub Actions CI to +avoid issues with OS keyring availability. + +WARNING: This is not secure and should only be used for testing. +""" + +from __future__ import annotations + +import os +from typing import ClassVar, Protocol + + +class KeyringProtocol(Protocol): + """Protocol defining the interface for keyring implementations.""" + + def get_password(self, service: str, username: str) -> str | None: ... + def set_password(self, service: str, username: str, password: str) -> None: ... + + +class MockKeyring: + """In-memory keyring for CI/testing when OS keyring is unavailable. + + WARNING: This is not secure and should only be used for testing. + Secrets are stored in a static dictionary and persist for the lifetime + of the process. + """ + + _storage: ClassVar[dict[str, dict[str, str]]] = {} + + def get_password(self, service: str, username: str) -> str | None: + """Retrieve a password from the mock storage.""" + return self._storage.get(service, {}).get(username) + + def set_password(self, service: str, username: str, password: str) -> None: + """Store a password in the mock storage.""" + if service not in self._storage: + self._storage[service] = {} + self._storage[service][username] = password + + +class RealKeyringWrapper: + """Wrapper for the real keyring module to implement KeyringProtocol.""" + + def __init__(self) -> None: + import keyring + + self._keyring = keyring + + def get_password(self, service: str, username: str) -> str | None: + """Retrieve a password using the real keyring.""" + return self._keyring.get_password(service, username) + + def set_password(self, service: str, username: str, password: str) -> None: + """Store a password using the real keyring.""" + self._keyring.set_password(service, username, password) + + +def get_keyring() -> KeyringProtocol: + """Get the appropriate keyring implementation. + + Returns an instance that implements KeyringProtocol. + Uses MockKeyring when running in GitHub Actions, otherwise + uses the real OS keyring via RealKeyringWrapper. + + Returns: + A KeyringProtocol instance (either MockKeyring or RealKeyringWrapper) + """ + if os.environ.get("GITHUB_ACTIONS") == "true": + return MockKeyring() + + return RealKeyringWrapper() diff --git a/examples/shared/utils.py b/examples/shared/utils.py new file mode 100644 index 00000000..7e18fd82 --- /dev/null +++ b/examples/shared/utils.py @@ -0,0 +1,387 @@ +""" +Shared utility functions for examples. + +This module provides helper functions for console output, formatting, +client creation, wallet management, transactions, and accounts. +""" + +from __future__ import annotations + +import contextlib +import secrets +from decimal import Decimal +from pathlib import Path +from typing import TYPE_CHECKING + +from algokit_algod_client import AlgodClient +from algokit_algod_client.config import ClientConfig as AlgodConfig +from algokit_indexer_client import IndexerClient +from algokit_indexer_client.config import ClientConfig as IndexerConfig +from algokit_kmd_client import KmdClient +from algokit_kmd_client.config import ClientConfig as KmdConfig +from algokit_kmd_client.models import ( + CreateWalletRequest, + InitWalletHandleTokenRequest, + ReleaseWalletHandleTokenRequest, +) +from algokit_utils import AlgoAmount, AlgorandClient + +from .constants import ( + ALGOD_PORT, + ALGOD_SERVER, + ALGOD_TOKEN, + INDEXER_PORT, + INDEXER_SERVER, + INDEXER_TOKEN, + KMD_PORT, + KMD_SERVER, + KMD_TOKEN, +) + +if TYPE_CHECKING: + from algokit_utils.accounts.account_manager import AddressAndSigner + + +# ============================================================================ +# Console Output Helpers +# ============================================================================ + + +def print_header(title: str) -> None: + """Print a header for an example section.""" + line = "=" * 60 + print(f"\n{line}") # noqa: T201 + print(f" {title}") # noqa: T201 + print(f"{line}\n") # noqa: T201 + + +def print_step(step: int, description: str) -> None: + """Print a step in the example.""" + print(f"\n Step {step}: {description}") # noqa: T201 + + +def print_info(message: str) -> None: + """Print informational message.""" + print(f" {message}") # noqa: T201 + + +def print_success(message: str) -> None: + """Print success message.""" + print(f" [OK] {message}") # noqa: T201 + + +def print_error(message: str) -> None: + """Print error message.""" + print(f" [ERROR] {message}") # noqa: T201 + + +# ============================================================================ +# Formatting Helpers +# ============================================================================ + + +def format_algo(amount: AlgoAmount | int | Decimal, decimals: int = 6) -> str: + """ + Format an AlgoAmount or microAlgo value to a human-readable string. + + Args: + amount: An AlgoAmount object or microAlgo value (int or Decimal) + decimals: Number of decimal places to show + + Returns: + Formatted string like "1.000000 ALGO" + """ + if isinstance(amount, AlgoAmount): + algo_value = amount.algo + else: + # Assume microAlgo value + algo_value = Decimal(amount) / Decimal(1_000_000) + + return f"{algo_value:.{decimals}f} ALGO" + + +def format_micro_algo(micro_algo: int) -> str: + """ + Format a microAlgo amount to a human-readable string. + + Args: + micro_algo: Amount in microAlgos + + Returns: + Formatted string like "1,000,000 microALGO" + """ + return f"{micro_algo:,} microALGO" + + +def shorten_address(address: str, prefix_length: int = 6, suffix_length: int = 4) -> str: + """ + Shorten an Algorand address for display. + + Args: + address: Full Algorand address + prefix_length: Number of characters to show at the start + suffix_length: Number of characters to show at the end + + Returns: + Shortened address like "ABC123...WXYZ" + """ + if len(address) <= prefix_length + suffix_length + 3: + return address + return f"{address[:prefix_length]}...{address[-suffix_length:]}" + + +def format_bytes(data: bytes, max_preview_bytes: int = 8) -> str: + """ + Format a byte array as a readable string showing length and preview. + + Args: + data: Bytes to format + max_preview_bytes: Maximum number of bytes to show in preview + + Returns: + Formatted string like "32 bytes: [0x01, 0x02, ...]" + """ + preview = ", ".join(f"0x{b:02x}" for b in data[:max_preview_bytes]) + suffix = ", ..." if len(data) > max_preview_bytes else "" + return f"{len(data)} bytes: [{preview}{suffix}]" + + +def format_hex(data: bytes) -> str: + """ + Format a byte array as a hexadecimal string. + + Args: + data: Bytes to format + + Returns: + Hex string like "0x0102030405" + """ + return f"0x{data.hex()}" + + +# ============================================================================ +# Client Creation Helpers +# ============================================================================ + + +def create_algod_client() -> AlgodClient: + """Create an Algod client using default LocalNet configuration.""" + config = AlgodConfig( + base_url=f"{ALGOD_SERVER}:{ALGOD_PORT}", + token=ALGOD_TOKEN, + ) + return AlgodClient(config) + + +def create_kmd_client() -> KmdClient: + """Create a KMD client using default LocalNet configuration.""" + config = KmdConfig( + base_url=f"{KMD_SERVER}:{KMD_PORT}", + token=KMD_TOKEN, + ) + return KmdClient(config) + + +def create_indexer_client() -> IndexerClient: + """Create an Indexer client using default LocalNet configuration.""" + config = IndexerConfig( + base_url=f"{INDEXER_SERVER}:{INDEXER_PORT}", + token=INDEXER_TOKEN, + ) + return IndexerClient(config) + + +def create_algorand_client() -> AlgorandClient: + """Create an AlgorandClient configured for LocalNet.""" + return AlgorandClient.default_localnet() + + +# ============================================================================ +# KMD Helpers +# ============================================================================ + + +def _generate_wallet_name() -> str: + """Generate a unique wallet name for testing.""" + random_suffix = secrets.token_hex(4) + return f"test-wallet-{random_suffix}" + + +def create_test_wallet( + kmd: KmdClient, + password: str = "", +) -> dict[str, str]: + """ + Create a test wallet for examples. + + Args: + kmd: KMD client instance + password: Wallet password (default: empty string) + + Returns: + Dictionary with wallet_id, wallet_name, and wallet_handle_token + """ + wallet_name = _generate_wallet_name() + + # Create the wallet + create_result = kmd.create_wallet( + CreateWalletRequest(wallet_name=wallet_name, wallet_password=password, wallet_driver_name="sqlite") + ) + wallet_id = create_result.wallet.id_ + + # Initialize the wallet handle (unlock the wallet) + init_result = kmd.init_wallet_handle(InitWalletHandleTokenRequest(wallet_id=wallet_id, wallet_password=password)) + wallet_handle_token = init_result.wallet_handle_token + + return { + "wallet_id": wallet_id, + "wallet_name": wallet_name, + "wallet_handle_token": wallet_handle_token, + } + + +def cleanup_test_wallet(kmd: KmdClient, wallet_handle_token: str) -> None: + """ + Cleanup a test wallet by releasing its handle token. + + Note: KMD doesn't support deleting wallets, so we just release the handle. + + Args: + kmd: KMD client instance + wallet_handle_token: The wallet handle token to release + """ + # Ignore errors during cleanup (handle may have already expired) + with contextlib.suppress(Exception): + kmd.release_wallet_handle_token(ReleaseWalletHandleTokenRequest(wallet_handle_token=wallet_handle_token)) + + +# ============================================================================ +# Transaction Helpers +# ============================================================================ + + +def wait_for_confirmation( + algod: AlgodClient, + tx_id: str, + max_rounds: int = 5, +) -> object: + """ + Wait for a transaction to be confirmed. + + Args: + algod: Algod client instance + tx_id: Transaction ID to wait for + max_rounds: Maximum number of rounds to wait + + Returns: + The pending transaction response once confirmed + + Raises: + Exception: If transaction is rejected or not confirmed within max_rounds + """ + status = algod.status() + current_round = status.last_round + end_round = current_round + max_rounds + + while current_round < end_round: + pending_info = algod.pending_transaction_information(tx_id) + + if pending_info.confirmed_round is not None and pending_info.confirmed_round > 0: + return pending_info + + pool_error = pending_info.pool_error + if pool_error: + raise Exception(f"Transaction rejected: {pool_error}") + + algod.status_after_block(current_round) + current_round += 1 + + raise Exception(f"Transaction {tx_id} not confirmed after {max_rounds} rounds") + + +def get_account_balance(algorand: AlgorandClient, address: str) -> AlgoAmount: + """ + Get the balance of an account. + + Args: + algorand: AlgorandClient instance + address: Account address to check + + Returns: + Account balance as AlgoAmount + """ + info = algorand.account.get_information(address) + return info.amount + + +# ============================================================================ +# Account Helpers +# ============================================================================ + + +def get_funded_account(algorand: AlgorandClient) -> AddressAndSigner: + """ + Get a funded account from the LocalNet dispenser. + + Args: + algorand: AlgorandClient instance + + Returns: + The dispenser account with signing capabilities + """ + return algorand.account.localnet_dispenser() + + +def create_random_account( + algorand: AlgorandClient, + funding_amount: AlgoAmount | None = None, +) -> AddressAndSigner: + """ + Create a random account and fund it from the dispenser. + + Args: + algorand: AlgorandClient instance + funding_amount: Amount to fund (default: 10 ALGO) + + Returns: + The funded random account with signing capabilities + """ + account = algorand.account.random() + dispenser = algorand.account.localnet_dispenser() + + amount = funding_amount if funding_amount is not None else AlgoAmount.from_algo(10) + + algorand.account.ensure_funded( + account_to_fund=account.addr, + dispenser_account=dispenser, + min_spending_balance=amount, + ) + + algorand.set_signer(sender=account.addr, signer=account.signer) + + return account + + +# ============================================================================ +# TEAL Artifact Helpers +# ============================================================================ + +# Path to the artifacts directory +_ARTIFACTS_DIR = Path(__file__).parent / "artifacts" + + +def load_teal_source(filename: str) -> str: + """ + Load a TEAL source file from the shared artifacts directory. + + Args: + filename: Name of the TEAL file (e.g., "approval-counter.teal") + + Returns: + The TEAL source code as a string + + Raises: + FileNotFoundError: If the specified file does not exist + """ + file_path = _ARTIFACTS_DIR / filename + return file_path.read_text() diff --git a/examples/signing/01_ed25519_from_keyring.py b/examples/signing/01_ed25519_from_keyring.py new file mode 100644 index 00000000..aae38c54 --- /dev/null +++ b/examples/signing/01_ed25519_from_keyring.py @@ -0,0 +1,139 @@ +# ruff: noqa: N999 +""" +Example: Ed25519 Signing From Keyring + +This example demonstrates how to retrieve secrets from a keyring and use them to sign +transactions. + +Key concepts: +- Using keyring library to securely store and retrieve mnemonic +- Mock keyring for CI/testing when OS keyring is unavailable +- Implementing WrappedEd25519Seed interface for secure key handling +- Converting mnemonic to seed and deriving signing key +- Creating Algorand account with generated signers +- Registering signer with AlgorandClient using set_signer_from_account() +- Signing and sending a payment transaction + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +- OS that has keyring support (macOS Keychain, Windows Credential Manager, Linux Secret Service) +- keyring library installed (uv pip install keyring) +- For testing without keyring: Mock keyring will be used automatically in CI +""" + +import base64 +import secrets + +from shared import print_header, print_info, print_step, print_success +from shared.mock_keyring import KeyringProtocol, get_keyring + +from algokit_algo25 import mnemonic_from_seed, seed_from_mnemonic +from algokit_crypto import WrappedEd25519Seed, ed25519_signing_key_from_wrapped_secret +from algokit_transact import generate_address_with_signers +from algokit_utils import AlgoAmount, AlgorandClient, PaymentParams + +MNEMONIC_NAME = "algorand-mainnet-mnemonic" + + +class KeyringWrappedSeed(WrappedEd25519Seed): + """Implementation of WrappedEd25519Seed using OS keyring.""" + + def __init__(self, service_name: str, account_name: str, keyring_instance: KeyringProtocol) -> None: + self._service = service_name + self._account = account_name + self._keyring = keyring_instance + + def unwrap_ed25519_seed(self) -> bytearray: + """Retrieve mnemonic from keyring and convert to seed.""" + mnemonic = self._keyring.get_password(self._service, self._account) + if mnemonic is None: + raise ValueError(f"No mnemonic found in keyring for {self._account}") + return bytearray(seed_from_mnemonic(mnemonic)) + + def wrap_ed25519_seed(self) -> None: + """Re-wrap the seed after use (no-op for keyring).""" + # Keyring handles persistence; nothing to wrap + + +def setup_keyring_secret(keyring_instance: KeyringProtocol) -> None: + """Setup: Generate a random seed, create mnemonic, and store in keyring.""" + print_step(1, "Setup: Generate seed and store in keyring") + + # Generate a random 32-byte seed + seed = secrets.token_bytes(32) + print_info(f"Generated seed: {base64.b64encode(seed).decode()[:20]}...") + + # Convert seed to mnemonic + mnemonic = mnemonic_from_seed(seed) + print_info(f"Generated mnemonic: {' '.join(mnemonic.split()[:3])}...") + + # Store in keyring + keyring_instance.set_password("algokit-examples", MNEMONIC_NAME, mnemonic) + print_info(f"Stored mnemonic in keyring (service='algokit-examples', account='{MNEMONIC_NAME}')") + + +def main() -> None: + print_header("Ed25519 Signing From Keyring Example") + + # Get appropriate keyring (real or mock) + keyring_instance = get_keyring() + if hasattr(keyring_instance, "__class__") and keyring_instance.__class__.__name__ == "MockKeyring": + print_info("WARNING: Using mock keyring for CI. Not secure - testing only!") + + # Setup: Create and store the secret + setup_keyring_secret(keyring_instance) + + # Step 2: Create wrapped seed instance + print_step(2, "Create wrapped seed implementation") + + wrapped_seed = KeyringWrappedSeed("algokit-examples", MNEMONIC_NAME, keyring_instance) + print_info("Created KeyringWrappedSeed instance") + + # Step 3: Derive signing key from wrapped secret + print_step(3, "Derive signing key from wrapped secret") + + signing_key = ed25519_signing_key_from_wrapped_secret(wrapped_seed) + print_info(f"Public key: {base64.b64encode(signing_key['ed25519_pubkey']).decode()[:20]}...") + + # Step 4: Create Algorand account with signers + print_step(4, "Generate Algorand address with signers") + + algorand_account = generate_address_with_signers( + signing_key["ed25519_pubkey"], + signing_key["raw_ed25519_signer"], + ) + print_info(f"Algorand address: {algorand_account.addr}") + + # Step 5: Connect to LocalNet and fund account + print_step(5, "Connect to LocalNet and fund account") + + algorand = AlgorandClient.default_localnet() + print_info("Connected to LocalNet") + + algorand.account.ensure_funded_from_environment(algorand_account.addr, AlgoAmount.from_algo(1)) + print_info("Account funded with 1 ALGO") + + # Step 6: Register signer with AlgorandClient + print_step(6, "Register signer with AlgorandClient") + + algorand.set_signer_from_account(algorand_account) + print_info("Signer registered for address") + + # Step 7: Sign and send payment transaction + print_step(7, "Sign and send payment transaction") + + pay = algorand.send.payment( + PaymentParams( + sender=algorand_account.addr, + receiver=algorand_account.addr, + amount=AlgoAmount.from_micro_algo(0), + ) + ) + print_info(f"Transaction ID: {pay.tx_ids[0]}") + print_info(f"Confirmed in round: {pay.confirmation.confirmed_round}") + + print_success("Ed25519 signing from keyring example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/signing/02_hd_from_keyring.py b/examples/signing/02_hd_from_keyring.py new file mode 100644 index 00000000..af74a4e5 --- /dev/null +++ b/examples/signing/02_hd_from_keyring.py @@ -0,0 +1,183 @@ +# ruff: noqa: N999 +""" +Example: HD Signing From Keyring + +This example demonstrates how to retrieve HD extended private keys from a keyring and use +them to sign transactions. + +Key concepts: +- Generating an HD wallet using the Peikert derivation scheme +- Deriving extended private keys (96 bytes: scalar + prefix + chain code) +- Storing and retrieving HD keys from OS keyring +- Mock keyring for CI/testing when OS keyring is unavailable +- Implementing WrappedHdExtendedPrivateKey interface +- The last 32 bytes (chain code) are not needed for signing +- Padding 64-byte secrets to 96 bytes for storage efficiency +- Registering signer with AlgorandClient using set_signer_from_account() + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +- OS that has keyring support (macOS Keychain, Windows Credential Manager, Linux Secret Service) +- keyring library installed (uv pip install keyring) +- For testing without keyring: Mock keyring will be used automatically in CI +""" + +import base64 +import secrets + +from shared import print_header, print_info, print_step, print_success +from shared.mock_keyring import KeyringProtocol, get_keyring + +from algokit_crypto import ( + WrappedHdExtendedPrivateKey, + ed25519_signing_key_from_wrapped_secret, + peikert_hd_wallet_generator, +) +from algokit_transact import generate_address_with_signers +from algokit_utils import AlgoAmount, AlgorandClient, PaymentParams + +SECRET_NAME = "algorand-hd-extended-key" +# Extended private key is 96 bytes (32 scalar + 32 prefix + 32 chain code) +# We store only first 64 bytes since chain code not needed for signing +EXTENDED_PRIVATE_KEY_LENGTH = 96 +STORED_KEY_LENGTH = 64 + + +class KeyringWrappedHdKey(WrappedHdExtendedPrivateKey): + """Implementation of WrappedHdExtendedPrivateKey using OS keyring. + + Note: We store only the first 64 bytes (scalar + prefix) in the keyring + since the chain code is not needed for signing. The unwrap function pads + it back to 96 bytes. + """ + + def __init__(self, service_name: str, account_name: str, keyring_instance: KeyringProtocol) -> None: + self._service = service_name + self._account = account_name + self._keyring = keyring_instance + + def unwrap_hd_extended_private_key(self) -> bytearray: + """Retrieve extended key from keyring and pad to 96 bytes if needed.""" + secret_b64 = self._keyring.get_password(self._service, self._account) + if secret_b64 is None: + raise ValueError(f"No HD key found in keyring for {self._account}") + + esk = bytearray(base64.b64decode(secret_b64)) + + # The last 32 bytes of the extended private key is the chain code, which is not + # needed for signing. This means in most cases you can just store the first 64 + # bytes and then pad the secret to 96 bytes in the unwrap function. If you are + # storing the full 96 bytes, you can just return the secret as is. + if len(esk) == STORED_KEY_LENGTH: + padded = bytearray(96) + padded[:64] = esk + print_info(" (Padded 64-byte key to 96 bytes - chain code not needed for signing)") + return padded + + return esk + + def wrap_hd_extended_private_key(self) -> None: + """Re-wrap the extended key after use (no-op for keyring).""" + # Keyring handles persistence; nothing to wrap + + +def setup_keyring_hd_secret(keyring_instance: KeyringProtocol) -> bytearray: + """Setup: Generate HD wallet, derive extended private key, and store in keyring.""" + print_step(1, "Setup: Generate HD wallet and store extended key in keyring") + + # Generate a random 64-byte seed for HD wallet + seed = secrets.token_bytes(64) + print_info(f"Generated HD wallet seed: {base64.b64encode(seed).decode()[:20]}...") + + # Create HD wallet using Peikert derivation + wallet = peikert_hd_wallet_generator(bytearray(seed)) + print_info("Created HD wallet with Peikert derivation scheme") + + # Derive account 0, index 0 + account_result = wallet["account_generator"](0, 0) + esk = account_result["extended_private_key"] # 96 bytes + + print_info(f"Extended private key length: {len(esk)} bytes") + print_info(" - First 32 bytes: scalar (for signing)") + print_info(" - Next 32 bytes: prefix (for nonce derivation)") + print_info(" - Last 32 bytes: chain code (for key derivation, not needed for signing)") + + # Store only the first 64 bytes in keyring (chain code not needed for signing) + esk_64 = bytes(esk[:64]) + esk_b64 = base64.b64encode(esk_64).decode() + keyring_instance.set_password("algokit-examples", SECRET_NAME, esk_b64) + print_info( + f"Stored first 64 bytes of extended key in keyring (service='algokit-examples', account='{SECRET_NAME}')" + ) + + return esk + + +def main() -> None: + print_header("HD Signing From Keyring Example") + + # Get appropriate keyring (real or mock) + keyring_instance = get_keyring() + if hasattr(keyring_instance, "__class__") and keyring_instance.__class__.__name__ == "MockKeyring": + print_info("WARNING: Using mock keyring for CI. Not secure - testing only!") + + # Setup: Create and store the HD secret + setup_keyring_hd_secret(keyring_instance) + + # Step 2: Create wrapped HD key instance + print_step(2, "Create wrapped HD key implementation") + + wrapped_key = KeyringWrappedHdKey("algokit-examples", SECRET_NAME, keyring_instance) + print_info("Created KeyringWrappedHdKey instance") + + # Step 3: Derive signing key from wrapped secret + print_step(3, "Derive signing key from wrapped HD secret") + + signing_key = ed25519_signing_key_from_wrapped_secret(wrapped_key) + print_info(f"Public key: {base64.b64encode(signing_key['ed25519_pubkey']).decode()[:20]}...") + + # Step 4: Create Algorand account with signers + print_step(4, "Generate Algorand address with signers") + + algorand_account = generate_address_with_signers( + signing_key["ed25519_pubkey"], + signing_key["raw_ed25519_signer"], + ) + print_info(f"Algorand address: {algorand_account.addr}") + + # Verify the signing key was created successfully + print_info("Derived signing key successfully from wrapped HD extended private key") + + # Step 5: Connect to LocalNet and fund account + print_step(5, "Connect to LocalNet and fund account") + + algorand = AlgorandClient.default_localnet() + print_info("Connected to LocalNet") + + algorand.account.ensure_funded_from_environment(algorand_account.addr, AlgoAmount.from_algo(1)) + print_info("Account funded with 1 ALGO") + + # Step 6: Register signer with AlgorandClient + print_step(6, "Register signer with AlgorandClient") + + algorand.set_signer_from_account(algorand_account) + print_info("Signer registered for address") + + # Step 7: Sign and send payment transaction + print_step(7, "Sign and send payment transaction") + + pay = algorand.send.payment( + PaymentParams( + sender=algorand_account.addr, + receiver=algorand_account.addr, + amount=AlgoAmount.from_micro_algo(0), + ) + ) + print_info(f"Transaction ID: {pay.tx_ids[0]}") + print_info(f"Confirmed in round: {pay.confirmation.confirmed_round}") + + print_success("HD signing from keyring example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/signing/03_aws_kms.py b/examples/signing/03_aws_kms.py new file mode 100644 index 00000000..ad7c86d8 --- /dev/null +++ b/examples/signing/03_aws_kms.py @@ -0,0 +1,207 @@ +# ruff: noqa: N999 +""" +Example: Ed25519 Signing from AWS KMS + +This example demonstrates how to use AWS KMS to perform Ed25519 signing for Algorand +transactions. Includes a mock KMS client for testing when AWS credentials are not available. + +Key concepts: +- Using AWS KMS for secure key storage and signing +- Mock KMS client for local development/testing +- Retrieving public key from KMS in SPKI format +- Parsing DER-encoded public key to extract raw Ed25519 public key +- Implementing RawEd25519Signer with KMS +- Generating Algorand address from KMS-managed key +- Registering signer with AlgorandClient using set_signer_from_account() + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +- AWS credentials configured (for real KMS usage): + - AWS_REGION environment variable + - KEY_ID environment variable + - AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY (or use OIDC in CI) +- boto3 library installed (uv pip install boto3) +- For testing without AWS: Mock client will be used automatically +""" + +import base64 +import os +from pathlib import Path +from typing import Protocol + +import nacl.signing +from dotenv import load_dotenv +from shared import print_header, print_info, print_step, print_success + +from algokit_transact import generate_address_with_signers +from algokit_utils import AlgoAmount, AlgorandClient, PaymentParams + +# Load .env file +load_dotenv(Path(__file__).parent / ".env") + +# Ed25519 SPKI prefix (DER-encoded SubjectPublicKeyInfo) +# 0x30 0x2a 0x30 0x05 0x06 0x03 0x2b 0x65 0x70 0x03 0x21 0x00 +ED25519_SPKI_PREFIX = bytes([0x30, 0x2A, 0x30, 0x05, 0x06, 0x03, 0x2B, 0x65, 0x70, 0x03, 0x21, 0x00]) +# SPKI format: 12-byte prefix + 32-byte Ed25519 public key +SPKI_PUBKEY_LENGTH = 44 + + +class MockKMSClient: + """Mock KMS client for local development/testing when AWS credentials are not available. + + This generates an in-memory keypair and simulates KMS signing operations. + WARNING: This is not secure and should only be used for testing. + """ + + def __init__(self) -> None: + print_info("WARNING: Using MockKMSClient with in-memory key pair. Not secure - testing only!") + # Generate an ephemeral keypair for testing + # In production, this would come from actual AWS KMS + self._signing_key = nacl.signing.SigningKey.generate() + self._verify_key = self._signing_key.verify_key + + def sign(self, *, KeyId: str, Message: bytes, MessageType: str, SigningAlgorithm: str) -> dict: # noqa: N803, ARG002 + """Mock sign operation.""" + if not Message: + raise ValueError("No message provided for signing") + + # Sign using PyNaCl (equivalent to Ed25519) + signed = self._signing_key.sign(Message) + return {"Signature": bytes(signed.signature), "SigningAlgorithm": "ED25519_SHA_512"} + + def get_public_key(self, *, KeyId: str) -> dict: # noqa: N803, ARG002 + """Mock get_public_key operation.""" + # Create SPKI format public key (DER-encoded SubjectPublicKeyInfo) + public_key_bytes = bytes(self._verify_key) + spki_key = ED25519_SPKI_PREFIX + public_key_bytes + return {"PublicKey": spki_key, "KeySpec": "ED25519"} + + +class KMSClient(Protocol): + """Protocol for KMS client interface.""" + + def sign(self, *, KeyId: str, Message: bytes, MessageType: str, SigningAlgorithm: str) -> dict: ... # noqa: N803 + def get_public_key(self, *, KeyId: str) -> dict: ... # noqa: N803 + + +def get_kms_client() -> KMSClient: + """Get KMS client - real if AWS_REGION is set, mock otherwise.""" + if os.environ.get("AWS_REGION"): + # Use real AWS KMS + import boto3 + + region = os.environ.get("AWS_REGION") + print_info(f"Using AWS KMS in region: {region}") + return boto3.client("kms", region_name=region) + else: + # Use mock client for testing + return MockKMSClient() + + +def extract_ed25519_pubkey(spki_pubkey: bytes) -> bytes: + """Extract raw Ed25519 public key from SPKI format. + + Args: + spki_pubkey: DER-encoded SubjectPublicKeyInfo + + Returns: + 32-byte Ed25519 public key + + Raises: + ValueError: If the public key format is unexpected + """ + if len(spki_pubkey) != SPKI_PUBKEY_LENGTH: # 12-byte prefix + 32-byte key + raise ValueError(f"Unexpected SPKI public key length: {len(spki_pubkey)} bytes (expected 44)") + + if not spki_pubkey.startswith(ED25519_SPKI_PREFIX): + raise ValueError("Unexpected public key format - not Ed25519 SPKI") + + return spki_pubkey[12:44] # Last 32 bytes are the raw Ed25519 public key + + +def main() -> None: + print_header("AWS KMS Signing Example") + + # Step 1: Initialize KMS client + print_step(1, "Initialize KMS client") + + kms = get_kms_client() + key_id = os.environ.get("KEY_ID", "mock-key-id") + print_info(f"Using Key ID: {key_id}") + + # Step 2: Get public key from KMS + print_step(2, "Retrieve public key from KMS") + + pubkey_response = kms.get_public_key(KeyId=key_id) + spki_pubkey = pubkey_response["PublicKey"] + + if isinstance(spki_pubkey, memoryview): + spki_pubkey = bytes(spki_pubkey) + + print_info(f"Retrieved public key: {len(spki_pubkey)} bytes (SPKI format)") + + # Step 3: Extract raw Ed25519 public key + print_step(3, "Extract raw Ed25519 public key from SPKI") + + ed25519_pubkey = extract_ed25519_pubkey(spki_pubkey) + print_info(f"Extracted Ed25519 public key: {base64.b64encode(ed25519_pubkey).decode()[:20]}...") + + # Step 4: Create raw signer function + print_step(4, "Create RawEd25519Signer using KMS") + + def raw_ed25519_signer(data: bytes) -> bytes: + """Sign data using KMS.""" + response = kms.sign( + KeyId=key_id, + Message=data, + MessageType="RAW", + SigningAlgorithm="ED25519_SHA_512", + ) + signature = response["Signature"] + if signature is None: + raise ValueError("No signature returned from KMS") + if isinstance(signature, memoryview): + return bytes(signature) + return signature + + print_info("Created raw_ed25519_signer function") + + # Step 5: Generate Algorand address with signers + print_step(5, "Generate Algorand address with KMS signers") + + algorand_account = generate_address_with_signers(ed25519_pubkey, raw_ed25519_signer) + print_info(f"Algorand address: {algorand_account.addr}") + + # Step 6: Connect to LocalNet and fund account + print_step(6, "Connect to LocalNet and fund account") + + algorand = AlgorandClient.default_localnet() + print_info("Connected to LocalNet") + + algorand.account.ensure_funded_from_environment(algorand_account.addr, AlgoAmount.from_algo(1)) + print_info("Account funded with 1 ALGO") + + # Step 7: Register signer with AlgorandClient + print_step(7, "Register signer with AlgorandClient") + + algorand.set_signer_from_account(algorand_account) + print_info("Signer registered for address") + + # Step 8: Sign and send payment transaction + print_step(8, "Sign and send payment transaction using KMS") + + pay = algorand.send.payment( + PaymentParams( + sender=algorand_account.addr, + receiver=algorand_account.addr, + amount=AlgoAmount.from_micro_algo(0), + ) + ) + print_info(f"Transaction ID: {pay.tx_ids[0]}") + print_info(f"Confirmed in round: {pay.confirmation.confirmed_round}") + + print_success("AWS KMS signing example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/signing/verify-all.sh b/examples/signing/verify-all.sh new file mode 100755 index 00000000..33d0730e --- /dev/null +++ b/examples/signing/verify-all.sh @@ -0,0 +1,75 @@ +#!/bin/bash + +# verify-all.sh - Run all signing examples and verify they work +# Exit with non-zero code if any example fails + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +cd "$SCRIPT_DIR" + +# Array of example files in order +EXAMPLES=( + "01_ed25519_from_keyring.py" + "02_hd_from_keyring.py" + "03_aws_kms.py" +) + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +NC='\033[0m' # No Color + +echo "========================================" +echo "Signing Examples Verification Script" +echo "========================================" +echo "" + +if [ ${#EXAMPLES[@]} -eq 0 ]; then + echo "No examples to run yet." + echo "" + echo -e "${GREEN}Signing examples suite passed (no examples)${NC}" + exit 0 +fi + +PASSED=0 +FAILED=0 +FAILED_EXAMPLES=() + +for example in "${EXAMPLES[@]}"; do + echo -n "Running $example... " + + if [ ! -f "$example" ]; then + echo -e "${RED}FAILED${NC} (file not found)" + FAILED=$((FAILED + 1)) + FAILED_EXAMPLES+=("$example") + continue + fi + + # Run the example and capture output/exit code + if OUTPUT=$(uv run python "$example" 2>&1); then + echo -e "${GREEN}PASSED${NC}" + PASSED=$((PASSED + 1)) + else + echo -e "${RED}FAILED${NC}" + echo "$OUTPUT" + FAILED=$((FAILED + 1)) + FAILED_EXAMPLES+=("$example") + fi +done + +echo "" +echo "========================================" +echo "Results: ${PASSED} passed, ${FAILED} failed" +echo "========================================" + +if [ $FAILED -gt 0 ]; then + echo "" + echo -e "${RED}Failed examples:${NC}" + for failed in "${FAILED_EXAMPLES[@]}"; do + echo " - $failed" + done + exit 1 +fi + +echo "" +echo -e "${GREEN}All Signing examples passed!${NC}" +exit 0 diff --git a/examples/transact/01_payment_transaction.py b/examples/transact/01_payment_transaction.py new file mode 100644 index 00000000..4c2dc7c8 --- /dev/null +++ b/examples/transact/01_payment_transaction.py @@ -0,0 +1,139 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Payment Transaction + +This example demonstrates how to send ALGO between accounts using the transact package. +It shows the low-level transaction construction pattern with: +- Transaction wrapper with PaymentTransactionFields for receiver and amount +- TransactionType.Payment for the transaction type +- assign_fee() to set transaction fee from suggested params +- Manual signing and submission + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from shared import ( + create_algod_client, + format_algo, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, + wait_for_confirmation, +) + +from algokit_transact import PaymentTransactionFields, Transaction, TransactionType, assign_fee +from algokit_utils import AlgorandClient + + +def main() -> None: + print_header("Payment Transaction Example") + + # Step 1: Initialize clients + print_step(1, "Initialize Algod Client") + algod = create_algod_client() + algorand = AlgorandClient.default_localnet() + + try: + algod.status() + print_info("Connected to LocalNet Algod") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 2: Get a funded account from KMD (sender) + print_step(2, "Get Funded Account from KMD") + sender = algorand.account.localnet_dispenser() + sender_info = algorand.account.get_information(sender.addr) + print_info(f"Sender address: {shorten_address(sender.addr)}") + print_info(f"Sender balance: {format_algo(sender_info.amount)}") + + # Step 3: Generate a new receiver account + print_step(3, "Generate Receiver Account") + receiver = algorand.account.random() + print_info(f"Receiver address: {shorten_address(receiver.addr)}") + + # Check initial receiver balance (should be 0) + receiver_info_before = algorand.account.get_information(receiver.addr) + receiver_balance_before = receiver_info_before.amount.micro_algo + print_info(f"Receiver initial balance: {format_algo(receiver_balance_before)}") + + # Step 4: Get suggested transaction parameters + print_step(4, "Get Suggested Transaction Parameters") + sp = algod.suggested_params() + print_info(f"First valid round: {sp.first_valid}") + print_info(f"Last valid round: {sp.last_valid}") + print_info(f"Min fee: {sp.min_fee} microALGO") + + # Step 5: Create payment transaction + print_step(5, "Create Payment Transaction") + payment_amount = 1_000_000 # 1 ALGO in microALGO + + # Create the transaction with Transaction wrapper and PaymentTransactionFields + transaction_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=sender.addr, + first_valid=sp.first_valid, + last_valid=sp.last_valid, + genesis_hash=sp.genesis_hash, + genesis_id=sp.genesis_id, + payment=PaymentTransactionFields( + receiver=receiver.addr, + amount=payment_amount, + ), + ) + + print_info(f"Transaction type: {transaction_without_fee.transaction_type}") + print_info(f"Amount: {format_algo(payment_amount)}") + print_info(f"Receiver: {shorten_address(receiver.addr)}") + + # Step 6: Assign fee using suggested params + print_step(6, "Assign Transaction Fee") + transaction = assign_fee( + transaction_without_fee, + fee_per_byte=sp.fee, + min_fee=sp.min_fee, + ) + print_info(f"Assigned fee: {transaction.fee} microALGO") + + # Step 7: Sign the transaction + print_step(7, "Sign Transaction") + signed_txns = sender.signer([transaction], [0]) + tx_id = transaction.tx_id() + print_info(f"Transaction ID: {tx_id}") + print_info("Transaction signed successfully") + + # Step 8: Submit transaction and wait for confirmation + print_step(8, "Submit Transaction and Wait for Confirmation") + algod.send_raw_transaction(signed_txns[0]) + print_info("Transaction submitted to network") + + # Wait for confirmation using the utility function + pending_info = wait_for_confirmation(algod, tx_id) + confirmed_round = pending_info.confirmed_round + print_info(f"Transaction confirmed in round: {confirmed_round}") + + # Step 9: Verify receiver balance increased + print_step(9, "Verify Receiver Balance") + receiver_info_after = algorand.account.get_information(receiver.addr) + receiver_balance_after = receiver_info_after.amount.micro_algo + print_info(f"Receiver balance after: {format_algo(receiver_balance_after)}") + + balance_increase = receiver_balance_after - receiver_balance_before + print_info(f"Balance increase: {format_algo(balance_increase)}") + + # Verify the balance increased by the sent amount + if balance_increase == payment_amount: + print_success(f"Payment of {format_algo(payment_amount)} completed successfully!") + else: + raise ValueError(f"Expected balance increase of {payment_amount}, but got {balance_increase}") + + print_success("Payment transaction example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/transact/02_payment_close.py b/examples/transact/02_payment_close.py new file mode 100644 index 00000000..aa04a521 --- /dev/null +++ b/examples/transact/02_payment_close.py @@ -0,0 +1,186 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Payment with Close + +This example demonstrates how to close an account by transferring all remaining +ALGO to another account using the close_remainder_to field in PaymentTransactionFields. + +Key concepts: +- close_remainder_to: Specifies an account to receive all remaining ALGO after the transaction +- When an account is closed, its balance becomes 0 +- The close-to account receives: (original balance - sent amount - fee) + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from shared import ( + create_algod_client, + format_algo, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, + wait_for_confirmation, +) + +from algokit_transact import PaymentTransactionFields, Transaction, TransactionType, assign_fee +from algokit_utils import AlgorandClient + + +def main() -> None: + print_header("Payment with Close Example") + + # Step 1: Initialize clients + print_step(1, "Initialize Algod Client") + algod = create_algod_client() + algorand = AlgorandClient.default_localnet() + + try: + algod.status() + print_info("Connected to LocalNet Algod") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 2: Get a funded account from KMD (funding source) + print_step(2, "Get Funded Account from KMD") + funding_account = algorand.account.localnet_dispenser() + print_info(f"Funding account: {shorten_address(funding_account.addr)}") + + # Step 3: Generate temporary account to be closed + print_step(3, "Generate Temporary Account (will be closed)") + temp_account = algorand.account.random() + print_info(f"Temporary account: {shorten_address(temp_account.addr)}") + + # Step 4: Generate close-to account (receives remaining balance) + print_step(4, "Generate Close-To Account (receives remainder)") + close_to_account = algorand.account.random() + print_info(f"Close-to account: {shorten_address(close_to_account.addr)}") + + # Step 5: Fund the temporary account + print_step(5, "Fund Temporary Account") + fund_amount = 2_000_000 # 2 ALGO in microALGO (enough to cover min balance + tx amount + fee) + + sp = algod.suggested_params() + + fund_tx_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=funding_account.addr, + first_valid=sp.first_valid, + last_valid=sp.last_valid, + genesis_hash=sp.genesis_hash, + genesis_id=sp.genesis_id, + payment=PaymentTransactionFields( + receiver=temp_account.addr, + amount=fund_amount, + ), + ) + + fund_tx = assign_fee( + fund_tx_without_fee, + fee_per_byte=sp.fee, + min_fee=sp.min_fee, + ) + + signed_fund_txns = funding_account.signer([fund_tx], [0]) + algod.send_raw_transaction(signed_fund_txns[0]) + wait_for_confirmation(algod, fund_tx.tx_id()) + + temp_balance_after_fund_info = algorand.account.get_information(temp_account.addr) + temp_balance_after_fund = temp_balance_after_fund_info.amount.micro_algo + print_info(f"Funded temporary account with: {format_algo(fund_amount)}") + print_info(f"Temporary account balance: {format_algo(temp_balance_after_fund)}") + + # Step 6: Record initial close-to account balance + print_step(6, "Check Initial Close-To Account Balance") + close_to_balance_before_info = algorand.account.get_information(close_to_account.addr) + close_to_balance_before = close_to_balance_before_info.amount.micro_algo + print_info(f"Close-to account initial balance: {format_algo(close_to_balance_before)}") + + # Step 7: Create payment transaction with close_remainder_to + print_step(7, "Create Payment Transaction with close_remainder_to") + sp = algod.suggested_params() + payment_amount = 100_000 # 0.1 ALGO sent to funding account (can be 0) + + # The key field: close_remainder_to specifies where remaining balance goes + close_tx_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=temp_account.addr, + first_valid=sp.first_valid, + last_valid=sp.last_valid, + genesis_hash=sp.genesis_hash, + genesis_id=sp.genesis_id, + payment=PaymentTransactionFields( + receiver=funding_account.addr, # Send a small amount to funding account + amount=payment_amount, + close_remainder_to=close_to_account.addr, # All remaining balance goes here + ), + ) + + print_info(f"Payment amount: {format_algo(payment_amount)}") + print_info(f"close_remainder_to: {shorten_address(close_to_account.addr)}") + + # Step 8: Assign fee and sign the transaction + print_step(8, "Assign Fee and Sign Transaction") + close_tx = assign_fee( + close_tx_without_fee, + fee_per_byte=sp.fee, + min_fee=sp.min_fee, + ) + tx_fee = close_tx.fee or 0 + print_info(f"Transaction fee: {tx_fee} microALGO") + + # Calculate expected remainder before signing + expected_remainder = temp_balance_after_fund - payment_amount - tx_fee + print_info(f"Expected remainder to close-to account: {format_algo(expected_remainder)}") + + # Sign using the temp account's signer + signed_close_txns = temp_account.signer([close_tx], [0]) + tx_id = close_tx.tx_id() + print_info(f"Transaction ID: {tx_id}") + + # Step 9: Submit and confirm the close transaction + print_step(9, "Submit Close Transaction") + algod.send_raw_transaction(signed_close_txns[0]) + print_info("Transaction submitted to network") + + pending_info = wait_for_confirmation(algod, tx_id) + confirmed_round = pending_info.confirmed_round + print_info(f"Transaction confirmed in round: {confirmed_round}") + + # Step 10: Verify closed account has 0 balance + print_step(10, "Verify Closed Account Balance") + temp_balance_after_close_info = algorand.account.get_information(temp_account.addr) + temp_balance_after_close = temp_balance_after_close_info.amount.micro_algo + print_info(f"Temporary account balance after close: {format_algo(temp_balance_after_close)}") + + if temp_balance_after_close == 0: + print_success("Temporary account successfully closed (balance is 0)") + else: + raise ValueError(f"Expected closed account to have 0 balance, but got {temp_balance_after_close}") + + # Step 11: Verify close-to account received the remainder + print_step(11, "Verify Close-To Account Received Remainder") + close_to_balance_after_info = algorand.account.get_information(close_to_account.addr) + close_to_balance_after = close_to_balance_after_info.amount.micro_algo + print_info(f"Close-to account balance after: {format_algo(close_to_balance_after)}") + + actual_remainder = close_to_balance_after - close_to_balance_before + print_info(f"Actual remainder received: {format_algo(actual_remainder)}") + print_info(f"Expected remainder: {format_algo(expected_remainder)}") + + # Verify the close-to account received the expected remainder + if actual_remainder == expected_remainder: + print_success(f"Close-to account received correct remainder of {format_algo(expected_remainder)}") + else: + raise ValueError(f"Expected remainder {expected_remainder}, but got {actual_remainder}") + + print_success("Payment with close example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/transact/03_asset_create.py b/examples/transact/03_asset_create.py new file mode 100644 index 00000000..aa0c4748 --- /dev/null +++ b/examples/transact/03_asset_create.py @@ -0,0 +1,209 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Asset Create + +This example demonstrates how to create a new Algorand Standard Asset (ASA) using +the transact package. It shows the low-level transaction construction pattern with: +- Transaction wrapper with AssetConfigTransactionFields for all configuration options +- TransactionType.AssetConfig for the transaction type +- Retrieving created asset ID from pending transaction info +- Verifying asset parameters and creator holdings + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from shared import ( + create_algod_client, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, + wait_for_confirmation, +) + +from algokit_transact import AssetConfigTransactionFields, Transaction, TransactionType, assign_fee +from algokit_utils import AlgorandClient + + +def main() -> None: + print_header("Asset Create Example") + + # Step 1: Initialize clients + print_step(1, "Initialize Algod Client") + algod = create_algod_client() + algorand = AlgorandClient.default_localnet() + + try: + algod.status() + print_info("Connected to LocalNet Algod") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 2: Get a funded account from KMD (creator) + print_step(2, "Get Funded Account from KMD (Asset Creator)") + creator = algorand.account.localnet_dispenser() + print_info(f"Creator address: {shorten_address(creator.addr)}") + + # Step 3: Get suggested transaction parameters + print_step(3, "Get Suggested Transaction Parameters") + sp = algod.suggested_params() + print_info(f"First valid round: {sp.first_valid}") + print_info(f"Last valid round: {sp.last_valid}") + print_info(f"Min fee: {sp.min_fee} microALGO") + + # Step 4: Define asset configuration with all fields + print_step(4, "Define Asset Configuration") + + # Asset parameters + asset_total = 1_000_000_000_000 # 1 million units with 6 decimals + asset_decimals = 6 + asset_name = "Example Token" + asset_unit_name = "EXMPL" + asset_url = "https://example.com/asset" + default_frozen = False + + print_info(f"Asset name: {asset_name}") + print_info(f"Unit name: {asset_unit_name}") + display_total = asset_total / (10**asset_decimals) + print_info(f"Total supply: {asset_total} ({display_total:,.0f} {asset_unit_name})") + print_info(f"Decimals: {asset_decimals}") + print_info(f"Default frozen: {default_frozen}") + print_info(f"URL: {asset_url}") + print_info(f"Manager: {shorten_address(creator.addr)}") + print_info(f"Reserve: {shorten_address(creator.addr)}") + print_info(f"Freeze: {shorten_address(creator.addr)}") + print_info(f"Clawback: {shorten_address(creator.addr)}") + + # Step 5: Create asset config transaction + print_step(5, "Create Asset Config Transaction") + + # Asset configuration fields - asset_id=0 indicates asset creation + transaction_without_fee = Transaction( + transaction_type=TransactionType.AssetConfig, + sender=creator.addr, + first_valid=sp.first_valid, + last_valid=sp.last_valid, + genesis_hash=sp.genesis_hash, + genesis_id=sp.genesis_id, + asset_config=AssetConfigTransactionFields( + asset_id=0, # 0 indicates asset creation + total=asset_total, + decimals=asset_decimals, + default_frozen=default_frozen, + asset_name=asset_name, + unit_name=asset_unit_name, + url=asset_url, + # Management addresses - all set to creator + manager=creator.addr, # Can reconfigure asset + reserve=creator.addr, # Holds non-minted units + freeze=creator.addr, # Can freeze/unfreeze accounts + clawback=creator.addr, # Can clawback assets + ), + ) + + print_info(f"Transaction type: {transaction_without_fee.transaction_type}") + + # Step 6: Assign fee using suggested params + print_step(6, "Assign Transaction Fee") + transaction = assign_fee( + transaction_without_fee, + fee_per_byte=sp.fee, + min_fee=sp.min_fee, + ) + print_info(f"Assigned fee: {transaction.fee} microALGO") + + # Step 7: Sign the transaction + print_step(7, "Sign Transaction") + signed_txns = creator.signer([transaction], [0]) + tx_id = transaction.tx_id() + print_info(f"Transaction ID: {tx_id}") + print_info("Transaction signed successfully") + + # Step 8: Submit transaction and wait for confirmation + print_step(8, "Submit Transaction and Wait for Confirmation") + algod.send_raw_transaction(signed_txns[0]) + print_info("Transaction submitted to network") + + # Wait for confirmation using the utility function + pending_info = wait_for_confirmation(algod, tx_id) + confirmed_round = pending_info.confirmed_round + print_info(f"Transaction confirmed in round: {confirmed_round}") + + # Step 9: Retrieve created asset ID from pending transaction info + print_step(9, "Retrieve Created Asset ID") + asset_id = pending_info.asset_id + if not asset_id: + raise ValueError("Asset ID not found in pending transaction response") + print_info(f"Created asset ID: {asset_id}") + print_success(f"Asset created with ID: {asset_id}") + + # Step 10: Verify asset exists with correct parameters using algod.asset_by_id() + print_step(10, "Verify Asset Parameters") + asset_info = algod.asset_by_id(asset_id) + params = asset_info.params + + print_info(f"Asset ID from API: {asset_info.id_}") + print_info(f"Creator: {params.creator}") + print_info(f"Total: {params.total}") + print_info(f"Decimals: {params.decimals}") + print_info(f"Name: {params.name}") + print_info(f"Unit Name: {params.unit_name}") + print_info(f"URL: {params.url}") + print_info(f"Default Frozen: {params.default_frozen}") + print_info(f"Manager: {params.manager}") + print_info(f"Reserve: {params.reserve}") + print_info(f"Freeze: {params.freeze}") + print_info(f"Clawback: {params.clawback}") + + # Verify all parameters match + creator_address = creator.addr + if params.total != asset_total: + raise ValueError(f"Total mismatch: expected {asset_total}, got {params.total}") + if params.decimals != asset_decimals: + raise ValueError(f"Decimals mismatch: expected {asset_decimals}, got {params.decimals}") + if params.name != asset_name: + raise ValueError(f"Name mismatch: expected {asset_name}, got {params.name}") + if params.unit_name != asset_unit_name: + raise ValueError(f"Unit name mismatch: expected {asset_unit_name}, got {params.unit_name}") + if params.url != asset_url: + raise ValueError(f"URL mismatch: expected {asset_url}, got {params.url}") + if params.creator != creator_address: + raise ValueError(f"Creator mismatch: expected {creator_address}, got {params.creator}") + if params.manager != creator_address: + raise ValueError(f"Manager mismatch: expected {creator_address}, got {params.manager}") + if params.reserve != creator_address: + raise ValueError(f"Reserve mismatch: expected {creator_address}, got {params.reserve}") + if params.freeze != creator_address: + raise ValueError(f"Freeze mismatch: expected {creator_address}, got {params.freeze}") + if params.clawback != creator_address: + raise ValueError(f"Clawback mismatch: expected {creator_address}, got {params.clawback}") + + print_success("All asset parameters verified correctly!") + + # Step 11: Verify creator holds total supply + print_step(11, "Verify Creator Holds Total Supply") + account_asset_info = algod.account_asset_information(creator_address, asset_id) + + asset_holding = account_asset_info.asset_holding + if not asset_holding: + raise ValueError("Creator does not have asset holding") + + creator_balance = asset_holding.amount + display_balance = creator_balance / (10**asset_decimals) + print_info(f"Creator balance: {creator_balance} ({display_balance:,.0f} {asset_unit_name})") + print_info(f"Total supply: {asset_total}") + + if creator_balance != asset_total: + raise ValueError(f"Creator balance {creator_balance} does not match total supply {asset_total}") + + print_success(f"Creator holds entire supply: {creator_balance} units") + print_success("Asset create example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/transact/04_asset_transfer.py b/examples/transact/04_asset_transfer.py new file mode 100644 index 00000000..b9c20236 --- /dev/null +++ b/examples/transact/04_asset_transfer.py @@ -0,0 +1,265 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Asset Transfer + +This example demonstrates the full asset transfer flow using the transact package: +1. Create a new Algorand Standard Asset (ASA) +2. Opt-in: receiver sends 0 amount of the asset to themselves +3. Transfer assets from creator to the opted-in receiver +4. Verify receiver's asset balance after transfer + +Uses Transaction wrapper with AssetConfigTransactionFields, AssetTransferTransactionFields, +and PaymentTransactionFields. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from shared import ( + create_algod_client, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, + wait_for_confirmation, +) + +from algokit_transact import ( + AssetConfigTransactionFields, + AssetTransferTransactionFields, + PaymentTransactionFields, + Transaction, + TransactionType, + assign_fee, +) +from algokit_utils import AlgorandClient + + +def main() -> None: + print_header("Asset Transfer Example") + + # Step 1: Initialize clients + print_step(1, "Initialize Algod Client") + algod = create_algod_client() + algorand = AlgorandClient.default_localnet() + + try: + algod.status() + print_info("Connected to LocalNet Algod") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 2: Get creator account from KMD + print_step(2, "Get Creator Account from KMD") + creator = algorand.account.localnet_dispenser() + print_info(f"Creator address: {shorten_address(creator.addr)}") + + # Step 3: Get suggested transaction parameters + print_step(3, "Get Suggested Transaction Parameters") + sp = algod.suggested_params() + print_info(f"First valid round: {sp.first_valid}") + print_info(f"Last valid round: {sp.last_valid}") + print_info(f"Min fee: {sp.min_fee} microALGO") + + # Step 4: Generate and fund receiver account + print_step(4, "Generate and Fund Receiver Account") + + # Generate a new account for the receiver + receiver = algorand.account.random() + print_info(f"Receiver address: {shorten_address(receiver.addr)}") + + # Fund the receiver with enough ALGO to cover transaction fees using low-level transaction + funding_amount = 1_000_000 # 1 ALGO in microALGO + + fund_tx_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=creator.addr, + first_valid=sp.first_valid, + last_valid=sp.last_valid, + genesis_hash=sp.genesis_hash, + genesis_id=sp.genesis_id, + payment=PaymentTransactionFields( + receiver=receiver.addr, + amount=funding_amount, + ), + ) + + fund_tx = assign_fee( + fund_tx_without_fee, + fee_per_byte=sp.fee, + min_fee=sp.min_fee, + ) + + signed_fund_tx = creator.signer([fund_tx], [0]) + algod.send_raw_transaction(signed_fund_tx[0]) + wait_for_confirmation(algod, fund_tx.tx_id()) + print_info("Funded receiver with 1 ALGO for transaction fees") + + # Step 5: Create a new asset + print_step(5, "Create New Asset") + + # Asset parameters + asset_total = 10_000_000_000 # 10,000 units with 6 decimals + asset_decimals = 6 + asset_name = "Transfer Test Token" + asset_unit_name = "TTT" + + display_total = asset_total / (10**asset_decimals) + print_info(f"Creating asset: {asset_name} ({asset_unit_name})") + print_info(f"Total supply: {asset_total} ({display_total:,.0f} {asset_unit_name})") + + # Create asset config transaction + create_asset_tx_without_fee = Transaction( + transaction_type=TransactionType.AssetConfig, + sender=creator.addr, + first_valid=sp.first_valid, + last_valid=sp.last_valid, + genesis_hash=sp.genesis_hash, + genesis_id=sp.genesis_id, + asset_config=AssetConfigTransactionFields( + asset_id=0, # 0 indicates asset creation + total=asset_total, + decimals=asset_decimals, + default_frozen=False, + asset_name=asset_name, + unit_name=asset_unit_name, + url="https://example.com/transfer-token", + manager=creator.addr, + reserve=creator.addr, + freeze=creator.addr, + clawback=creator.addr, + ), + ) + + create_asset_tx = assign_fee( + create_asset_tx_without_fee, + fee_per_byte=sp.fee, + min_fee=sp.min_fee, + ) + + # Sign and submit asset creation transaction + signed_create_tx = creator.signer([create_asset_tx], [0]) + create_tx_id = create_asset_tx.tx_id() + algod.send_raw_transaction(signed_create_tx[0]) + print_info(f"Asset creation transaction submitted: {create_tx_id}") + + create_pending_info = wait_for_confirmation(algod, create_tx_id) + asset_id = create_pending_info.asset_id + if not asset_id: + raise ValueError("Asset ID not found in pending transaction response") + print_info(f"Asset created with ID: {asset_id}") + print_success(f"Asset {asset_name} (ID: {asset_id}) created successfully!") + + # Step 6: Opt-in - Receiver sends 0 amount to themselves + print_step(6, "Opt-in: Receiver Opts Into the Asset") + print_info("Opt-in is done by sending 0 amount of the asset to yourself") + + # Refresh suggested params for the new transaction + opt_in_sp = algod.suggested_params() + + opt_in_tx_without_fee = Transaction( + transaction_type=TransactionType.AssetTransfer, + sender=receiver.addr, # Receiver is the sender for opt-in + first_valid=opt_in_sp.first_valid, + last_valid=opt_in_sp.last_valid, + genesis_hash=opt_in_sp.genesis_hash, + genesis_id=opt_in_sp.genesis_id, + asset_transfer=AssetTransferTransactionFields( + asset_id=asset_id, + receiver=receiver.addr, # Receiver sends to themselves + amount=0, # 0 amount for opt-in + ), + ) + + opt_in_tx = assign_fee( + opt_in_tx_without_fee, + fee_per_byte=opt_in_sp.fee, + min_fee=opt_in_sp.min_fee, + ) + + # Sign and submit opt-in transaction + signed_opt_in_tx = receiver.signer([opt_in_tx], [0]) + opt_in_tx_id = opt_in_tx.tx_id() + algod.send_raw_transaction(signed_opt_in_tx[0]) + print_info(f"Opt-in transaction submitted: {opt_in_tx_id}") + + wait_for_confirmation(algod, opt_in_tx_id) + print_info(f"Receiver opted into asset ID: {asset_id}") + print_success("Receiver successfully opted into the asset!") + + # Verify receiver has 0 balance after opt-in + receiver_asset_info_after_opt_in = algod.account_asset_information(receiver.addr, asset_id) + balance_after_opt_in = receiver_asset_info_after_opt_in.asset_holding.amount + print_info(f"Receiver asset balance after opt-in: {balance_after_opt_in}") + + # Step 7: Transfer assets from creator to receiver + print_step(7, "Transfer Assets from Creator to Receiver") + + transfer_amount = 1_000_000_000 # 1,000 units (with 6 decimals) + display_transfer = transfer_amount / (10**asset_decimals) + print_info(f"Transferring {transfer_amount} ({display_transfer:,.0f} {asset_unit_name}) to receiver") + + # Refresh suggested params for the transfer transaction + transfer_sp = algod.suggested_params() + + transfer_tx_without_fee = Transaction( + transaction_type=TransactionType.AssetTransfer, + sender=creator.addr, # Creator sends the assets + first_valid=transfer_sp.first_valid, + last_valid=transfer_sp.last_valid, + genesis_hash=transfer_sp.genesis_hash, + genesis_id=transfer_sp.genesis_id, + asset_transfer=AssetTransferTransactionFields( + asset_id=asset_id, + receiver=receiver.addr, + amount=transfer_amount, + ), + ) + + transfer_tx = assign_fee( + transfer_tx_without_fee, + fee_per_byte=transfer_sp.fee, + min_fee=transfer_sp.min_fee, + ) + + # Sign and submit transfer transaction + signed_transfer_tx = creator.signer([transfer_tx], [0]) + transfer_tx_id = transfer_tx.tx_id() + algod.send_raw_transaction(signed_transfer_tx[0]) + print_info(f"Transfer transaction submitted: {transfer_tx_id}") + + wait_for_confirmation(algod, transfer_tx_id) + print_success(f"Transferred {display_transfer:,.0f} {asset_unit_name} to receiver!") + + # Step 8: Verify receiver's asset balance after transfer + print_step(8, "Verify Receiver Asset Balance After Transfer") + + receiver_asset_info_after_transfer = algod.account_asset_information(receiver.addr, asset_id) + receiver_balance = receiver_asset_info_after_transfer.asset_holding.amount + display_receiver_balance = receiver_balance / (10**asset_decimals) + print_info(f"Receiver asset balance: {receiver_balance} ({display_receiver_balance:,.0f} {asset_unit_name})") + + if receiver_balance != transfer_amount: + raise ValueError(f"Balance mismatch: expected {transfer_amount}, got {receiver_balance}") + print_success(f"Receiver balance verified: {display_receiver_balance:,.0f} {asset_unit_name}") + + # Also verify creator's remaining balance + creator_asset_info_after_transfer = algod.account_asset_information(creator.addr, asset_id) + creator_balance = creator_asset_info_after_transfer.asset_holding.amount + expected_creator_balance = asset_total - transfer_amount + display_creator_balance = creator_balance / (10**asset_decimals) + print_info(f"Creator remaining balance: {creator_balance} ({display_creator_balance:,.0f} {asset_unit_name})") + + if creator_balance != expected_creator_balance: + raise ValueError(f"Creator balance mismatch: expected {expected_creator_balance}, got {creator_balance}") + print_success(f"Creator balance verified: {display_creator_balance:,.0f} {asset_unit_name}") + + print_success("Asset transfer example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/transact/05_asset_freeze.py b/examples/transact/05_asset_freeze.py new file mode 100644 index 00000000..86b95044 --- /dev/null +++ b/examples/transact/05_asset_freeze.py @@ -0,0 +1,394 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Asset Freeze + +This example demonstrates how to freeze and unfreeze asset holdings using +the transact package: +1. Create an asset with freeze address set +2. Transfer assets to another account +3. Freeze the account's asset holdings (prevent transfers) +4. Verify frozen account cannot transfer +5. Unfreeze the account's asset holdings +6. Verify account can transfer after unfreeze + +Uses AssetFreezeTransactionFields with TransactionType.AssetFreeze. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from shared import ( + create_algod_client, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, + wait_for_confirmation, +) + +from algokit_transact import ( + AssetConfigTransactionFields, + AssetFreezeTransactionFields, + AssetTransferTransactionFields, + PaymentTransactionFields, + Transaction, + TransactionType, + assign_fee, +) +from algokit_utils import AlgorandClient + + +def main() -> None: + print_header("Asset Freeze Example") + + # Step 1: Initialize clients + print_step(1, "Initialize Algod Client") + algod = create_algod_client() + algorand = AlgorandClient.default_localnet() + + try: + algod.status() + print_info("Connected to LocalNet Algod") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 2: Get freeze manager account from KMD + print_step(2, "Get Freeze Manager Account from KMD") + freeze_manager = algorand.account.localnet_dispenser() + print_info(f"Freeze manager address: {shorten_address(freeze_manager.addr)}") + + # Step 3: Get suggested transaction parameters + print_step(3, "Get Suggested Transaction Parameters") + suggested_params = algod.suggested_params() + print_info(f"First valid round: {suggested_params.first_valid}") + print_info(f"Last valid round: {suggested_params.last_valid}") + print_info(f"Min fee: {suggested_params.min_fee} microALGO") + + # Step 4: Generate and fund holder account + print_step(4, "Generate and Fund Holder Account") + holder = algorand.account.random() + print_info(f"Holder address: {shorten_address(holder.addr)}") + + # Fund the holder with enough ALGO to cover transaction fees + funding_amount = 1_000_000 # 1 ALGO in microALGO + + fund_tx_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=freeze_manager.addr, + first_valid=suggested_params.first_valid, + last_valid=suggested_params.last_valid, + genesis_hash=suggested_params.genesis_hash, + genesis_id=suggested_params.genesis_id, + payment=PaymentTransactionFields( + receiver=holder.addr, + amount=funding_amount, + ), + ) + + fund_tx = assign_fee( + fund_tx_without_fee, + fee_per_byte=suggested_params.fee, + min_fee=suggested_params.min_fee, + ) + + signed_fund_tx = freeze_manager.signer([fund_tx], [0]) + algod.send_raw_transaction(signed_fund_tx[0]) + wait_for_confirmation(algod, fund_tx.tx_id()) + print_info("Funded holder with 1 ALGO for transaction fees") + + # Step 5: Create an asset with freeze address set + print_step(5, "Create Asset with Freeze Address Set") + + asset_total = 10_000_000_000 # 10,000 units with 6 decimals + asset_decimals = 6 + asset_name = "Freezable Token" + asset_unit_name = "FRZ" + + print_info(f"Creating asset: {asset_name} ({asset_unit_name})") + print_info(f"Freeze address set to: {shorten_address(freeze_manager.addr)}") + + create_asset_tx_without_fee = Transaction( + transaction_type=TransactionType.AssetConfig, + sender=freeze_manager.addr, + first_valid=suggested_params.first_valid, + last_valid=suggested_params.last_valid, + genesis_hash=suggested_params.genesis_hash, + genesis_id=suggested_params.genesis_id, + asset_config=AssetConfigTransactionFields( + asset_id=0, # 0 indicates asset creation + total=asset_total, + decimals=asset_decimals, + default_frozen=False, + asset_name=asset_name, + unit_name=asset_unit_name, + url="https://example.com/freezable-token", + manager=freeze_manager.addr, + reserve=freeze_manager.addr, + freeze=freeze_manager.addr, # IMPORTANT: Set freeze address to enable freezing + clawback=freeze_manager.addr, + ), + ) + + create_asset_tx = assign_fee( + create_asset_tx_without_fee, + fee_per_byte=suggested_params.fee, + min_fee=suggested_params.min_fee, + ) + + signed_create_tx = freeze_manager.signer([create_asset_tx], [0]) + algod.send_raw_transaction(signed_create_tx[0]) + + create_pending_info = wait_for_confirmation(algod, create_asset_tx.tx_id()) + asset_id = create_pending_info.asset_id + if not asset_id: + raise ValueError("Asset ID not found in pending transaction response") + print_info(f"Asset created with ID: {asset_id}") + print_success(f"Asset {asset_name} (ID: {asset_id}) created with freeze capability!") + + # Step 6: Holder opts into the asset + print_step(6, "Holder Opts Into the Asset") + + opt_in_suggested_params = algod.suggested_params() + + opt_in_tx_without_fee = Transaction( + transaction_type=TransactionType.AssetTransfer, + sender=holder.addr, + first_valid=opt_in_suggested_params.first_valid, + last_valid=opt_in_suggested_params.last_valid, + genesis_hash=opt_in_suggested_params.genesis_hash, + genesis_id=opt_in_suggested_params.genesis_id, + asset_transfer=AssetTransferTransactionFields( + asset_id=asset_id, + receiver=holder.addr, + amount=0, # 0 amount for opt-in + ), + ) + + opt_in_tx = assign_fee( + opt_in_tx_without_fee, + fee_per_byte=opt_in_suggested_params.fee, + min_fee=opt_in_suggested_params.min_fee, + ) + + signed_opt_in_tx = holder.signer([opt_in_tx], [0]) + algod.send_raw_transaction(signed_opt_in_tx[0]) + wait_for_confirmation(algod, opt_in_tx.tx_id()) + print_info("Holder opted into the asset") + print_success("Holder successfully opted into the asset!") + + # Step 7: Transfer assets from creator to holder + print_step(7, "Transfer Assets to Holder") + + transfer_amount = 1_000_000_000 # 1,000 units + display_transfer = transfer_amount / (10**asset_decimals) + print_info(f"Transferring {display_transfer:,.0f} {asset_unit_name} to holder") + + transfer_suggested_params = algod.suggested_params() + + transfer_tx_without_fee = Transaction( + transaction_type=TransactionType.AssetTransfer, + sender=freeze_manager.addr, + first_valid=transfer_suggested_params.first_valid, + last_valid=transfer_suggested_params.last_valid, + genesis_hash=transfer_suggested_params.genesis_hash, + genesis_id=transfer_suggested_params.genesis_id, + asset_transfer=AssetTransferTransactionFields( + asset_id=asset_id, + receiver=holder.addr, + amount=transfer_amount, + ), + ) + + transfer_tx = assign_fee( + transfer_tx_without_fee, + fee_per_byte=transfer_suggested_params.fee, + min_fee=transfer_suggested_params.min_fee, + ) + + signed_transfer_tx = freeze_manager.signer([transfer_tx], [0]) + algod.send_raw_transaction(signed_transfer_tx[0]) + wait_for_confirmation(algod, transfer_tx.tx_id()) + + # Verify holder's balance + holder_asset_info = algod.account_asset_information(holder.addr, asset_id) + holder_balance = holder_asset_info.asset_holding.amount + holder_frozen = holder_asset_info.asset_holding.is_frozen + display_holder_balance = holder_balance / (10**asset_decimals) + print_info(f"Holder balance: {holder_balance} ({display_holder_balance:,.0f} {asset_unit_name})") + print_info(f"Holder frozen status: {holder_frozen}") + print_success(f"Transferred {display_transfer:,.0f} {asset_unit_name} to holder!") + + # Step 8: Freeze the holder's account + print_step(8, "Freeze Holder Account (TransactionType.AssetFreeze)") + print_info("Using AssetFreezeTransactionFields with asset_id, freeze_target, and frozen=True") + + freeze_suggested_params = algod.suggested_params() + + freeze_tx_without_fee = Transaction( + transaction_type=TransactionType.AssetFreeze, + sender=freeze_manager.addr, # Must be the freeze address of the asset + first_valid=freeze_suggested_params.first_valid, + last_valid=freeze_suggested_params.last_valid, + genesis_hash=freeze_suggested_params.genesis_hash, + genesis_id=freeze_suggested_params.genesis_id, + asset_freeze=AssetFreezeTransactionFields( + asset_id=asset_id, + freeze_target=holder.addr, + frozen=True, # Freeze the account + ), + ) + + freeze_tx = assign_fee( + freeze_tx_without_fee, + fee_per_byte=freeze_suggested_params.fee, + min_fee=freeze_suggested_params.min_fee, + ) + + signed_freeze_tx = freeze_manager.signer([freeze_tx], [0]) + algod.send_raw_transaction(signed_freeze_tx[0]) + wait_for_confirmation(algod, freeze_tx.tx_id()) + + # Verify frozen status + holder_asset_info_after_freeze = algod.account_asset_information(holder.addr, asset_id) + is_frozen = holder_asset_info_after_freeze.asset_holding.is_frozen + print_info(f"Holder frozen status after freeze: {is_frozen}") + + if not is_frozen: + raise ValueError("Account should be frozen but is not") + print_success("Holder account successfully frozen!") + + # Step 9: Verify frozen account cannot transfer + print_step(9, "Verify Frozen Account Cannot Transfer") + print_info("Attempting to transfer assets from frozen account (should fail)...") + + failed_transfer_suggested_params = algod.suggested_params() + + failed_transfer_tx_without_fee = Transaction( + transaction_type=TransactionType.AssetTransfer, + sender=holder.addr, # Frozen account trying to send + first_valid=failed_transfer_suggested_params.first_valid, + last_valid=failed_transfer_suggested_params.last_valid, + genesis_hash=failed_transfer_suggested_params.genesis_hash, + genesis_id=failed_transfer_suggested_params.genesis_id, + asset_transfer=AssetTransferTransactionFields( + asset_id=asset_id, + receiver=freeze_manager.addr, # Try to send back to creator + amount=100_000_000, # 100 units + ), + ) + + failed_transfer_tx = assign_fee( + failed_transfer_tx_without_fee, + fee_per_byte=failed_transfer_suggested_params.fee, + min_fee=failed_transfer_suggested_params.min_fee, + ) + + signed_failed_transfer_tx = holder.signer([failed_transfer_tx], [0]) + + try: + algod.send_raw_transaction(signed_failed_transfer_tx[0]) + wait_for_confirmation(algod, failed_transfer_tx.tx_id()) + raise ValueError("Transfer should have failed for frozen account") + except Exception as error: + error_message = str(error) + if "frozen" in error_message.lower() or "rejected" in error_message.lower(): + print_info(f"Transfer correctly rejected: {error_message[:100]}...") + print_success("Verified: Frozen account cannot transfer assets!") + elif "Transfer should have failed" in error_message: + raise + else: + print_info(f"Transfer rejected with error: {error_message[:100]}...") + print_success("Verified: Frozen account cannot transfer assets!") + + # Step 10: Unfreeze the holder's account + print_step(10, "Unfreeze Holder Account") + print_info("Using AssetFreezeTransactionFields with frozen=False") + + unfreeze_suggested_params = algod.suggested_params() + + unfreeze_tx_without_fee = Transaction( + transaction_type=TransactionType.AssetFreeze, + sender=freeze_manager.addr, + first_valid=unfreeze_suggested_params.first_valid, + last_valid=unfreeze_suggested_params.last_valid, + genesis_hash=unfreeze_suggested_params.genesis_hash, + genesis_id=unfreeze_suggested_params.genesis_id, + asset_freeze=AssetFreezeTransactionFields( + asset_id=asset_id, + freeze_target=holder.addr, + frozen=False, # Unfreeze the account + ), + ) + + unfreeze_tx = assign_fee( + unfreeze_tx_without_fee, + fee_per_byte=unfreeze_suggested_params.fee, + min_fee=unfreeze_suggested_params.min_fee, + ) + + signed_unfreeze_tx = freeze_manager.signer([unfreeze_tx], [0]) + algod.send_raw_transaction(signed_unfreeze_tx[0]) + wait_for_confirmation(algod, unfreeze_tx.tx_id()) + + # Verify unfrozen status + holder_asset_info_after_unfreeze = algod.account_asset_information(holder.addr, asset_id) + is_frozen_after_unfreeze = holder_asset_info_after_unfreeze.asset_holding.is_frozen + print_info(f"Holder frozen status after unfreeze: {is_frozen_after_unfreeze}") + + if is_frozen_after_unfreeze: + raise ValueError("Account should be unfrozen but is still frozen") + print_success("Holder account successfully unfrozen!") + + # Step 11: Verify account can transfer after unfreeze + print_step(11, "Verify Account Can Transfer After Unfreeze") + + success_transfer_amount = 100_000_000 # 100 units + display_success_transfer = success_transfer_amount / (10**asset_decimals) + print_info(f"Attempting to transfer {display_success_transfer:,.0f} {asset_unit_name} from unfrozen account...") + + success_transfer_suggested_params = algod.suggested_params() + + success_transfer_tx_without_fee = Transaction( + transaction_type=TransactionType.AssetTransfer, + sender=holder.addr, + first_valid=success_transfer_suggested_params.first_valid, + last_valid=success_transfer_suggested_params.last_valid, + genesis_hash=success_transfer_suggested_params.genesis_hash, + genesis_id=success_transfer_suggested_params.genesis_id, + asset_transfer=AssetTransferTransactionFields( + asset_id=asset_id, + receiver=freeze_manager.addr, + amount=success_transfer_amount, + ), + ) + + success_transfer_tx = assign_fee( + success_transfer_tx_without_fee, + fee_per_byte=success_transfer_suggested_params.fee, + min_fee=success_transfer_suggested_params.min_fee, + ) + + signed_success_transfer_tx = holder.signer([success_transfer_tx], [0]) + algod.send_raw_transaction(signed_success_transfer_tx[0]) + wait_for_confirmation(algod, success_transfer_tx.tx_id()) + + # Verify balances after transfer + holder_final_asset_info = algod.account_asset_information(holder.addr, asset_id) + holder_final_balance = holder_final_asset_info.asset_holding.amount + expected_holder_balance = transfer_amount - success_transfer_amount + display_holder_final = holder_final_balance / (10**asset_decimals) + print_info(f"Holder final balance: {holder_final_balance} ({display_holder_final:,.0f} {asset_unit_name})") + + if holder_final_balance != expected_holder_balance: + raise ValueError(f"Holder balance mismatch: expected {expected_holder_balance}, got {holder_final_balance}") + + print_success("Transfer successful! Unfrozen account can transfer assets.") + print_success("Asset freeze example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/transact/06_asset_clawback.py b/examples/transact/06_asset_clawback.py new file mode 100644 index 00000000..0521ed98 --- /dev/null +++ b/examples/transact/06_asset_clawback.py @@ -0,0 +1,367 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Asset Clawback + +This example demonstrates how to clawback assets from an account using +the clawback address and the transact package: +1. Create an asset with clawback address set +2. Transfer assets to a target account +3. Clawback assets from target account using asset_sender field +4. Verify target account balance decreased +5. Verify clawback receiver received the assets + +Uses AssetTransferTransactionFields with the asset_sender field for clawback operations. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from shared import ( + create_algod_client, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, + wait_for_confirmation, +) + +from algokit_transact import ( + AssetConfigTransactionFields, + AssetTransferTransactionFields, + PaymentTransactionFields, + Transaction, + TransactionType, + assign_fee, +) +from algokit_utils import AlgorandClient + + +def main() -> None: + print_header("Asset Clawback Example") + + # Step 1: Initialize clients + print_step(1, "Initialize Algod Client") + algod = create_algod_client() + algorand = AlgorandClient.default_localnet() + + try: + algod.status() + print_info("Connected to LocalNet Algod") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 2: Get clawback manager account from KMD + print_step(2, "Get Clawback Manager Account from KMD") + clawback_manager = algorand.account.localnet_dispenser() + print_info(f"Clawback manager address: {shorten_address(clawback_manager.addr)}") + + # Step 3: Get suggested transaction parameters + print_step(3, "Get Suggested Transaction Parameters") + suggested_params = algod.suggested_params() + print_info(f"First valid round: {suggested_params.first_valid}") + print_info(f"Last valid round: {suggested_params.last_valid}") + print_info(f"Min fee: {suggested_params.min_fee} microALGO") + + # Step 4: Generate and fund target account (will have assets clawed back) + print_step(4, "Generate and Fund Target Account") + target = algorand.account.random() + print_info(f"Target address: {shorten_address(target.addr)}") + + # Fund the target with enough ALGO to cover opt-in transaction fee + funding_amount = 1_000_000 # 1 ALGO in microALGO + + fund_target_tx_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=clawback_manager.addr, + first_valid=suggested_params.first_valid, + last_valid=suggested_params.last_valid, + genesis_hash=suggested_params.genesis_hash, + genesis_id=suggested_params.genesis_id, + payment=PaymentTransactionFields( + receiver=target.addr, + amount=funding_amount, + ), + ) + + fund_target_tx = assign_fee( + fund_target_tx_without_fee, + fee_per_byte=suggested_params.fee, + min_fee=suggested_params.min_fee, + ) + + signed_fund_target_tx = clawback_manager.signer([fund_target_tx], [0]) + algod.send_raw_transaction(signed_fund_target_tx[0]) + wait_for_confirmation(algod, fund_target_tx.tx_id()) + print_info("Funded target with 1 ALGO for transaction fees") + + # Step 5: Generate and fund clawback receiver account (will receive clawed back assets) + print_step(5, "Generate and Fund Clawback Receiver Account") + clawback_receiver = algorand.account.random() + print_info(f"Clawback receiver address: {shorten_address(clawback_receiver.addr)}") + + fund_receiver_suggested_params = algod.suggested_params() + + fund_receiver_tx_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=clawback_manager.addr, + first_valid=fund_receiver_suggested_params.first_valid, + last_valid=fund_receiver_suggested_params.last_valid, + genesis_hash=fund_receiver_suggested_params.genesis_hash, + genesis_id=fund_receiver_suggested_params.genesis_id, + payment=PaymentTransactionFields( + receiver=clawback_receiver.addr, + amount=funding_amount, + ), + ) + + fund_receiver_tx = assign_fee( + fund_receiver_tx_without_fee, + fee_per_byte=fund_receiver_suggested_params.fee, + min_fee=fund_receiver_suggested_params.min_fee, + ) + + signed_fund_receiver_tx = clawback_manager.signer([fund_receiver_tx], [0]) + algod.send_raw_transaction(signed_fund_receiver_tx[0]) + wait_for_confirmation(algod, fund_receiver_tx.tx_id()) + print_info("Funded clawback receiver with 1 ALGO for transaction fees") + + # Step 6: Create an asset with clawback address set + print_step(6, "Create Asset with Clawback Address Set") + + asset_total = 10_000_000_000 # 10,000 units with 6 decimals + asset_decimals = 6 + asset_name = "Clawbackable Token" + asset_unit_name = "CLW" + + create_suggested_params = algod.suggested_params() + + print_info(f"Creating asset: {asset_name} ({asset_unit_name})") + print_info(f"Clawback address set to: {shorten_address(clawback_manager.addr)}") + + create_asset_tx_without_fee = Transaction( + transaction_type=TransactionType.AssetConfig, + sender=clawback_manager.addr, + first_valid=create_suggested_params.first_valid, + last_valid=create_suggested_params.last_valid, + genesis_hash=create_suggested_params.genesis_hash, + genesis_id=create_suggested_params.genesis_id, + asset_config=AssetConfigTransactionFields( + asset_id=0, # 0 indicates asset creation + total=asset_total, + decimals=asset_decimals, + default_frozen=False, + asset_name=asset_name, + unit_name=asset_unit_name, + url="https://example.com/clawbackable-token", + manager=clawback_manager.addr, + reserve=clawback_manager.addr, + freeze=clawback_manager.addr, + clawback=clawback_manager.addr, # IMPORTANT: Set clawback address to enable clawback + ), + ) + + create_asset_tx = assign_fee( + create_asset_tx_without_fee, + fee_per_byte=create_suggested_params.fee, + min_fee=create_suggested_params.min_fee, + ) + + signed_create_tx = clawback_manager.signer([create_asset_tx], [0]) + algod.send_raw_transaction(signed_create_tx[0]) + + create_pending_info = wait_for_confirmation(algod, create_asset_tx.tx_id()) + asset_id = create_pending_info.asset_id + if not asset_id: + raise ValueError("Asset ID not found in pending transaction response") + print_info(f"Asset created with ID: {asset_id}") + print_success(f"Asset {asset_name} (ID: {asset_id}) created with clawback capability!") + + # Step 7: Target opts into the asset + print_step(7, "Target Opts Into the Asset") + + opt_in_target_suggested_params = algod.suggested_params() + + opt_in_target_tx_without_fee = Transaction( + transaction_type=TransactionType.AssetTransfer, + sender=target.addr, + first_valid=opt_in_target_suggested_params.first_valid, + last_valid=opt_in_target_suggested_params.last_valid, + genesis_hash=opt_in_target_suggested_params.genesis_hash, + genesis_id=opt_in_target_suggested_params.genesis_id, + asset_transfer=AssetTransferTransactionFields( + asset_id=asset_id, + receiver=target.addr, + amount=0, # 0 amount for opt-in + ), + ) + + opt_in_target_tx = assign_fee( + opt_in_target_tx_without_fee, + fee_per_byte=opt_in_target_suggested_params.fee, + min_fee=opt_in_target_suggested_params.min_fee, + ) + + signed_opt_in_target_tx = target.signer([opt_in_target_tx], [0]) + algod.send_raw_transaction(signed_opt_in_target_tx[0]) + wait_for_confirmation(algod, opt_in_target_tx.tx_id()) + print_info("Target opted into the asset") + print_success("Target successfully opted into the asset!") + + # Step 8: Clawback receiver opts into the asset + print_step(8, "Clawback Receiver Opts Into the Asset") + + opt_in_receiver_suggested_params = algod.suggested_params() + + opt_in_receiver_tx_without_fee = Transaction( + transaction_type=TransactionType.AssetTransfer, + sender=clawback_receiver.addr, + first_valid=opt_in_receiver_suggested_params.first_valid, + last_valid=opt_in_receiver_suggested_params.last_valid, + genesis_hash=opt_in_receiver_suggested_params.genesis_hash, + genesis_id=opt_in_receiver_suggested_params.genesis_id, + asset_transfer=AssetTransferTransactionFields( + asset_id=asset_id, + receiver=clawback_receiver.addr, + amount=0, # 0 amount for opt-in + ), + ) + + opt_in_receiver_tx = assign_fee( + opt_in_receiver_tx_without_fee, + fee_per_byte=opt_in_receiver_suggested_params.fee, + min_fee=opt_in_receiver_suggested_params.min_fee, + ) + + signed_opt_in_receiver_tx = clawback_receiver.signer([opt_in_receiver_tx], [0]) + algod.send_raw_transaction(signed_opt_in_receiver_tx[0]) + wait_for_confirmation(algod, opt_in_receiver_tx.tx_id()) + print_info("Clawback receiver opted into the asset") + print_success("Clawback receiver successfully opted into the asset!") + + # Step 9: Transfer assets from creator to target + print_step(9, "Transfer Assets to Target") + + transfer_amount = 1_000_000_000 # 1,000 units + display_transfer = transfer_amount / (10**asset_decimals) + print_info(f"Transferring {display_transfer:,.0f} {asset_unit_name} to target") + + transfer_suggested_params = algod.suggested_params() + + transfer_tx_without_fee = Transaction( + transaction_type=TransactionType.AssetTransfer, + sender=clawback_manager.addr, + first_valid=transfer_suggested_params.first_valid, + last_valid=transfer_suggested_params.last_valid, + genesis_hash=transfer_suggested_params.genesis_hash, + genesis_id=transfer_suggested_params.genesis_id, + asset_transfer=AssetTransferTransactionFields( + asset_id=asset_id, + receiver=target.addr, + amount=transfer_amount, + ), + ) + + transfer_tx = assign_fee( + transfer_tx_without_fee, + fee_per_byte=transfer_suggested_params.fee, + min_fee=transfer_suggested_params.min_fee, + ) + + signed_transfer_tx = clawback_manager.signer([transfer_tx], [0]) + algod.send_raw_transaction(signed_transfer_tx[0]) + wait_for_confirmation(algod, transfer_tx.tx_id()) + + # Verify target's balance before clawback + target_asset_info_before = algod.account_asset_information(target.addr, asset_id) + target_balance_before = target_asset_info_before.asset_holding.amount + display_before = target_balance_before / (10**asset_decimals) + print_info(f"Target balance before clawback: {target_balance_before} ({display_before:,.0f} {asset_unit_name})") + print_success(f"Transferred {display_transfer:,.0f} {asset_unit_name} to target!") + + # Step 10: Clawback assets from target to clawback receiver + print_step(10, "Clawback Assets Using asset_sender Field") + print_info("Demonstrating clawback: clawback address takes assets from target and sends to receiver") + print_info("Key: Use asset_sender field to specify the account to clawback FROM") + + clawback_amount = 500_000_000 # 500 units (half of what target holds) + display_clawback = clawback_amount / (10**asset_decimals) + print_info(f"Clawback amount: {display_clawback:,.0f} {asset_unit_name}") + + clawback_suggested_params = algod.suggested_params() + + # IMPORTANT: For clawback, use asset_sender to specify WHO we're taking assets FROM + clawback_tx_without_fee = Transaction( + transaction_type=TransactionType.AssetTransfer, + sender=clawback_manager.addr, # Transaction sender is the clawback address + first_valid=clawback_suggested_params.first_valid, + last_valid=clawback_suggested_params.last_valid, + genesis_hash=clawback_suggested_params.genesis_hash, + genesis_id=clawback_suggested_params.genesis_id, + asset_transfer=AssetTransferTransactionFields( + asset_id=asset_id, + receiver=clawback_receiver.addr, # Assets go TO clawback receiver + amount=clawback_amount, + asset_sender=target.addr, # CLAWBACK: Taking assets FROM target account + ), + ) + + clawback_tx = assign_fee( + clawback_tx_without_fee, + fee_per_byte=clawback_suggested_params.fee, + min_fee=clawback_suggested_params.min_fee, + ) + + # Only the clawback address needs to sign (not the target) + signed_clawback_tx = clawback_manager.signer([clawback_tx], [0]) + algod.send_raw_transaction(signed_clawback_tx[0]) + wait_for_confirmation(algod, clawback_tx.tx_id()) + + print_success("Clawback transaction confirmed!") + + # Step 11: Verify target account balance decreased + print_step(11, "Verify Target Account Balance Decreased") + + target_asset_info_after = algod.account_asset_information(target.addr, asset_id) + target_balance_after = target_asset_info_after.asset_holding.amount + expected_target_balance = target_balance_before - clawback_amount + + display_before = target_balance_before / (10**asset_decimals) + display_after = target_balance_after / (10**asset_decimals) + display_expected = expected_target_balance / (10**asset_decimals) + print_info(f"Target balance before: {display_before:,.0f} {asset_unit_name}") + print_info(f"Target balance after: {display_after:,.0f} {asset_unit_name}") + print_info(f"Expected balance: {display_expected:,.0f} {asset_unit_name}") + + if target_balance_after != expected_target_balance: + raise ValueError(f"Target balance mismatch: expected {expected_target_balance}, got {target_balance_after}") + print_success(f"Target balance correctly decreased by {display_clawback:,.0f} {asset_unit_name}!") + + # Step 12: Verify clawback receiver received the assets + print_step(12, "Verify Clawback Receiver Received the Assets") + + receiver_asset_info = algod.account_asset_information(clawback_receiver.addr, asset_id) + receiver_balance = receiver_asset_info.asset_holding.amount + + display_receiver = receiver_balance / (10**asset_decimals) + print_info(f"Clawback receiver balance: {display_receiver:,.0f} {asset_unit_name}") + + if receiver_balance != clawback_amount: + raise ValueError(f"Receiver balance mismatch: expected {clawback_amount}, got {receiver_balance}") + print_success(f"Clawback receiver correctly received {display_clawback:,.0f} {asset_unit_name}!") + + # Summary + print_success("Asset clawback example completed successfully!") + print_info("Summary:") + print_info(f" - Created asset {asset_name} (ID: {asset_id}) with clawback address") + print_info(f" - Transferred {display_transfer:,.0f} {asset_unit_name} to target") + print_info(f" - Clawed back {display_clawback:,.0f} {asset_unit_name} from target to receiver") + print_info(f" - Target final balance: {display_after:,.0f} {asset_unit_name}") + print_info(f" - Receiver final balance: {display_receiver:,.0f} {asset_unit_name}") + + +if __name__ == "__main__": + main() diff --git a/examples/transact/07_atomic_group.py b/examples/transact/07_atomic_group.py new file mode 100644 index 00000000..196c9707 --- /dev/null +++ b/examples/transact/07_atomic_group.py @@ -0,0 +1,250 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Atomic Transaction Group + +This example demonstrates how to group multiple transactions atomically. +All transactions in a group either succeed together or fail together. +It shows: +- Creating multiple payment transactions +- Using group_transactions() to assign a group ID +- Signing all transactions with the same signer +- Submitting as a single atomic group + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import base64 + +from shared import ( + create_algod_client, + format_algo, + get_account_balance, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, + wait_for_confirmation, +) + +from algokit_transact import ( + PaymentTransactionFields, + Transaction, + TransactionType, + assign_fee, + group_transactions, +) +from algokit_utils import AlgorandClient + + +def main() -> None: + print_header("Atomic Transaction Group Example") + + # Step 1: Initialize clients + print_step(1, "Initialize Algod Client") + algod = create_algod_client() + algorand = AlgorandClient.default_localnet() + + try: + algod.status() + print_info("Connected to LocalNet Algod") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 2: Get a funded account from KMD (sender for all transactions) + print_step(2, "Get Funded Account from KMD") + sender = algorand.account.localnet_dispenser() + sender_balance = get_account_balance(algorand, sender.addr) + print_info(f"Sender address: {shorten_address(sender.addr)}") + print_info(f"Sender balance: {format_algo(sender_balance)}") + + # Step 3: Generate 3 receiver accounts + print_step(3, "Generate 3 Receiver Accounts") + receiver1 = algorand.account.random() + receiver2 = algorand.account.random() + receiver3 = algorand.account.random() + + print_info(f"Receiver 1: {shorten_address(receiver1.addr)}") + print_info(f"Receiver 2: {shorten_address(receiver2.addr)}") + print_info(f"Receiver 3: {shorten_address(receiver3.addr)}") + + # Step 4: Get suggested transaction parameters + print_step(4, "Get Suggested Transaction Parameters") + suggested_params = algod.suggested_params() + print_info(f"First valid round: {suggested_params.first_valid}") + print_info(f"Last valid round: {suggested_params.last_valid}") + print_info(f"Min fee: {suggested_params.min_fee} microALGO") + + # Step 5: Create 3 payment transactions with different amounts + print_step(5, "Create 3 Payment Transactions") + amounts = [1_000_000, 2_000_000, 3_000_000] # 1, 2, 3 ALGO + + # Create base transactions + tx1_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=sender.addr, + first_valid=suggested_params.first_valid, + last_valid=suggested_params.last_valid, + genesis_hash=suggested_params.genesis_hash, + genesis_id=suggested_params.genesis_id, + payment=PaymentTransactionFields( + receiver=receiver1.addr, + amount=amounts[0], + ), + ) + + tx2_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=sender.addr, + first_valid=suggested_params.first_valid, + last_valid=suggested_params.last_valid, + genesis_hash=suggested_params.genesis_hash, + genesis_id=suggested_params.genesis_id, + payment=PaymentTransactionFields( + receiver=receiver2.addr, + amount=amounts[1], + ), + ) + + tx3_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=sender.addr, + first_valid=suggested_params.first_valid, + last_valid=suggested_params.last_valid, + genesis_hash=suggested_params.genesis_hash, + genesis_id=suggested_params.genesis_id, + payment=PaymentTransactionFields( + receiver=receiver3.addr, + amount=amounts[2], + ), + ) + + print_info(f"Transaction 1: {format_algo(amounts[0])} to Receiver 1") + print_info(f"Transaction 2: {format_algo(amounts[1])} to Receiver 2") + print_info(f"Transaction 3: {format_algo(amounts[2])} to Receiver 3") + + # Step 6: Assign fees to all transactions + print_step(6, "Assign Transaction Fees") + tx1_with_fee = assign_fee( + tx1_without_fee, + fee_per_byte=suggested_params.fee, + min_fee=suggested_params.min_fee, + ) + tx2_with_fee = assign_fee( + tx2_without_fee, + fee_per_byte=suggested_params.fee, + min_fee=suggested_params.min_fee, + ) + tx3_with_fee = assign_fee( + tx3_without_fee, + fee_per_byte=suggested_params.fee, + min_fee=suggested_params.min_fee, + ) + + fee1 = tx1_with_fee.fee if tx1_with_fee.fee else 0 + fee2 = tx2_with_fee.fee if tx2_with_fee.fee else 0 + fee3 = tx3_with_fee.fee if tx3_with_fee.fee else 0 + print_info(f"Fee per transaction: {fee1} microALGO") + print_info(f"Total fees: {fee1 + fee2 + fee3} microALGO") + + # Step 7: Group the transactions using group_transactions() + print_step(7, "Group Transactions with group_transactions()") + transactions_with_fees = [tx1_with_fee, tx2_with_fee, tx3_with_fee] + grouped_transactions = group_transactions(transactions_with_fees) + + # All transactions now have the same group ID + group_id = grouped_transactions[0].group + group_id_b64 = base64.b64encode(group_id).decode() if group_id else "undefined" + print_info("Group ID assigned to all transactions") + print_info(f"Group ID (base64): {group_id_b64}") + print_info("All 3 transactions now share the same group ID") + + # Step 8: Sign all transactions with the same signer + print_step(8, "Sign All Transactions") + + # Sign each transaction (all from same sender) + signed_tx1 = sender.signer([grouped_transactions[0]], [0]) + signed_tx2 = sender.signer([grouped_transactions[1]], [0]) + signed_tx3 = sender.signer([grouped_transactions[2]], [0]) + + print_info("All 3 transactions signed successfully") + + # Get transaction IDs for confirmation tracking + tx_id1 = grouped_transactions[0].tx_id() + tx_id2 = grouped_transactions[1].tx_id() + tx_id3 = grouped_transactions[2].tx_id() + + print_info(f"Transaction 1 ID: {tx_id1}") + print_info(f"Transaction 2 ID: {tx_id2}") + print_info(f"Transaction 3 ID: {tx_id3}") + + # Step 9: Submit as a single group using concatenated bytes + print_step(9, "Submit Atomic Group") + + # Concatenate all signed transaction bytes + concatenated_bytes = signed_tx1[0] + signed_tx2[0] + signed_tx3[0] + + print_info(f"Submitting {len(grouped_transactions)} grouped transactions as a single atomic unit") + + algod.send_raw_transaction(concatenated_bytes) + print_info("Atomic group submitted to network") + + # Wait for confirmation of the first transaction (all will be confirmed together) + pending_info = wait_for_confirmation(algod, tx_id1) + print_info(f"Atomic group confirmed in round: {pending_info.confirmed_round}") + + # Step 10: Verify all receivers received their amounts + print_step(10, "Verify All Receivers Received Amounts") + + receiver1_balance = get_account_balance(algorand, receiver1.addr) + receiver2_balance = get_account_balance(algorand, receiver2.addr) + receiver3_balance = get_account_balance(algorand, receiver3.addr) + + print_info(f"Receiver 1 balance: {format_algo(receiver1_balance)} (expected: {format_algo(amounts[0])})") + print_info(f"Receiver 2 balance: {format_algo(receiver2_balance)} (expected: {format_algo(amounts[1])})") + print_info(f"Receiver 3 balance: {format_algo(receiver3_balance)} (expected: {format_algo(amounts[2])})") + + # Verify all balances match expected amounts + all_correct = ( + receiver1_balance.micro_algo == amounts[0] + and receiver2_balance.micro_algo == amounts[1] + and receiver3_balance.micro_algo == amounts[2] + ) + + if all_correct: + print_success("All receivers received their expected amounts!") + else: + raise ValueError("One or more receivers did not receive the expected amount") + + # Step 11: Demonstrate atomicity concept + print_step(11, "Atomicity Explanation") + print_info("Group transactions succeed or fail together:") + print_info("- If any transaction in the group fails validation, ALL fail") + print_info("- If all transactions pass validation, ALL succeed") + print_info("- This is crucial for atomic swaps, multi-party payments, etc.") + print_info("") + print_info("Example failure scenarios that would cause ALL transactions to fail:") + print_info("- Insufficient funds for any payment") + print_info("- Invalid signature on any transaction") + print_info("- Mismatched group IDs between transactions") + + # Get final sender balance + sender_final_balance = get_account_balance(algorand, sender.addr) + total_sent = amounts[0] + amounts[1] + amounts[2] + total_fees = fee1 + fee2 + fee3 + + print_info("") + print_info(f"Total ALGO sent: {format_algo(total_sent)}") + print_info(f"Total fees paid: {format_algo(total_fees)}") + change = sender_balance.micro_algo - sender_final_balance.micro_algo + print_info(f"Sender balance change: {format_algo(change)}") + + print_success("Atomic transaction group example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/transact/08_atomic_swap.py b/examples/transact/08_atomic_swap.py new file mode 100644 index 00000000..45d817ac --- /dev/null +++ b/examples/transact/08_atomic_swap.py @@ -0,0 +1,336 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Atomic Swap + +This example demonstrates how to perform an atomic swap of ALGO for ASA between two parties. +In an atomic swap: +- Party A sends ASA to Party B +- Party B sends ALGO to Party A +- Each party signs ONLY their own transaction +- Signatures are combined and submitted together +- Both transfers succeed or both fail (atomicity) + +Key difference from regular atomic groups: different parties sign different transactions. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import base64 + +from shared import ( + create_algod_client, + format_algo, + get_account_balance, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, + wait_for_confirmation, +) + +from algokit_transact import ( + AssetConfigTransactionFields, + AssetTransferTransactionFields, + PaymentTransactionFields, + Transaction, + TransactionType, + assign_fee, + group_transactions, +) +from algokit_utils import AlgorandClient + + +def main() -> None: + print_header("Atomic Swap Example (ALGO <-> ASA)") + + # Step 1: Initialize clients + print_step(1, "Initialize Algod Client") + algod = create_algod_client() + algorand = AlgorandClient.default_localnet() + + try: + algod.status() + print_info("Connected to LocalNet Algod") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 2: Get Party A from KMD (asset owner) + print_step(2, "Setup Party A (Asset Owner)") + party_a = algorand.account.localnet_dispenser() + party_a_balance_before = get_account_balance(algorand, party_a.addr) + print_info(f"Party A address: {shorten_address(party_a.addr)}") + print_info(f"Party A ALGO balance: {format_algo(party_a_balance_before)}") + + # Step 3: Generate and fund Party B + print_step(3, "Setup Party B (ALGO holder)") + party_b = algorand.account.random() + + # Fund Party B with ALGO for the swap + fees + suggested_params = algod.suggested_params() + party_b_funding_amount = 10_000_000 # 10 ALGO (will use 5 ALGO for swap) + + fund_b_tx_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=party_a.addr, + first_valid=suggested_params.first_valid, + last_valid=suggested_params.last_valid, + genesis_hash=suggested_params.genesis_hash, + genesis_id=suggested_params.genesis_id, + payment=PaymentTransactionFields( + receiver=party_b.addr, + amount=party_b_funding_amount, + ), + ) + + fund_b_tx = assign_fee( + fund_b_tx_without_fee, + fee_per_byte=suggested_params.fee, + min_fee=suggested_params.min_fee, + ) + + signed_fund_b_tx = party_a.signer([fund_b_tx], [0]) + algod.send_raw_transaction(signed_fund_b_tx[0]) + wait_for_confirmation(algod, fund_b_tx.tx_id()) + + party_b_balance_before = get_account_balance(algorand, party_b.addr) + print_info(f"Party B address: {shorten_address(party_b.addr)}") + print_info(f"Party B ALGO balance: {format_algo(party_b_balance_before)}") + + # Step 4: Party A creates an asset + print_step(4, "Party A Creates Asset") + + asset_total = 1_000_000 # 1,000,000 units (no decimals for simplicity) + asset_decimals = 0 + asset_name = "Swap Token" + asset_unit_name = "SWAP" + + create_params = algod.suggested_params() + + create_asset_tx_without_fee = Transaction( + transaction_type=TransactionType.AssetConfig, + sender=party_a.addr, + first_valid=create_params.first_valid, + last_valid=create_params.last_valid, + genesis_hash=create_params.genesis_hash, + genesis_id=create_params.genesis_id, + asset_config=AssetConfigTransactionFields( + asset_id=0, + total=asset_total, + decimals=asset_decimals, + default_frozen=False, + asset_name=asset_name, + unit_name=asset_unit_name, + url="https://example.com/swap-token", + manager=party_a.addr, + reserve=party_a.addr, + freeze=party_a.addr, + clawback=party_a.addr, + ), + ) + + create_asset_tx = assign_fee( + create_asset_tx_without_fee, + fee_per_byte=create_params.fee, + min_fee=create_params.min_fee, + ) + + signed_create_tx = party_a.signer([create_asset_tx], [0]) + algod.send_raw_transaction(signed_create_tx[0]) + create_pending_info = wait_for_confirmation(algod, create_asset_tx.tx_id()) + + asset_id = create_pending_info.asset_id + if not asset_id: + raise ValueError("Asset ID not found") + + print_info(f"Created asset: {asset_name} ({asset_unit_name})") + print_info(f"Asset ID: {asset_id}") + print_info(f"Party A holds: {asset_total} {asset_unit_name}") + + # Step 5: Party B opts into the asset + print_step(5, "Party B Opts Into Asset") + + opt_in_params = algod.suggested_params() + + opt_in_tx_without_fee = Transaction( + transaction_type=TransactionType.AssetTransfer, + sender=party_b.addr, + first_valid=opt_in_params.first_valid, + last_valid=opt_in_params.last_valid, + genesis_hash=opt_in_params.genesis_hash, + genesis_id=opt_in_params.genesis_id, + asset_transfer=AssetTransferTransactionFields( + asset_id=asset_id, + receiver=party_b.addr, + amount=0, + ), + ) + + opt_in_tx = assign_fee( + opt_in_tx_without_fee, + fee_per_byte=opt_in_params.fee, + min_fee=opt_in_params.min_fee, + ) + + signed_opt_in_tx = party_b.signer([opt_in_tx], [0]) + algod.send_raw_transaction(signed_opt_in_tx[0]) + wait_for_confirmation(algod, opt_in_tx.tx_id()) + + print_info(f"Party B opted into asset ID: {asset_id}") + print_success("Opt-in successful!") + + # Step 6: Build the atomic swap transactions + print_step(6, "Build Atomic Swap Transactions") + + swap_asset_amount = 100 # Party A sends 100 SWAP to Party B + swap_algo_amount = 5_000_000 # Party B sends 5 ALGO to Party A + + print_info("Swap terms:") + print_info(f" - Party A sends: {swap_asset_amount} {asset_unit_name} -> Party B") + print_info(f" - Party B sends: {format_algo(swap_algo_amount)} -> Party A") + + swap_params = algod.suggested_params() + + # Transaction 1: Party A sends ASA to Party B + asa_send_tx_without_fee = Transaction( + transaction_type=TransactionType.AssetTransfer, + sender=party_a.addr, + first_valid=swap_params.first_valid, + last_valid=swap_params.last_valid, + genesis_hash=swap_params.genesis_hash, + genesis_id=swap_params.genesis_id, + asset_transfer=AssetTransferTransactionFields( + asset_id=asset_id, + receiver=party_b.addr, + amount=swap_asset_amount, + ), + ) + + asa_send_tx = assign_fee( + asa_send_tx_without_fee, + fee_per_byte=swap_params.fee, + min_fee=swap_params.min_fee, + ) + + # Transaction 2: Party B sends ALGO to Party A + algo_send_tx_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=party_b.addr, + first_valid=swap_params.first_valid, + last_valid=swap_params.last_valid, + genesis_hash=swap_params.genesis_hash, + genesis_id=swap_params.genesis_id, + payment=PaymentTransactionFields( + receiver=party_a.addr, + amount=swap_algo_amount, + ), + ) + + algo_send_tx = assign_fee( + algo_send_tx_without_fee, + fee_per_byte=swap_params.fee, + min_fee=swap_params.min_fee, + ) + + print_info("Transaction 1: Party A sends ASA to Party B") + print_info("Transaction 2: Party B sends ALGO to Party A") + + # Step 7: Group the transactions using group_transactions() + print_step(7, "Group Transactions with group_transactions()") + + grouped_transactions = group_transactions([asa_send_tx, algo_send_tx]) + + group_id = grouped_transactions[0].group + group_id_b64 = base64.b64encode(group_id).decode() if group_id else "undefined" + print_info("Group ID assigned to both transactions") + print_info(f"Group ID (base64): {group_id_b64}") + print_success("Transactions grouped successfully!") + + # Step 8: Each party signs ONLY their transaction + print_step(8, "Each Party Signs Their Own Transaction") + + print_info("Party A signs transaction 0 (ASA transfer)") + signed_asa_tx = party_a.signer([grouped_transactions[0]], [0]) + + print_info("Party B signs transaction 1 (ALGO payment)") + signed_algo_tx = party_b.signer([grouped_transactions[1]], [0]) + + print_success("Both parties signed their respective transactions!") + print_info("Note: Party A cannot see/modify Party B's transaction and vice versa") + print_info("The atomic group ensures both execute or neither does") + + # Step 9: Combine signatures and submit + print_step(9, "Combine Signatures and Submit Atomic Swap") + + # Concatenate signed transactions in group order + combined_signed_txns = signed_asa_tx[0] + signed_algo_tx[0] + + print_info("Submitting atomic swap to network...") + algod.send_raw_transaction(combined_signed_txns) + + swap_tx_id = grouped_transactions[0].tx_id() + pending_info = wait_for_confirmation(algod, swap_tx_id) + print_info(f"Atomic swap confirmed in round: {pending_info.confirmed_round}") + print_success("Atomic swap executed successfully!") + + # Step 10: Verify the swap results + print_step(10, "Verify Swap Results") + + # Get Party A's balances after swap + party_a_balance_after = get_account_balance(algorand, party_a.addr) + party_a_asset_info = algod.account_asset_information(party_a.addr, asset_id) + party_a_asset_balance = party_a_asset_info.asset_holding.amount + + # Get Party B's balances after swap + party_b_balance_after = get_account_balance(algorand, party_b.addr) + party_b_asset_info = algod.account_asset_information(party_b.addr, asset_id) + party_b_asset_balance = party_b_asset_info.asset_holding.amount + + print_info("Party A (after swap):") + print_info(f" - ALGO: {format_algo(party_a_balance_after)}") + remaining_a = asset_total - swap_asset_amount + print_info(f" - {asset_unit_name}: {party_a_asset_balance} (sent {swap_asset_amount}, remaining: {remaining_a})") + + print_info("Party B (after swap):") + print_info(f" - ALGO: {format_algo(party_b_balance_after)}") + print_info(f" - {asset_unit_name}: {party_b_asset_balance} (received {swap_asset_amount})") + + # Verification + print_info("") + print_info("Verification:") + + # Verify Party B received ASA + if party_b_asset_balance != swap_asset_amount: + raise ValueError(f"Party B ASA balance mismatch: expected {swap_asset_amount}, got {party_b_asset_balance}") + print_success(f"Party B received {swap_asset_amount} {asset_unit_name}") + + # Verify Party A's ASA balance decreased + expected_party_a_asa_balance = asset_total - swap_asset_amount + if party_a_asset_balance != expected_party_a_asa_balance: + msg = f"Party A ASA balance mismatch: expected {expected_party_a_asa_balance}, got {party_a_asset_balance}" + raise ValueError(msg) + print_success(f"Party A ASA balance correctly reduced to {party_a_asset_balance} {asset_unit_name}") + + # Verify Party B's ALGO balance decreased (sent 5 ALGO + fee) + party_b_algo_decrease = party_b_balance_before.micro_algo - party_b_balance_after.micro_algo + if party_b_algo_decrease < swap_algo_amount: + raise ValueError(f"Party B should have sent at least {swap_algo_amount} microALGO") + fees_paid = party_b_algo_decrease - swap_algo_amount + print_success(f"Party B sent {format_algo(swap_algo_amount)} (plus {format_algo(fees_paid)} in fees)") + + print_info("") + print_info("Atomic Swap Summary:") + print_info(f" - Party A gave: {swap_asset_amount} {asset_unit_name}") + print_info(f" - Party A received: {format_algo(swap_algo_amount)}") + print_info(f" - Party B gave: {format_algo(swap_algo_amount)}") + print_info(f" - Party B received: {swap_asset_amount} {asset_unit_name}") + + print_success("Atomic swap example completed successfully!") + + +if __name__ == "__main__": + main() diff --git a/examples/transact/09_single_sig.py b/examples/transact/09_single_sig.py new file mode 100644 index 00000000..319c0714 --- /dev/null +++ b/examples/transact/09_single_sig.py @@ -0,0 +1,228 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Single Signature + +This example demonstrates how to create an ed25519 keypair and sign transactions +using the low-level transact package APIs. + +Key concepts: +- Creating a keypair using nacl (ed25519 signature scheme) +- Using generate_address_with_signers() to derive an Algorand address from the public key +- Understanding the relationship between ed25519 public key and Algorand address +- Signing transactions with a raw ed25519 signer function + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import nacl.signing +from shared import ( + create_algod_client, + format_algo, + get_account_balance, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, + wait_for_confirmation, +) + +from algokit_transact import ( + PaymentTransactionFields, + Transaction, + TransactionType, + assign_fee, + generate_address_with_signers, +) +from algokit_utils import AlgorandClient + + +def main() -> None: + print_header("Single Signature Example") + + # Step 1: Initialize clients + print_step(1, "Initialize Algod Client") + algod = create_algod_client() + algorand = AlgorandClient.default_localnet() + + try: + algod.status() + print_info("Connected to LocalNet Algod") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 2: Create a keypair using nacl + print_step(2, "Create Keypair Using nacl") + + # The keypair generation uses a cryptographically secure random number generator + signing_key = nacl.signing.SigningKey.generate() + verify_key = signing_key.verify_key + + public_key_bytes = bytes(verify_key) + private_key_bytes = bytes(signing_key) + + print_info(f"Public key (32 bytes): {public_key_bytes.hex()[:32]}...") + print_info(f"Secret key (32 bytes): {private_key_bytes.hex()[:32]}... (truncated for security)") + print_info("") + print_info("Note: In ed25519, the signing key seed is 32 bytes.") + print_info(" nacl derives the full 64-byte key internally when signing.") + + # Step 3: Derive Algorand address using generate_address_with_signers + print_step(3, "Derive Algorand Address with generate_address_with_signers()") + + # generate_address_with_signers() does the following internally: + # 1. Takes the 32-byte ed25519 public key + # 2. Computes a 4-byte checksum using SHA-512/256 + # 3. Concatenates: public_key (32 bytes) + checksum (4 bytes) = 36 bytes + # 4. Base32 encodes the 36 bytes to get the 58-character Algorand address + + def raw_ed25519_signer(bytes_to_sign: bytes) -> bytes: + """Sign bytes using the ed25519 private key.""" + signed_message = signing_key.sign(bytes_to_sign) + return signed_message.signature + + account = generate_address_with_signers( + ed25519_pubkey=public_key_bytes, + raw_ed25519_signer=raw_ed25519_signer, + ) + + print_info(f"Ed25519 public key (hex): {public_key_bytes.hex()}") + print_info(f"Algorand address (base32): {account.addr}") + print_info("") + print_info("The Algorand address is derived from the public key by:") + print_info(" 1. Computing SHA-512/256 checksum of the public key") + print_info(" 2. Appending last 4 bytes of checksum to public key") + print_info(" 3. Base32 encoding the result (36 bytes -> 58 characters)") + + # Step 4: Fund the account from dispenser + print_step(4, "Fund Account from Dispenser") + dispenser = algorand.account.localnet_dispenser() + funding_amount = 2_000_000 # 2 ALGO + + suggested_params = algod.suggested_params() + + fund_tx_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=dispenser.addr, + first_valid=suggested_params.first_valid, + last_valid=suggested_params.last_valid, + genesis_hash=suggested_params.genesis_hash, + genesis_id=suggested_params.genesis_id, + payment=PaymentTransactionFields( + receiver=account.addr, + amount=funding_amount, + ), + ) + + fund_tx = assign_fee( + fund_tx_without_fee, + fee_per_byte=suggested_params.fee, + min_fee=suggested_params.min_fee, + ) + + signed_fund_tx = dispenser.signer([fund_tx], [0]) + algod.send_raw_transaction(signed_fund_tx[0]) + wait_for_confirmation(algod, fund_tx.tx_id()) + + balance = get_account_balance(algorand, account.addr) + print_info(f"Funded account with {format_algo(funding_amount)}") + print_info(f"Account balance: {format_algo(balance)}") + + # Step 5: Create a payment transaction to demonstrate signing + print_step(5, "Create Payment Transaction") + + payment_amount = 100_000 # 0.1 ALGO + # Use AlgorandClient helper for the receiver (this example focuses on sender signing) + receiver = algorand.account.random() + + pay_params = algod.suggested_params() + + payment_tx_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=account.addr, + first_valid=pay_params.first_valid, + last_valid=pay_params.last_valid, + genesis_hash=pay_params.genesis_hash, + genesis_id=pay_params.genesis_id, + payment=PaymentTransactionFields( + receiver=receiver.addr, + amount=payment_amount, + ), + ) + + payment_tx = assign_fee( + payment_tx_without_fee, + fee_per_byte=pay_params.fee, + min_fee=pay_params.min_fee, + ) + + print_info(f"Payment amount: {format_algo(payment_amount)}") + print_info(f"Sender: {shorten_address(account.addr)}") + print_info(f"Receiver: {shorten_address(receiver.addr)}") + print_info(f"Transaction ID: {payment_tx.tx_id()}") + + # Step 6: Sign the transaction (explaining the process) + print_step(6, "Sign Transaction with ed25519 Signature") + + print_info("Signing process:") + print_info(" 1. Transaction is encoded to msgpack bytes") + print_info(' 2. Bytes are prefixed with "TX" (to prevent cross-protocol attacks)') + print_info(" 3. The prefixed bytes are signed using ed25519 with the secret key") + print_info(" 4. Signature (64 bytes) is attached to create a SignedTransaction") + print_info("") + + # The signer function handles all of this internally + # account.signer([transaction], [indices]) signs the specified transactions + signed_txns = account.signer([payment_tx], [0]) + + print_info(f"Signed transaction size: {len(signed_txns[0])} bytes") + print_info("Transaction signed successfully!") + + # Step 7: Submit and verify + print_step(7, "Submit Transaction") + algod.send_raw_transaction(signed_txns[0]) + print_info("Transaction submitted to network") + + pending_info = wait_for_confirmation(algod, payment_tx.tx_id()) + print_info(f"Transaction confirmed in round: {pending_info.confirmed_round}") + + # Step 8: Verify balances + print_step(8, "Verify Balances") + + sender_balance_after = get_account_balance(algorand, account.addr) + + try: + receiver_info = algorand.account.get_information(receiver.addr) + receiver_balance_after = receiver_info.amount.micro_algo + except Exception: + receiver_balance_after = 0 + + print_info(f"Sender balance after: {format_algo(sender_balance_after)}") + print_info(f"Receiver balance after: {format_algo(receiver_balance_after)}") + + fee = payment_tx.fee if payment_tx.fee else 0 + expected_sender_balance = funding_amount - payment_amount - fee + if sender_balance_after.micro_algo == expected_sender_balance: + print_success("Sender balance verified!") + + if receiver_balance_after == payment_amount: + print_success("Receiver received the payment!") + + # Summary + print_info("") + print_info("Summary - Single Signature Key Points:") + print_info(" - ed25519 is the signature algorithm used by Algorand") + print_info(" - Public key (32 bytes) -> Algorand address (58 chars base32)") + print_info(" - generate_address_with_signers() bridges raw crypto to Algorand") + print_info(" - The signer function signs transaction bytes with ed25519") + print_info(" - Each transaction requires a valid signature from the sender") + + print_success("Single signature example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/transact/10_multisig.py b/examples/transact/10_multisig.py new file mode 100644 index 00000000..fbe321b1 --- /dev/null +++ b/examples/transact/10_multisig.py @@ -0,0 +1,284 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Multisig + +This example demonstrates how to create and use a 2-of-3 multisig account. + +Key concepts: +- Creating a MultisigAccount with version, threshold, and addresses +- Deriving the multisig address from the participant addresses +- Signing transactions with a subset of participants (2 of 3) +- Demonstrating that insufficient signatures (1 of 3) will fail + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from shared import ( + create_algod_client, + format_algo, + get_account_balance, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, + wait_for_confirmation, +) + +from algokit_transact import ( + MultisigAccount, + MultisigMetadata, + PaymentTransactionFields, + Transaction, + TransactionType, + assign_fee, +) +from algokit_utils import AlgorandClient + + +def main() -> None: + print_header("Multisig Example (2-of-3)") + + # Step 1: Initialize clients + print_step(1, "Initialize Algod Client") + algod = create_algod_client() + algorand = AlgorandClient.default_localnet() + + try: + algod.status() + print_info("Connected to LocalNet Algod") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 2: Create 3 individual accounts + print_step(2, "Create 3 Individual Accounts") + account1 = algorand.account.random() + account2 = algorand.account.random() + account3 = algorand.account.random() + + print_info(f"Account 1: {shorten_address(account1.addr)}") + print_info(f"Account 2: {shorten_address(account2.addr)}") + print_info(f"Account 3: {shorten_address(account3.addr)}") + + # Step 3: Create MultisigAccount with version=1, threshold=2, and all 3 addresses + print_step(3, "Create MultisigAccount (2-of-3)") + + # The multisig parameters: + # - version: 1 (standard multisig version) + # - threshold: 2 (minimum signatures required) + # - addrs: list of participant addresses (order matters!) + # - signers: list of AddressWithSigners objects that can sign + multisig_addrs = [account1.addr, account2.addr, account3.addr] + + multisig_params = MultisigMetadata( + version=1, + threshold=2, + addrs=multisig_addrs, + ) + + # Create the MultisigAccount with 2 sub-signers (accounts 1 and 2) + # These are the accounts that will provide signatures + multisig_with_2_signers = MultisigAccount( + params=multisig_params, + sub_signers=[account1, account2], + ) + + print_info("Multisig version: 1") + print_info("Multisig threshold: 2") + print_info(f"Number of participants: {len(multisig_addrs)}") + + # Step 4: Show the derived multisig address + print_step(4, "Show Derived Multisig Address") + + # The multisig address is deterministically derived from: + # Hash("MultisigAddr" || version || threshold || pk1 || pk2 || pk3) + multisig_address = multisig_with_2_signers.address + print_info(f"Multisig address: {multisig_address}") + print_info("") + print_info("The multisig address is derived by hashing:") + print_info(' "MultisigAddr" prefix + version + threshold + all public keys') + print_info(" Order of public keys matters - different order = different address!") + + # Step 5: Fund the multisig address + print_step(5, "Fund the Multisig Address") + + dispenser = algorand.account.localnet_dispenser() + funding_amount = 5_000_000 # 5 ALGO + + suggested_params = algod.suggested_params() + + fund_tx_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=dispenser.addr, + first_valid=suggested_params.first_valid, + last_valid=suggested_params.last_valid, + genesis_hash=suggested_params.genesis_hash, + genesis_id=suggested_params.genesis_id, + payment=PaymentTransactionFields( + receiver=multisig_address, + amount=funding_amount, + ), + ) + + fund_tx = assign_fee( + fund_tx_without_fee, + fee_per_byte=suggested_params.fee, + min_fee=suggested_params.min_fee, + ) + + signed_fund_tx = dispenser.signer([fund_tx], [0]) + algod.send_raw_transaction(signed_fund_tx[0]) + wait_for_confirmation(algod, fund_tx.tx_id()) + + multisig_balance = get_account_balance(algorand, multisig_address) + print_info(f"Funded multisig with {format_algo(funding_amount)}") + print_info(f"Multisig balance: {format_algo(multisig_balance)}") + + # Step 6: Create a payment transaction from the multisig + print_step(6, "Create Payment Transaction from Multisig") + + receiver = algorand.account.random() + payment_amount = 1_000_000 # 1 ALGO + + pay_params = algod.suggested_params() + + payment_tx_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=multisig_address, # The sender is the multisig address + first_valid=pay_params.first_valid, + last_valid=pay_params.last_valid, + genesis_hash=pay_params.genesis_hash, + genesis_id=pay_params.genesis_id, + payment=PaymentTransactionFields( + receiver=receiver.addr, + amount=payment_amount, + ), + ) + + payment_tx = assign_fee( + payment_tx_without_fee, + fee_per_byte=pay_params.fee, + min_fee=pay_params.min_fee, + ) + + print_info(f"Payment amount: {format_algo(payment_amount)}") + print_info(f"Sender (multisig): {shorten_address(multisig_address)}") + print_info(f"Receiver: {shorten_address(receiver.addr)}") + print_info(f"Transaction ID: {payment_tx.tx_id()}") + + # Step 7: Sign with 2 of the 3 accounts using MultisigAccount.signer + print_step(7, "Sign with 2 of 3 Accounts") + + print_info("Signing with accounts 1 and 2 (meeting 2-of-3 threshold)...") + print_info("") + print_info("How multisig signing works:") + print_info(" 1. Each sub-signer signs the transaction individually") + print_info(" 2. Signatures are collected into a MultisigSignature structure") + print_info(" 3. The structure includes version, threshold, and all subsigs") + print_info(" 4. Subsigs contain public key + signature (or undefined if not signed)") + print_info("") + + # The MultisigAccount.signer automatically collects signatures from all sub-signers + signed_txns = multisig_with_2_signers.signer([payment_tx], [0]) + + print_info(f"Signed transaction size: {len(signed_txns[0])} bytes") + print_success("Transaction signed by accounts 1 and 2!") + + # Step 8: Submit and verify the transaction succeeds + print_step(8, "Submit and Verify Transaction") + + algod.send_raw_transaction(signed_txns[0]) + print_info("Transaction submitted to network...") + + pending_info = wait_for_confirmation(algod, payment_tx.tx_id()) + print_info(f"Transaction confirmed in round: {pending_info.confirmed_round}") + + # Verify balances + multisig_balance_after = get_account_balance(algorand, multisig_address) + + try: + receiver_info = algorand.account.get_information(receiver.addr) + receiver_balance = receiver_info.amount.micro_algo + except Exception: + receiver_balance = 0 + + print_info(f"Multisig balance after: {format_algo(multisig_balance_after)}") + print_info(f"Receiver balance: {format_algo(receiver_balance)}") + + if receiver_balance == payment_amount: + print_success("Receiver received the payment!") + + # Step 9: Demonstrate that 1 signature is insufficient + print_step(9, "Demonstrate Insufficient Signatures (1 of 3)") + + print_info("Creating a MultisigAccount with only 1 sub-signer (account 3)...") + print_info("") + + # Create a MultisigAccount with only 1 signer - below the threshold + multisig_with_1_signer = MultisigAccount( + params=multisig_params, + sub_signers=[account3], + ) + + # Create another payment transaction + insufficient_params = algod.suggested_params() + + insufficient_tx_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=multisig_address, + first_valid=insufficient_params.first_valid, + last_valid=insufficient_params.last_valid, + genesis_hash=insufficient_params.genesis_hash, + genesis_id=insufficient_params.genesis_id, + payment=PaymentTransactionFields( + receiver=receiver.addr, + amount=500_000, # 0.5 ALGO + ), + ) + + insufficient_tx = assign_fee( + insufficient_tx_without_fee, + fee_per_byte=insufficient_params.fee, + min_fee=insufficient_params.min_fee, + ) + + print_info("Signing with only account 3 (not meeting 2-of-3 threshold)...") + + # Sign with only 1 account + insufficient_signed_txns = multisig_with_1_signer.signer([insufficient_tx], [0]) + + # Try to submit - this should fail + try: + algod.send_raw_transaction(insufficient_signed_txns[0]) + print_info("ERROR: Transaction should have been rejected!") + except Exception as error: + error_message = str(error) + print_info("Transaction rejected as expected!") + if "multisig" in error_message.lower(): + print_info("Reason: Insufficient signatures for multisig") + else: + print_info(f"Reason: {error_message[:100]}...") + print_success("Demonstrated that 1 signature is insufficient for 2-of-3 multisig!") + + # Summary + print_info("") + print_info("Summary - Multisig Key Points:") + print_info(" - MultisigAccount wraps multiple signers with a threshold") + print_info(" - version=1 is the standard multisig version") + print_info(" - threshold specifies minimum signatures required") + print_info(" - The multisig address is deterministically derived from params") + print_info(" - Order of addresses matters for address derivation") + print_info(" - Transactions require at least threshold signatures to succeed") + threshold = 2 + num_addrs = len(multisig_addrs) + print_info(f" - This example used {threshold}-of-{num_addrs} multisig") + + print_success("Multisig example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/transact/11_logic_sig.py b/examples/transact/11_logic_sig.py new file mode 100644 index 00000000..f5313bb0 --- /dev/null +++ b/examples/transact/11_logic_sig.py @@ -0,0 +1,359 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Logic Signature + +This example demonstrates how to use a logic signature (lsig) to authorize transactions. + +Key concepts: +- Compiling a TEAL program using algod.teal_compile() +- Creating a LogicSig from compiled program bytes +- Understanding the logic signature address (derived from program hash) +- Funding and using a logic signature as a standalone account +- Creating a delegated logic signature where an account delegates signing to a program + +Logic signatures allow transactions to be authorized by a program instead of (or in addition to) +a cryptographic signature. This enables smart contracts that can hold and send funds based +purely on program logic. + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import base64 + +from shared import ( + create_algod_client, + format_algo, + get_account_balance, + load_teal_source, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, + wait_for_confirmation, +) + +from algokit_transact import ( + LogicSigAccount, + PaymentTransactionFields, + Transaction, + TransactionType, + assign_fee, +) +from algokit_utils import AlgorandClient + + +def main() -> None: + print_header("Logic Signature Example") + + # Step 1: Initialize clients + print_step(1, "Initialize Algod Client") + algod = create_algod_client() + algorand = AlgorandClient.default_localnet() + + try: + algod.status() + print_info("Connected to LocalNet Algod") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 2: Compile a simple TEAL program using algod.teal_compile() + print_step(2, "Compile TEAL Program") + + # Load the "always approve" TEAL program from shared artifacts + # In real-world use cases, you would have logic that validates: + # - Who the receiver is + # - Maximum amount that can be sent + # - Time-based restrictions + # - etc. + teal_source = load_teal_source("always-approve.teal") + + print_info("TEAL source code:") + print_info(" #pragma version 10") + print_info(" int 1") + print_info(" return") + print_info("") + print_info("This program always returns 1 (true), meaning it approves all transactions.") + print_info("WARNING: Real logic sigs should have proper validation logic!") + print_info("") + + # Compile the TEAL program using algod + compile_result = algod.teal_compile(teal_source) + program_bytes = base64.b64decode(compile_result.result) + + print_info(f"Compiled program size: {len(program_bytes)} bytes") + print_info(f"Program hash (base32): {compile_result.hash_}") + + # Step 3: Create LogicSig from the compiled program bytes + print_step(3, "Create LogicSig from Program Bytes") + + # The LogicSigAccount wraps the compiled program and provides a signer + # Optionally, you can pass arguments to the program + logic_sig = LogicSigAccount(logic=program_bytes) + + print_info("LogicSig created from compiled program bytes") + print_info("") + print_info("How LogicSig address is derived:") + print_info(' 1. Prefix "Program" is concatenated with program bytes') + print_info(" 2. SHA512/256 hash is computed") + print_info(" 3. Hash becomes the 32-byte public key equivalent") + print_info(" 4. Address is derived same as for ed25519 keys") + + # Step 4: Show the logic signature address + print_step(4, "Show Logic Signature Address") + + lsig_address = logic_sig.addr + print_info(f"Logic signature address: {lsig_address}") + print_info("") + print_info("This address is deterministically derived from the program.") + print_info("Anyone with the same program can compute this address.") + print_info("Funds sent to this address can only be spent by providing the program.") + + # Step 5: Fund the logic signature address + print_step(5, "Fund the Logic Signature Address") + + dispenser = algorand.account.localnet_dispenser() + funding_amount = 5_000_000 # 5 ALGO + + suggested_params = algod.suggested_params() + + fund_tx_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=dispenser.addr, + first_valid=suggested_params.first_valid, + last_valid=suggested_params.last_valid, + genesis_hash=suggested_params.genesis_hash, + genesis_id=suggested_params.genesis_id, + payment=PaymentTransactionFields( + receiver=lsig_address, + amount=funding_amount, + ), + ) + + fund_tx = assign_fee( + fund_tx_without_fee, + fee_per_byte=suggested_params.fee, + min_fee=suggested_params.min_fee, + ) + + signed_fund_tx = dispenser.signer([fund_tx], [0]) + algod.send_raw_transaction(signed_fund_tx[0]) + wait_for_confirmation(algod, fund_tx.tx_id()) + + lsig_balance = get_account_balance(algorand, lsig_address) + print_info(f"Funded logic signature with {format_algo(funding_amount)}") + print_info(f"Logic signature balance: {format_algo(lsig_balance)}") + + # Step 6: Create LogicSigAccount and use its signer to authorize a payment + print_step(6, "Create LogicSigAccount and Send Payment") + + # LogicSigAccount wraps the LogicSig and provides a signer function + # For a non-delegated lsig, the sender is the lsig address itself + lsig_account = LogicSigAccount(logic=program_bytes) + + receiver = algorand.account.random() + payment_amount = 1_000_000 # 1 ALGO + + pay_params = algod.suggested_params() + + payment_tx_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=lsig_address, # The logic signature is the sender + first_valid=pay_params.first_valid, + last_valid=pay_params.last_valid, + genesis_hash=pay_params.genesis_hash, + genesis_id=pay_params.genesis_id, + payment=PaymentTransactionFields( + receiver=receiver.addr, + amount=payment_amount, + ), + ) + + payment_tx = assign_fee( + payment_tx_without_fee, + fee_per_byte=pay_params.fee, + min_fee=pay_params.min_fee, + ) + + print_info(f"Payment amount: {format_algo(payment_amount)}") + print_info(f"Sender (lsig): {shorten_address(lsig_address)}") + print_info(f"Receiver: {shorten_address(receiver.addr)}") + print_info("") + print_info("How logic signature authorization works:") + print_info(" 1. Transaction is created with lsig address as sender") + print_info(" 2. Instead of a signature, the program bytes are attached") + print_info(" 3. Network executes the program to validate the transaction") + print_info(" 4. If program returns non-zero, transaction is authorized") + + # Step 7: Submit transaction authorized by the logic signature + print_step(7, "Submit Logic Signature Transaction") + + # The LogicSigAccount.signer attaches the program instead of a signature + signed_txns = lsig_account.signer([payment_tx], [0]) + + print_info(f"Signed transaction size: {len(signed_txns[0])} bytes") + print_info("(Contains program bytes instead of ed25519 signature)") + + algod.send_raw_transaction(signed_txns[0]) + print_info("Transaction submitted to network...") + + pending_info = wait_for_confirmation(algod, payment_tx.tx_id()) + print_info(f"Transaction confirmed in round: {pending_info.confirmed_round}") + + # Verify balances + lsig_balance_after = get_account_balance(algorand, lsig_address) + try: + receiver_info = algorand.account.get_information(receiver.addr) + receiver_balance = receiver_info.amount.micro_algo + except Exception: + receiver_balance = 0 + + print_info(f"Logic signature balance after: {format_algo(lsig_balance_after)}") + print_info(f"Receiver balance: {format_algo(receiver_balance)}") + + if receiver_balance == payment_amount: + print_success("Receiver received the payment from logic signature!") + + # Step 8: Demonstrate delegated logic signature + print_step(8, "Demonstrate Delegated Logic Signature") + + print_info("A delegated logic signature allows an account to delegate") + print_info("transaction authorization to a program. The account signs") + print_info("the program once, and then transactions from that account") + print_info("can be authorized by the program without further signatures.") + print_info("") + + # Create an account that will delegate to the lsig + delegator = algorand.account.random() + + # Fund the delegator account + fund_delegator_params = algod.suggested_params() + fund_delegator_tx_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=dispenser.addr, + first_valid=fund_delegator_params.first_valid, + last_valid=fund_delegator_params.last_valid, + genesis_hash=fund_delegator_params.genesis_hash, + genesis_id=fund_delegator_params.genesis_id, + payment=PaymentTransactionFields( + receiver=delegator.addr, + amount=3_000_000, # 3 ALGO + ), + ) + + fund_delegator_tx = assign_fee( + fund_delegator_tx_without_fee, + fee_per_byte=fund_delegator_params.fee, + min_fee=fund_delegator_params.min_fee, + ) + + signed_fund_delegator_tx = dispenser.signer([fund_delegator_tx], [0]) + algod.send_raw_transaction(signed_fund_delegator_tx[0]) + wait_for_confirmation(algod, fund_delegator_tx.tx_id()) + + delegator_balance = get_account_balance(algorand, delegator.addr) + print_info(f"Delegator account: {shorten_address(delegator.addr)}") + print_info(f"Delegator balance: {format_algo(delegator_balance)}") + print_info("") + + # Create a delegated logic signature + # The delegator signs the program, allowing it to authorize transactions on their behalf + print_info("Creating delegated logic signature...") + print_info("The delegator signs the program bytes to create a delegation.") + print_info("") + + # Create a LogicSigAccount with the delegator's address + delegated_lsig = LogicSigAccount(logic=program_bytes, _address=delegator.addr) + + # Sign the lsig for delegation using the delegator's signer + delegated_lsig.sign_for_delegation(delegator) + + print_info("Delegator has signed the program for delegation.") + delegator_addr = shorten_address(delegator.addr) + print_info(f"Delegated lsig will authorize transactions FROM: {delegator_addr}") + print_info("") + print_info("How delegation works:") + print_info(' 1. Delegator signs: Hash("Program" || program_bytes) with their key') + print_info(" 2. This signature is stored in the LogicSigAccount") + print_info(" 3. Transactions include: program + delegator signature") + print_info(" 4. Network verifies signature matches delegator public key") + print_info(" 5. Then executes program to authorize the transaction") + + # Create a payment from the delegator, authorized by the delegated lsig + delegated_receiver = algorand.account.random() + delegated_payment_amount = 500_000 # 0.5 ALGO + + delegated_pay_params = algod.suggested_params() + + delegated_payment_tx_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=delegator.addr, # Sender is the delegator's address, NOT the lsig address + first_valid=delegated_pay_params.first_valid, + last_valid=delegated_pay_params.last_valid, + genesis_hash=delegated_pay_params.genesis_hash, + genesis_id=delegated_pay_params.genesis_id, + payment=PaymentTransactionFields( + receiver=delegated_receiver.addr, + amount=delegated_payment_amount, + ), + ) + + delegated_payment_tx = assign_fee( + delegated_payment_tx_without_fee, + fee_per_byte=delegated_pay_params.fee, + min_fee=delegated_pay_params.min_fee, + ) + + print_info(f"Delegated payment amount: {format_algo(delegated_payment_amount)}") + print_info(f"Sender (delegator account): {shorten_address(delegator.addr)}") + print_info(f"Receiver: {shorten_address(delegated_receiver.addr)}") + + # Sign with the delegated lsig - this uses the program + stored delegation signature + delegated_signed_txns = delegated_lsig.signer([delegated_payment_tx], [0]) + + algod.send_raw_transaction(delegated_signed_txns[0]) + print_info("Delegated transaction submitted to network...") + + delegated_pending_info = wait_for_confirmation(algod, delegated_payment_tx.tx_id()) + delegated_confirmed_round = delegated_pending_info.confirmed_round + print_info(f"Transaction confirmed in round: {delegated_confirmed_round}") + + # Verify balances + delegator_balance_after = get_account_balance(algorand, delegator.addr) + try: + delegated_receiver_info = algorand.account.get_information(delegated_receiver.addr) + delegated_receiver_balance = delegated_receiver_info.amount.micro_algo + except Exception: + delegated_receiver_balance = 0 + + print_info(f"Delegator balance after: {format_algo(delegator_balance_after)}") + print_info(f"Receiver balance: {format_algo(delegated_receiver_balance)}") + + if delegated_receiver_balance == delegated_payment_amount: + print_success("Delegated logic signature successfully authorized the transaction!") + + # Summary + print_info("") + print_info("Summary - Logic Signature Key Points:") + print_info(" - LogicSig wraps a compiled TEAL program") + print_info(" - The lsig address is derived from the program hash") + print_info(" - Non-delegated: lsig acts as its own account") + print_info(" - Delegated: an account signs the program to delegate auth") + print_info(" - Program is executed to validate each transaction") + print_info(" - Real programs should have strict validation logic!") + print_info("") + print_info("Common use cases for logic signatures:") + print_info(" - Escrow accounts with release conditions") + print_info(" - Hash time-locked contracts (HTLC)") + print_info(" - Recurring payment authorizations") + print_info(" - Multi-condition authorization logic") + + print_success("Logic signature example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/transact/12_fee_calculation.py b/examples/transact/12_fee_calculation.py new file mode 100644 index 00000000..8e98a2d2 --- /dev/null +++ b/examples/transact/12_fee_calculation.py @@ -0,0 +1,273 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Fee Calculation + +This example demonstrates how to estimate transaction size and calculate fees +using the transact package: +- estimate_transaction_size() to get estimated byte size +- calculate_fee() with different fee parameters +- assign_fee() to set fee on transaction +- How fee_per_byte, min_fee, extra_fee, and max_fee work +- Compare estimated vs actual transaction sizes + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from shared import ( + create_algod_client, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_transact import ( + AppCallTransactionFields, + AssetTransferTransactionFields, + OnApplicationComplete, + PaymentTransactionFields, + Transaction, + TransactionType, + assign_fee, + calculate_fee, + estimate_transaction_size, +) +from algokit_utils import AlgorandClient + + +def main() -> None: + print_header("Fee Calculation Example") + + # Step 1: Initialize clients + print_step(1, "Initialize Algod Client") + algod = create_algod_client() + algorand = AlgorandClient.default_localnet() + + try: + algod.status() + print_info("Connected to LocalNet Algod") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 2: Get accounts + print_step(2, "Get Accounts") + sender = algorand.account.localnet_dispenser() + print_info(f"Sender address: {shorten_address(sender.addr)}") + + receiver = algorand.account.random() + print_info(f"Receiver address: {shorten_address(receiver.addr)}") + + # Step 3: Get suggested transaction parameters + print_step(3, "Get Suggested Transaction Parameters") + suggested_params = algod.suggested_params() + print_info(f"First valid round: {suggested_params.first_valid}") + print_info(f"Last valid round: {suggested_params.last_valid}") + print_info(f"Fee per byte from network: {suggested_params.fee} microALGO") + print_info(f"Minimum fee from network: {suggested_params.min_fee} microALGO") + + # Step 4: Create a simple payment transaction and estimate its size + print_step(4, "Estimate Payment Transaction Size") + + payment_tx = Transaction( + transaction_type=TransactionType.Payment, + sender=sender.addr, + first_valid=suggested_params.first_valid, + last_valid=suggested_params.last_valid, + genesis_hash=suggested_params.genesis_hash, + genesis_id=suggested_params.genesis_id, + payment=PaymentTransactionFields( + receiver=receiver.addr, + amount=1_000_000, # 1 ALGO + ), + ) + + payment_estimated_size = estimate_transaction_size(payment_tx) + print_info(f"Payment transaction estimated size: {payment_estimated_size} bytes") + + # Step 5: Create an asset transfer transaction and estimate its size + print_step(5, "Estimate Asset Transfer Transaction Size") + + asset_transfer_tx = Transaction( + transaction_type=TransactionType.AssetTransfer, + sender=sender.addr, + first_valid=suggested_params.first_valid, + last_valid=suggested_params.last_valid, + genesis_hash=suggested_params.genesis_hash, + genesis_id=suggested_params.genesis_id, + asset_transfer=AssetTransferTransactionFields( + asset_id=123456, # Example asset ID + receiver=receiver.addr, + amount=1000, + ), + ) + + asset_transfer_estimated_size = estimate_transaction_size(asset_transfer_tx) + print_info(f"Asset transfer transaction estimated size: {asset_transfer_estimated_size} bytes") + + # Step 6: Create an app call transaction and estimate its size + print_step(6, "Estimate App Call Transaction Size") + + # Simple approval program: #pragma version 9; int 1 + simple_program = bytes([0x09, 0x81, 0x01]) + + app_call_tx = Transaction( + transaction_type=TransactionType.AppCall, + sender=sender.addr, + first_valid=suggested_params.first_valid, + last_valid=suggested_params.last_valid, + genesis_hash=suggested_params.genesis_hash, + genesis_id=suggested_params.genesis_id, + application_call=AppCallTransactionFields( + app_id=0, # App creation (0 = new app) + on_complete=OnApplicationComplete.NoOp, + approval_program=simple_program, + clear_state_program=simple_program, + args=[b"arg1", b"arg2"], + ), + ) + + app_call_estimated_size = estimate_transaction_size(app_call_tx) + print_info(f"App call transaction estimated size: {app_call_estimated_size} bytes") + + # Step 7: Demonstrate calculate_fee with fee_per_byte and min_fee + print_step(7, "Calculate Fee with fee_per_byte and min_fee") + + # When fee_per_byte is 0, min_fee is used + fee_with_zero_per_byte = calculate_fee(payment_tx, fee_per_byte=0, min_fee=1000) + print_info(f"Fee with fee_per_byte=0, min_fee=1000: {fee_with_zero_per_byte} microALGO") + + # When fee_per_byte results in fee less than min_fee, min_fee is used + fee_with_low_per_byte = calculate_fee(payment_tx, fee_per_byte=1, min_fee=1000) + print_info(f"Fee with fee_per_byte=1, min_fee=1000: {fee_with_low_per_byte} microALGO") + calculated_fee = 1 * payment_estimated_size + print_info(f" (fee_per_byte * {payment_estimated_size} = {calculated_fee} < min_fee, so min_fee is used)") + + # When fee_per_byte results in fee greater than min_fee + fee_with_high_per_byte = calculate_fee(payment_tx, fee_per_byte=10, min_fee=1000) + print_info(f"Fee with fee_per_byte=10, min_fee=1000: {fee_with_high_per_byte} microALGO") + high_calculated_fee = 10 * payment_estimated_size + print_info(f" (fee_per_byte * {payment_estimated_size} = {high_calculated_fee} > min_fee)") + + # Step 8: Demonstrate calculate_fee with extra_fee + print_step(8, "Calculate Fee with extra_fee") + + fee_with_extra = calculate_fee( + payment_tx, + fee_per_byte=suggested_params.fee, + min_fee=suggested_params.min_fee, + extra_fee=500, # Add 500 microALGO extra + ) + base_fee = calculate_fee( + payment_tx, + fee_per_byte=suggested_params.fee, + min_fee=suggested_params.min_fee, + ) + print_info(f"Base fee: {base_fee} microALGO") + print_info(f"Fee with extra_fee=500: {fee_with_extra} microALGO") + print_info(f" (baseFee {base_fee} + extra_fee 500 = {fee_with_extra})") + + # Step 9: Demonstrate calculate_fee with max_fee (error case) + print_step(9, "Calculate Fee with max_fee Limit") + + # max_fee throws an error if calculated fee exceeds it + try: + calculate_fee( + payment_tx, + fee_per_byte=10, + min_fee=1000, + max_fee=500, # max_fee less than calculated fee will throw + ) + print_info("This should not be reached") + except Exception as error: + print_info("max_fee=500 with fee_per_byte=10 throws error:") + error_msg = str(error)[:100] + print_info(f' "{error_msg}"') + + # max_fee that allows the fee through + fee_with_max_fee = calculate_fee( + payment_tx, + fee_per_byte=suggested_params.fee, + min_fee=suggested_params.min_fee, + max_fee=10000, # Allow up to 10000 microALGO + ) + print_info(f"Fee with max_fee=10000: {fee_with_max_fee} microALGO (within limit)") + + # Step 10: Use assign_fee to set fee on transaction + print_step(10, "Assign Fee to Transaction") + + tx_with_fee = assign_fee( + payment_tx, + fee_per_byte=suggested_params.fee, + min_fee=suggested_params.min_fee, + ) + original_fee = payment_tx.fee if payment_tx.fee else "not set" + print_info(f"Original transaction fee: {original_fee}") + print_info(f"Transaction fee after assign_fee: {tx_with_fee.fee} microALGO") + + # Step 11: Compare estimated vs actual signed transaction sizes + print_step(11, "Compare Estimated vs Actual Transaction Sizes") + + # Sign the transaction + signed_txns = sender.signer([tx_with_fee], [0]) + signed_tx_bytes = signed_txns[0] + + # Decode the signed transaction to get the actual size + print_info(f"Estimated transaction size: {payment_estimated_size} bytes") + print_info(f"Actual signed transaction size: {len(signed_tx_bytes)} bytes") + + size_difference = len(signed_tx_bytes) - payment_estimated_size + if size_difference >= 0: + print_info(f"Difference: +{size_difference} bytes (actual is larger)") + else: + print_info(f"Difference: {size_difference} bytes (estimate was larger)") + print_info("Note: The estimate includes signature overhead, so sizes should be close") + + # Step 12: Compare sizes across transaction types + print_step(12, "Size Comparison Across Transaction Types") + + print_info("Transaction type size comparison:") + print_info(f" Payment: {payment_estimated_size} bytes") + print_info(f" Asset Transfer: {asset_transfer_estimated_size} bytes") + print_info(f" App Call: {app_call_estimated_size} bytes") + print_info("") + print_info("App calls tend to be larger due to programs and arguments.") + print_info("Asset transfers include the asset ID field.") + print_info("Payments are typically the smallest transaction type.") + + # Step 13: Fee calculation for covering inner transactions + print_step(13, "Calculate Extra Fee for Inner Transactions") + + # When an app makes inner transactions, the outer transaction needs to pay for them + inner_tx_count = 3 + fee_per_inner_tx = suggested_params.min_fee + extra_fee_for_inner_txs = inner_tx_count * fee_per_inner_tx + + fee_for_app_with_inner_txs = calculate_fee( + app_call_tx, + fee_per_byte=suggested_params.fee, + min_fee=suggested_params.min_fee, + extra_fee=extra_fee_for_inner_txs, + ) + + base_app_fee = calculate_fee( + app_call_tx, + fee_per_byte=suggested_params.fee, + min_fee=suggested_params.min_fee, + ) + + print_info(f"Scenario: App call that makes {inner_tx_count} inner transactions") + print_info(f"Base app call fee: {base_app_fee} microALGO") + extra_fee_info = f"{extra_fee_for_inner_txs} microALGO ({inner_tx_count} x {fee_per_inner_tx})" + print_info(f"Extra fee for inner txns: {extra_fee_info}") + print_info(f"Total fee: {fee_for_app_with_inner_txs} microALGO") + + print_success("Fee calculation example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/transact/13_encoding_decoding.py b/examples/transact/13_encoding_decoding.py new file mode 100644 index 00000000..fdc902b2 --- /dev/null +++ b/examples/transact/13_encoding_decoding.py @@ -0,0 +1,303 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004, PLR0911 +""" +Example: Encoding/Decoding + +This example demonstrates how to serialize and deserialize transactions +using the transact package: +- encode_transaction() to get msgpack bytes with TX prefix +- encode_transaction_raw() to get msgpack bytes without prefix +- decode_transaction() to reconstruct transaction from bytes +- encode_signed_transaction() and decode_signed_transaction() for signed transactions +- tx_id() for calculating transaction ID + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +from shared import ( + create_algod_client, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, +) + +from algokit_transact import ( + PaymentTransactionFields, + SignedTransaction, + Transaction, + TransactionType, + assign_fee, + decode_signed_transaction, + decode_transaction, + encode_signed_transaction, + encode_transaction, + encode_transaction_raw, +) +from algokit_utils import AlgorandClient + + +def bytes_to_hex(data: bytes, max_length: int | None = None) -> str: + """Converts bytes to a hex string for display.""" + hex_str = data.hex() + if max_length and len(hex_str) > max_length: + return f"{hex_str[:max_length]}..." + return hex_str + + +def compare_transactions(original: Transaction, decoded: Transaction) -> bool: + """Compare two transactions field by field.""" + # Compare basic fields + if original.transaction_type != decoded.transaction_type: + return False + if original.sender != decoded.sender: + return False + if original.first_valid != decoded.first_valid: + return False + if original.last_valid != decoded.last_valid: + return False + if original.fee != decoded.fee: + return False + if original.genesis_id != decoded.genesis_id: + return False + + # Compare genesis hash + if original.genesis_hash and decoded.genesis_hash: + if original.genesis_hash != decoded.genesis_hash: + return False + elif original.genesis_hash != decoded.genesis_hash: + return False + + # Compare payment fields if present + if original.payment and decoded.payment: + if original.payment.receiver != decoded.payment.receiver: + return False + if original.payment.amount != decoded.payment.amount: + return False + elif original.payment != decoded.payment: + return False + + return True + + +def main() -> None: + print_header("Encoding/Decoding Example") + + # Step 1: Initialize clients + print_step(1, "Initialize Algod Client") + algod = create_algod_client() + algorand = AlgorandClient.default_localnet() + + try: + algod.status() + print_info("Connected to LocalNet Algod") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 2: Get accounts + print_step(2, "Get Accounts") + sender = algorand.account.localnet_dispenser() + print_info(f"Sender address: {shorten_address(sender.addr)}") + + receiver = algorand.account.random() + print_info(f"Receiver address: {shorten_address(receiver.addr)}") + + # Step 3: Create a transaction object + print_step(3, "Create Transaction Object") + suggested_params = algod.suggested_params() + + transaction = Transaction( + transaction_type=TransactionType.Payment, + sender=sender.addr, + first_valid=suggested_params.first_valid, + last_valid=suggested_params.last_valid, + genesis_hash=suggested_params.genesis_hash, + genesis_id=suggested_params.genesis_id, + payment=PaymentTransactionFields( + receiver=receiver.addr, + amount=1_000_000, # 1 ALGO + ), + ) + + tx_with_fee = assign_fee( + transaction, + fee_per_byte=suggested_params.fee, + min_fee=suggested_params.min_fee, + ) + + print_info(f"Transaction type: {tx_with_fee.transaction_type}") + print_info("Amount: 1,000,000 microALGO") + print_info(f"Fee: {tx_with_fee.fee} microALGO") + + # Step 4: Use encode_transaction() to get msgpack bytes with TX prefix + print_step(4, "Encode Transaction with TX Prefix (encode_transaction)") + + encoded_with_prefix = encode_transaction(tx_with_fee) + print_info(f"Encoded bytes length: {len(encoded_with_prefix)} bytes") + print_info(f"First bytes (hex): {bytes_to_hex(encoded_with_prefix, 40)}") + print_info("") + print_info('The "TX" prefix (0x5458) is prepended for domain separation.') + print_info("This prevents the same bytes from being valid in multiple contexts.") + first_char = chr(encoded_with_prefix[0]) + second_char = chr(encoded_with_prefix[1]) + print_info(f'TX in ASCII: "{first_char}{second_char}"') + + # Step 5: Use encode_transaction_raw() to get msgpack bytes without prefix + print_step(5, "Encode Transaction Raw (encode_transaction_raw)") + + encoded_raw = encode_transaction_raw(tx_with_fee) + print_info(f"Raw encoded bytes length: {len(encoded_raw)} bytes") + print_info(f"First bytes (hex): {bytes_to_hex(encoded_raw, 40)}") + print_info("") + length_diff = len(encoded_with_prefix) - len(encoded_raw) + print_info(f"Difference in length: {length_diff} bytes (TX prefix)") + print_info("Use encode_transaction_raw() when the signing tool adds its own prefix.") + + # Step 6: Use decode_transaction() to reconstruct from bytes + print_step(6, "Decode Transaction (decode_transaction)") + + # Decode from bytes with prefix + decoded_from_prefix = decode_transaction(encoded_with_prefix) + print_info("Decoded from bytes with TX prefix:") + print_info(f" Type: {decoded_from_prefix.transaction_type}") + print_info(f" Sender: {shorten_address(decoded_from_prefix.sender)}") + print_info(f" Amount: {decoded_from_prefix.payment.amount} microALGO") + print_info(f" Fee: {decoded_from_prefix.fee} microALGO") + + # Decode from raw bytes (without prefix) + decoded_from_raw = decode_transaction(encoded_raw) + print_info("") + print_info("Decoded from raw bytes (without prefix):") + print_info(f" Type: {decoded_from_raw.transaction_type}") + print_info(f" Sender: {shorten_address(decoded_from_raw.sender)}") + print_info(f" Amount: {decoded_from_raw.payment.amount} microALGO") + print_info("") + print_info("Note: decode_transaction() auto-detects and handles both formats.") + + # Step 7: Verify decoded transaction matches original + print_step(7, "Verify Decoded Transaction Matches Original") + + matches_original = compare_transactions(tx_with_fee, decoded_from_prefix) + if matches_original: + print_success("Decoded transaction matches original!") + else: + print_info("Warning: Decoded transaction differs from original") + + print_info("") + print_info("Field comparison:") + type_match = tx_with_fee.transaction_type == decoded_from_prefix.transaction_type + print_info( + f" Type: {tx_with_fee.transaction_type} === {decoded_from_prefix.transaction_type} {'match' if type_match else 'mismatch'}" + ) + sender_match = tx_with_fee.sender == decoded_from_prefix.sender + print_info(f" Sender: {'match' if sender_match else 'mismatch'}") + receiver_match = tx_with_fee.payment.receiver == decoded_from_prefix.payment.receiver + print_info(f" Receiver: {'match' if receiver_match else 'mismatch'}") + amount_match = tx_with_fee.payment.amount == decoded_from_prefix.payment.amount + print_info(f" Amount: {'match' if amount_match else 'mismatch'}") + fee_match = tx_with_fee.fee == decoded_from_prefix.fee + print_info(f" Fee: {'match' if fee_match else 'mismatch'}") + first_valid_match = tx_with_fee.first_valid == decoded_from_prefix.first_valid + print_info(f" First valid: {'match' if first_valid_match else 'mismatch'}") + last_valid_match = tx_with_fee.last_valid == decoded_from_prefix.last_valid + print_info(f" Last valid: {'match' if last_valid_match else 'mismatch'}") + + # Step 8: Demonstrate encode_signed_transaction() and decode_signed_transaction() + print_step(8, "Encode and Decode Signed Transaction") + + # Sign the transaction + signed_tx_bytes_list = sender.signer([tx_with_fee], [0]) + signed_tx_bytes = signed_tx_bytes_list[0] + print_info(f"Signed transaction bytes length: {len(signed_tx_bytes)} bytes") + + # Decode the signed transaction + decoded_signed_tx = decode_signed_transaction(signed_tx_bytes) + print_info("") + print_info("Decoded SignedTransaction structure:") + print_info(f" txn.type: {decoded_signed_tx.txn.transaction_type}") + print_info(f" txn.sender: {shorten_address(decoded_signed_tx.txn.sender)}") + sig_length = len(decoded_signed_tx.sig) if decoded_signed_tx.sig else 0 + print_info(f" sig length: {sig_length} bytes (ed25519 signature)") + + # Re-encode the signed transaction + re_encoded_signed_tx = encode_signed_transaction(decoded_signed_tx) + print_info("") + print_info("Re-encoded signed transaction:") + print_info(f" Length: {len(re_encoded_signed_tx)} bytes") + + # Verify re-encoded matches original + signed_bytes_match = re_encoded_signed_tx == signed_tx_bytes + + if signed_bytes_match: + print_success("Re-encoded signed transaction matches original!") + else: + print_info("Re-encoded signed transaction differs (may be due to canonicalization)") + + # Step 9: Show transaction ID calculation using tx_id() + print_step(9, "Calculate Transaction ID (tx_id)") + + tx_id = tx_with_fee.tx_id() + print_info(f"Transaction ID: {tx_id}") + print_info("") + print_info("Transaction ID calculation:") + print_info(" 1. Encode transaction with TX prefix") + print_info(" 2. Hash the bytes using SHA-512/256") + print_info(" 3. Base32 encode the hash (first 52 characters)") + print_info("") + print_info(f"ID length: {len(tx_id)} characters") + + # Verify the decoded transaction has the same ID + decoded_tx_id = decoded_from_prefix.tx_id() + if tx_id == decoded_tx_id: + print_success("Decoded transaction has same ID as original!") + else: + print_info("Warning: Transaction IDs differ") + + # Step 10: Demonstrate round-trip encoding with SignedTransaction structure + print_step(10, "Create and Encode SignedTransaction Manually") + + # Create a SignedTransaction structure manually (for demonstration) + manual_signed_tx = SignedTransaction( + txn=tx_with_fee, + sig=decoded_signed_tx.sig, # Reuse the signature from earlier + ) + + manual_encoded_signed_tx = encode_signed_transaction(manual_signed_tx) + print_info(f"Manually created SignedTransaction encoded: {len(manual_encoded_signed_tx)} bytes") + + manual_decoded_signed_tx = decode_signed_transaction(manual_encoded_signed_tx) + sig_present = manual_decoded_signed_tx.sig is not None + txn_type = manual_decoded_signed_tx.txn.transaction_type + print_info(f"Decoded back: txn.type={txn_type}, sig present={sig_present}") + + # Summary + print_step(11, "Summary") + print_info("") + print_info("Encoding functions:") + print_info(' encode_transaction(tx) - Returns msgpack bytes WITH "TX" prefix') + print_info(" encode_transaction_raw(tx) - Returns msgpack bytes WITHOUT prefix") + print_info(" encode_signed_transaction() - Encodes signed transaction for network") + print_info("") + print_info("Decoding functions:") + print_info(" decode_transaction(bytes) - Decodes bytes to Transaction") + print_info(" (auto-detects prefix)") + print_info(" decode_signed_transaction(bytes) - Decodes bytes to SignedTransaction") + print_info("") + print_info("Other utilities:") + print_info(" tx.tx_id() - Calculate transaction ID (hash of encoded bytes)") + print_info("") + print_info("Use cases:") + print_info(" - Serialize transactions for storage or transmission") + print_info(" - Deserialize transactions received from external sources") + print_info(" - Calculate transaction IDs for tracking and verification") + print_info(" - Inspect signed transactions to verify signature presence") + + print_success("Encoding/Decoding example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/transact/14_app_call.py b/examples/transact/14_app_call.py new file mode 100644 index 00000000..743da088 --- /dev/null +++ b/examples/transact/14_app_call.py @@ -0,0 +1,379 @@ +# ruff: noqa: N999, C901, PLR0912, PLR0915, PLR2004 +""" +Example: Application Call + +This example demonstrates how to deploy and interact with a smart contract +on Algorand using the transact package: +- Compile simple approval and clear TEAL programs using algod.teal_compile() +- Create an app with TransactionType.AppCall and OnApplicationComplete.NoOp +- Use Transaction with application_call=AppCallTransactionFields(...) + including approval_program, clear_state_program, global_state_schema, + and local_state_schema +- Retrieve the created app ID from pending transaction info +- Call the app with application arguments +- Demonstrate OnApplicationComplete.OptIn for local state +- Delete the app at the end + +Prerequisites: +- LocalNet running (via `algokit localnet start`) +""" + +import base64 + +from shared import ( + create_algod_client, + format_algo, + load_teal_source, + print_error, + print_header, + print_info, + print_step, + print_success, + shorten_address, + wait_for_confirmation, +) + +from algokit_transact import ( + AppCallTransactionFields, + OnApplicationComplete, + PaymentTransactionFields, + StateSchema, + Transaction, + TransactionType, + assign_fee, +) +from algokit_utils import AlgorandClient + + +def main() -> None: + print_header("Application Call Example") + + # Step 1: Initialize clients + print_step(1, "Initialize Algod Client") + algod = create_algod_client() + algorand = AlgorandClient.default_localnet() + + try: + algod.status() + print_info("Connected to LocalNet Algod") + except Exception as e: + print_error(f"Failed to connect to LocalNet: {e}") + print_info("Make sure LocalNet is running (e.g., algokit localnet start)") + return + + # Step 2: Get funded account + print_step(2, "Get Funded Account") + creator = algorand.account.localnet_dispenser() + print_info(f"Creator address: {shorten_address(creator.addr)}") + + # Step 3: Compile approval and clear TEAL programs + print_step(3, "Compile TEAL Programs") + + # Load approval and clear state programs from shared artifacts + # The approval program handles app creation, calls, opt-in, and deletion + # with global and local state counters + approval_source = load_teal_source("approval-counter.teal") + + # Simple clear state program that always approves + clear_source = load_teal_source("clear-state-approve.teal") + + print_info("Compiling approval program...") + approval_result = algod.teal_compile(approval_source) + approval_program = base64.b64decode(approval_result.result) + print_info(f"Approval program size: {len(approval_program)} bytes") + print_info(f"Approval program hash: {approval_result.hash_}") + + print_info("") + print_info("Compiling clear state program...") + clear_result = algod.teal_compile(clear_source) + clear_state_program = base64.b64decode(clear_result.result) + print_info(f"Clear state program size: {len(clear_state_program)} bytes") + print_info(f"Clear state program hash: {clear_result.hash_}") + + # Step 4: Create app with TransactionType.AppCall and OnApplicationComplete.NoOp + print_step(4, "Create Application") + + suggested_params = algod.suggested_params() + + # Define state schemas + global_state_schema = StateSchema( + num_uints=1, # For the counter + num_byte_slices=0, # No byte slices in global state + ) + + local_state_schema = StateSchema( + num_uints=1, # For user counter + num_byte_slices=0, # No byte slices in local state + ) + + print_info("App configuration:") + global_uints = global_state_schema.num_uints + global_bytes = global_state_schema.num_byte_slices + print_info(f" Global state: {global_uints} uints, {global_bytes} byte slices") + local_uints = local_state_schema.num_uints + local_bytes = local_state_schema.num_byte_slices + print_info(f" Local state: {local_uints} uints, {local_bytes} byte slices") + print_info("") + + create_app_tx_without_fee = Transaction( + transaction_type=TransactionType.AppCall, + sender=creator.addr, + first_valid=suggested_params.first_valid, + last_valid=suggested_params.last_valid, + genesis_hash=suggested_params.genesis_hash, + genesis_id=suggested_params.genesis_id, + application_call=AppCallTransactionFields( + app_id=0, # 0 means app creation + on_complete=OnApplicationComplete.NoOp, + approval_program=approval_program, + clear_state_program=clear_state_program, + global_state_schema=global_state_schema, + local_state_schema=local_state_schema, + ), + ) + + create_app_tx = assign_fee( + create_app_tx_without_fee, + fee_per_byte=suggested_params.fee, + min_fee=suggested_params.min_fee, + ) + + print_info("Creating app transaction...") + print_info(f" Transaction type: {create_app_tx.transaction_type}") + print_info(" OnComplete: NoOp (for creation)") + print_info(f" Fee: {create_app_tx.fee} microALGO") + + signed_create_tx = creator.signer([create_app_tx], [0]) + algod.send_raw_transaction(signed_create_tx[0]) + + # Step 5: Retrieve created app ID from pending transaction info + print_step(5, "Retrieve Created App ID") + + create_pending_info = wait_for_confirmation(algod, create_app_tx.tx_id()) + app_id = create_pending_info.app_id + + print_info(f"Transaction confirmed in round: {create_pending_info.confirmed_round}") + print_info(f"Created app ID: {app_id}") + print_success("Application created successfully!") + + # Step 6: Call the app with application arguments + print_step(6, "Call the App with Arguments") + + call_params = algod.suggested_params() + + # First call with an argument + arg1 = b"Hello, Algorand!" + call_app_tx_without_fee_1 = Transaction( + transaction_type=TransactionType.AppCall, + sender=creator.addr, + first_valid=call_params.first_valid, + last_valid=call_params.last_valid, + genesis_hash=call_params.genesis_hash, + genesis_id=call_params.genesis_id, + application_call=AppCallTransactionFields( + app_id=app_id, + on_complete=OnApplicationComplete.NoOp, + args=[arg1], + ), + ) + + call_app_tx_1 = assign_fee( + call_app_tx_without_fee_1, + fee_per_byte=call_params.fee, + min_fee=call_params.min_fee, + ) + + print_info(f'Calling app {app_id} with argument: "Hello, Algorand!"') + + signed_call_tx_1 = creator.signer([call_app_tx_1], [0]) + algod.send_raw_transaction(signed_call_tx_1[0]) + + call_pending_info_1 = wait_for_confirmation(algod, call_app_tx_1.tx_id()) + print_info(f"Transaction confirmed in round: {call_pending_info_1.confirmed_round}") + + # Check logs (the app logs the first argument) + logs = call_pending_info_1.logs or [] + if logs and len(logs) > 0: + log_bytes = logs[0] + log_message = log_bytes.decode("utf-8") + print_info(f'App logged: "{log_message}"') + + # Second call to increment counter + call_params_2 = algod.suggested_params() + arg2 = b"Second call!" + + call_app_tx_without_fee_2 = Transaction( + transaction_type=TransactionType.AppCall, + sender=creator.addr, + first_valid=call_params_2.first_valid, + last_valid=call_params_2.last_valid, + genesis_hash=call_params_2.genesis_hash, + genesis_id=call_params_2.genesis_id, + application_call=AppCallTransactionFields( + app_id=app_id, + on_complete=OnApplicationComplete.NoOp, + args=[arg2], + ), + ) + + call_app_tx_2 = assign_fee( + call_app_tx_without_fee_2, + fee_per_byte=call_params_2.fee, + min_fee=call_params_2.min_fee, + ) + + print_info('Calling app again with argument: "Second call!"') + + signed_call_tx_2 = creator.signer([call_app_tx_2], [0]) + algod.send_raw_transaction(signed_call_tx_2[0]) + + call_pending_info_2 = wait_for_confirmation(algod, call_app_tx_2.tx_id()) + print_info(f"Transaction confirmed in round: {call_pending_info_2.confirmed_round}") + + logs_2 = call_pending_info_2.logs or [] + if logs_2 and len(logs_2) > 0: + log_bytes = logs_2[0] + log_message = log_bytes.decode("utf-8") + print_info(f'App logged: "{log_message}"') + + print_success("App calls completed successfully!") + + # Step 7: Demonstrate OnApplicationComplete.OptIn for local state + print_step(7, "Demonstrate OptIn for Local State") + + # Create a new account that will opt into the app + opt_in_user = algorand.account.random() + print_info(f"OptIn user address: {shorten_address(opt_in_user.addr)}") + + # Fund the new account + fund_params = algod.suggested_params() + fund_tx_without_fee = Transaction( + transaction_type=TransactionType.Payment, + sender=creator.addr, + first_valid=fund_params.first_valid, + last_valid=fund_params.last_valid, + genesis_hash=fund_params.genesis_hash, + genesis_id=fund_params.genesis_id, + payment=PaymentTransactionFields( + receiver=opt_in_user.addr, + amount=1_000_000, # 1 ALGO + ), + ) + + fund_tx = assign_fee( + fund_tx_without_fee, + fee_per_byte=fund_params.fee, + min_fee=fund_params.min_fee, + ) + + signed_fund_tx = creator.signer([fund_tx], [0]) + algod.send_raw_transaction(signed_fund_tx[0]) + wait_for_confirmation(algod, fund_tx.tx_id()) + print_info(f"Funded OptIn user with {format_algo(1_000_000)}") + + # OptIn to the app + opt_in_params = algod.suggested_params() + + opt_in_tx_without_fee = Transaction( + transaction_type=TransactionType.AppCall, + sender=opt_in_user.addr, + first_valid=opt_in_params.first_valid, + last_valid=opt_in_params.last_valid, + genesis_hash=opt_in_params.genesis_hash, + genesis_id=opt_in_params.genesis_id, + application_call=AppCallTransactionFields( + app_id=app_id, + on_complete=OnApplicationComplete.OptIn, + ), + ) + + opt_in_tx = assign_fee( + opt_in_tx_without_fee, + fee_per_byte=opt_in_params.fee, + min_fee=opt_in_params.min_fee, + ) + + print_info(f"User opting into app {app_id}...") + print_info(" OnComplete: OptIn") + + signed_opt_in_tx = opt_in_user.signer([opt_in_tx], [0]) + algod.send_raw_transaction(signed_opt_in_tx[0]) + + opt_in_pending_info = wait_for_confirmation(algod, opt_in_tx.tx_id()) + print_info(f"Transaction confirmed in round: {opt_in_pending_info.confirmed_round}") + print_success("User successfully opted into the app!") + + print_info("") + print_info("OptIn explanation:") + print_info(" - OptIn allocates local storage for the user in this app") + print_info(" - The app can now read/write user-specific state") + print_info(" - The user pays for the minimum balance increase") + print_info(" - Our app initializes user_counter to 0 on OptIn") + + # Step 8: Delete the app + print_step(8, "Delete the Application") + + delete_params = algod.suggested_params() + + delete_tx_without_fee = Transaction( + transaction_type=TransactionType.AppCall, + sender=creator.addr, + first_valid=delete_params.first_valid, + last_valid=delete_params.last_valid, + genesis_hash=delete_params.genesis_hash, + genesis_id=delete_params.genesis_id, + application_call=AppCallTransactionFields( + app_id=app_id, + on_complete=OnApplicationComplete.DeleteApplication, + ), + ) + + delete_tx = assign_fee( + delete_tx_without_fee, + fee_per_byte=delete_params.fee, + min_fee=delete_params.min_fee, + ) + + print_info(f"Deleting app {app_id}...") + print_info(" OnComplete: DeleteApplication") + + signed_delete_tx = creator.signer([delete_tx], [0]) + algod.send_raw_transaction(signed_delete_tx[0]) + + delete_pending_info = wait_for_confirmation(algod, delete_tx.tx_id()) + print_info(f"Transaction confirmed in round: {delete_pending_info.confirmed_round}") + print_success("Application deleted successfully!") + + # Summary + print_step(9, "Summary") + print_info("") + print_info("App lifecycle demonstrated:") + print_info(" 1. Create - Deploy with approval_program, clear_state_program, and schemas") + print_info(" 2. Call - Invoke app logic with OnComplete.NoOp") + print_info(" 3. OptIn - User opts in to allocate local state") + print_info(" 4. Delete - Remove app from the blockchain") + print_info("") + print_info("OnComplete values:") + print_info(" - NoOp: Standard app call or creation") + print_info(" - OptIn: Allocate local storage for the sender") + print_info(" - CloseOut: Deallocate local storage (graceful exit)") + print_info(" - ClearState: Deallocate local storage (forced, always succeeds)") + print_info(" - UpdateApplication: Update the programs") + print_info(" - DeleteApplication: Remove the app") + print_info("") + print_info("Key fields for app creation:") + print_info(" - app_id: 0 for creation, actual ID for existing apps") + print_info(" - approval_program: Logic for most operations") + print_info(" - clear_state_program: Logic for ClearState (cannot reject)") + print_info(" - global_state_schema: StateSchema(num_uints, num_byte_slices) for global storage") + print_info(" - local_state_schema: StateSchema(num_uints, num_byte_slices) for per-user storage") + print_info("") + print_info("Retrieving app ID after creation:") + print_info(" pending_info = wait_for_confirmation(algod, tx_id)") + print_info(" app_id = pending_info.app_id") + + print_success("Application call example completed!") + + +if __name__ == "__main__": + main() diff --git a/examples/transact/verify-all.sh b/examples/transact/verify-all.sh new file mode 100755 index 00000000..7b8bee02 --- /dev/null +++ b/examples/transact/verify-all.sh @@ -0,0 +1,86 @@ +#!/bin/bash + +# verify-all.sh - Run all transact examples and verify they work +# Exit with non-zero code if any example fails + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +cd "$SCRIPT_DIR" + +# Array of example files in order +EXAMPLES=( + "01_payment_transaction.py" + "02_payment_close.py" + "03_asset_create.py" + "04_asset_transfer.py" + "05_asset_freeze.py" + "06_asset_clawback.py" + "07_atomic_group.py" + "08_atomic_swap.py" + "09_single_sig.py" + "10_multisig.py" + "11_logic_sig.py" + "12_fee_calculation.py" + "13_encoding_decoding.py" + "14_app_call.py" +) + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +NC='\033[0m' # No Color + +echo "========================================" +echo "Transact Examples Verification Script" +echo "========================================" +echo "" + +if [ ${#EXAMPLES[@]} -eq 0 ]; then + echo "No examples to run yet." + echo "" + echo -e "${GREEN}Transact examples suite passed (no examples)${NC}" + exit 0 +fi + +PASSED=0 +FAILED=0 +FAILED_EXAMPLES=() + +for example in "${EXAMPLES[@]}"; do + echo -n "Running $example... " + + if [ ! -f "$example" ]; then + echo -e "${RED}FAILED${NC} (file not found)" + FAILED=$((FAILED + 1)) + FAILED_EXAMPLES+=("$example") + continue + fi + + # Run the example and capture output/exit code + if OUTPUT=$(uv run python "$example" 2>&1); then + echo -e "${GREEN}PASSED${NC}" + PASSED=$((PASSED + 1)) + else + echo -e "${RED}FAILED${NC}" + echo "$OUTPUT" + FAILED=$((FAILED + 1)) + FAILED_EXAMPLES+=("$example") + fi +done + +echo "" +echo "========================================" +echo "Results: ${PASSED} passed, ${FAILED} failed" +echo "========================================" + +if [ $FAILED -gt 0 ]; then + echo "" + echo -e "${RED}Failed examples:${NC}" + for failed in "${FAILED_EXAMPLES[@]}"; do + echo " - $failed" + done + exit 1 +fi + +echo "" +echo -e "${GREEN}All Transact examples passed!${NC}" +exit 0 diff --git a/examples/uv.lock b/examples/uv.lock new file mode 100644 index 00000000..0d603690 --- /dev/null +++ b/examples/uv.lock @@ -0,0 +1,932 @@ +version = 1 +revision = 1 +requires-python = ">=3.10" + +[[package]] +name = "algokit-examples" +version = "0.0.0" +source = { editable = "." } +dependencies = [ + { name = "algokit-utils" }, + { name = "boto3" }, + { name = "keyring" }, + { name = "python-dotenv" }, +] + +[package.dev-dependencies] +dev = [ + { name = "mypy" }, +] + +[package.metadata] +requires-dist = [ + { name = "algokit-utils", editable = "../" }, + { name = "boto3" }, + { name = "keyring" }, + { name = "python-dotenv", specifier = ">=1.2.2" }, +] + +[package.metadata.requires-dev] +dev = [{ name = "mypy", specifier = ">=1.20.1" }] + +[[package]] +name = "algokit-utils" +version = "5.0.0b2" +source = { editable = "../" } +dependencies = [ + { name = "exceptiongroup" }, + { name = "httpx" }, + { name = "msgpack" }, + { name = "msgpack-types" }, + { name = "pycryptodomex" }, + { name = "pynacl" }, + { name = "typing-extensions" }, + { name = "xhd-wallet-api" }, +] + +[package.metadata] +requires-dist = [ + { name = "exceptiongroup", specifier = ">=1.3.1" }, + { name = "httpx", specifier = ">=0.23.1,<=0.28.1" }, + { name = "msgpack", specifier = ">=1.0.0,<2" }, + { name = "msgpack-types", specifier = ">=0.2.0,<=0.5.0" }, + { name = "pycryptodomex", specifier = ">=3.19,<4" }, + { name = "pynacl", specifier = ">=1.4.0,<2" }, + { name = "typing-extensions", specifier = ">=4.6.0" }, + { name = "xhd-wallet-api", specifier = ">=1.0.0" }, +] + +[package.metadata.requires-dev] +api-generator = [{ name = "oas-generator", editable = "../api/oas-generator" }] +cicd = [] +dev = [ + { name = "filelock", specifier = ">=3.12.0,<4" }, + { name = "furo", specifier = ">=2024.8.6,<2026" }, + { name = "linkify-it-py", specifier = ">=2.0.3,<3" }, + { name = "mypy", specifier = ">=1.5.1,<2" }, + { name = "myst-parser", specifier = ">=4.0.0,<5" }, + { name = "pip", specifier = ">=26.0,<27" }, + { name = "pip-audit", specifier = ">=2.5.6,<3" }, + { name = "poethepoet", specifier = ">=0.19,<0.39" }, + { name = "pre-commit", specifier = ">=3.4.0,<4" }, + { name = "pydantic", specifier = ">=2.0.0,<3" }, + { name = "pydoclint", specifier = ">=0.6.0,<0.9" }, + { name = "pygments", specifier = ">=2.20.0,<3" }, + { name = "pytest", specifier = ">=9.0.3,<10" }, + { name = "pytest-cov", specifier = ">=6,<7" }, + { name = "pytest-httpx", specifier = ">=0.36.0,<0.37" }, + { name = "pytest-mock", specifier = "~=3.14" }, + { name = "pytest-sugar", specifier = ">=1.0.0,<2" }, + { name = "pytest-xdist", specifier = ">=3.6.1,<4" }, + { name = "python-dotenv", specifier = ">=1.0.0,<2" }, + { name = "python-semantic-release", specifier = ">=10.5.0,<11" }, + { name = "requests", specifier = ">=2.33.0,<3" }, + { name = "ruff", specifier = ">=0.1.6,<=0.14.8" }, + { name = "setuptools", specifier = ">=80.9.0,<81" }, + { name = "sphinx", specifier = ">=8.0.0,<9" }, + { name = "sphinx-autoapi", specifier = ">=3.4.0,<4" }, + { name = "sphinx-autobuild", specifier = ">=2024.10.3,<2025" }, + { name = "sphinx-markdown-builder", specifier = ">=0.6.8,<0.7" }, + { name = "syrupy", specifier = ">=5.0.0,<6" }, + { name = "types-deprecated", specifier = ">=1.2.15.20241117,<2" }, +] + +[[package]] +name = "anyio" +version = "4.12.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "idna" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592 }, +] + +[[package]] +name = "backports-tarfile" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/86/72/cd9b395f25e290e633655a100af28cb253e4393396264a98bd5f5951d50f/backports_tarfile-1.2.0.tar.gz", hash = "sha256:d75e02c268746e1b8144c278978b6e98e85de6ad16f8e4b0844a154557eca991", size = 86406 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/fa/123043af240e49752f1c4bd24da5053b6bd00cad78c2be53c0d1e8b975bc/backports.tarfile-1.2.0-py3-none-any.whl", hash = "sha256:77e284d754527b01fb1e6fa8a1afe577858ebe4e9dad8919e34c862cb399bc34", size = 30181 }, +] + +[[package]] +name = "boto3" +version = "1.42.78" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "botocore" }, + { name = "jmespath" }, + { name = "s3transfer" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a8/2b/ebdad075934cf6bb78bf81fe31d83339bcd804ad6c856f7341376cbc88b6/boto3-1.42.78.tar.gz", hash = "sha256:cef2ebdb9be5c0e96822f8d3941ac4b816c90a5737a7ffb901d664c808964b63", size = 112789 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/57/bb/1f6dade1f1e86858bef7bd332bc8106c445f2dbabec7b32ab5d7d118c9b6/boto3-1.42.78-py3-none-any.whl", hash = "sha256:480a34a077484a5ca60124dfd150ba3ea6517fc89963a679e45b30c6db614d26", size = 140556 }, +] + +[[package]] +name = "botocore" +version = "1.42.78" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jmespath" }, + { name = "python-dateutil" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/67/8e/cdb34c8ca71216d214e049ada2148ee08bcda12b1ac72af3a720dea300ff/botocore-1.42.78.tar.gz", hash = "sha256:61cbd49728e23f68cfd945406ab40044d49abed143362f7ffa4a4f4bd4311791", size = 15023592 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/72/94bba1a375d45c685b00e051b56142359547837086a83861d76f6aec26f4/botocore-1.42.78-py3-none-any.whl", hash = "sha256:038ab63c7f898e8b5db58cb6a45e4da56c31dd984e7e995839a3540c735564ea", size = 14701729 }, +] + +[[package]] +name = "certifi" +version = "2026.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900 }, +] + +[[package]] +name = "cffi" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/93/d7/516d984057745a6cd96575eea814fe1edd6646ee6efd552fb7b0921dec83/cffi-2.0.0-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:0cf2d91ecc3fcc0625c2c530fe004f82c110405f101548512cce44322fa8ac44", size = 184283 }, + { url = "https://files.pythonhosted.org/packages/9e/84/ad6a0b408daa859246f57c03efd28e5dd1b33c21737c2db84cae8c237aa5/cffi-2.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f73b96c41e3b2adedc34a7356e64c8eb96e03a3782b535e043a986276ce12a49", size = 180504 }, + { url = "https://files.pythonhosted.org/packages/50/bd/b1a6362b80628111e6653c961f987faa55262b4002fcec42308cad1db680/cffi-2.0.0-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:53f77cbe57044e88bbd5ed26ac1d0514d2acf0591dd6bb02a3ae37f76811b80c", size = 208811 }, + { url = "https://files.pythonhosted.org/packages/4f/27/6933a8b2562d7bd1fb595074cf99cc81fc3789f6a6c05cdabb46284a3188/cffi-2.0.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3e837e369566884707ddaf85fc1744b47575005c0a229de3327f8f9a20f4efeb", size = 216402 }, + { url = "https://files.pythonhosted.org/packages/05/eb/b86f2a2645b62adcfff53b0dd97e8dfafb5c8aa864bd0d9a2c2049a0d551/cffi-2.0.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5eda85d6d1879e692d546a078b44251cdd08dd1cfb98dfb77b670c97cee49ea0", size = 203217 }, + { url = "https://files.pythonhosted.org/packages/9f/e0/6cbe77a53acf5acc7c08cc186c9928864bd7c005f9efd0d126884858a5fe/cffi-2.0.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9332088d75dc3241c702d852d4671613136d90fa6881da7d770a483fd05248b4", size = 203079 }, + { url = "https://files.pythonhosted.org/packages/98/29/9b366e70e243eb3d14a5cb488dfd3a0b6b2f1fb001a203f653b93ccfac88/cffi-2.0.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc7de24befaeae77ba923797c7c87834c73648a05a4bde34b3b7e5588973a453", size = 216475 }, + { url = "https://files.pythonhosted.org/packages/21/7a/13b24e70d2f90a322f2900c5d8e1f14fa7e2a6b3332b7309ba7b2ba51a5a/cffi-2.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cf364028c016c03078a23b503f02058f1814320a56ad535686f90565636a9495", size = 218829 }, + { url = "https://files.pythonhosted.org/packages/60/99/c9dc110974c59cc981b1f5b66e1d8af8af764e00f0293266824d9c4254bc/cffi-2.0.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e11e82b744887154b182fd3e7e8512418446501191994dbf9c9fc1f32cc8efd5", size = 211211 }, + { url = "https://files.pythonhosted.org/packages/49/72/ff2d12dbf21aca1b32a40ed792ee6b40f6dc3a9cf1644bd7ef6e95e0ac5e/cffi-2.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8ea985900c5c95ce9db1745f7933eeef5d314f0565b27625d9a10ec9881e1bfb", size = 218036 }, + { url = "https://files.pythonhosted.org/packages/e2/cc/027d7fb82e58c48ea717149b03bcadcbdc293553edb283af792bd4bcbb3f/cffi-2.0.0-cp310-cp310-win32.whl", hash = "sha256:1f72fb8906754ac8a2cc3f9f5aaa298070652a0ffae577e0ea9bd480dc3c931a", size = 172184 }, + { url = "https://files.pythonhosted.org/packages/33/fa/072dd15ae27fbb4e06b437eb6e944e75b068deb09e2a2826039e49ee2045/cffi-2.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:b18a3ed7d5b3bd8d9ef7a8cb226502c6bf8308df1525e1cc676c3680e7176739", size = 182790 }, + { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344 }, + { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560 }, + { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613 }, + { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476 }, + { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374 }, + { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597 }, + { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574 }, + { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971 }, + { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972 }, + { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078 }, + { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076 }, + { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820 }, + { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635 }, + { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271 }, + { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048 }, + { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529 }, + { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097 }, + { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983 }, + { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519 }, + { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572 }, + { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963 }, + { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361 }, + { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932 }, + { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557 }, + { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762 }, + { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230 }, + { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043 }, + { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446 }, + { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101 }, + { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948 }, + { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422 }, + { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499 }, + { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928 }, + { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302 }, + { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909 }, + { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402 }, + { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780 }, + { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320 }, + { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487 }, + { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049 }, + { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793 }, + { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300 }, + { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244 }, + { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828 }, + { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926 }, + { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328 }, + { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650 }, + { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687 }, + { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773 }, + { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013 }, + { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593 }, + { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354 }, + { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480 }, + { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584 }, + { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443 }, + { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437 }, + { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487 }, + { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726 }, + { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195 }, +] + +[[package]] +name = "cryptography" +version = "46.0.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a4/ba/04b1bd4218cbc58dc90ce967106d51582371b898690f3ae0402876cc4f34/cryptography-46.0.6.tar.gz", hash = "sha256:27550628a518c5c6c903d84f637fbecf287f6cb9ced3804838a1295dc1fd0759", size = 750542 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/f8/e61f8f13950ab6195b31913b42d39f0f9afc7d93f76710f299b5ec286ae6/cryptography-46.0.6-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:26031f1e5ca62fcb9d1fcb34b2b60b390d1aacaa15dc8b895a9ed00968b97b30", size = 4275275 }, + { url = "https://files.pythonhosted.org/packages/19/69/732a736d12c2631e140be2348b4ad3d226302df63ef64d30dfdb8db7ad1c/cryptography-46.0.6-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9a693028b9cbe51b5a1136232ee8f2bc242e4e19d456ded3fa7c86e43c713b4a", size = 4425320 }, + { url = "https://files.pythonhosted.org/packages/d4/12/123be7292674abf76b21ac1fc0e1af50661f0e5b8f0ec8285faac18eb99e/cryptography-46.0.6-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:67177e8a9f421aa2d3a170c3e56eca4e0128883cf52a071a7cbf53297f18b175", size = 4278082 }, + { url = "https://files.pythonhosted.org/packages/5b/ba/d5e27f8d68c24951b0a484924a84c7cdaed7502bac9f18601cd357f8b1d2/cryptography-46.0.6-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:d9528b535a6c4f8ff37847144b8986a9a143585f0540fbcb1a98115b543aa463", size = 4926514 }, + { url = "https://files.pythonhosted.org/packages/34/71/1ea5a7352ae516d5512d17babe7e1b87d9db5150b21f794b1377eac1edc0/cryptography-46.0.6-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:22259338084d6ae497a19bae5d4c66b7ca1387d3264d1c2c0e72d9e9b6a77b97", size = 4457766 }, + { url = "https://files.pythonhosted.org/packages/01/59/562be1e653accee4fdad92c7a2e88fced26b3fdfce144047519bbebc299e/cryptography-46.0.6-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:760997a4b950ff00d418398ad73fbc91aa2894b5c1db7ccb45b4f68b42a63b3c", size = 3986535 }, + { url = "https://files.pythonhosted.org/packages/d6/8b/b1ebfeb788bf4624d36e45ed2662b8bd43a05ff62157093c1539c1288a18/cryptography-46.0.6-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:3dfa6567f2e9e4c5dceb8ccb5a708158a2a871052fa75c8b78cb0977063f1507", size = 4277618 }, + { url = "https://files.pythonhosted.org/packages/dd/52/a005f8eabdb28df57c20f84c44d397a755782d6ff6d455f05baa2785bd91/cryptography-46.0.6-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:cdcd3edcbc5d55757e5f5f3d330dd00007ae463a7e7aa5bf132d1f22a4b62b19", size = 4890802 }, + { url = "https://files.pythonhosted.org/packages/ec/4d/8e7d7245c79c617d08724e2efa397737715ca0ec830ecb3c91e547302555/cryptography-46.0.6-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:d4e4aadb7fc1f88687f47ca20bb7227981b03afaae69287029da08096853b738", size = 4457425 }, + { url = "https://files.pythonhosted.org/packages/1d/5c/f6c3596a1430cec6f949085f0e1a970638d76f81c3ea56d93d564d04c340/cryptography-46.0.6-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:2b417edbe8877cda9022dde3a008e2deb50be9c407eef034aeeb3a8b11d9db3c", size = 4405530 }, + { url = "https://files.pythonhosted.org/packages/7e/c9/9f9cea13ee2dbde070424e0c4f621c091a91ffcc504ffea5e74f0e1daeff/cryptography-46.0.6-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:380343e0653b1c9d7e1f55b52aaa2dbb2fdf2730088d48c43ca1c7c0abb7cc2f", size = 4667896 }, + { url = "https://files.pythonhosted.org/packages/fa/87/887f35a6fca9dde90cad08e0de0c89263a8e59b2d2ff904fd9fcd8025b6f/cryptography-46.0.6-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7f417f034f91dcec1cb6c5c35b07cdbb2ef262557f701b4ecd803ee8cefed4f4", size = 4266221 }, + { url = "https://files.pythonhosted.org/packages/aa/a8/0a90c4f0b0871e0e3d1ed126aed101328a8a57fd9fd17f00fb67e82a51ca/cryptography-46.0.6-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d24c13369e856b94892a89ddf70b332e0b70ad4a5c43cf3e9cb71d6d7ffa1f7b", size = 4408952 }, + { url = "https://files.pythonhosted.org/packages/16/0b/b239701eb946523e4e9f329336e4ff32b1247e109cbab32d1a7b61da8ed7/cryptography-46.0.6-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:aad75154a7ac9039936d50cf431719a2f8d4ed3d3c277ac03f3339ded1a5e707", size = 4270141 }, + { url = "https://files.pythonhosted.org/packages/0f/a8/976acdd4f0f30df7b25605f4b9d3d89295351665c2091d18224f7ad5cdbf/cryptography-46.0.6-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:3c21d92ed15e9cfc6eb64c1f5a0326db22ca9c2566ca46d845119b45b4400361", size = 4904178 }, + { url = "https://files.pythonhosted.org/packages/b1/1b/bf0e01a88efd0e59679b69f42d4afd5bced8700bb5e80617b2d63a3741af/cryptography-46.0.6-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:4668298aef7cddeaf5c6ecc244c2302a2b8e40f384255505c22875eebb47888b", size = 4441812 }, + { url = "https://files.pythonhosted.org/packages/bb/8b/11df86de2ea389c65aa1806f331cae145f2ed18011f30234cc10ca253de8/cryptography-46.0.6-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:8ce35b77aaf02f3b59c90b2c8a05c73bac12cea5b4e8f3fbece1f5fddea5f0ca", size = 3963923 }, + { url = "https://files.pythonhosted.org/packages/91/e0/207fb177c3a9ef6a8108f234208c3e9e76a6aa8cf20d51932916bd43bda0/cryptography-46.0.6-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:c89eb37fae9216985d8734c1afd172ba4927f5a05cfd9bf0e4863c6d5465b013", size = 4269695 }, + { url = "https://files.pythonhosted.org/packages/21/5e/19f3260ed1e95bced52ace7501fabcd266df67077eeb382b79c81729d2d3/cryptography-46.0.6-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:ed418c37d095aeddf5336898a132fba01091f0ac5844e3e8018506f014b6d2c4", size = 4869785 }, + { url = "https://files.pythonhosted.org/packages/10/38/cd7864d79aa1d92ef6f1a584281433419b955ad5a5ba8d1eb6c872165bcb/cryptography-46.0.6-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:69cf0056d6947edc6e6760e5f17afe4bea06b56a9ac8a06de9d2bd6b532d4f3a", size = 4441404 }, + { url = "https://files.pythonhosted.org/packages/09/0a/4fe7a8d25fed74419f91835cf5829ade6408fd1963c9eae9c4bce390ecbb/cryptography-46.0.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8e7304c4f4e9490e11efe56af6713983460ee0780f16c63f219984dab3af9d2d", size = 4397549 }, + { url = "https://files.pythonhosted.org/packages/5f/a0/7d738944eac6513cd60a8da98b65951f4a3b279b93479a7e8926d9cd730b/cryptography-46.0.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b928a3ca837c77a10e81a814a693f2295200adb3352395fad024559b7be7a736", size = 4651874 }, + { url = "https://files.pythonhosted.org/packages/49/b3/dc27efd8dcc4bff583b3f01d4a3943cd8b5821777a58b3a6a5f054d61b79/cryptography-46.0.6-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:639301950939d844a9e1c4464d7e07f902fe9a7f6b215bb0d4f28584729935d8", size = 4270529 }, + { url = "https://files.pythonhosted.org/packages/e6/05/e8d0e6eb4f0d83365b3cb0e00eb3c484f7348db0266652ccd84632a3d58d/cryptography-46.0.6-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ed3775295fb91f70b4027aeba878d79b3e55c0b3e97eaa4de71f8f23a9f2eb77", size = 4414827 }, + { url = "https://files.pythonhosted.org/packages/2f/97/daba0f5d2dc6d855e2dcb70733c812558a7977a55dd4a6722756628c44d1/cryptography-46.0.6-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:8927ccfbe967c7df312ade694f987e7e9e22b2425976ddbf28271d7e58845290", size = 4271265 }, + { url = "https://files.pythonhosted.org/packages/89/06/fe1fce39a37ac452e58d04b43b0855261dac320a2ebf8f5260dd55b201a9/cryptography-46.0.6-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:b12c6b1e1651e42ab5de8b1e00dc3b6354fdfd778e7fa60541ddacc27cd21410", size = 4916800 }, + { url = "https://files.pythonhosted.org/packages/ff/8a/b14f3101fe9c3592603339eb5d94046c3ce5f7fc76d6512a2d40efd9724e/cryptography-46.0.6-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:063b67749f338ca9c5a0b7fe438a52c25f9526b851e24e6c9310e7195aad3b4d", size = 4448771 }, + { url = "https://files.pythonhosted.org/packages/01/b3/0796998056a66d1973fd52ee89dc1bb3b6581960a91ad4ac705f182d398f/cryptography-46.0.6-cp38-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:02fad249cb0e090b574e30b276a3da6a149e04ee2f049725b1f69e7b8351ec70", size = 3978333 }, + { url = "https://files.pythonhosted.org/packages/c5/3d/db200af5a4ffd08918cd55c08399dc6c9c50b0bc72c00a3246e099d3a849/cryptography-46.0.6-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:7e6142674f2a9291463e5e150090b95a8519b2fb6e6aaec8917dd8d094ce750d", size = 4271069 }, + { url = "https://files.pythonhosted.org/packages/d7/18/61acfd5b414309d74ee838be321c636fe71815436f53c9f0334bf19064fa/cryptography-46.0.6-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:456b3215172aeefb9284550b162801d62f5f264a081049a3e94307fe20792cfa", size = 4878358 }, + { url = "https://files.pythonhosted.org/packages/8b/65/5bf43286d566f8171917cae23ac6add941654ccf085d739195a4eacf1674/cryptography-46.0.6-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:341359d6c9e68834e204ceaf25936dffeafea3829ab80e9503860dcc4f4dac58", size = 4448061 }, + { url = "https://files.pythonhosted.org/packages/e0/25/7e49c0fa7205cf3597e525d156a6bce5b5c9de1fd7e8cb01120e459f205a/cryptography-46.0.6-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9a9c42a2723999a710445bc0d974e345c32adfd8d2fac6d8a251fa829ad31cfb", size = 4399103 }, + { url = "https://files.pythonhosted.org/packages/44/46/466269e833f1c4718d6cd496ffe20c56c9c8d013486ff66b4f69c302a68d/cryptography-46.0.6-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6617f67b1606dfd9fe4dbfa354a9508d4a6d37afe30306fe6c101b7ce3274b72", size = 4659255 }, + { url = "https://files.pythonhosted.org/packages/bc/1f/4c926f50df7749f000f20eede0c896769509895e2648db5da0ed55db711d/cryptography-46.0.6-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:a3e84d5ec9ba01f8fd03802b2147ba77f0c8f2617b2aff254cedd551844209c8", size = 4218227 }, + { url = "https://files.pythonhosted.org/packages/c6/65/707be3ffbd5f786028665c3223e86e11c4cda86023adbc56bd72b1b6bab5/cryptography-46.0.6-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:12f0fa16cc247b13c43d56d7b35287ff1569b5b1f4c5e87e92cc4fcc00cd10c0", size = 4381399 }, + { url = "https://files.pythonhosted.org/packages/f3/6d/73557ed0ef7d73d04d9aba745d2c8e95218213687ee5e76b7d236a5030fc/cryptography-46.0.6-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:50575a76e2951fe7dbd1f56d181f8c5ceeeb075e9ff88e7ad997d2f42af06e7b", size = 4217595 }, + { url = "https://files.pythonhosted.org/packages/9e/c5/e1594c4eec66a567c3ac4400008108a415808be2ce13dcb9a9045c92f1a0/cryptography-46.0.6-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:90e5f0a7b3be5f40c3a0a0eafb32c681d8d2c181fc2a1bdabe9b3f611d9f6b1a", size = 4380912 }, +] + +[[package]] +name = "exceptiongroup" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740 }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515 }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784 }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517 }, +] + +[[package]] +name = "idna" +version = "3.11" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008 }, +] + +[[package]] +name = "importlib-metadata" +version = "9.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "zipp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/01/15bb152d77b21318514a96f43af312635eb2500c96b55398d020c93d86ea/importlib_metadata-9.0.0.tar.gz", hash = "sha256:a4f57ab599e6a2e3016d7595cfd72eb4661a5106e787a95bcc90c7105b831efc", size = 56405 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/3d/2d244233ac4f76e38533cfcb2991c9eb4c7bf688ae0a036d30725b8faafe/importlib_metadata-9.0.0-py3-none-any.whl", hash = "sha256:2d21d1cc5a017bd0559e36150c21c830ab1dc304dedd1b7ea85d20f45ef3edd7", size = 27789 }, +] + +[[package]] +name = "jaraco-classes" +version = "3.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "more-itertools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/c0/ed4a27bc5571b99e3cff68f8a9fa5b56ff7df1c2251cc715a652ddd26402/jaraco.classes-3.4.0.tar.gz", hash = "sha256:47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd", size = 11780 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/66/b15ce62552d84bbfcec9a4873ab79d993a1dd4edb922cbfccae192bd5b5f/jaraco.classes-3.4.0-py3-none-any.whl", hash = "sha256:f662826b6bed8cace05e7ff873ce0f9283b5c924470fe664fff1c2f00f581790", size = 6777 }, +] + +[[package]] +name = "jaraco-context" +version = "6.1.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "backports-tarfile", marker = "python_full_version < '3.12'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/af/50/4763cd07e722bb6285316d390a164bc7e479db9d90daa769f22578f698b4/jaraco_context-6.1.2.tar.gz", hash = "sha256:f1a6c9d391e661cc5b8d39861ff077a7dc24dc23833ccee564b234b81c82dfe3", size = 16801 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f2/58/bc8954bda5fcda97bd7c19be11b85f91973d67a706ed4a3aec33e7de22db/jaraco_context-6.1.2-py3-none-any.whl", hash = "sha256:bf8150b79a2d5d91ae48629d8b427a8f7ba0e1097dd6202a9059f29a36379535", size = 7871 }, +] + +[[package]] +name = "jaraco-functools" +version = "4.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "more-itertools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0f/27/056e0638a86749374d6f57d0b0db39f29509cce9313cf91bdc0ac4d91084/jaraco_functools-4.4.0.tar.gz", hash = "sha256:da21933b0417b89515562656547a77b4931f98176eb173644c0d35032a33d6bb", size = 19943 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/c4/813bb09f0985cb21e959f21f2464169eca882656849adf727ac7bb7e1767/jaraco_functools-4.4.0-py3-none-any.whl", hash = "sha256:9eec1e36f45c818d9bf307c8948eb03b2b56cd44087b3cdc989abca1f20b9176", size = 10481 }, +] + +[[package]] +name = "jeepney" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7b/6f/357efd7602486741aa73ffc0617fb310a29b588ed0fd69c2399acbb85b0c/jeepney-0.9.0.tar.gz", hash = "sha256:cf0e9e845622b81e4a28df94c40345400256ec608d0e55bb8a3feaa9163f5732", size = 106758 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/a3/e137168c9c44d18eff0376253da9f1e9234d0239e0ee230d2fee6cea8e55/jeepney-0.9.0-py3-none-any.whl", hash = "sha256:97e5714520c16fc0a45695e5365a2e11b81ea79bba796e26f9f1d178cb182683", size = 49010 }, +] + +[[package]] +name = "jmespath" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d3/59/322338183ecda247fb5d1763a6cbe46eff7222eaeebafd9fa65d4bf5cb11/jmespath-1.1.0.tar.gz", hash = "sha256:472c87d80f36026ae83c6ddd0f1d05d4e510134ed462851fd5f754c8c3cbb88d", size = 27377 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/2f/967ba146e6d58cf6a652da73885f52fc68001525b4197effc174321d70b4/jmespath-1.1.0-py3-none-any.whl", hash = "sha256:a5663118de4908c91729bea0acadca56526eb2698e83de10cd116ae0f4e97c64", size = 20419 }, +] + +[[package]] +name = "keyring" +version = "25.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "importlib-metadata", marker = "python_full_version < '3.12'" }, + { name = "jaraco-classes" }, + { name = "jaraco-context" }, + { name = "jaraco-functools" }, + { name = "jeepney", marker = "sys_platform == 'linux'" }, + { name = "pywin32-ctypes", marker = "sys_platform == 'win32'" }, + { name = "secretstorage", marker = "sys_platform == 'linux'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/4b/674af6ef2f97d56f0ab5153bf0bfa28ccb6c3ed4d1babf4305449668807b/keyring-25.7.0.tar.gz", hash = "sha256:fe01bd85eb3f8fb3dd0405defdeac9a5b4f6f0439edbb3149577f244a2e8245b", size = 63516 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/db/e655086b7f3a705df045bf0933bdd9c2f79bb3c97bfef1384598bb79a217/keyring-25.7.0-py3-none-any.whl", hash = "sha256:be4a0b195f149690c166e850609a477c532ddbfbaed96a404d4e43f8d5e2689f", size = 39160 }, +] + +[[package]] +name = "librt" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/eb/6b/3d5c13fb3e3c4f43206c8f9dfed13778c2ed4f000bacaa0b7ce3c402a265/librt-0.9.0.tar.gz", hash = "sha256:a0951822531e7aee6e0dfb556b30d5ee36bbe234faf60c20a16c01be3530869d", size = 184368 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/4a/c64265d71b84030174ff3ac2cd16d8b664072afab8c41fccd8e2ee5a6f8d/librt-0.9.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f8e12706dcb8ff6b3ed57514a19e45c49ad00bcd423e87b2b2e4b5f64578443", size = 67529 }, + { url = "https://files.pythonhosted.org/packages/23/b1/30ca0b3a8bdac209a00145c66cf42e5e7da2cc056ffc6ebc5c7b430ddd34/librt-0.9.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4e3dda8345307fd7306db0ed0cb109a63a2c85ba780eb9dc2d09b2049a931f9c", size = 70248 }, + { url = "https://files.pythonhosted.org/packages/fa/fc/c6018dc181478d6ac5aa24a5846b8185101eb90894346db239eb3ea53209/librt-0.9.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:de7dac64e3eb832ffc7b840eb8f52f76420cde1b845be51b2a0f6b870890645e", size = 202184 }, + { url = "https://files.pythonhosted.org/packages/bf/58/d69629f002203370ef41ea69ff71c49a2c618aec39b226ff49986ecd8623/librt-0.9.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22a904cbdb678f7cb348c90d543d3c52f581663d687992fee47fd566dcbf5285", size = 212926 }, + { url = "https://files.pythonhosted.org/packages/cc/55/01d859f57824e42bd02465c77bec31fa5ef9d8c2bcee702ccf8ef1b9f508/librt-0.9.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:224b9727eb8bc188bc3bcf29d969dba0cd61b01d9bac80c41575520cc4baabb2", size = 225664 }, + { url = "https://files.pythonhosted.org/packages/9b/02/32f63ad0ef085a94a70315291efe1151a48b9947af12261882f8445b2a30/librt-0.9.0-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e94cbc6ad9a6aeea46d775cbb11f361022f778a9cc8cc90af653d3a594b057ce", size = 219534 }, + { url = "https://files.pythonhosted.org/packages/6a/5a/9d77111a183c885acf3b3b6e4c00f5b5b07b5817028226499a55f1fedc59/librt-0.9.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7bc30ad339f4e1a01d4917d645e522a0bc0030644d8973f6346397c93ba1503f", size = 227322 }, + { url = "https://files.pythonhosted.org/packages/d5/e7/05d700c93063753e12ab230b972002a3f8f3b9c95d8a980c2f646c8b6963/librt-0.9.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:56d65b583cf43b8cf4c8fbe1e1da20fa3076cc32a1149a141507af1062718236", size = 223407 }, + { url = "https://files.pythonhosted.org/packages/c0/26/26c3124823c67c987456977c683da9a27cc874befc194ddcead5f9988425/librt-0.9.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:0a1be03168b2691ba61927e299b352a6315189199ca18a57b733f86cb3cc8d38", size = 221302 }, + { url = "https://files.pythonhosted.org/packages/50/2b/c7cc2be5cf4ff7b017d948a789256288cb33a517687ff1995e72a7eea79f/librt-0.9.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:63c12efcd160e1d14da11af0c46c0217473e1e0d2ae1acbccc83f561ea4c2a7b", size = 243893 }, + { url = "https://files.pythonhosted.org/packages/62/d3/da553d37417a337d12660450535d5fd51373caffbedf6962173c87867246/librt-0.9.0-cp310-cp310-win32.whl", hash = "sha256:e9002e98dcb1c0a66723592520decd86238ddcef168b37ff6cfb559200b4b774", size = 55375 }, + { url = "https://files.pythonhosted.org/packages/9b/5a/46fa357bab8311b6442a83471591f2f9e5b15ecc1d2121a43725e0c529b8/librt-0.9.0-cp310-cp310-win_amd64.whl", hash = "sha256:9fcb461fbf70654a52a7cc670e606f04449e2374c199b1825f754e16dacfedd8", size = 62581 }, + { url = "https://files.pythonhosted.org/packages/e2/1e/2ec7afcebcf3efea593d13aee18bbcfdd3a243043d848ebf385055e9f636/librt-0.9.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:90904fac73c478f4b83f4ed96c99c8208b75e6f9a8a1910548f69a00f1eaa671", size = 67155 }, + { url = "https://files.pythonhosted.org/packages/18/77/72b85afd4435268338ad4ec6231b3da8c77363f212a0227c1ff3b45e4d35/librt-0.9.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:789fff71757facc0738e8d89e3b84e4f0251c1c975e85e81b152cdaca927cc2d", size = 69916 }, + { url = "https://files.pythonhosted.org/packages/27/fb/948ea0204fbe2e78add6d46b48330e58d39897e425560674aee302dca81c/librt-0.9.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1bf465d1e5b0a27713862441f6467b5ab76385f4ecf8f1f3a44f8aa3c695b4b6", size = 199635 }, + { url = "https://files.pythonhosted.org/packages/ac/cd/894a29e251b296a27957856804cfd21e93c194aa131de8bb8032021be07e/librt-0.9.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f819e0c6413e259a17a7c0d49f97f405abadd3c2a316a3b46c6440b7dbbedbb1", size = 211051 }, + { url = "https://files.pythonhosted.org/packages/18/8f/dcaed0bc084a35f3721ff2d081158db569d2c57ea07d35623ddaca5cfc8e/librt-0.9.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e0785c2fb4a81e1aece366aa3e2e039f4a4d7d21aaaded5227d7f3c703427882", size = 224031 }, + { url = "https://files.pythonhosted.org/packages/03/44/88f6c1ed1132cd418601cc041fbd92fed28b3a09f39de81978e0822d13ff/librt-0.9.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80b25c7b570a86c03b5da69e665809deb39265476e8e21d96a9328f9762f9990", size = 218069 }, + { url = "https://files.pythonhosted.org/packages/a3/90/7d02e981c2db12188d82b4410ff3e35bfdb844b26aecd02233626f46af2b/librt-0.9.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d4d16b608a1c43d7e33142099a75cd93af482dadce0bf82421e91cad077157f4", size = 224857 }, + { url = "https://files.pythonhosted.org/packages/ef/c3/c77e706b7215ca32e928d47535cf13dbc3d25f096f84ddf8fbc06693e229/librt-0.9.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:194fc1a32e1e21fe809d38b5faea66cc65eaa00217c8901fbdb99866938adbdb", size = 219865 }, + { url = "https://files.pythonhosted.org/packages/52/d1/32b0c1a0eb8461c70c11656c46a29f760b7c7edf3c36d6f102470c17170f/librt-0.9.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:8c6bc1384d9738781cfd41d09ad7f6e8af13cfea2c75ece6bd6d2566cdea2076", size = 218451 }, + { url = "https://files.pythonhosted.org/packages/74/d1/adfd0f9c44761b1d49b1bec66173389834c33ee2bd3c7fd2e2367f1942d4/librt-0.9.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:15cb151e52a044f06e54ac7f7b47adbfc89b5c8e2b63e1175a9d587c43e8942a", size = 241300 }, + { url = "https://files.pythonhosted.org/packages/09/b0/9074b64407712f0003c27f5b1d7655d1438979155f049720e8a1abd9b1a1/librt-0.9.0-cp311-cp311-win32.whl", hash = "sha256:f100bfe2acf8a3689af9d0cc660d89f17286c9c795f9f18f7b62dd1a6b247ae6", size = 55668 }, + { url = "https://files.pythonhosted.org/packages/24/19/40b77b77ce80b9389fb03971431b09b6b913911c38d412059e0b3e2a9ef2/librt-0.9.0-cp311-cp311-win_amd64.whl", hash = "sha256:0b73e4266307e51c95e09c0750b7ec383c561d2e97d58e473f6f6a209952fbb8", size = 62976 }, + { url = "https://files.pythonhosted.org/packages/70/9d/9fa7a64041e29035cb8c575af5f0e3840be1b97b4c4d9061e0713f171849/librt-0.9.0-cp311-cp311-win_arm64.whl", hash = "sha256:bc5518873822d2faa8ebdd2c1a4d7c8ef47b01a058495ab7924cb65bdbf5fc9a", size = 53502 }, + { url = "https://files.pythonhosted.org/packages/bf/90/89ddba8e1c20b0922783cd93ed8e64f34dc05ab59c38a9c7e313632e20ff/librt-0.9.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9b3e3bc363f71bda1639a4ee593cb78f7fbfeacc73411ec0d4c92f00730010a4", size = 68332 }, + { url = "https://files.pythonhosted.org/packages/a8/40/7aa4da1fb08bdeeb540cb07bfc8207cb32c5c41642f2594dbd0098a0662d/librt-0.9.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0a09c2f5869649101738653a9b7ab70cf045a1105ac66cbb8f4055e61df78f2d", size = 70581 }, + { url = "https://files.pythonhosted.org/packages/48/ac/73a2187e1031041e93b7e3a25aae37aa6f13b838c550f7e0f06f66766212/librt-0.9.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5ca8e133d799c948db2ab1afc081c333a825b5540475164726dcbf73537e5c2f", size = 203984 }, + { url = "https://files.pythonhosted.org/packages/5e/3d/23460d571e9cbddb405b017681df04c142fb1b04cbfce77c54b08e28b108/librt-0.9.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:603138ee838ee1583f1b960b62d5d0007845c5c423feb68e44648b1359014e27", size = 215762 }, + { url = "https://files.pythonhosted.org/packages/de/1e/42dc7f8ab63e65b20640d058e63e97fd3e482c1edbda3570d813b4d0b927/librt-0.9.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f4003f70c56a5addd6aa0897f200dd59afd3bf7bcd5b3cce46dd21f925743bc2", size = 230288 }, + { url = "https://files.pythonhosted.org/packages/dc/08/ca812b6d8259ad9ece703397f8ad5c03af5b5fedfce64279693d3ce4087c/librt-0.9.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:78042f6facfd98ecb25e9829c7e37cce23363d9d7c83bc5f72702c5059eb082b", size = 224103 }, + { url = "https://files.pythonhosted.org/packages/b6/3f/620490fb2fa66ffd44e7f900254bc110ebec8dac6c1b7514d64662570e6f/librt-0.9.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a361c9434a64d70a7dbb771d1de302c0cc9f13c0bffe1cf7e642152814b35265", size = 232122 }, + { url = "https://files.pythonhosted.org/packages/e9/83/12864700a1b6a8be458cf5d05db209b0d8e94ae281e7ec261dbe616597b4/librt-0.9.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:dd2c7e082b0b92e1baa4da28163a808672485617bc855cc22a2fd06978fa9084", size = 225045 }, + { url = "https://files.pythonhosted.org/packages/fd/1b/845d339c29dc7dbc87a2e992a1ba8d28d25d0e0372f9a0a2ecebde298186/librt-0.9.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7e6274fd33fc5b2a14d41c9119629d3ff395849d8bcbc80cf637d9e8d2034da8", size = 227372 }, + { url = "https://files.pythonhosted.org/packages/8d/fe/277985610269d926a64c606f761d58d3db67b956dbbf40024921e95e7fcb/librt-0.9.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5093043afb226ecfa1400120d1ebd4442b4f99977783e4f4f7248879009b227f", size = 248224 }, + { url = "https://files.pythonhosted.org/packages/92/1b/ee486d244b8de6b8b5dbaefabe6bfdd4a72e08f6353edf7d16d27114da8d/librt-0.9.0-cp312-cp312-win32.whl", hash = "sha256:9edcc35d1cae9fd5320171b1a838c7da8a5c968af31e82ecc3dff30b4be0957f", size = 55986 }, + { url = "https://files.pythonhosted.org/packages/89/7a/ba1737012308c17dc6d5516143b5dce9a2c7ba3474afd54e11f44a4d1ef3/librt-0.9.0-cp312-cp312-win_amd64.whl", hash = "sha256:3cc2917258e131ae5f958a4d872e07555b51cb7466a43433218061c74ef33745", size = 63260 }, + { url = "https://files.pythonhosted.org/packages/36/e4/01752c113da15127f18f7bf11142f5640038f062407a611c059d0036c6aa/librt-0.9.0-cp312-cp312-win_arm64.whl", hash = "sha256:90e6d5420fc8a300518d4d2288154ff45005e920425c22cbbfe8330f3f754bd9", size = 53694 }, + { url = "https://files.pythonhosted.org/packages/5f/d7/1b3e26fffde1452d82f5666164858a81c26ebe808e7ae8c9c88628981540/librt-0.9.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f29b68cd9714531672db62cc54f6e8ff981900f824d13fa0e00749189e13778e", size = 68367 }, + { url = "https://files.pythonhosted.org/packages/a5/5b/c61b043ad2e091fbe1f2d35d14795e545d0b56b03edaa390fa1dcee3d160/librt-0.9.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7d5c8a5929ac325729f6119802070b561f4db793dffc45e9ac750992a4ed4d22", size = 70595 }, + { url = "https://files.pythonhosted.org/packages/a3/22/2448471196d8a73370aa2f23445455dc42712c21404081fcd7a03b9e0749/librt-0.9.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:756775d25ec8345b837ab52effee3ad2f3b2dfd6bbee3e3f029c517bd5d8f05a", size = 204354 }, + { url = "https://files.pythonhosted.org/packages/ac/5e/39fc4b153c78cfd2c8a2dcb32700f2d41d2312aa1050513183be4540930d/librt-0.9.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2b8f5d00b49818f4e2b1667db994488b045835e0ac16fe2f924f3871bd2b8ac5", size = 216238 }, + { url = "https://files.pythonhosted.org/packages/d7/42/bc2d02d0fa7badfa63aa8d6dcd8793a9f7ef5a94396801684a51ed8d8287/librt-0.9.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c81aef782380f0f13ead670aae01825eb653b44b046aa0e5ebbb79f76ed4aa11", size = 230589 }, + { url = "https://files.pythonhosted.org/packages/c8/7b/e2d95cc513866373692aa5edf98080d5602dd07cabfb9e5d2f70df2f25f7/librt-0.9.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:66b58fed90a545328e80d575467244de3741e088c1af928f0b489ebec3ef3858", size = 224610 }, + { url = "https://files.pythonhosted.org/packages/31/d5/6cec4607e998eaba57564d06a1295c21b0a0c8de76e4e74d699e627bd98c/librt-0.9.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e78fb7419e07d98c2af4b8567b72b3eaf8cb05caad642e9963465569c8b2d87e", size = 232558 }, + { url = "https://files.pythonhosted.org/packages/95/8c/27f1d8d3aaf079d3eb26439bf0b32f1482340c3552e324f7db9dca858671/librt-0.9.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2c3786f0f4490a5cd87f1ed6cefae833ad6b1060d52044ce0434a2e85893afd0", size = 225521 }, + { url = "https://files.pythonhosted.org/packages/6b/d8/1e0d43b1c329b416017619469b3c3801a25a6a4ef4a1c68332aeaa6f72ca/librt-0.9.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:8494cfc61e03542f2d381e71804990b3931175a29b9278fdb4a5459948778dc2", size = 227789 }, + { url = "https://files.pythonhosted.org/packages/2c/b4/d3d842e88610fcd4c8eec7067b0c23ef2d7d3bff31496eded6a83b0f99be/librt-0.9.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:07cf11f769831186eeac424376e6189f20ace4f7263e2134bdb9757340d84d4d", size = 248616 }, + { url = "https://files.pythonhosted.org/packages/ec/28/527df8ad0d1eb6c8bdfa82fc190f1f7c4cca5a1b6d7b36aeabf95b52d74d/librt-0.9.0-cp313-cp313-win32.whl", hash = "sha256:850d6d03177e52700af605fd60db7f37dcb89782049a149674d1a9649c2138fd", size = 56039 }, + { url = "https://files.pythonhosted.org/packages/f3/a7/413652ad0d92273ee5e30c000fc494b361171177c83e57c060ecd3c21538/librt-0.9.0-cp313-cp313-win_amd64.whl", hash = "sha256:a5af136bfba820d592f86c67affcef9b3ff4d4360ac3255e341e964489b48519", size = 63264 }, + { url = "https://files.pythonhosted.org/packages/a4/0a/92c244309b774e290ddb15e93363846ae7aa753d9586b8aad511c5e6145b/librt-0.9.0-cp313-cp313-win_arm64.whl", hash = "sha256:4c4d0440a3a8e31d962340c3e1cc3fc9ee7febd34c8d8f770d06adb947779ea5", size = 53728 }, + { url = "https://files.pythonhosted.org/packages/cd/c1/184e539543f06ea2912f4b92a5ffaede4f9b392689e3f00acbf8134bee92/librt-0.9.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:3f05d145df35dca5056a8bc3838e940efebd893a54b3e19b2dda39ceaa299bcb", size = 67830 }, + { url = "https://files.pythonhosted.org/packages/f3/ad/23399bdcb7afca819acacdef31b37ee59de261bd66b503a7995c03c4b0dc/librt-0.9.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1c587494461ebd42229d0f1739f3aa34237dd9980623ecf1be8d3bcba79f4499", size = 70280 }, + { url = "https://files.pythonhosted.org/packages/9f/0b/4542dc5a2b8772dbf92cafb9194701230157e73c14b017b6961a23598b03/librt-0.9.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:b0a2040f801406b93657a70b72fa12311063a319fee72ce98e1524da7200171f", size = 201925 }, + { url = "https://files.pythonhosted.org/packages/31/d4/8ee7358b08fd0cfce051ef96695380f09b3c2c11b77c9bfbc367c921cce5/librt-0.9.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f38bc489037eca88d6ebefc9c4d41a4e07c8e8b4de5188a9e6d290273ad7ebb1", size = 212381 }, + { url = "https://files.pythonhosted.org/packages/f2/94/a2025fe442abedf8b038038dab3dba942009ad42b38ea064a1a9e6094241/librt-0.9.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3fd278f5e6bf7c75ccd6d12344eb686cc020712683363b66f46ac79d37c799f", size = 227065 }, + { url = "https://files.pythonhosted.org/packages/7c/e9/b9fcf6afa909f957cfbbf918802f9dada1bd5d3c1da43d722fd6a310dc3f/librt-0.9.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fcbdf2a9ca24e87bbebb47f1fe34e531ef06f104f98c9ccfc953a3f3344c567a", size = 221333 }, + { url = "https://files.pythonhosted.org/packages/ac/7c/ba54cd6aa6a3c8cd12757a6870e0c79a64b1e6327f5248dcff98423f4d43/librt-0.9.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e306d956cfa027fe041585f02a1602c32bfa6bb8ebea4899d373383295a6c62f", size = 229051 }, + { url = "https://files.pythonhosted.org/packages/4b/4b/8cfdbad314c8677a0148bf0b70591d6d18587f9884d930276098a235461b/librt-0.9.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:465814ab157986acb9dfa5ccd7df944be5eefc0d08d31ec6e8d88bc71251d845", size = 222492 }, + { url = "https://files.pythonhosted.org/packages/1f/d1/2eda69563a1a88706808decdce035e4b32755dbfbb0d05e1a65db9547ed1/librt-0.9.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:703f4ae36d6240bfe24f542bac784c7e4194ec49c3ba5a994d02891649e2d85b", size = 223849 }, + { url = "https://files.pythonhosted.org/packages/04/44/b2ed37df6be5b3d42cfe36318e0598e80843d5c6308dd63d0bf4e0ce5028/librt-0.9.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3be322a15ee5e70b93b7a59cfd074614f22cc8c9ff18bd27f474e79137ea8d3b", size = 245001 }, + { url = "https://files.pythonhosted.org/packages/47/e7/617e412426df89169dd2a9ed0cc8752d5763336252c65dbf945199915119/librt-0.9.0-cp314-cp314-win32.whl", hash = "sha256:b8da9f8035bb417770b1e1610526d87ad4fc58a2804dc4d79c53f6d2cf5a6eb9", size = 51799 }, + { url = "https://files.pythonhosted.org/packages/24/ed/c22ca4db0ca3cbc285e4d9206108746beda561a9792289c3c31281d7e9df/librt-0.9.0-cp314-cp314-win_amd64.whl", hash = "sha256:b8bd70d5d816566a580d193326912f4a76ec2d28a97dc4cd4cc831c0af8e330e", size = 59165 }, + { url = "https://files.pythonhosted.org/packages/24/56/875398fafa4cbc8f15b89366fc3287304ddd3314d861f182a4b87595ace0/librt-0.9.0-cp314-cp314-win_arm64.whl", hash = "sha256:fc5758e2b7a56532dc33e3c544d78cbaa9ecf0a0f2a2da2df882c1d6b99a317f", size = 49292 }, + { url = "https://files.pythonhosted.org/packages/4c/61/bc448ecbf9b2d69c5cff88fe41496b19ab2a1cbda0065e47d4d0d51c0867/librt-0.9.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:f24b90b0e0c8cc9491fb1693ae91fe17cb7963153a1946395acdbdd5818429a4", size = 70175 }, + { url = "https://files.pythonhosted.org/packages/60/f2/c47bb71069a73e2f04e70acbd196c1e5cc411578ac99039a224b98920fd4/librt-0.9.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3fe56e80badb66fdcde06bef81bbaa5bfcf6fbd7aefb86222d9e369c38c6b228", size = 72951 }, + { url = "https://files.pythonhosted.org/packages/29/19/0549df59060631732df758e8886d92088da5fdbedb35b80e4643664e8412/librt-0.9.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:527b5b820b47a09e09829051452bb0d1dd2122261254e2a6f674d12f1d793d54", size = 225864 }, + { url = "https://files.pythonhosted.org/packages/9d/f8/3b144396d302ac08e50f89e64452c38db84bc7b23f6c60479c5d3abd303c/librt-0.9.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d429bdd4ac0ab17c8e4a8af0ed2a7440b16eba474909ab357131018fe8c7e71", size = 241155 }, + { url = "https://files.pythonhosted.org/packages/7a/ce/ee67ec14581de4043e61d05786d2aed6c9b5338816b7859bcf07455c6a9f/librt-0.9.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7202bdcac47d3a708271c4304a474a8605a4a9a4a709e954bf2d3241140aa938", size = 252235 }, + { url = "https://files.pythonhosted.org/packages/8a/fa/0ead15daa2b293a54101550b08d4bafe387b7d4a9fc6d2b985602bae69b6/librt-0.9.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c0d620e74897f8c2613b3c4e2e9c1e422eb46d2ddd07df540784d44117836af3", size = 244963 }, + { url = "https://files.pythonhosted.org/packages/29/68/9fbf9a9aa704ba87689e40017e720aced8d9a4d2b46b82451d8142f91ec9/librt-0.9.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d69fc39e627908f4c03297d5a88d9284b73f4d90b424461e32e8c2485e21c283", size = 257364 }, + { url = "https://files.pythonhosted.org/packages/1a/8d/9d60869f1b6716c762e45f66ed945b1e5dd649f7377684c3b176ae424648/librt-0.9.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:c2640e23d2b7c98796f123ffd95cf2022c7777aa8a4a3b98b36c570d37e85eee", size = 247661 }, + { url = "https://files.pythonhosted.org/packages/70/ff/a5c365093962310bfdb4f6af256f191085078ffb529b3f0cbebb5b33ebe2/librt-0.9.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:451daa98463b7695b0a30aa56bf637831ea559e7b8101ac2ef6382e8eb15e29c", size = 248238 }, + { url = "https://files.pythonhosted.org/packages/a0/3c/2d34365177f412c9e19c0a29f969d70f5343f27634b76b765a54d8b27705/librt-0.9.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:928bd06eca2c2bbf4349e5b817f837509b0604342e65a502de1d50a7570afd15", size = 269457 }, + { url = "https://files.pythonhosted.org/packages/bc/cd/de45b239ea3bdf626f982a00c14bfcf2e12d261c510ba7db62c5969a27cd/librt-0.9.0-cp314-cp314t-win32.whl", hash = "sha256:a9c63e04d003bc0fb6a03b348018b9a3002f98268200e22cc80f146beac5dc40", size = 52453 }, + { url = "https://files.pythonhosted.org/packages/7f/f9/bfb32ae428aa75c0c533915622176f0a17d6da7b72b5a3c6363685914f70/librt-0.9.0-cp314-cp314t-win_amd64.whl", hash = "sha256:f162af66a2ed3f7d1d161a82ca584efd15acd9c1cff190a373458c32f7d42118", size = 60044 }, + { url = "https://files.pythonhosted.org/packages/aa/47/7d70414bcdbb3bc1f458a8d10558f00bbfdb24e5a11740fc8197e12c3255/librt-0.9.0-cp314-cp314t-win_arm64.whl", hash = "sha256:a4b25c6c25cac5d0d9d6d6da855195b254e0021e513e0249f0e3b444dc6e0e61", size = 50009 }, +] + +[[package]] +name = "more-itertools" +version = "10.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ea/5d/38b681d3fce7a266dd9ab73c66959406d565b3e85f21d5e66e1181d93721/more_itertools-10.8.0.tar.gz", hash = "sha256:f638ddf8a1a0d134181275fb5d58b086ead7c6a72429ad725c67503f13ba30bd", size = 137431 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a4/8e/469e5a4a2f5855992e425f3cb33804cc07bf18d48f2db061aec61ce50270/more_itertools-10.8.0-py3-none-any.whl", hash = "sha256:52d4362373dcf7c52546bc4af9a86ee7c4579df9a8dc268be0a2f949d376cc9b", size = 69667 }, +] + +[[package]] +name = "msgpack" +version = "1.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4d/f2/bfb55a6236ed8725a96b0aa3acbd0ec17588e6a2c3b62a93eb513ed8783f/msgpack-1.1.2.tar.gz", hash = "sha256:3b60763c1373dd60f398488069bcdc703cd08a711477b5d480eecc9f9626f47e", size = 173581 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f5/a2/3b68a9e769db68668b25c6108444a35f9bd163bb848c0650d516761a59c0/msgpack-1.1.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0051fffef5a37ca2cd16978ae4f0aef92f164df86823871b5162812bebecd8e2", size = 81318 }, + { url = "https://files.pythonhosted.org/packages/5b/e1/2b720cc341325c00be44e1ed59e7cfeae2678329fbf5aa68f5bda57fe728/msgpack-1.1.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a605409040f2da88676e9c9e5853b3449ba8011973616189ea5ee55ddbc5bc87", size = 83786 }, + { url = "https://files.pythonhosted.org/packages/71/e5/c2241de64bfceac456b140737812a2ab310b10538a7b34a1d393b748e095/msgpack-1.1.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b696e83c9f1532b4af884045ba7f3aa741a63b2bc22617293a2c6a7c645f251", size = 398240 }, + { url = "https://files.pythonhosted.org/packages/b7/09/2a06956383c0fdebaef5aa9246e2356776f12ea6f2a44bd1368abf0e46c4/msgpack-1.1.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:365c0bbe981a27d8932da71af63ef86acc59ed5c01ad929e09a0b88c6294e28a", size = 406070 }, + { url = "https://files.pythonhosted.org/packages/0e/74/2957703f0e1ef20637d6aead4fbb314330c26f39aa046b348c7edcf6ca6b/msgpack-1.1.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:41d1a5d875680166d3ac5c38573896453bbbea7092936d2e107214daf43b1d4f", size = 393403 }, + { url = "https://files.pythonhosted.org/packages/a5/09/3bfc12aa90f77b37322fc33e7a8a7c29ba7c8edeadfa27664451801b9860/msgpack-1.1.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:354e81bcdebaab427c3df4281187edc765d5d76bfb3a7c125af9da7a27e8458f", size = 398947 }, + { url = "https://files.pythonhosted.org/packages/4b/4f/05fcebd3b4977cb3d840f7ef6b77c51f8582086de5e642f3fefee35c86fc/msgpack-1.1.2-cp310-cp310-win32.whl", hash = "sha256:e64c8d2f5e5d5fda7b842f55dec6133260ea8f53c4257d64494c534f306bf7a9", size = 64769 }, + { url = "https://files.pythonhosted.org/packages/d0/3e/b4547e3a34210956382eed1c85935fff7e0f9b98be3106b3745d7dec9c5e/msgpack-1.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:db6192777d943bdaaafb6ba66d44bf65aa0e9c5616fa1d2da9bb08828c6b39aa", size = 71293 }, + { url = "https://files.pythonhosted.org/packages/2c/97/560d11202bcd537abca693fd85d81cebe2107ba17301de42b01ac1677b69/msgpack-1.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2e86a607e558d22985d856948c12a3fa7b42efad264dca8a3ebbcfa2735d786c", size = 82271 }, + { url = "https://files.pythonhosted.org/packages/83/04/28a41024ccbd67467380b6fb440ae916c1e4f25e2cd4c63abe6835ac566e/msgpack-1.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:283ae72fc89da59aa004ba147e8fc2f766647b1251500182fac0350d8af299c0", size = 84914 }, + { url = "https://files.pythonhosted.org/packages/71/46/b817349db6886d79e57a966346cf0902a426375aadc1e8e7a86a75e22f19/msgpack-1.1.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:61c8aa3bd513d87c72ed0b37b53dd5c5a0f58f2ff9f26e1555d3bd7948fb7296", size = 416962 }, + { url = "https://files.pythonhosted.org/packages/da/e0/6cc2e852837cd6086fe7d8406af4294e66827a60a4cf60b86575a4a65ca8/msgpack-1.1.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:454e29e186285d2ebe65be34629fa0e8605202c60fbc7c4c650ccd41870896ef", size = 426183 }, + { url = "https://files.pythonhosted.org/packages/25/98/6a19f030b3d2ea906696cedd1eb251708e50a5891d0978b012cb6107234c/msgpack-1.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7bc8813f88417599564fafa59fd6f95be417179f76b40325b500b3c98409757c", size = 411454 }, + { url = "https://files.pythonhosted.org/packages/b7/cd/9098fcb6adb32187a70b7ecaabf6339da50553351558f37600e53a4a2a23/msgpack-1.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bafca952dc13907bdfdedfc6a5f579bf4f292bdd506fadb38389afa3ac5b208e", size = 422341 }, + { url = "https://files.pythonhosted.org/packages/e6/ae/270cecbcf36c1dc85ec086b33a51a4d7d08fc4f404bdbc15b582255d05ff/msgpack-1.1.2-cp311-cp311-win32.whl", hash = "sha256:602b6740e95ffc55bfb078172d279de3773d7b7db1f703b2f1323566b878b90e", size = 64747 }, + { url = "https://files.pythonhosted.org/packages/2a/79/309d0e637f6f37e83c711f547308b91af02b72d2326ddd860b966080ef29/msgpack-1.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:d198d275222dc54244bf3327eb8cbe00307d220241d9cec4d306d49a44e85f68", size = 71633 }, + { url = "https://files.pythonhosted.org/packages/73/4d/7c4e2b3d9b1106cd0aa6cb56cc57c6267f59fa8bfab7d91df5adc802c847/msgpack-1.1.2-cp311-cp311-win_arm64.whl", hash = "sha256:86f8136dfa5c116365a8a651a7d7484b65b13339731dd6faebb9a0242151c406", size = 64755 }, + { url = "https://files.pythonhosted.org/packages/ad/bd/8b0d01c756203fbab65d265859749860682ccd2a59594609aeec3a144efa/msgpack-1.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:70a0dff9d1f8da25179ffcf880e10cf1aad55fdb63cd59c9a49a1b82290062aa", size = 81939 }, + { url = "https://files.pythonhosted.org/packages/34/68/ba4f155f793a74c1483d4bdef136e1023f7bcba557f0db4ef3db3c665cf1/msgpack-1.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:446abdd8b94b55c800ac34b102dffd2f6aa0ce643c55dfc017ad89347db3dbdb", size = 85064 }, + { url = "https://files.pythonhosted.org/packages/f2/60/a064b0345fc36c4c3d2c743c82d9100c40388d77f0b48b2f04d6041dbec1/msgpack-1.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c63eea553c69ab05b6747901b97d620bb2a690633c77f23feb0c6a947a8a7b8f", size = 417131 }, + { url = "https://files.pythonhosted.org/packages/65/92/a5100f7185a800a5d29f8d14041f61475b9de465ffcc0f3b9fba606e4505/msgpack-1.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:372839311ccf6bdaf39b00b61288e0557916c3729529b301c52c2d88842add42", size = 427556 }, + { url = "https://files.pythonhosted.org/packages/f5/87/ffe21d1bf7d9991354ad93949286f643b2bb6ddbeab66373922b44c3b8cc/msgpack-1.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2929af52106ca73fcb28576218476ffbb531a036c2adbcf54a3664de124303e9", size = 404920 }, + { url = "https://files.pythonhosted.org/packages/ff/41/8543ed2b8604f7c0d89ce066f42007faac1eaa7d79a81555f206a5cdb889/msgpack-1.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:be52a8fc79e45b0364210eef5234a7cf8d330836d0a64dfbb878efa903d84620", size = 415013 }, + { url = "https://files.pythonhosted.org/packages/41/0d/2ddfaa8b7e1cee6c490d46cb0a39742b19e2481600a7a0e96537e9c22f43/msgpack-1.1.2-cp312-cp312-win32.whl", hash = "sha256:1fff3d825d7859ac888b0fbda39a42d59193543920eda9d9bea44d958a878029", size = 65096 }, + { url = "https://files.pythonhosted.org/packages/8c/ec/d431eb7941fb55a31dd6ca3404d41fbb52d99172df2e7707754488390910/msgpack-1.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:1de460f0403172cff81169a30b9a92b260cb809c4cb7e2fc79ae8d0510c78b6b", size = 72708 }, + { url = "https://files.pythonhosted.org/packages/c5/31/5b1a1f70eb0e87d1678e9624908f86317787b536060641d6798e3cf70ace/msgpack-1.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:be5980f3ee0e6bd44f3a9e9dea01054f175b50c3e6cdb692bc9424c0bbb8bf69", size = 64119 }, + { url = "https://files.pythonhosted.org/packages/6b/31/b46518ecc604d7edf3a4f94cb3bf021fc62aa301f0cb849936968164ef23/msgpack-1.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4efd7b5979ccb539c221a4c4e16aac1a533efc97f3b759bb5a5ac9f6d10383bf", size = 81212 }, + { url = "https://files.pythonhosted.org/packages/92/dc/c385f38f2c2433333345a82926c6bfa5ecfff3ef787201614317b58dd8be/msgpack-1.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:42eefe2c3e2af97ed470eec850facbe1b5ad1d6eacdbadc42ec98e7dcf68b4b7", size = 84315 }, + { url = "https://files.pythonhosted.org/packages/d3/68/93180dce57f684a61a88a45ed13047558ded2be46f03acb8dec6d7c513af/msgpack-1.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fdf7d83102bf09e7ce3357de96c59b627395352a4024f6e2458501f158bf999", size = 412721 }, + { url = "https://files.pythonhosted.org/packages/5d/ba/459f18c16f2b3fc1a1ca871f72f07d70c07bf768ad0a507a698b8052ac58/msgpack-1.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fac4be746328f90caa3cd4bc67e6fe36ca2bf61d5c6eb6d895b6527e3f05071e", size = 424657 }, + { url = "https://files.pythonhosted.org/packages/38/f8/4398c46863b093252fe67368b44edc6c13b17f4e6b0e4929dbf0bdb13f23/msgpack-1.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fffee09044073e69f2bad787071aeec727183e7580443dfeb8556cbf1978d162", size = 402668 }, + { url = "https://files.pythonhosted.org/packages/28/ce/698c1eff75626e4124b4d78e21cca0b4cc90043afb80a507626ea354ab52/msgpack-1.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5928604de9b032bc17f5099496417f113c45bc6bc21b5c6920caf34b3c428794", size = 419040 }, + { url = "https://files.pythonhosted.org/packages/67/32/f3cd1667028424fa7001d82e10ee35386eea1408b93d399b09fb0aa7875f/msgpack-1.1.2-cp313-cp313-win32.whl", hash = "sha256:a7787d353595c7c7e145e2331abf8b7ff1e6673a6b974ded96e6d4ec09f00c8c", size = 65037 }, + { url = "https://files.pythonhosted.org/packages/74/07/1ed8277f8653c40ebc65985180b007879f6a836c525b3885dcc6448ae6cb/msgpack-1.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:a465f0dceb8e13a487e54c07d04ae3ba131c7c5b95e2612596eafde1dccf64a9", size = 72631 }, + { url = "https://files.pythonhosted.org/packages/e5/db/0314e4e2db56ebcf450f277904ffd84a7988b9e5da8d0d61ab2d057df2b6/msgpack-1.1.2-cp313-cp313-win_arm64.whl", hash = "sha256:e69b39f8c0aa5ec24b57737ebee40be647035158f14ed4b40e6f150077e21a84", size = 64118 }, + { url = "https://files.pythonhosted.org/packages/22/71/201105712d0a2ff07b7873ed3c220292fb2ea5120603c00c4b634bcdafb3/msgpack-1.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e23ce8d5f7aa6ea6d2a2b326b4ba46c985dbb204523759984430db7114f8aa00", size = 81127 }, + { url = "https://files.pythonhosted.org/packages/1b/9f/38ff9e57a2eade7bf9dfee5eae17f39fc0e998658050279cbb14d97d36d9/msgpack-1.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6c15b7d74c939ebe620dd8e559384be806204d73b4f9356320632d783d1f7939", size = 84981 }, + { url = "https://files.pythonhosted.org/packages/8e/a9/3536e385167b88c2cc8f4424c49e28d49a6fc35206d4a8060f136e71f94c/msgpack-1.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99e2cb7b9031568a2a5c73aa077180f93dd2e95b4f8d3b8e14a73ae94a9e667e", size = 411885 }, + { url = "https://files.pythonhosted.org/packages/2f/40/dc34d1a8d5f1e51fc64640b62b191684da52ca469da9cd74e84936ffa4a6/msgpack-1.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:180759d89a057eab503cf62eeec0aa61c4ea1200dee709f3a8e9397dbb3b6931", size = 419658 }, + { url = "https://files.pythonhosted.org/packages/3b/ef/2b92e286366500a09a67e03496ee8b8ba00562797a52f3c117aa2b29514b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:04fb995247a6e83830b62f0b07bf36540c213f6eac8e851166d8d86d83cbd014", size = 403290 }, + { url = "https://files.pythonhosted.org/packages/78/90/e0ea7990abea5764e4655b8177aa7c63cdfa89945b6e7641055800f6c16b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8e22ab046fa7ede9e36eeb4cfad44d46450f37bb05d5ec482b02868f451c95e2", size = 415234 }, + { url = "https://files.pythonhosted.org/packages/72/4e/9390aed5db983a2310818cd7d3ec0aecad45e1f7007e0cda79c79507bb0d/msgpack-1.1.2-cp314-cp314-win32.whl", hash = "sha256:80a0ff7d4abf5fecb995fcf235d4064b9a9a8a40a3ab80999e6ac1e30b702717", size = 66391 }, + { url = "https://files.pythonhosted.org/packages/6e/f1/abd09c2ae91228c5f3998dbd7f41353def9eac64253de3c8105efa2082f7/msgpack-1.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:9ade919fac6a3e7260b7f64cea89df6bec59104987cbea34d34a2fa15d74310b", size = 73787 }, + { url = "https://files.pythonhosted.org/packages/6a/b0/9d9f667ab48b16ad4115c1935d94023b82b3198064cb84a123e97f7466c1/msgpack-1.1.2-cp314-cp314-win_arm64.whl", hash = "sha256:59415c6076b1e30e563eb732e23b994a61c159cec44deaf584e5cc1dd662f2af", size = 66453 }, + { url = "https://files.pythonhosted.org/packages/16/67/93f80545eb1792b61a217fa7f06d5e5cb9e0055bed867f43e2b8e012e137/msgpack-1.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:897c478140877e5307760b0ea66e0932738879e7aa68144d9b78ea4c8302a84a", size = 85264 }, + { url = "https://files.pythonhosted.org/packages/87/1c/33c8a24959cf193966ef11a6f6a2995a65eb066bd681fd085afd519a57ce/msgpack-1.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a668204fa43e6d02f89dbe79a30b0d67238d9ec4c5bd8a940fc3a004a47b721b", size = 89076 }, + { url = "https://files.pythonhosted.org/packages/fc/6b/62e85ff7193663fbea5c0254ef32f0c77134b4059f8da89b958beb7696f3/msgpack-1.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5559d03930d3aa0f3aacb4c42c776af1a2ace2611871c84a75afe436695e6245", size = 435242 }, + { url = "https://files.pythonhosted.org/packages/c1/47/5c74ecb4cc277cf09f64e913947871682ffa82b3b93c8dad68083112f412/msgpack-1.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70c5a7a9fea7f036b716191c29047374c10721c389c21e9ffafad04df8c52c90", size = 432509 }, + { url = "https://files.pythonhosted.org/packages/24/a4/e98ccdb56dc4e98c929a3f150de1799831c0a800583cde9fa022fa90602d/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f2cb069d8b981abc72b41aea1c580ce92d57c673ec61af4c500153a626cb9e20", size = 415957 }, + { url = "https://files.pythonhosted.org/packages/da/28/6951f7fb67bc0a4e184a6b38ab71a92d9ba58080b27a77d3e2fb0be5998f/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d62ce1f483f355f61adb5433ebfd8868c5f078d1a52d042b0a998682b4fa8c27", size = 422910 }, + { url = "https://files.pythonhosted.org/packages/f0/03/42106dcded51f0a0b5284d3ce30a671e7bd3f7318d122b2ead66ad289fed/msgpack-1.1.2-cp314-cp314t-win32.whl", hash = "sha256:1d1418482b1ee984625d88aa9585db570180c286d942da463533b238b98b812b", size = 75197 }, + { url = "https://files.pythonhosted.org/packages/15/86/d0071e94987f8db59d4eeb386ddc64d0bb9b10820a8d82bcd3e53eeb2da6/msgpack-1.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:5a46bf7e831d09470ad92dff02b8b1ac92175ca36b087f904a0519857c6be3ff", size = 85772 }, + { url = "https://files.pythonhosted.org/packages/81/f2/08ace4142eb281c12701fc3b93a10795e4d4dc7f753911d836675050f886/msgpack-1.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d99ef64f349d5ec3293688e91486c5fdb925ed03807f64d98d205d2713c60b46", size = 70868 }, +] + +[[package]] +name = "msgpack-types" +version = "0.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "msgpack" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7f/26/a15707f2af5681333cd598724bedd1948844ac2af45eafc4175af0671a8d/msgpack_types-0.5.0.tar.gz", hash = "sha256:aebd1b8da23f8f9966d66ebb1a43bd261b95751c6a267bd21a124d2ccac84201", size = 6702 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/19/dd/cd9d2b0ef506f6164cd81d4e92e408095041f28523d751b9f7dabdc244eb/msgpack_types-0.5.0-py3-none-any.whl", hash = "sha256:8b633ed75e495a555fa0615843de559a74b1d176828d59bb393d266e51f6bda7", size = 8182 }, +] + +[[package]] +name = "mypy" +version = "1.20.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "librt", marker = "platform_python_implementation != 'PyPy'" }, + { name = "mypy-extensions" }, + { name = "pathspec" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0b/3d/5b373635b3146264eb7a68d09e5ca11c305bbb058dfffbb47c47daf4f632/mypy-1.20.1.tar.gz", hash = "sha256:6fc3f4ecd52de81648fed1945498bf42fa2993ddfad67c9056df36ae5757f804", size = 3815892 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/21/4b/b1fa23297c8a5c403aabaac0649549efc5a0af7095f3dd33e7482863f973/mypy-1.20.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3ba5d1e712ada9c3b6223dcbc5a31dac334ed62991e5caa17bcf5a4ddc349af0", size = 14426426 }, + { url = "https://files.pythonhosted.org/packages/22/53/82923480aee5507a46df22428316e28b2b710d08506a128b2acef81ab18e/mypy-1.20.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2e731284c117b0987fb1e6c5013a56f33e7faa1fce594066ab83876183ce1c66", size = 13307651 }, + { url = "https://files.pythonhosted.org/packages/4e/0c/91905b393c790440fa273f0903ee2b07cce95bb6deccac87e6eb343d077a/mypy-1.20.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f8e945b872a05f4fbefabe2249c0b07b6b194e5e11a86ebee9edf855de09806c", size = 13746066 }, + { url = "https://files.pythonhosted.org/packages/88/b9/8a7017270438e34544e19dd6284cad54fd65dde3c35418a2ce07a1897804/mypy-1.20.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2fc88acef0dc9b15246502b418980478c1bfc9702057a0e1e7598d01a7af8937", size = 14617944 }, + { url = "https://files.pythonhosted.org/packages/0c/cf/5a61ceec3fc133e0f559d1e1f9adf4150abdbc2ad8eb831ec26fc8459196/mypy-1.20.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:14911a115c73608f155f648b978c5055d16ff974e6b1b5512d7fedf4fa8b15c6", size = 14918205 }, + { url = "https://files.pythonhosted.org/packages/6f/80/afb1c665e9c426c78e4711cce04e446b645867bfb97936158886103c1648/mypy-1.20.1-cp310-cp310-win_amd64.whl", hash = "sha256:76d9b4c992cca3331d9793ef197ae360ea44953cf35beb2526e95b9e074f2866", size = 10823344 }, + { url = "https://files.pythonhosted.org/packages/11/68/7ad64b49b7663c88fef76a2ac689ea73e17804832ac4cb5416bcff17775b/mypy-1.20.1-cp310-cp310-win_arm64.whl", hash = "sha256:b408722f80be44845da555671a5ef3a0c63f51ca5752b0c20e992dc9c0fbd3cd", size = 9760694 }, + { url = "https://files.pythonhosted.org/packages/82/0d/555ab7453cc4a4a8643b7f21c842b1a84c36b15392061ae7b052ee119320/mypy-1.20.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c01eb9bac2c6a962d00f9d23421cd2913840e65bba365167d057bd0b4171a92e", size = 14336012 }, + { url = "https://files.pythonhosted.org/packages/57/26/85a28893f7db8a16ebb41d1e9dfcb4475844d06a88480b6639e32a74d6ef/mypy-1.20.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:55d12ddbd8a9cac5b276878bd534fa39fff5bf543dc6ae18f25d30c8d7d27fca", size = 13224636 }, + { url = "https://files.pythonhosted.org/packages/93/41/bd4cd3c2caeb6c448b669222b8cfcbdee4a03b89431527b56fca9e56b6f3/mypy-1.20.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0aa322c1468b6cdfc927a44ce130f79bb44bcd34eb4a009eb9f96571fd80955", size = 13663471 }, + { url = "https://files.pythonhosted.org/packages/3e/56/7ee8c471e10402d64b6517ae10434541baca053cffd81090e4097d5609d4/mypy-1.20.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3f8bc95899cf676b6e2285779a08a998cc3a7b26f1026752df9d2741df3c79e8", size = 14532344 }, + { url = "https://files.pythonhosted.org/packages/b5/95/b37d1fa859a433f6156742e12f62b0bb75af658544fb6dada9363918743a/mypy-1.20.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:47c2b90191a870a04041e910277494b0d92f0711be9e524d45c074fe60c00b65", size = 14776670 }, + { url = "https://files.pythonhosted.org/packages/03/77/b302e4cb0b80d2bdf6bf4fce5864bb4cbfa461f7099cea544eaf2457df78/mypy-1.20.1-cp311-cp311-win_amd64.whl", hash = "sha256:9857dc8d2ec1a392ffbda518075beb00ac58859979c79f9e6bdcb7277082c2f2", size = 10816524 }, + { url = "https://files.pythonhosted.org/packages/7f/21/d969d7a68eb964993ebcc6170d5ecaf0cf65830c58ac3344562e16dc42a9/mypy-1.20.1-cp311-cp311-win_arm64.whl", hash = "sha256:09d8df92bb25b6065ab91b178da843dda67b33eb819321679a6e98a907ce0e10", size = 9750419 }, + { url = "https://files.pythonhosted.org/packages/69/1b/75a7c825a02781ca10bc2f2f12fba2af5202f6d6005aad8d2d1f264d8d78/mypy-1.20.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:36ee2b9c6599c230fea89bbd79f401f9f9f8e9fcf0c777827789b19b7da90f51", size = 14494077 }, + { url = "https://files.pythonhosted.org/packages/b0/54/5e5a569ea5c2b4d48b729fb32aa936eeb4246e4fc3e6f5b3d36a2dfbefb9/mypy-1.20.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fba3fb0968a7b48806b0c90f38d39296f10766885a94c83bd21399de1e14eb28", size = 13319495 }, + { url = "https://files.pythonhosted.org/packages/6f/a4/a1945b19f33e91721b59deee3abb484f2fa5922adc33bb166daf5325d76d/mypy-1.20.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef1415a637cd3627d6304dfbeddbadd21079dafc2a8a753c477ce4fc0c2af54f", size = 13696948 }, + { url = "https://files.pythonhosted.org/packages/b2/c6/75e969781c2359b2f9c15b061f28ec6d67c8b61865ceda176e85c8e7f2de/mypy-1.20.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ef3461b1ad5cd446e540016e90b5984657edda39f982f4cc45ca317b628f5a37", size = 14706744 }, + { url = "https://files.pythonhosted.org/packages/a8/6e/b221b1de981fc4262fe3e0bf9ec272d292dfe42394a689c2d49765c144c4/mypy-1.20.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:542dd63c9e1339b6092eb25bd515f3a32a1453aee8c9521d2ddb17dacd840237", size = 14949035 }, + { url = "https://files.pythonhosted.org/packages/ca/4b/298ba2de0aafc0da3ff2288da06884aae7ba6489bc247c933f87847c41b3/mypy-1.20.1-cp312-cp312-win_amd64.whl", hash = "sha256:1d55c7cd8ca22e31f93af2a01160a9e95465b5878de23dba7e48116052f20a8d", size = 10883216 }, + { url = "https://files.pythonhosted.org/packages/c7/f9/5e25b8f0b8cb92f080bfed9c21d3279b2a0b6a601cdca369a039ba84789d/mypy-1.20.1-cp312-cp312-win_arm64.whl", hash = "sha256:f5b84a79070586e0d353ee07b719d9d0a4aa7c8ee90c0ea97747e98cbe193019", size = 9814299 }, + { url = "https://files.pythonhosted.org/packages/21/e8/ef0991aa24c8f225df10b034f3c2681213cb54cf247623c6dec9a5744e70/mypy-1.20.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8f3886c03e40afefd327bd70b3f634b39ea82e87f314edaa4d0cce4b927ddcc1", size = 14500739 }, + { url = "https://files.pythonhosted.org/packages/23/73/416ebec3047636ed89fa871dc8c54bf05e9e20aa9499da59790d7adb312d/mypy-1.20.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e860eb3904f9764e83bafd70c8250bdffdc7dde6b82f486e8156348bf7ceb184", size = 13314735 }, + { url = "https://files.pythonhosted.org/packages/10/1e/1505022d9c9ac2e014a384eb17638fb37bf8e9d0a833ea60605b66f8f7ba/mypy-1.20.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a4b5aac6e785719da51a84f5d09e9e843d473170a9045b1ea7ea1af86225df4b", size = 13704356 }, + { url = "https://files.pythonhosted.org/packages/98/91/275b01f5eba5c467a3318ec214dd865abb66e9c811231c8587287b92876a/mypy-1.20.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f37b6cd0fe2ad3a20f05ace48ca3523fc52ff86940e34937b439613b6854472e", size = 14696420 }, + { url = "https://files.pythonhosted.org/packages/a1/57/b3779e134e1b7250d05f874252780d0a88c068bc054bcff99ca20a3a2986/mypy-1.20.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e4bbb0f6b54ce7cc350ef4a770650d15fa70edd99ad5267e227133eda9c94218", size = 14936093 }, + { url = "https://files.pythonhosted.org/packages/be/33/81b64991b0f3f278c3b55c335888794af190b2d59031a5ad1401bcb69f1e/mypy-1.20.1-cp313-cp313-win_amd64.whl", hash = "sha256:c3dc20f8ec76eecd77148cdd2f1542ed496e51e185713bf488a414f862deb8f2", size = 10889659 }, + { url = "https://files.pythonhosted.org/packages/1b/fd/7adcb8053572edf5ef8f3db59599dfeeee3be9cc4c8c97e2d28f66f42ac5/mypy-1.20.1-cp313-cp313-win_arm64.whl", hash = "sha256:a9d62bbac5d6d46718e2b0330b25e6264463ed832722b8f7d4440ff1be3ca895", size = 9815515 }, + { url = "https://files.pythonhosted.org/packages/40/cd/db831e84c81d57d4886d99feee14e372f64bbec6a9cb1a88a19e243f2ef5/mypy-1.20.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:12927b9c0ed794daedcf1dab055b6c613d9d5659ac511e8d936d96f19c087d12", size = 14483064 }, + { url = "https://files.pythonhosted.org/packages/d5/82/74e62e7097fa67da328ac8ece8de09133448c04d20ddeaeba251a3000f01/mypy-1.20.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:752507dd481e958b2c08fc966d3806c962af5a9433b5bf8f3bdd7175c20e34fe", size = 13335694 }, + { url = "https://files.pythonhosted.org/packages/74/c4/97e9a0abe4f3cdbbf4d079cb87a03b786efeccf5bf2b89fe4f96939ab2e6/mypy-1.20.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c614655b5a065e56274c6cbbe405f7cf7e96c0654db7ba39bc680238837f7b08", size = 13726365 }, + { url = "https://files.pythonhosted.org/packages/d7/aa/a19d884a8d28fcd3c065776323029f204dbc774e70ec9c85eba228b680de/mypy-1.20.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2c3f6221a76f34d5100c6d35b3ef6b947054123c3f8d6938a4ba00b1308aa572", size = 14693472 }, + { url = "https://files.pythonhosted.org/packages/84/44/cc9324bd21cf786592b44bf3b5d224b3923c1230ec9898d508d00241d465/mypy-1.20.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4bdfc06303ac06500af71ea0cdbe995c502b3c9ba32f3f8313523c137a25d1b6", size = 14919266 }, + { url = "https://files.pythonhosted.org/packages/6e/dc/779abb25a8c63e8f44bf5a336217fa92790fa17e0c40e0c725d10cb01bbd/mypy-1.20.1-cp314-cp314-win_amd64.whl", hash = "sha256:0131edd7eba289973d1ba1003d1a37c426b85cdef76650cd02da6420898a5eb3", size = 11049713 }, + { url = "https://files.pythonhosted.org/packages/28/08/4172be2ad7de9119b5a92ca36abbf641afdc5cb1ef4ae0c3a8182f29674f/mypy-1.20.1-cp314-cp314-win_arm64.whl", hash = "sha256:33f02904feb2c07e1fdf7909026206396c9deeb9e6f34d466b4cfedb0aadbbe4", size = 9999819 }, + { url = "https://files.pythonhosted.org/packages/2d/af/af9e46b0c8eabbce9fc04a477564170f47a1c22b308822282a59b7ff315f/mypy-1.20.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:168472149dd8cc505c98cefd21ad77e4257ed6022cd5ed2fe2999bed56977a5a", size = 15547508 }, + { url = "https://files.pythonhosted.org/packages/a7/cd/39c9e4ad6ba33e069e5837d772a9e6c304b4a5452a14a975d52b36444650/mypy-1.20.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:eb674600309a8f22790cca883a97c90299f948183ebb210fbef6bcee07cb1986", size = 14399557 }, + { url = "https://files.pythonhosted.org/packages/83/c1/3fd71bdc118ffc502bf57559c909927bb7e011f327f7bb8e0488e98a5870/mypy-1.20.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef2b2e4cc464ba9795459f2586923abd58a0055487cbe558cb538ea6e6bc142a", size = 15045789 }, + { url = "https://files.pythonhosted.org/packages/8e/73/6f07ff8b57a7d7b3e6e5bf34685d17632382395c8bb53364ec331661f83e/mypy-1.20.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dee461d396dd46b3f0ed5a098dbc9b8860c81c46ad44fa071afcfbc149f167c9", size = 15850795 }, + { url = "https://files.pythonhosted.org/packages/ec/e2/f7dffec1c7767078f9e9adf0c786d1fe0ff30964a77eb213c09b8b58cb76/mypy-1.20.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e364926308b3e66f1361f81a566fc1b2f8cd47fc8525e8136d4058a65a4b4f02", size = 16088539 }, + { url = "https://files.pythonhosted.org/packages/1a/76/e0dee71035316e75a69d73aec2f03c39c21c967b97e277fd0ef8fd6aec66/mypy-1.20.1-cp314-cp314t-win_amd64.whl", hash = "sha256:a0c17fbd746d38c70cbc42647cfd884f845a9708a4b160a8b4f7e70d41f4d7fa", size = 12575567 }, + { url = "https://files.pythonhosted.org/packages/22/a8/7ed43c9d9c3d1468f86605e323a5d97e411a448790a00f07e779f3211a46/mypy-1.20.1-cp314-cp314t-win_arm64.whl", hash = "sha256:db2cb89654626a912efda69c0d5c1d22d948265e2069010d3dde3abf751c7d08", size = 10378823 }, + { url = "https://files.pythonhosted.org/packages/d8/28/926bd972388e65a39ee98e188ccf67e81beb3aacfd5d6b310051772d974b/mypy-1.20.1-py3-none-any.whl", hash = "sha256:1aae28507f253fe82d883790d1c0a0d35798a810117c88184097fe8881052f06", size = 2636553 }, +] + +[[package]] +name = "mypy-extensions" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963 }, +] + +[[package]] +name = "pathspec" +version = "1.0.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fa/36/e27608899f9b8d4dff0617b2d9ab17ca5608956ca44461ac14ac48b44015/pathspec-1.0.4.tar.gz", hash = "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645", size = 131200 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/3c/2c197d226f9ea224a9ab8d197933f9da0ae0aac5b6e0f884e2b8d9c8e9f7/pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723", size = 55206 }, +] + +[[package]] +name = "pycparser" +version = "3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172 }, +] + +[[package]] +name = "pycryptodomex" +version = "3.23.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c9/85/e24bf90972a30b0fcd16c73009add1d7d7cd9140c2498a68252028899e41/pycryptodomex-3.23.0.tar.gz", hash = "sha256:71909758f010c82bc99b0abf4ea12012c98962fbf0583c2164f8b84533c2e4da", size = 4922157 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2e/00/10edb04777069a42490a38c137099d4b17ba6e36a4e6e28bdc7470e9e853/pycryptodomex-3.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:7b37e08e3871efe2187bc1fd9320cc81d87caf19816c648f24443483005ff886", size = 2498764 }, + { url = "https://files.pythonhosted.org/packages/6b/3f/2872a9c2d3a27eac094f9ceaa5a8a483b774ae69018040ea3240d5b11154/pycryptodomex-3.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:91979028227543010d7b2ba2471cf1d1e398b3f183cb105ac584df0c36dac28d", size = 1643012 }, + { url = "https://files.pythonhosted.org/packages/70/af/774c2e2b4f6570fbf6a4972161adbb183aeeaa1863bde31e8706f123bf92/pycryptodomex-3.23.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b8962204c47464d5c1c4038abeadd4514a133b28748bcd9fa5b6d62e3cec6fa", size = 2187643 }, + { url = "https://files.pythonhosted.org/packages/de/a3/71065b24cb889d537954cedc3ae5466af00a2cabcff8e29b73be047e9a19/pycryptodomex-3.23.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a33986a0066860f7fcf7c7bd2bc804fa90e434183645595ae7b33d01f3c91ed8", size = 2273762 }, + { url = "https://files.pythonhosted.org/packages/c9/0b/ff6f43b7fbef4d302c8b981fe58467b8871902cdc3eb28896b52421422cc/pycryptodomex-3.23.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c7947ab8d589e3178da3d7cdeabe14f841b391e17046954f2fbcd941705762b5", size = 2313012 }, + { url = "https://files.pythonhosted.org/packages/02/de/9d4772c0506ab6da10b41159493657105d3f8bb5c53615d19452afc6b315/pycryptodomex-3.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c25e30a20e1b426e1f0fa00131c516f16e474204eee1139d1603e132acffc314", size = 2186856 }, + { url = "https://files.pythonhosted.org/packages/28/ad/8b30efcd6341707a234e5eba5493700a17852ca1ac7a75daa7945fcf6427/pycryptodomex-3.23.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:da4fa650cef02db88c2b98acc5434461e027dce0ae8c22dd5a69013eaf510006", size = 2347523 }, + { url = "https://files.pythonhosted.org/packages/0f/02/16868e9f655b7670dbb0ac4f2844145cbc42251f916fc35c414ad2359849/pycryptodomex-3.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:58b851b9effd0d072d4ca2e4542bf2a4abcf13c82a29fd2c93ce27ee2a2e9462", size = 2272825 }, + { url = "https://files.pythonhosted.org/packages/ca/18/4ca89ac737230b52ac8ffaca42f9c6f1fd07c81a6cd821e91af79db60632/pycryptodomex-3.23.0-cp313-cp313t-win32.whl", hash = "sha256:a9d446e844f08299236780f2efa9898c818fe7e02f17263866b8550c7d5fb328", size = 1772078 }, + { url = "https://files.pythonhosted.org/packages/73/34/13e01c322db027682e00986873eca803f11c56ade9ba5bbf3225841ea2d4/pycryptodomex-3.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:bc65bdd9fc8de7a35a74cab1c898cab391a4add33a8fe740bda00f5976ca4708", size = 1803656 }, + { url = "https://files.pythonhosted.org/packages/54/68/9504c8796b1805d58f4425002bcca20f12880e6fa4dc2fc9a668705c7a08/pycryptodomex-3.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:c885da45e70139464f082018ac527fdaad26f1657a99ee13eecdce0f0ca24ab4", size = 1707172 }, + { url = "https://files.pythonhosted.org/packages/dd/9c/1a8f35daa39784ed8adf93a694e7e5dc15c23c741bbda06e1d45f8979e9e/pycryptodomex-3.23.0-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:06698f957fe1ab229a99ba2defeeae1c09af185baa909a31a5d1f9d42b1aaed6", size = 2499240 }, + { url = "https://files.pythonhosted.org/packages/7a/62/f5221a191a97157d240cf6643747558759126c76ee92f29a3f4aee3197a5/pycryptodomex-3.23.0-cp37-abi3-macosx_10_9_x86_64.whl", hash = "sha256:b2c2537863eccef2d41061e82a881dcabb04944c5c06c5aa7110b577cc487545", size = 1644042 }, + { url = "https://files.pythonhosted.org/packages/8c/fd/5a054543c8988d4ed7b612721d7e78a4b9bf36bc3c5ad45ef45c22d0060e/pycryptodomex-3.23.0-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:43c446e2ba8df8889e0e16f02211c25b4934898384c1ec1ec04d7889c0333587", size = 2186227 }, + { url = "https://files.pythonhosted.org/packages/c8/a9/8862616a85cf450d2822dbd4fff1fcaba90877907a6ff5bc2672cafe42f8/pycryptodomex-3.23.0-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f489c4765093fb60e2edafdf223397bc716491b2b69fe74367b70d6999257a5c", size = 2272578 }, + { url = "https://files.pythonhosted.org/packages/46/9f/bda9c49a7c1842820de674ab36c79f4fbeeee03f8ff0e4f3546c3889076b/pycryptodomex-3.23.0-cp37-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bdc69d0d3d989a1029df0eed67cc5e8e5d968f3724f4519bd03e0ec68df7543c", size = 2312166 }, + { url = "https://files.pythonhosted.org/packages/03/cc/870b9bf8ca92866ca0186534801cf8d20554ad2a76ca959538041b7a7cf4/pycryptodomex-3.23.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:6bbcb1dd0f646484939e142462d9e532482bc74475cecf9c4903d4e1cd21f003", size = 2185467 }, + { url = "https://files.pythonhosted.org/packages/96/e3/ce9348236d8e669fea5dd82a90e86be48b9c341210f44e25443162aba187/pycryptodomex-3.23.0-cp37-abi3-musllinux_1_2_i686.whl", hash = "sha256:8a4fcd42ccb04c31268d1efeecfccfd1249612b4de6374205376b8f280321744", size = 2346104 }, + { url = "https://files.pythonhosted.org/packages/a5/e9/e869bcee87beb89040263c416a8a50204f7f7a83ac11897646c9e71e0daf/pycryptodomex-3.23.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:55ccbe27f049743a4caf4f4221b166560d3438d0b1e5ab929e07ae1702a4d6fd", size = 2271038 }, + { url = "https://files.pythonhosted.org/packages/8d/67/09ee8500dd22614af5fbaa51a4aee6e342b5fa8aecf0a6cb9cbf52fa6d45/pycryptodomex-3.23.0-cp37-abi3-win32.whl", hash = "sha256:189afbc87f0b9f158386bf051f720e20fa6145975f1e76369303d0f31d1a8d7c", size = 1771969 }, + { url = "https://files.pythonhosted.org/packages/69/96/11f36f71a865dd6df03716d33bd07a67e9d20f6b8d39820470b766af323c/pycryptodomex-3.23.0-cp37-abi3-win_amd64.whl", hash = "sha256:52e5ca58c3a0b0bd5e100a9fbc8015059b05cffc6c66ce9d98b4b45e023443b9", size = 1803124 }, + { url = "https://files.pythonhosted.org/packages/f9/93/45c1cdcbeb182ccd2e144c693eaa097763b08b38cded279f0053ed53c553/pycryptodomex-3.23.0-cp37-abi3-win_arm64.whl", hash = "sha256:02d87b80778c171445d67e23d1caef279bf4b25c3597050ccd2e13970b57fd51", size = 1707161 }, + { url = "https://files.pythonhosted.org/packages/f3/b8/3e76d948c3c4ac71335bbe75dac53e154b40b0f8f1f022dfa295257a0c96/pycryptodomex-3.23.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ebfff755c360d674306e5891c564a274a47953562b42fb74a5c25b8fc1fb1cb5", size = 1627695 }, + { url = "https://files.pythonhosted.org/packages/6a/cf/80f4297a4820dfdfd1c88cf6c4666a200f204b3488103d027b5edd9176ec/pycryptodomex-3.23.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eca54f4bb349d45afc17e3011ed4264ef1cc9e266699874cdd1349c504e64798", size = 1675772 }, + { url = "https://files.pythonhosted.org/packages/d1/42/1e969ee0ad19fe3134b0e1b856c39bd0b70d47a4d0e81c2a8b05727394c9/pycryptodomex-3.23.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f2596e643d4365e14d0879dc5aafe6355616c61c2176009270f3048f6d9a61f", size = 1668083 }, + { url = "https://files.pythonhosted.org/packages/6e/c3/1de4f7631fea8a992a44ba632aa40e0008764c0fb9bf2854b0acf78c2cf2/pycryptodomex-3.23.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fdfac7cda115bca3a5abb2f9e43bc2fb66c2b65ab074913643803ca7083a79ea", size = 1706056 }, + { url = "https://files.pythonhosted.org/packages/f2/5f/af7da8e6f1e42b52f44a24d08b8e4c726207434e2593732d39e7af5e7256/pycryptodomex-3.23.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:14c37aaece158d0ace436f76a7bb19093db3b4deade9797abfc39ec6cd6cc2fe", size = 1806478 }, +] + +[[package]] +name = "pynacl" +version = "1.6.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d9/9a/4019b524b03a13438637b11538c82781a5eda427394380381af8f04f467a/pynacl-1.6.2.tar.gz", hash = "sha256:018494d6d696ae03c7e656e5e74cdfd8ea1326962cc401bcf018f1ed8436811c", size = 3511692 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/79/0e3c34dc3c4671f67d251c07aa8eb100916f250ee470df230b0ab89551b4/pynacl-1.6.2-cp314-cp314t-macosx_10_10_universal2.whl", hash = "sha256:622d7b07cc5c02c666795792931b50c91f3ce3c2649762efb1ef0d5684c81594", size = 390064 }, + { url = "https://files.pythonhosted.org/packages/eb/1c/23a26e931736e13b16483795c8a6b2f641bf6a3d5238c22b070a5112722c/pynacl-1.6.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d071c6a9a4c94d79eb665db4ce5cedc537faf74f2355e4d502591d850d3913c0", size = 809370 }, + { url = "https://files.pythonhosted.org/packages/87/74/8d4b718f8a22aea9e8dcc8b95deb76d4aae380e2f5b570cc70b5fd0a852d/pynacl-1.6.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fe9847ca47d287af41e82be1dd5e23023d3c31a951da134121ab02e42ac218c9", size = 1408304 }, + { url = "https://files.pythonhosted.org/packages/fd/73/be4fdd3a6a87fe8a4553380c2b47fbd1f7f58292eb820902f5c8ac7de7b0/pynacl-1.6.2-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:04316d1fc625d860b6c162fff704eb8426b1a8bcd3abacea11142cbd99a6b574", size = 844871 }, + { url = "https://files.pythonhosted.org/packages/55/ad/6efc57ab75ee4422e96b5f2697d51bbcf6cdcc091e66310df91fbdc144a8/pynacl-1.6.2-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:44081faff368d6c5553ccf55322ef2819abb40e25afaec7e740f159f74813634", size = 1446356 }, + { url = "https://files.pythonhosted.org/packages/78/b7/928ee9c4779caa0a915844311ab9fb5f99585621c5d6e4574538a17dca07/pynacl-1.6.2-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:a9f9932d8d2811ce1a8ffa79dcbdf3970e7355b5c8eb0c1a881a57e7f7d96e88", size = 826814 }, + { url = "https://files.pythonhosted.org/packages/f7/a9/1bdba746a2be20f8809fee75c10e3159d75864ef69c6b0dd168fc60e485d/pynacl-1.6.2-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:bc4a36b28dd72fb4845e5d8f9760610588a96d5a51f01d84d8c6ff9849968c14", size = 1411742 }, + { url = "https://files.pythonhosted.org/packages/f3/2f/5e7ea8d85f9f3ea5b6b87db1d8388daa3587eed181bdeb0306816fdbbe79/pynacl-1.6.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3bffb6d0f6becacb6526f8f42adfb5efb26337056ee0831fb9a7044d1a964444", size = 801714 }, + { url = "https://files.pythonhosted.org/packages/06/ea/43fe2f7eab5f200e40fb10d305bf6f87ea31b3bbc83443eac37cd34a9e1e/pynacl-1.6.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:2fef529ef3ee487ad8113d287a593fa26f48ee3620d92ecc6f1d09ea38e0709b", size = 1372257 }, + { url = "https://files.pythonhosted.org/packages/4d/54/c9ea116412788629b1347e415f72195c25eb2f3809b2d3e7b25f5c79f13a/pynacl-1.6.2-cp314-cp314t-win32.whl", hash = "sha256:a84bf1c20339d06dc0c85d9aea9637a24f718f375d861b2668b2f9f96fa51145", size = 231319 }, + { url = "https://files.pythonhosted.org/packages/ce/04/64e9d76646abac2dccf904fccba352a86e7d172647557f35b9fe2a5ee4a1/pynacl-1.6.2-cp314-cp314t-win_amd64.whl", hash = "sha256:320ef68a41c87547c91a8b58903c9caa641ab01e8512ce291085b5fe2fcb7590", size = 244044 }, + { url = "https://files.pythonhosted.org/packages/33/33/7873dc161c6a06f43cda13dec67b6fe152cb2f982581151956fa5e5cdb47/pynacl-1.6.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d29bfe37e20e015a7d8b23cfc8bd6aa7909c92a1b8f41ee416bbb3e79ef182b2", size = 188740 }, + { url = "https://files.pythonhosted.org/packages/be/7b/4845bbf88e94586ec47a432da4e9107e3fc3ce37eb412b1398630a37f7dd/pynacl-1.6.2-cp38-abi3-macosx_10_10_universal2.whl", hash = "sha256:c949ea47e4206af7c8f604b8278093b674f7c79ed0d4719cc836902bf4517465", size = 388458 }, + { url = "https://files.pythonhosted.org/packages/1e/b4/e927e0653ba63b02a4ca5b4d852a8d1d678afbf69b3dbf9c4d0785ac905c/pynacl-1.6.2-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8845c0631c0be43abdd865511c41eab235e0be69c81dc66a50911594198679b0", size = 800020 }, + { url = "https://files.pythonhosted.org/packages/7f/81/d60984052df5c97b1d24365bc1e30024379b42c4edcd79d2436b1b9806f2/pynacl-1.6.2-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:22de65bb9010a725b0dac248f353bb072969c94fa8d6b1f34b87d7953cf7bbe4", size = 1399174 }, + { url = "https://files.pythonhosted.org/packages/68/f7/322f2f9915c4ef27d140101dd0ed26b479f7e6f5f183590fd32dfc48c4d3/pynacl-1.6.2-cp38-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:46065496ab748469cdd999246d17e301b2c24ae2fdf739132e580a0e94c94a87", size = 835085 }, + { url = "https://files.pythonhosted.org/packages/3e/d0/f301f83ac8dbe53442c5a43f6a39016f94f754d7a9815a875b65e218a307/pynacl-1.6.2-cp38-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a66d6fb6ae7661c58995f9c6435bda2b1e68b54b598a6a10247bfcdadac996c", size = 1437614 }, + { url = "https://files.pythonhosted.org/packages/c4/58/fc6e649762b029315325ace1a8c6be66125e42f67416d3dbd47b69563d61/pynacl-1.6.2-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:26bfcd00dcf2cf160f122186af731ae30ab120c18e8375684ec2670dccd28130", size = 818251 }, + { url = "https://files.pythonhosted.org/packages/c9/a8/b917096b1accc9acd878819a49d3d84875731a41eb665f6ebc826b1af99e/pynacl-1.6.2-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:c8a231e36ec2cab018c4ad4358c386e36eede0319a0c41fed24f840b1dac59f6", size = 1402859 }, + { url = "https://files.pythonhosted.org/packages/85/42/fe60b5f4473e12c72f977548e4028156f4d340b884c635ec6b063fe7e9a5/pynacl-1.6.2-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:68be3a09455743ff9505491220b64440ced8973fe930f270c8e07ccfa25b1f9e", size = 791926 }, + { url = "https://files.pythonhosted.org/packages/fa/f9/e40e318c604259301cc091a2a63f237d9e7b424c4851cafaea4ea7c4834e/pynacl-1.6.2-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:8b097553b380236d51ed11356c953bf8ce36a29a3e596e934ecabe76c985a577", size = 1363101 }, + { url = "https://files.pythonhosted.org/packages/48/47/e761c254f410c023a469284a9bc210933e18588ca87706ae93002c05114c/pynacl-1.6.2-cp38-abi3-win32.whl", hash = "sha256:5811c72b473b2f38f7e2a3dc4f8642e3a3e9b5e7317266e4ced1fba85cae41aa", size = 227421 }, + { url = "https://files.pythonhosted.org/packages/41/ad/334600e8cacc7d86587fe5f565480fde569dfb487389c8e1be56ac21d8ac/pynacl-1.6.2-cp38-abi3-win_amd64.whl", hash = "sha256:62985f233210dee6548c223301b6c25440852e13d59a8b81490203c3227c5ba0", size = 239754 }, + { url = "https://files.pythonhosted.org/packages/29/7d/5945b5af29534641820d3bd7b00962abbbdfee84ec7e19f0d5b3175f9a31/pynacl-1.6.2-cp38-abi3-win_arm64.whl", hash = "sha256:834a43af110f743a754448463e8fd61259cd4ab5bbedcf70f9dabad1d28a394c", size = 184801 }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 }, +] + +[[package]] +name = "python-dotenv" +version = "1.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101 }, +] + +[[package]] +name = "pywin32-ctypes" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/85/9f/01a1a99704853cb63f253eea009390c88e7131c67e66a0a02099a8c917cb/pywin32-ctypes-0.2.3.tar.gz", hash = "sha256:d162dc04946d704503b2edc4d55f3dba5c1d539ead017afa00142c38b9885755", size = 29471 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl", hash = "sha256:8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", size = 30756 }, +] + +[[package]] +name = "s3transfer" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "botocore" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/05/04/74127fc843314818edfa81b5540e26dd537353b123a4edc563109d8f17dd/s3transfer-0.16.0.tar.gz", hash = "sha256:8e990f13268025792229cd52fa10cb7163744bf56e719e0b9cb925ab79abf920", size = 153827 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/51/727abb13f44c1fcf6d145979e1535a35794db0f6e450a0cb46aa24732fe2/s3transfer-0.16.0-py3-none-any.whl", hash = "sha256:18e25d66fed509e3868dc1572b3f427ff947dd2c56f844a5bf09481ad3f3b2fe", size = 86830 }, +] + +[[package]] +name = "secretstorage" +version = "3.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cryptography" }, + { name = "jeepney" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1c/03/e834bcd866f2f8a49a85eaff47340affa3bfa391ee9912a952a1faa68c7b/secretstorage-3.5.0.tar.gz", hash = "sha256:f04b8e4689cbce351744d5537bf6b1329c6fc68f91fa666f60a380edddcd11be", size = 19884 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/46/f5af3402b579fd5e11573ce652019a67074317e18c1935cc0b4ba9b35552/secretstorage-3.5.0-py3-none-any.whl", hash = "sha256:0ce65888c0725fcb2c5bc0fdb8e5438eece02c523557ea40ce0703c266248137", size = 15554 }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 }, +] + +[[package]] +name = "tomli" +version = "2.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/11/db3d5885d8528263d8adc260bb2d28ebf1270b96e98f0e0268d32b8d9900/tomli-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30", size = 154704 }, + { url = "https://files.pythonhosted.org/packages/6d/f7/675db52c7e46064a9aa928885a9b20f4124ecb9bc2e1ce74c9106648d202/tomli-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a", size = 149454 }, + { url = "https://files.pythonhosted.org/packages/61/71/81c50943cf953efa35bce7646caab3cf457a7d8c030b27cfb40d7235f9ee/tomli-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076", size = 237561 }, + { url = "https://files.pythonhosted.org/packages/48/c1/f41d9cb618acccca7df82aaf682f9b49013c9397212cb9f53219e3abac37/tomli-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9", size = 243824 }, + { url = "https://files.pythonhosted.org/packages/22/e4/5a816ecdd1f8ca51fb756ef684b90f2780afc52fc67f987e3c61d800a46d/tomli-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c", size = 242227 }, + { url = "https://files.pythonhosted.org/packages/6b/49/2b2a0ef529aa6eec245d25f0c703e020a73955ad7edf73e7f54ddc608aa5/tomli-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc", size = 247859 }, + { url = "https://files.pythonhosted.org/packages/83/bd/6c1a630eaca337e1e78c5903104f831bda934c426f9231429396ce3c3467/tomli-2.4.1-cp311-cp311-win32.whl", hash = "sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049", size = 97204 }, + { url = "https://files.pythonhosted.org/packages/42/59/71461df1a885647e10b6bb7802d0b8e66480c61f3f43079e0dcd315b3954/tomli-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e", size = 108084 }, + { url = "https://files.pythonhosted.org/packages/b8/83/dceca96142499c069475b790e7913b1044c1a4337e700751f48ed723f883/tomli-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece", size = 95285 }, + { url = "https://files.pythonhosted.org/packages/c1/ba/42f134a3fe2b370f555f44b1d72feebb94debcab01676bf918d0cb70e9aa/tomli-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a", size = 155924 }, + { url = "https://files.pythonhosted.org/packages/dc/c7/62d7a17c26487ade21c5422b646110f2162f1fcc95980ef7f63e73c68f14/tomli-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085", size = 150018 }, + { url = "https://files.pythonhosted.org/packages/5c/05/79d13d7c15f13bdef410bdd49a6485b1c37d28968314eabee452c22a7fda/tomli-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9", size = 244948 }, + { url = "https://files.pythonhosted.org/packages/10/90/d62ce007a1c80d0b2c93e02cab211224756240884751b94ca72df8a875ca/tomli-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5", size = 253341 }, + { url = "https://files.pythonhosted.org/packages/1a/7e/caf6496d60152ad4ed09282c1885cca4eea150bfd007da84aea07bcc0a3e/tomli-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585", size = 248159 }, + { url = "https://files.pythonhosted.org/packages/99/e7/c6f69c3120de34bbd882c6fba7975f3d7a746e9218e56ab46a1bc4b42552/tomli-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1", size = 253290 }, + { url = "https://files.pythonhosted.org/packages/d6/2f/4a3c322f22c5c66c4b836ec58211641a4067364f5dcdd7b974b4c5da300c/tomli-2.4.1-cp312-cp312-win32.whl", hash = "sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917", size = 98141 }, + { url = "https://files.pythonhosted.org/packages/24/22/4daacd05391b92c55759d55eaee21e1dfaea86ce5c571f10083360adf534/tomli-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9", size = 108847 }, + { url = "https://files.pythonhosted.org/packages/68/fd/70e768887666ddd9e9f5d85129e84910f2db2796f9096aa02b721a53098d/tomli-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257", size = 95088 }, + { url = "https://files.pythonhosted.org/packages/07/06/b823a7e818c756d9a7123ba2cda7d07bc2dd32835648d1a7b7b7a05d848d/tomli-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54", size = 155866 }, + { url = "https://files.pythonhosted.org/packages/14/6f/12645cf7f08e1a20c7eb8c297c6f11d31c1b50f316a7e7e1e1de6e2e7b7e/tomli-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a", size = 149887 }, + { url = "https://files.pythonhosted.org/packages/5c/e0/90637574e5e7212c09099c67ad349b04ec4d6020324539297b634a0192b0/tomli-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897", size = 243704 }, + { url = "https://files.pythonhosted.org/packages/10/8f/d3ddb16c5a4befdf31a23307f72828686ab2096f068eaf56631e136c1fdd/tomli-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f", size = 251628 }, + { url = "https://files.pythonhosted.org/packages/e3/f1/dbeeb9116715abee2485bf0a12d07a8f31af94d71608c171c45f64c0469d/tomli-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d", size = 247180 }, + { url = "https://files.pythonhosted.org/packages/d3/74/16336ffd19ed4da28a70959f92f506233bd7cfc2332b20bdb01591e8b1d1/tomli-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5", size = 251674 }, + { url = "https://files.pythonhosted.org/packages/16/f9/229fa3434c590ddf6c0aa9af64d3af4b752540686cace29e6281e3458469/tomli-2.4.1-cp313-cp313-win32.whl", hash = "sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd", size = 97976 }, + { url = "https://files.pythonhosted.org/packages/6a/1e/71dfd96bcc1c775420cb8befe7a9d35f2e5b1309798f009dca17b7708c1e/tomli-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36", size = 108755 }, + { url = "https://files.pythonhosted.org/packages/83/7a/d34f422a021d62420b78f5c538e5b102f62bea616d1d75a13f0a88acb04a/tomli-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd", size = 95265 }, + { url = "https://files.pythonhosted.org/packages/3c/fb/9a5c8d27dbab540869f7c1f8eb0abb3244189ce780ba9cd73f3770662072/tomli-2.4.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fd0409a3653af6c147209d267a0e4243f0ae46b011aa978b1080359fddc9b6cf", size = 155726 }, + { url = "https://files.pythonhosted.org/packages/62/05/d2f816630cc771ad836af54f5001f47a6f611d2d39535364f148b6a92d6b/tomli-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a120733b01c45e9a0c34aeef92bf0cf1d56cfe81ed9d47d562f9ed591a9828ac", size = 149859 }, + { url = "https://files.pythonhosted.org/packages/ce/48/66341bdb858ad9bd0ceab5a86f90eddab127cf8b046418009f2125630ecb/tomli-2.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:559db847dc486944896521f68d8190be1c9e719fced785720d2216fe7022b662", size = 244713 }, + { url = "https://files.pythonhosted.org/packages/df/6d/c5fad00d82b3c7a3ab6189bd4b10e60466f22cfe8a08a9394185c8a8111c/tomli-2.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01f520d4f53ef97964a240a035ec2a869fe1a37dde002b57ebc4417a27ccd853", size = 252084 }, + { url = "https://files.pythonhosted.org/packages/00/71/3a69e86f3eafe8c7a59d008d245888051005bd657760e96d5fbfb0b740c2/tomli-2.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7f94b27a62cfad8496c8d2513e1a222dd446f095fca8987fceef261225538a15", size = 247973 }, + { url = "https://files.pythonhosted.org/packages/67/50/361e986652847fec4bd5e4a0208752fbe64689c603c7ae5ea7cb16b1c0ca/tomli-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ede3e6487c5ef5d28634ba3f31f989030ad6af71edfb0055cbbd14189ff240ba", size = 256223 }, + { url = "https://files.pythonhosted.org/packages/8c/9a/b4173689a9203472e5467217e0154b00e260621caa227b6fa01feab16998/tomli-2.4.1-cp314-cp314-win32.whl", hash = "sha256:3d48a93ee1c9b79c04bb38772ee1b64dcf18ff43085896ea460ca8dec96f35f6", size = 98973 }, + { url = "https://files.pythonhosted.org/packages/14/58/640ac93bf230cd27d002462c9af0d837779f8773bc03dee06b5835208214/tomli-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:88dceee75c2c63af144e456745e10101eb67361050196b0b6af5d717254dddf7", size = 109082 }, + { url = "https://files.pythonhosted.org/packages/d5/2f/702d5e05b227401c1068f0d386d79a589bb12bf64c3d2c72ce0631e3bc49/tomli-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:b8c198f8c1805dc42708689ed6864951fd2494f924149d3e4bce7710f8eb5232", size = 96490 }, + { url = "https://files.pythonhosted.org/packages/45/4b/b877b05c8ba62927d9865dd980e34a755de541eb65fffba52b4cc495d4d2/tomli-2.4.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d4d8fe59808a54658fcc0160ecfb1b30f9089906c50b23bcb4c69eddc19ec2b4", size = 164263 }, + { url = "https://files.pythonhosted.org/packages/24/79/6ab420d37a270b89f7195dec5448f79400d9e9c1826df982f3f8e97b24fd/tomli-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7008df2e7655c495dd12d2a4ad038ff878d4ca4b81fccaf82b714e07eae4402c", size = 160736 }, + { url = "https://files.pythonhosted.org/packages/02/e0/3630057d8eb170310785723ed5adcdfb7d50cb7e6455f85ba8a3deed642b/tomli-2.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1d8591993e228b0c930c4bb0db464bdad97b3289fb981255d6c9a41aedc84b2d", size = 270717 }, + { url = "https://files.pythonhosted.org/packages/7a/b4/1613716072e544d1a7891f548d8f9ec6ce2faf42ca65acae01d76ea06bb0/tomli-2.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:734e20b57ba95624ecf1841e72b53f6e186355e216e5412de414e3c51e5e3c41", size = 278461 }, + { url = "https://files.pythonhosted.org/packages/05/38/30f541baf6a3f6df77b3df16b01ba319221389e2da59427e221ef417ac0c/tomli-2.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a650c2dbafa08d42e51ba0b62740dae4ecb9338eefa093aa5c78ceb546fcd5c", size = 274855 }, + { url = "https://files.pythonhosted.org/packages/77/a3/ec9dd4fd2c38e98de34223b995a3b34813e6bdadf86c75314c928350ed14/tomli-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:504aa796fe0569bb43171066009ead363de03675276d2d121ac1a4572397870f", size = 283144 }, + { url = "https://files.pythonhosted.org/packages/ef/be/605a6261cac79fba2ec0c9827e986e00323a1945700969b8ee0b30d85453/tomli-2.4.1-cp314-cp314t-win32.whl", hash = "sha256:b1d22e6e9387bf4739fbe23bfa80e93f6b0373a7f1b96c6227c32bef95a4d7a8", size = 108683 }, + { url = "https://files.pythonhosted.org/packages/12/64/da524626d3b9cc40c168a13da8335fe1c51be12c0a63685cc6db7308daae/tomli-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2c1c351919aca02858f740c6d33adea0c5deea37f9ecca1cc1ef9e884a619d26", size = 121196 }, + { url = "https://files.pythonhosted.org/packages/5a/cd/e80b62269fc78fc36c9af5a6b89c835baa8af28ff5ad28c7028d60860320/tomli-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:eab21f45c7f66c13f2a9e0e1535309cee140182a9cdae1e041d02e47291e8396", size = 100393 }, + { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583 }, +] + +[[package]] +name = "types-cffi" +version = "2.0.0.20260316" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "types-setuptools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/07/4c/805b40b094eb3fd60f8d17fa7b3c58a33781311a95d0e6a74da0751ce294/types_cffi-2.0.0.20260316.tar.gz", hash = "sha256:8fb06ed4709675c999853689941133affcd2250cd6121cc11fd22c0d81ad510c", size = 17399 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/5e/9f1a709225ad9d0e1d7a6e4366ff285f0113c749e882d6cbeb40eab32e75/types_cffi-2.0.0.20260316-py3-none-any.whl", hash = "sha256:dd504698029db4c580385f679324621cc64d886e6a23e9821d52bc5169251302", size = 20096 }, +] + +[[package]] +name = "types-setuptools" +version = "82.0.0.20260210" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4b/90/796ac8c774a7f535084aacbaa6b7053d16fff5c630eff87c3ecff7896c37/types_setuptools-82.0.0.20260210.tar.gz", hash = "sha256:d9719fbbeb185254480ade1f25327c4654f8c00efda3fec36823379cebcdee58", size = 44768 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3e/54/3489432b1d9bc713c9d8aa810296b8f5b0088403662959fb63a8acdbd4fc/types_setuptools-82.0.0.20260210-py3-none-any.whl", hash = "sha256:5124a7daf67f195c6054e0f00f1d97c69caad12fdcf9113eba33eff0bce8cd2b", size = 68433 }, +] + +[[package]] +name = "typing-extensions" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614 }, +] + +[[package]] +name = "urllib3" +version = "2.6.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584 }, +] + +[[package]] +name = "xhd-wallet-api" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, + { name = "types-cffi" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/fb/a50dbe3ec6ed5b7257894735e46306bd11c0daee09e971441b2fadeeb05c/xhd_wallet_api-1.0.0-py3-none-macosx_10_9_x86_64.whl", hash = "sha256:e37dbb3f434d9baf28f49decf09d52a8ab64a58f926d50f49eab124a961a3a7e", size = 378250 }, + { url = "https://files.pythonhosted.org/packages/f0/46/32d7fdbc321a89ba5cedbf772a328badd76c3ff0e04c61d574f93801032e/xhd_wallet_api-1.0.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:915a89efacc1174f64af07c52672b026a355aee4374ab04d92721fc2b0930db9", size = 363100 }, + { url = "https://files.pythonhosted.org/packages/64/df/51a32ee17ed10723239215a6dc6a3eda81308ed9f29a10598de61d5fa25f/xhd_wallet_api-1.0.0-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:092b079f244e5d88c254d8af3630181b4c049269374e4e25ed764baf417fdd3d", size = 386354 }, + { url = "https://files.pythonhosted.org/packages/53/5a/5da7ef4c70ede3b1bfbbe445a78857de99019b66169a0f9d75ebe0563e2f/xhd_wallet_api-1.0.0-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:38b4843464cdf2398ca635bc4cb6ba37ef7fbd2191c6b9053743bcc66a4784be", size = 395015 }, + { url = "https://files.pythonhosted.org/packages/d2/f8/6052412d8b360240fa4958319dc257a01517e864a1539accda639a7836cc/xhd_wallet_api-1.0.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:71d6aa0291fea0f0ecc22f7eda8a0f61482dc92e19345c0a354dd8a4f1bdb72a", size = 450127 }, + { url = "https://files.pythonhosted.org/packages/f8/38/9f3d3849e1bdff900f405dc4a636c872c189e0f4d3202bdfa969e3206825/xhd_wallet_api-1.0.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:a956ca70a155de9a0afc528a3bf216f9408172bc54afc5b8103c5425c5f9f912", size = 474598 }, + { url = "https://files.pythonhosted.org/packages/b1/78/5477067a40347a88af0b57b9dabf0f1dc3e5796f785073c2dd157434f56b/xhd_wallet_api-1.0.0-py3-none-win_amd64.whl", hash = "sha256:d4a633e0cdb8095e941b9ce84e05e96904ef273f7b655abd81f13f265bf195a9", size = 267934 }, +] + +[[package]] +name = "zipp" +version = "3.23.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276 }, +] diff --git a/examples/verify-all.sh b/examples/verify-all.sh new file mode 100755 index 00000000..91c1d553 --- /dev/null +++ b/examples/verify-all.sh @@ -0,0 +1,80 @@ +#!/bin/bash + +# verify-all.sh - Run all example verification scripts +# Exit with non-zero code if any example suite fails + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +cd "$SCRIPT_DIR" + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +NC='\033[0m' # No Color + +# Example suites to run (8 categories) +SUITES=( + "abi" + "algo25" + "algod_client" + "algorand_client" + "common" + "indexer_client" + "kmd_client" + "signing" + "transact" +) + +echo "========================================" +echo "Examples Verification Suite" +echo "========================================" +echo "" + +PASSED=0 +FAILED=0 +FAILED_SUITES=() + +for suite in "${SUITES[@]}"; do + echo "----------------------------------------" + echo "Running $suite examples..." + echo "----------------------------------------" + + if [ ! -d "$suite" ]; then + echo -e "${RED}FAILED${NC} (directory not found)" + FAILED=$((FAILED + 1)) + FAILED_SUITES+=("$suite") + continue + fi + + if [ ! -f "$suite/verify-all.sh" ]; then + echo -e "${RED}FAILED${NC} (verify-all.sh not found)" + FAILED=$((FAILED + 1)) + FAILED_SUITES+=("$suite") + continue + fi + + if (cd "$suite" && ./verify-all.sh); then + PASSED=$((PASSED + 1)) + else + FAILED=$((FAILED + 1)) + FAILED_SUITES+=("$suite") + fi + + echo "" +done + +echo "========================================" +echo "Overall Results: ${PASSED} suites passed, ${FAILED} suites failed" +echo "========================================" + +if [ $FAILED -gt 0 ]; then + echo "" + echo -e "${RED}Failed suites:${NC}" + for failed in "${FAILED_SUITES[@]}"; do + echo " - $failed" + done + exit 1 +fi + +echo "" +echo -e "${GREEN}All example suites passed!${NC}" +exit 0 diff --git a/legacy_v2_tests/app_client_test.json b/legacy_v2_tests/app_client_test.json deleted file mode 100644 index 1ddf81b2..00000000 --- a/legacy_v2_tests/app_client_test.json +++ /dev/null @@ -1,378 +0,0 @@ -{ - "hints": { - "version()uint64": { - "call_config": { - "no_op": "CALL" - } - }, - "readonly(uint64)void": { - "read_only": true, - "call_config": { - "no_op": "CALL" - } - }, - "set_box(byte[4],string)void": { - "call_config": { - "no_op": "CALL" - } - }, - "get_box(byte[4])string": { - "call_config": { - "no_op": "CALL" - } - }, - "get_box_readonly(byte[4])string": { - "read_only": true, - "call_config": { - "no_op": "CALL" - } - }, - "update()void": { - "call_config": { - "update_application": "CALL" - } - }, - "update_args(string)void": { - "call_config": { - "update_application": "CALL" - } - }, - "delete()void": { - "call_config": { - "delete_application": "CALL" - } - }, - "delete_args(string)void": { - "call_config": { - "delete_application": "CALL" - } - }, - "create_opt_in()void": { - "call_config": { - "opt_in": "CREATE" - } - }, - "update_greeting(string)void": { - "call_config": { - "no_op": "CALL" - } - }, - "create()void": { - "call_config": { - "no_op": "CREATE" - } - }, - "create_args(string)void": { - "call_config": { - "no_op": "CREATE" - } - }, - "hello(string)string": { - "read_only": true, - "call_config": { - "no_op": "CALL" - } - }, - "hello_remember(string)string": { - "call_config": { - "no_op": "CALL" - } - }, - "get_last()string": { - "read_only": true, - "call_config": { - "no_op": "CALL" - } - }, - "opt_in()void": { - "call_config": { - "opt_in": "CALL" - } - }, - "opt_in_args(string)void": { - "call_config": { - "opt_in": "CALL" - } - }, - "close_out()void": { - "call_config": { - "close_out": "CALL" - } - }, - "close_out_args(string)void": { - "call_config": { - "close_out": "CALL" - } - }, - "call_with_payment(pay)string": { - "call_config": { - "no_op": "CALL" - } - } - }, - "source": { - "approval": "#pragma version 8
intcblock 0 1 2 5 TMPL_UPDATABLE TMPL_DELETABLE
bytecblock 0x 0x6772656574696e67 0x151f7c75 0x6c617374 0x596573 0x2c20
txn NumAppArgs
intc_0 // 0
==
bnz main_l44
txna ApplicationArgs 0
pushbytes 0x19d6b186 // "version()uint64"
==
bnz main_l43
txna ApplicationArgs 0
pushbytes 0x53bd6186 // "readonly(uint64)void"
==
bnz main_l42
txna ApplicationArgs 0
pushbytes 0xa4b4a230 // "set_box(byte[4],string)void"
==
bnz main_l41
txna ApplicationArgs 0
pushbytes 0x7f5de28f // "get_box(byte[4])string"
==
bnz main_l40
txna ApplicationArgs 0
pushbytes 0x13d12b50 // "get_box_readonly(byte[4])string"
==
bnz main_l39
txna ApplicationArgs 0
pushbytes 0xa0e81872 // "update()void"
==
bnz main_l38
txna ApplicationArgs 0
pushbytes 0x7d08518b // "update_args(string)void"
==
bnz main_l37
txna ApplicationArgs 0
pushbytes 0x24378d3c // "delete()void"
==
bnz main_l36
txna ApplicationArgs 0
pushbytes 0x5861bb50 // "delete_args(string)void"
==
bnz main_l35
txna ApplicationArgs 0
pushbytes 0x8bdf9eb0 // "create_opt_in()void"
==
bnz main_l34
txna ApplicationArgs 0
pushbytes 0x0055f006 // "update_greeting(string)void"
==
bnz main_l33
txna ApplicationArgs 0
pushbytes 0x4c5c61ba // "create()void"
==
bnz main_l32
txna ApplicationArgs 0
pushbytes 0xd1454c78 // "create_args(string)void"
==
bnz main_l31
txna ApplicationArgs 0
pushbytes 0x02bece11 // "hello(string)string"
==
bnz main_l30
txna ApplicationArgs 0
pushbytes 0xbc1c1dd4 // "hello_remember(string)string"
==
bnz main_l29
txna ApplicationArgs 0
pushbytes 0xa9ae7627 // "get_last()string"
==
bnz main_l28
txna ApplicationArgs 0
pushbytes 0x30c6d58a // "opt_in()void"
==
bnz main_l27
txna ApplicationArgs 0
pushbytes 0x22c7deda // "opt_in_args(string)void"
==
bnz main_l26
txna ApplicationArgs 0
pushbytes 0x1658aa2f // "close_out()void"
==
bnz main_l25
txna ApplicationArgs 0
pushbytes 0xde84d9ad // "close_out_args(string)void"
==
bnz main_l24
txna ApplicationArgs 0
pushbytes 0x88963c99 // "call_with_payment(pay)string"
==
bnz main_l23
err
main_l23:
txn OnCompletion
intc_0 // NoOp
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub callwithpaymentcaster_46
intc_1 // 1
return
main_l24:
txn OnCompletion
intc_2 // CloseOut
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub closeoutargscaster_45
intc_1 // 1
return
main_l25:
txn OnCompletion
intc_2 // CloseOut
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub closeoutcaster_44
intc_1 // 1
return
main_l26:
txn OnCompletion
intc_1 // OptIn
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub optinargscaster_43
intc_1 // 1
return
main_l27:
txn OnCompletion
intc_1 // OptIn
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub optincaster_42
intc_1 // 1
return
main_l28:
txn OnCompletion
intc_0 // NoOp
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub getlastcaster_41
intc_1 // 1
return
main_l29:
txn OnCompletion
intc_0 // NoOp
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub helloremembercaster_40
intc_1 // 1
return
main_l30:
txn OnCompletion
intc_0 // NoOp
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub hellocaster_39
intc_1 // 1
return
main_l31:
txn OnCompletion
intc_0 // NoOp
==
txn ApplicationID
intc_0 // 0
==
&&
assert
callsub createargscaster_38
intc_1 // 1
return
main_l32:
txn OnCompletion
intc_0 // NoOp
==
txn ApplicationID
intc_0 // 0
==
&&
assert
callsub createcaster_37
intc_1 // 1
return
main_l33:
txn OnCompletion
intc_0 // NoOp
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub updategreetingcaster_36
intc_1 // 1
return
main_l34:
txn OnCompletion
intc_1 // OptIn
==
txn ApplicationID
intc_0 // 0
==
&&
assert
callsub createoptincaster_35
intc_1 // 1
return
main_l35:
txn OnCompletion
intc_3 // DeleteApplication
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub deleteargscaster_34
intc_1 // 1
return
main_l36:
txn OnCompletion
intc_3 // DeleteApplication
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub deletecaster_33
intc_1 // 1
return
main_l37:
txn OnCompletion
pushint 4 // UpdateApplication
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub updateargscaster_32
intc_1 // 1
return
main_l38:
txn OnCompletion
pushint 4 // UpdateApplication
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub updatecaster_31
intc_1 // 1
return
main_l39:
txn OnCompletion
intc_0 // NoOp
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub getboxreadonlycaster_30
intc_1 // 1
return
main_l40:
txn OnCompletion
intc_0 // NoOp
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub getboxcaster_29
intc_1 // 1
return
main_l41:
txn OnCompletion
intc_0 // NoOp
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub setboxcaster_28
intc_1 // 1
return
main_l42:
txn OnCompletion
intc_0 // NoOp
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub readonlycaster_27
intc_1 // 1
return
main_l43:
txn OnCompletion
intc_0 // NoOp
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub versioncaster_26
intc_1 // 1
return
main_l44:
txn OnCompletion
intc_0 // NoOp
==
bnz main_l54
txn OnCompletion
intc_1 // OptIn
==
bnz main_l53
txn OnCompletion
intc_2 // CloseOut
==
bnz main_l52
txn OnCompletion
pushint 4 // UpdateApplication
==
bnz main_l51
txn OnCompletion
intc_3 // DeleteApplication
==
bnz main_l50
err
main_l50:
txn ApplicationID
intc_0 // 0
!=
assert
callsub deletebare_9
intc_1 // 1
return
main_l51:
txn ApplicationID
intc_0 // 0
!=
assert
callsub updatebare_6
intc_1 // 1
return
main_l52:
txn ApplicationID
intc_0 // 0
!=
assert
callsub closeoutbare_23
intc_1 // 1
return
main_l53:
txn ApplicationID
intc_0 // 0
!=
assert
callsub optinbare_20
intc_1 // 1
return
main_l54:
txn ApplicationID
intc_0 // 0
==
assert
callsub createbare_13
intc_1 // 1
return

// version
version_0:
proto 0 1
intc_0 // 0
pushint TMPL_VERSION // TMPL_VERSION
frame_bury 0
retsub

// readonly
readonly_1:
proto 1 0
frame_dig -1
bnz readonly_1_l2
intc_1 // 1
return
readonly_1_l2:
intc_0 // 0
// An error
assert
retsub

// set_box
setbox_2:
proto 2 0
frame_dig -2
box_del
pop
frame_dig -2
frame_dig -1
extract 2 0
box_put
retsub

// get_box
getbox_3:
proto 1 1
bytec_0 // ""
frame_dig -1
box_get
store 1
store 0
load 1
assert
load 0
frame_bury 0
frame_dig 0
len
itob
extract 6 0
frame_dig 0
concat
frame_bury 0
retsub

// get_box_readonly
getboxreadonly_4:
proto 1 1
bytec_0 // ""
frame_dig -1
box_get
store 3
store 2
load 3
assert
load 2
frame_bury 0
frame_dig 0
len
itob
extract 6 0
frame_dig 0
concat
frame_bury 0
retsub

// update
update_5:
proto 0 0
txn Sender
global CreatorAddress
==
// unauthorized
assert
intc 4 // TMPL_UPDATABLE
// is updatable
assert
bytec_1 // "greeting"
pushbytes 0x5570646174656420414249 // "Updated ABI"
app_global_put
retsub

// update_bare
updatebare_6:
proto 0 0
txn Sender
global CreatorAddress
==
// unauthorized
assert
intc 4 // TMPL_UPDATABLE
// is updatable
assert
bytec_1 // "greeting"
pushbytes 0x557064617465642042617265 // "Updated Bare"
app_global_put
retsub

// update_args
updateargs_7:
proto 1 0
txn Sender
global CreatorAddress
==
// unauthorized
assert
frame_dig -1
extract 2 0
bytec 4 // "Yes"
==
// passes update check
assert
intc 4 // TMPL_UPDATABLE
// is updatable
assert
bytec_1 // "greeting"
pushbytes 0x557064617465642041726773 // "Updated Args"
app_global_put
retsub

// delete
delete_8:
proto 0 0
txn Sender
global CreatorAddress
==
// unauthorized
assert
intc 5 // TMPL_DELETABLE
// is deletable
assert
retsub

// delete_bare
deletebare_9:
proto 0 0
txn Sender
global CreatorAddress
==
// unauthorized
assert
intc 5 // TMPL_DELETABLE
// is deletable
assert
retsub

// delete_args
deleteargs_10:
proto 1 0
txn Sender
global CreatorAddress
==
// unauthorized
assert
frame_dig -1
extract 2 0
bytec 4 // "Yes"
==
// passes delete check
assert
intc 5 // TMPL_DELETABLE
// is deletable
assert
retsub

// create_opt_in
createoptin_11:
proto 0 0
bytec_1 // "greeting"
pushbytes 0x4f707420496e // "Opt In"
app_global_put
intc_1 // 1
return

// update_greeting
updategreeting_12:
proto 1 0
bytec_1 // "greeting"
frame_dig -1
extract 2 0
app_global_put
retsub

// create_bare
createbare_13:
proto 0 0
bytec_1 // "greeting"
pushbytes 0x48656c6c6f2042617265 // "Hello Bare"
app_global_put
intc_1 // 1
return

// create
create_14:
proto 0 0
bytec_1 // "greeting"
pushbytes 0x48656c6c6f20414249 // "Hello ABI"
app_global_put
intc_1 // 1
return

// create_args
createargs_15:
proto 1 0
bytec_1 // "greeting"
frame_dig -1
extract 2 0
app_global_put
intc_1 // 1
return

// hello
hello_16:
proto 1 1
bytec_0 // ""
bytec_1 // "greeting"
app_global_get
bytec 5 // ", "
concat
frame_dig -1
extract 2 0
concat
frame_bury 0
frame_dig 0
len
itob
extract 6 0
frame_dig 0
concat
frame_bury 0
retsub

// hello_remember
helloremember_17:
proto 1 1
bytec_0 // ""
txn Sender
bytec_3 // "last"
frame_dig -1
extract 2 0
app_local_put
bytec_1 // "greeting"
app_global_get
bytec 5 // ", "
concat
frame_dig -1
extract 2 0
concat
frame_bury 0
frame_dig 0
len
itob
extract 6 0
frame_dig 0
concat
frame_bury 0
retsub

// get_last
getlast_18:
proto 0 1
bytec_0 // ""
txn Sender
bytec_3 // "last"
app_local_get
frame_bury 0
frame_dig 0
len
itob
extract 6 0
frame_dig 0
concat
frame_bury 0
retsub

// opt_in
optin_19:
proto 0 0
txn Sender
bytec_3 // "last"
pushbytes 0x4f707420496e20414249 // "Opt In ABI"
app_local_put
intc_1 // 1
return

// opt_in_bare
optinbare_20:
proto 0 0
txn Sender
bytec_3 // "last"
pushbytes 0x4f707420496e2042617265 // "Opt In Bare"
app_local_put
intc_1 // 1
return

// opt_in_args
optinargs_21:
proto 1 0
frame_dig -1
extract 2 0
bytec 4 // "Yes"
==
// passes opt_in check
assert
txn Sender
bytec_3 // "last"
pushbytes 0x4f707420496e2041726773 // "Opt In Args"
app_local_put
intc_1 // 1
return

// close_out
closeout_22:
proto 0 0
intc_1 // 1
return

// close_out_bare
closeoutbare_23:
proto 0 0
intc_1 // 1
return

// close_out_args
closeoutargs_24:
proto 1 0
frame_dig -1
extract 2 0
bytec 4 // "Yes"
==
// passes close_out check
assert
intc_1 // 1
return

// call_with_payment
callwithpayment_25:
proto 1 1
bytec_0 // ""
frame_dig -1
gtxns Amount
intc_0 // 0
>
assert
pushbytes 0x00125061796d656e74205375636365737366756c // 0x00125061796d656e74205375636365737366756c
frame_bury 0
retsub

// version_caster
versioncaster_26:
proto 0 0
intc_0 // 0
callsub version_0
frame_bury 0
bytec_2 // 0x151f7c75
frame_dig 0
itob
concat
log
retsub

// readonly_caster
readonlycaster_27:
proto 0 0
intc_0 // 0
txna ApplicationArgs 1
btoi
frame_bury 0
frame_dig 0
callsub readonly_1
retsub

// set_box_caster
setboxcaster_28:
proto 0 0
bytec_0 // ""
dup
txna ApplicationArgs 1
frame_bury 0
txna ApplicationArgs 2
frame_bury 1
frame_dig 0
frame_dig 1
callsub setbox_2
retsub

// get_box_caster
getboxcaster_29:
proto 0 0
bytec_0 // ""
dup
txna ApplicationArgs 1
frame_bury 1
frame_dig 1
callsub getbox_3
frame_bury 0
bytec_2 // 0x151f7c75
frame_dig 0
concat
log
retsub

// get_box_readonly_caster
getboxreadonlycaster_30:
proto 0 0
bytec_0 // ""
dup
txna ApplicationArgs 1
frame_bury 1
frame_dig 1
callsub getboxreadonly_4
frame_bury 0
bytec_2 // 0x151f7c75
frame_dig 0
concat
log
retsub

// update_caster
updatecaster_31:
proto 0 0
callsub update_5
retsub

// update_args_caster
updateargscaster_32:
proto 0 0
bytec_0 // ""
txna ApplicationArgs 1
frame_bury 0
frame_dig 0
callsub updateargs_7
retsub

// delete_caster
deletecaster_33:
proto 0 0
callsub delete_8
retsub

// delete_args_caster
deleteargscaster_34:
proto 0 0
bytec_0 // ""
txna ApplicationArgs 1
frame_bury 0
frame_dig 0
callsub deleteargs_10
retsub

// create_opt_in_caster
createoptincaster_35:
proto 0 0
callsub createoptin_11
retsub

// update_greeting_caster
updategreetingcaster_36:
proto 0 0
bytec_0 // ""
txna ApplicationArgs 1
frame_bury 0
frame_dig 0
callsub updategreeting_12
retsub

// create_caster
createcaster_37:
proto 0 0
callsub create_14
retsub

// create_args_caster
createargscaster_38:
proto 0 0
bytec_0 // ""
txna ApplicationArgs 1
frame_bury 0
frame_dig 0
callsub createargs_15
retsub

// hello_caster
hellocaster_39:
proto 0 0
bytec_0 // ""
dup
txna ApplicationArgs 1
frame_bury 1
frame_dig 1
callsub hello_16
frame_bury 0
bytec_2 // 0x151f7c75
frame_dig 0
concat
log
retsub

// hello_remember_caster
helloremembercaster_40:
proto 0 0
bytec_0 // ""
dup
txna ApplicationArgs 1
frame_bury 1
frame_dig 1
callsub helloremember_17
frame_bury 0
bytec_2 // 0x151f7c75
frame_dig 0
concat
log
retsub

// get_last_caster
getlastcaster_41:
proto 0 0
bytec_0 // ""
callsub getlast_18
frame_bury 0
bytec_2 // 0x151f7c75
frame_dig 0
concat
log
retsub

// opt_in_caster
optincaster_42:
proto 0 0
callsub optin_19
retsub

// opt_in_args_caster
optinargscaster_43:
proto 0 0
bytec_0 // ""
txna ApplicationArgs 1
frame_bury 0
frame_dig 0
callsub optinargs_21
retsub

// close_out_caster
closeoutcaster_44:
proto 0 0
callsub closeout_22
retsub

// close_out_args_caster
closeoutargscaster_45:
proto 0 0
bytec_0 // ""
txna ApplicationArgs 1
frame_bury 0
frame_dig 0
callsub closeoutargs_24
retsub

// call_with_payment_caster
callwithpaymentcaster_46:
proto 0 0
bytec_0 // ""
intc_0 // 0
txn GroupIndex
intc_1 // 1
-
frame_bury 1
frame_dig 1
gtxns TypeEnum
intc_1 // pay
==
assert
frame_dig 1
callsub callwithpayment_25
frame_bury 0
bytec_2 // 0x151f7c75
frame_dig 0
concat
log
retsub", - "clear": "I3ByYWdtYSB2ZXJzaW9uIDgKaW50Y2Jsb2NrIDEKY2FsbHN1YiBjbGVhcnN0YXRlXzAKaW50Y18wIC8vIDEKcmV0dXJuCgovLyBjbGVhcl9zdGF0ZQpjbGVhcnN0YXRlXzA6CnByb3RvIDAgMAppbnRjXzAgLy8gMQpyZXR1cm4=" - }, - "state": { - "global": { - "num_byte_slices": 1, - "num_uints": 0 - }, - "local": { - "num_byte_slices": 1, - "num_uints": 0 - } - }, - "schema": { - "global": { - "declared": { - "greeting": { - "type": "bytes", - "key": "greeting", - "descr": "" - } - }, - "reserved": {} - }, - "local": { - "declared": { - "last": { - "type": "bytes", - "key": "last", - "descr": "" - } - }, - "reserved": {} - } - }, - "contract": { - "name": "HelloWorldApp", - "methods": [ - { - "name": "version", - "args": [], - "returns": { - "type": "uint64" - } - }, - { - "name": "readonly", - "args": [ - { - "type": "uint64", - "name": "error" - } - ], - "returns": { - "type": "void" - } - }, - { - "name": "set_box", - "args": [ - { - "type": "byte[4]", - "name": "name" - }, - { - "type": "string", - "name": "value" - } - ], - "returns": { - "type": "void" - } - }, - { - "name": "get_box", - "args": [ - { - "type": "byte[4]", - "name": "name" - } - ], - "returns": { - "type": "string" - } - }, - { - "name": "get_box_readonly", - "args": [ - { - "type": "byte[4]", - "name": "name" - } - ], - "returns": { - "type": "string" - } - }, - { - "name": "update", - "args": [], - "returns": { - "type": "void" - } - }, - { - "name": "update_args", - "args": [ - { - "type": "string", - "name": "check" - } - ], - "returns": { - "type": "void" - } - }, - { - "name": "delete", - "args": [], - "returns": { - "type": "void" - } - }, - { - "name": "delete_args", - "args": [ - { - "type": "string", - "name": "check" - } - ], - "returns": { - "type": "void" - } - }, - { - "name": "create_opt_in", - "args": [], - "returns": { - "type": "void" - } - }, - { - "name": "update_greeting", - "args": [ - { - "type": "string", - "name": "greeting" - } - ], - "returns": { - "type": "void" - } - }, - { - "name": "create", - "args": [], - "returns": { - "type": "void" - } - }, - { - "name": "create_args", - "args": [ - { - "type": "string", - "name": "greeting" - } - ], - "returns": { - "type": "void" - } - }, - { - "name": "hello", - "args": [ - { - "type": "string", - "name": "name" - } - ], - "returns": { - "type": "string" - } - }, - { - "name": "hello_remember", - "args": [ - { - "type": "string", - "name": "name" - } - ], - "returns": { - "type": "string" - } - }, - { - "name": "get_last", - "args": [], - "returns": { - "type": "string" - } - }, - { - "name": "opt_in", - "args": [], - "returns": { - "type": "void" - } - }, - { - "name": "opt_in_args", - "args": [ - { - "type": "string", - "name": "check" - } - ], - "returns": { - "type": "void" - } - }, - { - "name": "close_out", - "args": [], - "returns": { - "type": "void" - } - }, - { - "name": "close_out_args", - "args": [ - { - "type": "string", - "name": "check" - } - ], - "returns": { - "type": "void" - } - }, - { - "name": "call_with_payment", - "args": [ - { - "type": "pay", - "name": "payment" - } - ], - "returns": { - "type": "string" - } - } - ], - "networks": {} - }, - "bare_call_config": { - "close_out": "CALL", - "delete_application": "CALL", - "no_op": "CREATE", - "opt_in": "CALL", - "update_application": "CALL" - } -} diff --git a/legacy_v2_tests/app_resolve.json b/legacy_v2_tests/app_resolve.json deleted file mode 100644 index cccae640..00000000 --- a/legacy_v2_tests/app_resolve.json +++ /dev/null @@ -1,141 +0,0 @@ -{ - "hints": { - "update()void": { - "call_config": { - "update_application": "CALL" - } - }, - "delete()void": { - "call_config": { - "delete_application": "CALL" - } - }, - "opt_in()void": { - "call_config": { - "opt_in": "CALL" - } - }, - "close_out()void": { - "call_config": { - "close_out": "CALL" - } - }, - "add(uint64,uint64)uint64": { - "call_config": { - "no_op": "CALL" - } - }, - "dummy()string": { - "read_only": true, - "call_config": { - "no_op": "CALL" - } - } - }, - "source": { - "approval": "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", - "clear": "I3ByYWdtYSB2ZXJzaW9uIDgKaW50Y2Jsb2NrIDEKY2FsbHN1YiBjbGVhcnN0YXRlXzAKaW50Y18wIC8vIDEKcmV0dXJuCgovLyBjbGVhcl9zdGF0ZQpjbGVhcnN0YXRlXzA6CnByb3RvIDAgMAp0eG4gTm90ZQpsZW4KcHVzaGludCAwIC8vIDAKPT0KYXNzZXJ0CmludGNfMCAvLyAxCnJldHVybg==" - }, - "state": { - "global": { - "num_byte_slices": 1, - "num_uints": 1 - }, - "local": { - "num_byte_slices": 1, - "num_uints": 1 - } - }, - "schema": { - "global": { - "declared": { - "global_state_val_byte": { - "type": "bytes", - "key": "global_state_val_byte", - "descr": "" - }, - "global_state_val_int": { - "type": "uint64", - "key": "global_state_val_int", - "descr": "" - } - }, - "reserved": {} - }, - "local": { - "declared": { - "acct_state_val_byte": { - "type": "bytes", - "key": "acct_state_val_byte", - "descr": "" - }, - "acct_state_val_int": { - "type": "uint64", - "key": "acct_state_val_int", - "descr": "" - } - }, - "reserved": {} - } - }, - "contract": { - "name": "App", - "methods": [ - { - "name": "update", - "args": [], - "returns": { - "type": "void" - } - }, - { - "name": "delete", - "args": [], - "returns": { - "type": "void" - } - }, - { - "name": "opt_in", - "args": [], - "returns": { - "type": "void" - } - }, - { - "name": "close_out", - "args": [], - "returns": { - "type": "void" - } - }, - { - "name": "add", - "args": [ - { - "type": "uint64", - "name": "a" - }, - { - "type": "uint64", - "name": "b" - } - ], - "returns": { - "type": "uint64" - } - }, - { - "name": "dummy", - "args": [], - "returns": { - "type": "string" - } - } - ], - "networks": {} - }, - "bare_call_config": { - "no_op": "CREATE" - } -} \ No newline at end of file diff --git a/legacy_v2_tests/app_v1.json b/legacy_v2_tests/app_v1.json deleted file mode 100644 index 112a67e3..00000000 --- a/legacy_v2_tests/app_v1.json +++ /dev/null @@ -1,79 +0,0 @@ -{ - "hints": { - "update()void": { - "call_config": { - "update_application": "CALL" - } - }, - "delete()void": { - "call_config": { - "delete_application": "CALL" - } - }, - "hello(string)string": { - "read_only": true, - "call_config": { - "no_op": "CALL" - } - } - }, - "source": { - "approval": "I3ByYWdtYSB2ZXJzaW9uIDgKaW50Y2Jsb2NrIDAgMQp0eG4gTnVtQXBwQXJncwppbnRjXzAgLy8gMAo9PQpibnogbWFpbl9sOAp0eG5hIEFwcGxpY2F0aW9uQXJncyAwCnB1c2hieXRlcyAweGEwZTgxODcyIC8vICJ1cGRhdGUoKXZvaWQiCj09CmJueiBtYWluX2w3CnR4bmEgQXBwbGljYXRpb25BcmdzIDAKcHVzaGJ5dGVzIDB4MjQzNzhkM2MgLy8gImRlbGV0ZSgpdm9pZCIKPT0KYm56IG1haW5fbDYKdHhuYSBBcHBsaWNhdGlvbkFyZ3MgMApwdXNoYnl0ZXMgMHgwMmJlY2UxMSAvLyAiaGVsbG8oc3RyaW5nKXN0cmluZyIKPT0KYm56IG1haW5fbDUKZXJyCm1haW5fbDU6CnR4biBPbkNvbXBsZXRpb24KaW50Y18wIC8vIE5vT3AKPT0KdHhuIEFwcGxpY2F0aW9uSUQKaW50Y18wIC8vIDAKIT0KJiYKYXNzZXJ0CnR4bmEgQXBwbGljYXRpb25BcmdzIDEKY2FsbHN1YiBoZWxsb18yCnN0b3JlIDAKcHVzaGJ5dGVzIDB4MTUxZjdjNzUgLy8gMHgxNTFmN2M3NQpsb2FkIDAKY29uY2F0CmxvZwppbnRjXzEgLy8gMQpyZXR1cm4KbWFpbl9sNjoKdHhuIE9uQ29tcGxldGlvbgpwdXNoaW50IDUgLy8gRGVsZXRlQXBwbGljYXRpb24KPT0KdHhuIEFwcGxpY2F0aW9uSUQKaW50Y18wIC8vIDAKIT0KJiYKYXNzZXJ0CmNhbGxzdWIgZGVsZXRlXzEKaW50Y18xIC8vIDEKcmV0dXJuCm1haW5fbDc6CnR4biBPbkNvbXBsZXRpb24KcHVzaGludCA0IC8vIFVwZGF0ZUFwcGxpY2F0aW9uCj09CnR4biBBcHBsaWNhdGlvbklECmludGNfMCAvLyAwCiE9CiYmCmFzc2VydApjYWxsc3ViIHVwZGF0ZV8wCmludGNfMSAvLyAxCnJldHVybgptYWluX2w4Ogp0eG4gT25Db21wbGV0aW9uCmludGNfMCAvLyBOb09wCj09CmJueiBtYWluX2wxMAplcnIKbWFpbl9sMTA6CnR4biBBcHBsaWNhdGlvbklECmludGNfMCAvLyAwCj09CmFzc2VydAppbnRjXzEgLy8gMQpyZXR1cm4KCi8vIHVwZGF0ZQp1cGRhdGVfMDoKcHJvdG8gMCAwCnR4biBTZW5kZXIKZ2xvYmFsIENyZWF0b3JBZGRyZXNzCj09Ci8vIHVuYXV0aG9yaXplZAphc3NlcnQKcHVzaGludCBUTVBMX1VQREFUQUJMRSAvLyBUTVBMX1VQREFUQUJMRQovLyBDaGVjayBhcHAgaXMgdXBkYXRhYmxlCmFzc2VydApyZXRzdWIKCi8vIGRlbGV0ZQpkZWxldGVfMToKcHJvdG8gMCAwCnR4biBTZW5kZXIKZ2xvYmFsIENyZWF0b3JBZGRyZXNzCj09Ci8vIHVuYXV0aG9yaXplZAphc3NlcnQKcHVzaGludCBUTVBMX0RFTEVUQUJMRSAvLyBUTVBMX0RFTEVUQUJMRQovLyBDaGVjayBhcHAgaXMgZGVsZXRhYmxlCmFzc2VydApyZXRzdWIKCi8vIGhlbGxvCmhlbGxvXzI6CnByb3RvIDEgMQpwdXNoYnl0ZXMgMHggLy8gIiIKcHVzaGJ5dGVzIDB4NDg2NTZjNmM2ZjJjMjAgLy8gIkhlbGxvLCAiCmZyYW1lX2RpZyAtMQpleHRyYWN0IDIgMApjb25jYXQKZnJhbWVfYnVyeSAwCmZyYW1lX2RpZyAwCmxlbgppdG9iCmV4dHJhY3QgNiAwCmZyYW1lX2RpZyAwCmNvbmNhdApmcmFtZV9idXJ5IDAKcmV0c3Vi", - "clear": "I3ByYWdtYSB2ZXJzaW9uIDgKcHVzaGludCAwIC8vIDAKcmV0dXJu" - }, - "state": { - "global": { - "num_byte_slices": 0, - "num_uints": 0 - }, - "local": { - "num_byte_slices": 0, - "num_uints": 0 - } - }, - "schema": { - "global": { - "declared": {}, - "reserved": {} - }, - "local": { - "declared": {}, - "reserved": {} - } - }, - "contract": { - "name": "SampleApp", - "methods": [ - { - "name": "update", - "args": [], - "returns": { - "type": "void" - } - }, - { - "name": "delete", - "args": [], - "returns": { - "type": "void" - } - }, - { - "name": "hello", - "args": [ - { - "type": "string", - "name": "name" - } - ], - "returns": { - "type": "string" - } - } - ], - "networks": {} - }, - "bare_call_config": { - "no_op": "CREATE" - } -} \ No newline at end of file diff --git a/legacy_v2_tests/app_v2.json b/legacy_v2_tests/app_v2.json deleted file mode 100644 index cfca3103..00000000 --- a/legacy_v2_tests/app_v2.json +++ /dev/null @@ -1,79 +0,0 @@ -{ - "hints": { - "update()void": { - "call_config": { - "update_application": "CALL" - } - }, - "delete()void": { - "call_config": { - "delete_application": "CALL" - } - }, - "hello(string)string": { - "read_only": true, - "call_config": { - "no_op": "CALL" - } - } - }, - "source": { - "approval": "I3ByYWdtYSB2ZXJzaW9uIDgKaW50Y2Jsb2NrIDAgMQp0eG4gTnVtQXBwQXJncwppbnRjXzAgLy8gMAo9PQpibnogbWFpbl9sOAp0eG5hIEFwcGxpY2F0aW9uQXJncyAwCnB1c2hieXRlcyAweGEwZTgxODcyIC8vICJ1cGRhdGUoKXZvaWQiCj09CmJueiBtYWluX2w3CnR4bmEgQXBwbGljYXRpb25BcmdzIDAKcHVzaGJ5dGVzIDB4MjQzNzhkM2MgLy8gImRlbGV0ZSgpdm9pZCIKPT0KYm56IG1haW5fbDYKdHhuYSBBcHBsaWNhdGlvbkFyZ3MgMApwdXNoYnl0ZXMgMHgwMmJlY2UxMSAvLyAiaGVsbG8oc3RyaW5nKXN0cmluZyIKPT0KYm56IG1haW5fbDUKZXJyCm1haW5fbDU6CnR4biBPbkNvbXBsZXRpb24KaW50Y18wIC8vIE5vT3AKPT0KdHhuIEFwcGxpY2F0aW9uSUQKaW50Y18wIC8vIDAKIT0KJiYKYXNzZXJ0CnR4bmEgQXBwbGljYXRpb25BcmdzIDEKY2FsbHN1YiBoZWxsb18yCnN0b3JlIDAKcHVzaGJ5dGVzIDB4MTUxZjdjNzUgLy8gMHgxNTFmN2M3NQpsb2FkIDAKY29uY2F0CmxvZwppbnRjXzEgLy8gMQpyZXR1cm4KbWFpbl9sNjoKdHhuIE9uQ29tcGxldGlvbgpwdXNoaW50IDUgLy8gRGVsZXRlQXBwbGljYXRpb24KPT0KdHhuIEFwcGxpY2F0aW9uSUQKaW50Y18wIC8vIDAKIT0KJiYKYXNzZXJ0CmNhbGxzdWIgZGVsZXRlXzEKaW50Y18xIC8vIDEKcmV0dXJuCm1haW5fbDc6CnR4biBPbkNvbXBsZXRpb24KcHVzaGludCA0IC8vIFVwZGF0ZUFwcGxpY2F0aW9uCj09CnR4biBBcHBsaWNhdGlvbklECmludGNfMCAvLyAwCiE9CiYmCmFzc2VydApjYWxsc3ViIHVwZGF0ZV8wCmludGNfMSAvLyAxCnJldHVybgptYWluX2w4Ogp0eG4gT25Db21wbGV0aW9uCmludGNfMCAvLyBOb09wCj09CmJueiBtYWluX2wxMAplcnIKbWFpbl9sMTA6CnR4biBBcHBsaWNhdGlvbklECmludGNfMCAvLyAwCj09CmFzc2VydAppbnRjXzEgLy8gMQpyZXR1cm4KCi8vIHVwZGF0ZQp1cGRhdGVfMDoKcHJvdG8gMCAwCnR4biBTZW5kZXIKZ2xvYmFsIENyZWF0b3JBZGRyZXNzCj09Ci8vIHVuYXV0aG9yaXplZAphc3NlcnQKcHVzaGludCBUTVBMX1VQREFUQUJMRSAvLyBUTVBMX1VQREFUQUJMRQovLyBDaGVjayBhcHAgaXMgdXBkYXRhYmxlCmFzc2VydApyZXRzdWIKCi8vIGRlbGV0ZQpkZWxldGVfMToKcHJvdG8gMCAwCnR4biBTZW5kZXIKZ2xvYmFsIENyZWF0b3JBZGRyZXNzCj09Ci8vIHVuYXV0aG9yaXplZAphc3NlcnQKcHVzaGludCBUTVBMX0RFTEVUQUJMRSAvLyBUTVBMX0RFTEVUQUJMRQovLyBDaGVjayBhcHAgaXMgZGVsZXRhYmxlCmFzc2VydApyZXRzdWIKCi8vIGhlbGxvCmhlbGxvXzI6CnByb3RvIDEgMQpwdXNoYnl0ZXMgMHggLy8gIiIKcHVzaGJ5dGVzIDB4NDc3MjY1NjU3NDY5NmU2NzczMmMyMCAvLyAiR3JlZXRpbmdzLCAiCmZyYW1lX2RpZyAtMQpleHRyYWN0IDIgMApjb25jYXQKZnJhbWVfYnVyeSAwCmZyYW1lX2RpZyAwCmxlbgppdG9iCmV4dHJhY3QgNiAwCmZyYW1lX2RpZyAwCmNvbmNhdApmcmFtZV9idXJ5IDAKcmV0c3Vi", - "clear": "I3ByYWdtYSB2ZXJzaW9uIDgKcHVzaGludCAwIC8vIDAKcmV0dXJu" - }, - "state": { - "global": { - "num_byte_slices": 0, - "num_uints": 0 - }, - "local": { - "num_byte_slices": 0, - "num_uints": 0 - } - }, - "schema": { - "global": { - "declared": {}, - "reserved": {} - }, - "local": { - "declared": {}, - "reserved": {} - } - }, - "contract": { - "name": "SampleApp", - "methods": [ - { - "name": "update", - "args": [], - "returns": { - "type": "void" - } - }, - { - "name": "delete", - "args": [], - "returns": { - "type": "void" - } - }, - { - "name": "hello", - "args": [ - { - "type": "string", - "name": "name" - } - ], - "returns": { - "type": "string" - } - } - ], - "networks": {} - }, - "bare_call_config": { - "no_op": "CREATE" - } -} \ No newline at end of file diff --git a/legacy_v2_tests/app_v3.json b/legacy_v2_tests/app_v3.json deleted file mode 100644 index 1998b2be..00000000 --- a/legacy_v2_tests/app_v3.json +++ /dev/null @@ -1,93 +0,0 @@ -{ - "hints": { - "update()void": { - "call_config": { - "update_application": "CALL" - } - }, - "delete()void": { - "call_config": { - "delete_application": "CALL" - } - }, - "increment()uint64": { - "call_config": { - "no_op": "CALL" - } - }, - "decrement()uint64": { - "call_config": { - "no_op": "CALL" - } - } - }, - "source": { - "approval": "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", - "clear": "I3ByYWdtYSB2ZXJzaW9uIDgKcHVzaGludCAwIC8vIDAKcmV0dXJu" - }, - "state": { - "global": { - "num_byte_slices": 0, - "num_uints": 1 - }, - "local": { - "num_byte_slices": 0, - "num_uints": 0 - } - }, - "schema": { - "global": { - "declared": { - "counter": { - "type": "uint64", - "key": "counter", - "descr": "A counter for showing how to use application state" - } - }, - "reserved": {} - }, - "local": { - "declared": {}, - "reserved": {} - } - }, - "contract": { - "name": "SampleApp", - "methods": [ - { - "name": "update", - "args": [], - "returns": { - "type": "void" - } - }, - { - "name": "delete", - "args": [], - "returns": { - "type": "void" - } - }, - { - "name": "increment", - "args": [], - "returns": { - "type": "uint64" - }, - "desc": "increment the counter" - }, - { - "name": "decrement", - "args": [], - "returns": { - "type": "uint64" - }, - "desc": "decrement the counter" - } - ], - "networks": {} - }, - "bare_call_config": { - "no_op": "CREATE" - } -} \ No newline at end of file diff --git a/legacy_v2_tests/conftest.py b/legacy_v2_tests/conftest.py deleted file mode 100644 index ef046763..00000000 --- a/legacy_v2_tests/conftest.py +++ /dev/null @@ -1,207 +0,0 @@ -import inspect -import math -import random -import subprocess -from pathlib import Path -from typing import TYPE_CHECKING -from uuid import uuid4 - -import algosdk.transaction -import pytest -from dotenv import load_dotenv - -from algokit_utils import ( - DELETABLE_TEMPLATE_NAME, - UPDATABLE_TEMPLATE_NAME, - Account, - ApplicationClient, - ApplicationSpecification, - EnsureBalanceParameters, - ensure_funded, - get_account, - get_algod_client, - get_indexer_client, - get_kmd_client_from_algod_client, - replace_template_variables, -) - -if TYPE_CHECKING: - from algosdk.kmd import KMDClient - from algosdk.v2client.algod import AlgodClient - from algosdk.v2client.indexer import IndexerClient - - -@pytest.fixture(autouse=True, scope="session") -def _environment_fixture() -> None: - env_path = Path(__file__).parent / ".." / "example.env" - load_dotenv(env_path) - - -def check_output_stability(logs: str, *, test_name: str | None = None) -> None: - """Test that the contract output hasn't changed for an Application, using git diff""" - caller_frame = inspect.stack()[1] - caller_path = Path(caller_frame.filename).resolve() - caller_dir = caller_path.parent - test_name = test_name or caller_frame.function - caller_stem = Path(caller_frame.filename).stem - output_dir = caller_dir / f"{caller_stem}.approvals" - output_dir.mkdir(exist_ok=True) - output_file = output_dir / f"{test_name}.approved.txt" - output_file_str = str(output_file) - output_file_did_exist = output_file.exists() - output_file.write_text(logs, encoding="utf-8") - - git_diff = subprocess.run( - [ - "git", - "diff", - "--exit-code", - "--no-ext-diff", - "--no-color", - output_file_str, - ], - stdout=subprocess.PIPE, - stderr=subprocess.STDOUT, - text=True, - check=False, - ) - # first fail if there are any changes to already committed files, you must manually add them in that case - assert git_diff.returncode == 0, git_diff.stdout - - # if first time running, fail in case of accidental change to output directory - if not output_file_did_exist: - pytest.fail( - f"New output folder created at {output_file_str} from test {test_name} - " - "if this was intentional, please commit the files to the git repo" - ) - - -def read_spec( - file_name: str, - *, - updatable: bool | None = None, - deletable: bool | None = None, - template_values: dict | None = None, -) -> ApplicationSpecification: - path = Path(__file__).parent / file_name - spec = ApplicationSpecification.from_json(Path(path).read_text(encoding="utf-8")) - - template_variables = template_values or {} - if updatable is not None: - template_variables["UPDATABLE"] = int(updatable) - - if deletable is not None: - template_variables["DELETABLE"] = int(deletable) - - spec.approval_program = ( - replace_template_variables(spec.approval_program, template_variables) - .replace(f"// {UPDATABLE_TEMPLATE_NAME}", "// updatable") - .replace(f"// {DELETABLE_TEMPLATE_NAME}", "// deletable") - ) - return spec - - -def get_specs( - updatable: bool | None = None, - deletable: bool | None = None, -) -> tuple[ApplicationSpecification, ApplicationSpecification, ApplicationSpecification]: - return ( - read_spec("app_v1.json", updatable=updatable, deletable=deletable), - read_spec("app_v2.json", updatable=updatable, deletable=deletable), - read_spec("app_v3.json", updatable=updatable, deletable=deletable), - ) - - -def get_unique_name() -> str: - name = str(uuid4()).replace("-", "") - assert name.isalnum() - return name - - -def is_opted_in(client_fixture: ApplicationClient) -> bool: - _, sender = client_fixture.resolve_signer_sender() - account_info = client_fixture.algod_client.account_info(sender) - assert isinstance(account_info, dict) - apps_local_state = account_info["apps-local-state"] - return any(x for x in apps_local_state if x["id"] == client_fixture.app_id) - - -@pytest.fixture(scope="session") -def algod_client() -> "AlgodClient": - return get_algod_client() - - -@pytest.fixture(scope="session") -def kmd_client(algod_client: "AlgodClient") -> "KMDClient": - return get_kmd_client_from_algod_client(algod_client) - - -@pytest.fixture(scope="session") -def indexer_client() -> "IndexerClient": - return get_indexer_client() - - -@pytest.fixture -def creator(algod_client: "AlgodClient") -> Account: - creator_name = get_unique_name() - return get_account(algod_client, creator_name) - - -@pytest.fixture(scope="session") -def funded_account(algod_client: "AlgodClient") -> Account: - creator_name = get_unique_name() - return get_account(algod_client, creator_name) - - -@pytest.fixture(scope="session") -def app_spec() -> ApplicationSpecification: - return read_spec("app_client_test.json", deletable=True, updatable=True, template_values={"VERSION": 1}) - - -def generate_test_asset(algod_client: "AlgodClient", sender: Account, total: int | None) -> int: - if total is None: - total = math.floor(random.random() * 100) + 20 - - decimals = 0 - asset_name = f"ASA ${math.floor(random.random() * 100) + 1}_${math.floor(random.random() * 100) + 1}_${total}" - - params = algod_client.suggested_params() - - txn = algosdk.transaction.AssetConfigTxn( - sender=sender.address, - sp=params, - total=total * 10**decimals, - decimals=decimals, - default_frozen=False, - unit_name="", - asset_name=asset_name, - manager=sender.address, - reserve=sender.address, - freeze=sender.address, - clawback=sender.address, - url="https://path/to/my/asset/details", - metadata_hash=None, - note=None, - lease=None, - rekey_to=None, - ) - - signed_transaction = txn.sign(sender.private_key) - algod_client.send_transaction(signed_transaction) - ptx = algod_client.pending_transaction_info(txn.get_txid()) - - if isinstance(ptx, dict) and "asset-index" in ptx and isinstance(ptx["asset-index"], int): - return ptx["asset-index"] - else: - raise ValueError("Unexpected response from pending_transaction_info") - - -def assure_funds(algod_client: "AlgodClient", account: Account) -> None: - ensure_funded( - algod_client, - EnsureBalanceParameters( - account_to_fund=account, - min_spending_balance_micro_algos=300000, - min_funding_increment_micro_algos=1, - ), - ) diff --git a/legacy_v2_tests/test_account.py b/legacy_v2_tests/test_account.py deleted file mode 100644 index e1ee2228..00000000 --- a/legacy_v2_tests/test_account.py +++ /dev/null @@ -1,15 +0,0 @@ -from typing import TYPE_CHECKING - -from algokit_utils import get_account -from legacy_v2_tests.conftest import get_unique_name - -if TYPE_CHECKING: - from algosdk.v2client.algod import AlgodClient - - -def test_account_can_be_called_twice(algod_client: "AlgodClient") -> None: - account_name = get_unique_name() - account1 = get_account(algod_client, account_name) - account2 = get_account(algod_client, account_name) - - assert account1 == account2 diff --git a/legacy_v2_tests/test_app.py b/legacy_v2_tests/test_app.py deleted file mode 100644 index 1b79f708..00000000 --- a/legacy_v2_tests/test_app.py +++ /dev/null @@ -1,15 +0,0 @@ -import pytest - -from algokit_utils import AppDeployMetaData - - -@pytest.mark.parametrize( - "app_note_json", - [ - b'ALGOKIT_DEPLOYER:j{"name":"VotingRoundApp","version":"1.0","deletable":true,"updatable":true}', - b'ALGOKIT_DEPLOYER:j{"name":"VotingRoundApp","version":"1.0","deletable":true}', - ], -) -def test_metadata_serialization(app_note_json: bytes) -> None: - metadata = AppDeployMetaData.decode(app_note_json) - assert metadata diff --git a/legacy_v2_tests/test_app_client.py b/legacy_v2_tests/test_app_client.py deleted file mode 100644 index b6565148..00000000 --- a/legacy_v2_tests/test_app_client.py +++ /dev/null @@ -1,30 +0,0 @@ -import pytest - -from algokit_utils import ( - DeploymentFailedError, - get_next_version, -) - - -@pytest.mark.parametrize( - ("current", "expected_next"), - [ - ("1", "2"), - ("v1", "v2"), - ("v1-alpha", "v2-alpha"), - ("1.0", "1.1"), - ("v1.0", "v1.1"), - ("v1.0-alpha", "v1.1-alpha"), - ("1.0.0", "1.0.1"), - ("v1.0.0", "v1.0.1"), - ("v1.0.0-alpha", "v1.0.1-alpha"), - ], -) -def test_auto_version_increment(current: str, expected_next: str) -> None: - value = get_next_version(current) - assert value == expected_next - - -def test_auto_version_increment_failure() -> None: - with pytest.raises(DeploymentFailedError): - get_next_version("teapot") diff --git a/legacy_v2_tests/test_app_client_call.approvals/test_readonly_call_with_error.approved.txt b/legacy_v2_tests/test_app_client_call.approvals/test_readonly_call_with_error.approved.txt deleted file mode 100644 index 72d21d06..00000000 --- a/legacy_v2_tests/test_app_client_call.approvals/test_readonly_call_with_error.approved.txt +++ /dev/null @@ -1,12 +0,0 @@ -Txn {txn} had error 'assert failed pc=743' at PC 743 and Source Line 425: - - intc_1 // 1 - return - readonly_1_l2: - intc_0 // 0 - // An error - assert <-- Error - retsub - - // set_box - setbox_2: \ No newline at end of file diff --git a/legacy_v2_tests/test_app_client_call.approvals/test_readonly_call_with_error_debug_mode_disabled.approved.txt b/legacy_v2_tests/test_app_client_call.approvals/test_readonly_call_with_error_debug_mode_disabled.approved.txt deleted file mode 100644 index 4af18322..00000000 --- a/legacy_v2_tests/test_app_client_call.approvals/test_readonly_call_with_error_debug_mode_disabled.approved.txt +++ /dev/null @@ -1 +0,0 @@ -None \ No newline at end of file diff --git a/legacy_v2_tests/test_app_client_call.approvals/test_readonly_call_with_error_with_imported_source_map.approved.txt b/legacy_v2_tests/test_app_client_call.approvals/test_readonly_call_with_error_with_imported_source_map.approved.txt deleted file mode 100644 index 72d21d06..00000000 --- a/legacy_v2_tests/test_app_client_call.approvals/test_readonly_call_with_error_with_imported_source_map.approved.txt +++ /dev/null @@ -1,12 +0,0 @@ -Txn {txn} had error 'assert failed pc=743' at PC 743 and Source Line 425: - - intc_1 // 1 - return - readonly_1_l2: - intc_0 // 0 - // An error - assert <-- Error - retsub - - // set_box - setbox_2: \ No newline at end of file diff --git a/legacy_v2_tests/test_app_client_call.approvals/test_readonly_call_with_error_with_new_client_missing_source_map.approved.txt b/legacy_v2_tests/test_app_client_call.approvals/test_readonly_call_with_error_with_new_client_missing_source_map.approved.txt deleted file mode 100644 index fb8b9ea5..00000000 --- a/legacy_v2_tests/test_app_client_call.approvals/test_readonly_call_with_error_with_new_client_missing_source_map.approved.txt +++ /dev/null @@ -1,7 +0,0 @@ -Txn {txn} had error 'assert failed pc=743' at PC 743: - -Could not determine TEAL source line for the error as no approval source map was provided, to receive a trace of the -error please provide an approval SourceMap. Either by: - 1.Providing template_values when creating the ApplicationClient, so a SourceMap can be obtained automatically OR - 2.Set approval_source_map from a previously compiled approval program OR - 3.Import a previously exported source map using import_source_map \ No newline at end of file diff --git a/legacy_v2_tests/test_app_client_call.approvals/test_readonly_call_with_error_with_new_client_provided_source_map.approved.txt b/legacy_v2_tests/test_app_client_call.approvals/test_readonly_call_with_error_with_new_client_provided_source_map.approved.txt deleted file mode 100644 index 72d21d06..00000000 --- a/legacy_v2_tests/test_app_client_call.approvals/test_readonly_call_with_error_with_new_client_provided_source_map.approved.txt +++ /dev/null @@ -1,12 +0,0 @@ -Txn {txn} had error 'assert failed pc=743' at PC 743 and Source Line 425: - - intc_1 // 1 - return - readonly_1_l2: - intc_0 // 0 - // An error - assert <-- Error - retsub - - // set_box - setbox_2: \ No newline at end of file diff --git a/legacy_v2_tests/test_app_client_call.approvals/test_readonly_call_with_error_with_new_client_provided_template_values.approved.txt b/legacy_v2_tests/test_app_client_call.approvals/test_readonly_call_with_error_with_new_client_provided_template_values.approved.txt deleted file mode 100644 index 72d21d06..00000000 --- a/legacy_v2_tests/test_app_client_call.approvals/test_readonly_call_with_error_with_new_client_provided_template_values.approved.txt +++ /dev/null @@ -1,12 +0,0 @@ -Txn {txn} had error 'assert failed pc=743' at PC 743 and Source Line 425: - - intc_1 // 1 - return - readonly_1_l2: - intc_0 // 0 - // An error - assert <-- Error - retsub - - // set_box - setbox_2: \ No newline at end of file diff --git a/legacy_v2_tests/test_app_client_call.py b/legacy_v2_tests/test_app_client_call.py deleted file mode 100644 index 14933f1b..00000000 --- a/legacy_v2_tests/test_app_client_call.py +++ /dev/null @@ -1,355 +0,0 @@ -from collections.abc import Generator -from hashlib import sha256 -from pathlib import Path -from typing import TYPE_CHECKING -from unittest.mock import Mock, patch - -import pytest -from algosdk.atomic_transaction_composer import ( - AccountTransactionSigner, - AtomicTransactionComposer, - TransactionWithSigner, -) -from algosdk.transaction import ApplicationCallTxn, PaymentTxn - -import algokit_utils -import algokit_utils._legacy_v2 -import algokit_utils._legacy_v2.logic_error -from algokit_utils import ( - Account, - ApplicationClient, - ApplicationSpecification, - CreateCallParameters, - get_account, -) -from legacy_v2_tests.conftest import check_output_stability, get_unique_name - -if TYPE_CHECKING: - from algosdk.abi import Method - from algosdk.v2client.algod import AlgodClient - - -@pytest.fixture(scope="module") -def client_fixture(algod_client: "AlgodClient", app_spec: ApplicationSpecification) -> ApplicationClient: - creator_name = get_unique_name() - creator = get_account(algod_client, creator_name) - client = ApplicationClient(algod_client, app_spec, signer=creator) - create_response = client.create("create") - assert create_response.tx_id - return client - - -# This fixture is automatically applied to all application call tests. -# If you need to run a test without debug mode, you can reference this mock within the test and disable it explicitly. -@pytest.fixture(autouse=True) -def mock_config() -> Generator[Mock, None, None]: - with patch("algokit_utils._legacy_v2.application_client.config", new_callable=Mock) as mock_config: - mock_config.debug = True - mock_config.project_root = None - yield mock_config - - -def test_app_client_from_app_spec_path(algod_client: "AlgodClient") -> None: - client = ApplicationClient(algod_client, Path(__file__).parent / "app_client_test.json") - - assert client.app_spec - - -def test_abi_call_with_atc(client_fixture: ApplicationClient) -> None: - atc = AtomicTransactionComposer() - client_fixture.compose_call(atc, "hello", name="test") - result = atc.execute(client_fixture.algod_client, 4) - - assert result.abi_results[0].return_value == "Hello ABI, test" - - -class PretendSubroutine: - def __init__(self, method: "Method"): - self._method = method - - def method_spec(self) -> "Method": - return self._method - - -def test_abi_call_with_method_spec(client_fixture: ApplicationClient) -> None: - hello = client_fixture.app_spec.contract.get_method_by_name("hello") - subroutine = PretendSubroutine(hello) - - result = client_fixture.call(subroutine, name="test") - - assert result.return_value == "Hello ABI, test" - - -def test_abi_call_with_transaction_arg(client_fixture: ApplicationClient, funded_account: Account) -> None: - call_with_payment = client_fixture.app_spec.contract.get_method_by_name("call_with_payment") - - payment = PaymentTxn( - sender=funded_account.address, - receiver=client_fixture.app_address, - amt=1_000_000, - note=sha256(b"self-payment").digest(), - sp=client_fixture.algod_client.suggested_params(), - ) # type: ignore[no-untyped-call] - payment_with_signer = TransactionWithSigner(payment, AccountTransactionSigner(funded_account.private_key)) - - result = client_fixture.call(call_with_payment, payment=payment_with_signer) - - assert result.return_value == "Payment Successful" - - -def test_abi_call_multiple_times_with_atc(client_fixture: ApplicationClient) -> None: - atc = AtomicTransactionComposer() - client_fixture.compose_call(atc, "hello", name="test") - client_fixture.compose_call(atc, "hello", name="test2") - client_fixture.compose_call(atc, "hello", name="test3") - result = atc.execute(client_fixture.algod_client, 4) - - assert result.abi_results[0].return_value == "Hello ABI, test" - assert result.abi_results[1].return_value == "Hello ABI, test2" - assert result.abi_results[2].return_value == "Hello ABI, test3" - - -def test_call_parameters_from_derived_type_ignored(client_fixture: ApplicationClient) -> None: - client_fixture = client_fixture.prepare() # make a copy - parameters = CreateCallParameters( - extra_pages=1, - ) - - client_fixture.app_id = 123 - atc = AtomicTransactionComposer() - client_fixture.compose_call(atc, "hello", transaction_parameters=parameters, name="test") - - signed_txn = atc.txn_list[0] - app_txn = signed_txn.txn - assert isinstance(app_txn, ApplicationCallTxn) - assert app_txn.extra_pages == 0 - - -def test_call_with_box(client_fixture: ApplicationClient) -> None: - algokit_utils.ensure_funded( - client_fixture.algod_client, - algokit_utils.EnsureBalanceParameters( - account_to_fund=client_fixture.app_address, - min_spending_balance_micro_algos=200_000, - min_funding_increment_micro_algos=200_000, - ), - ) - set_response = client_fixture.call( - "set_box", - algokit_utils.OnCompleteCallParameters(boxes=[(0, b"ssss")]), - name=b"ssss", - value="test", - ) - - assert set_response.confirmed_round - - get_response = client_fixture.call( - "get_box", - algokit_utils.OnCompleteCallParameters(boxes=[(0, b"ssss")]), - name=b"ssss", - ) - - assert get_response.return_value == "test" - - -def test_call_with_box_readonly(client_fixture: ApplicationClient) -> None: - algokit_utils.ensure_funded( - client_fixture.algod_client, - algokit_utils.EnsureBalanceParameters( - account_to_fund=client_fixture.app_address, - min_spending_balance_micro_algos=200_000, - min_funding_increment_micro_algos=200_000, - ), - ) - set_response = client_fixture.call( - "set_box", - algokit_utils.OnCompleteCallParameters(boxes=[(0, b"ssss")]), - name=b"ssss", - value="test", - ) - - assert set_response.confirmed_round - - get_response = client_fixture.call( - "get_box_readonly", - algokit_utils.OnCompleteCallParameters(boxes=[(0, b"ssss")]), - name=b"ssss", - ) - - assert get_response.return_value == "test" - - -def test_readonly_call(client_fixture: ApplicationClient) -> None: - response = client_fixture.call( - "readonly", - error=0, - ) - - assert response.confirmed_round is None - - -def test_readonly_call_with_error(client_fixture: ApplicationClient) -> None: - with pytest.raises(algokit_utils._legacy_v2.logic_error.LogicError) as ex: # noqa: SLF001 - client_fixture.call( - "readonly", - error=1, - ) - - check_output_stability(str(ex.value).replace(ex.value.transaction_id, "{txn}")) - - -def test_readonly_call_with_error_with_new_client_provided_template_values( - algod_client: "AlgodClient", - funded_account: Account, -) -> None: - app_spec = Path(__file__).parent / "app_client_test.json" - client = ApplicationClient( - algod_client, app_spec, signer=funded_account, template_values={"VERSION": 1, "UPDATABLE": 1, "DELETABLE": 1} - ) - create_response = client.create("create") - assert create_response.tx_id - - new_client = ApplicationClient( - algod_client, app_spec, app_id=client.app_id, signer=funded_account, template_values=client.template_values - ) - new_client.approval_source_map = client.approval_source_map - - with pytest.raises(algokit_utils._legacy_v2.logic_error.LogicError) as ex: # noqa: SLF001 - new_client.call( - "readonly", - error=1, - ) - - check_output_stability(str(ex.value).replace(ex.value.transaction_id, "{txn}")) - - -def test_readonly_call_with_error_with_new_client_provided_source_map( - algod_client: "AlgodClient", - funded_account: Account, -) -> None: - app_spec = Path(__file__).parent / "app_client_test.json" - client = ApplicationClient( - algod_client, app_spec, signer=funded_account, template_values={"VERSION": 1, "UPDATABLE": 1, "DELETABLE": 1} - ) - create_response = client.create("create") - assert create_response.tx_id - - new_client = ApplicationClient(algod_client, app_spec, app_id=client.app_id, signer=funded_account) - new_client.approval_source_map = client.approval_source_map - - with pytest.raises(algokit_utils._legacy_v2.logic_error.LogicError) as ex: # noqa: SLF001 - new_client.call( - "readonly", - error=1, - ) - - check_output_stability(str(ex.value).replace(ex.value.transaction_id, "{txn}")) - - -def test_readonly_call_with_error_with_imported_source_map( - algod_client: "AlgodClient", - funded_account: Account, -) -> None: - app_spec = Path(__file__).parent / "app_client_test.json" - client = ApplicationClient( - algod_client, app_spec, signer=funded_account, template_values={"VERSION": 1, "UPDATABLE": 1, "DELETABLE": 1} - ) - create_response = client.create("create") - assert create_response.tx_id - source_map_export = client.export_source_map() - assert source_map_export - - new_client = ApplicationClient(algod_client, app_spec, app_id=client.app_id, signer=funded_account) - new_client.import_source_map(source_map_export) - - with pytest.raises(algokit_utils._legacy_v2.logic_error.LogicError) as ex: # noqa: SLF001 - new_client.call( - "readonly", - error=1, - ) - - check_output_stability(str(ex.value).replace(ex.value.transaction_id, "{txn}")) - - -def test_readonly_call_with_error_with_new_client_missing_source_map( - algod_client: "AlgodClient", - funded_account: Account, -) -> None: - app_spec = Path(__file__).parent / "app_client_test.json" - client = ApplicationClient( - algod_client, app_spec, signer=funded_account, template_values={"VERSION": 1, "UPDATABLE": 1, "DELETABLE": 1} - ) - create_response = client.create("create") - assert create_response.tx_id - - new_client = ApplicationClient(algod_client, app_spec, app_id=client.app_id, signer=funded_account) - - with pytest.raises(algokit_utils._legacy_v2.logic_error.LogicError) as ex: # noqa: SLF001 - new_client.call( - "readonly", - error=1, - ) - - check_output_stability(str(ex.value).replace(ex.value.transaction_id, "{txn}")) - - -def test_readonly_call_with_error_debug_mode_disabled(mock_config: Mock, client_fixture: ApplicationClient) -> None: - mock_config.debug = False - with pytest.raises(algokit_utils._legacy_v2.logic_error.LogicError) as ex: # noqa: SLF001 - client_fixture.call( - "readonly", - error=1, - ) - assert ex.value.traces is None - mock_config.debug = True - - -def test_readonly_call_with_error_debug_mode_enabled(client_fixture: ApplicationClient) -> None: - with pytest.raises(algokit_utils._legacy_v2.logic_error.LogicError) as ex: # noqa: SLF001 - client_fixture.call( - "readonly", - error=1, - ) - - assert ex.value.traces is not None - assert ex.value.traces[0].exec_trace["approval-program-trace"] is not None - - -def test_app_call_with_error_debug_mode_disabled(mock_config: Mock, client_fixture: ApplicationClient) -> None: - mock_config.debug = False - algokit_utils.ensure_funded( - client_fixture.algod_client, - algokit_utils.EnsureBalanceParameters( - account_to_fund=client_fixture.app_address, - min_spending_balance_micro_algos=200_000, - min_funding_increment_micro_algos=200_000, - ), - ) - with pytest.raises(algokit_utils._legacy_v2.logic_error.LogicError) as ex: # noqa: SLF001 - client_fixture.call( - "set_box", - name=b"ssss", - value="test", - ) - - assert ex.value.traces is None - mock_config.debug = True - - -def test_app_call_with_error_debug_mode_enabled(client_fixture: ApplicationClient) -> None: - algokit_utils.ensure_funded( - client_fixture.algod_client, - algokit_utils.EnsureBalanceParameters( - account_to_fund=client_fixture.app_address, - min_spending_balance_micro_algos=200_000, - min_funding_increment_micro_algos=200_000, - ), - ) - with pytest.raises(algokit_utils._legacy_v2.logic_error.LogicError) as ex: # noqa: SLF001 - client_fixture.call( - "set_box", - name=b"ssss", - value="test", - ) - - assert ex.value.traces is not None diff --git a/legacy_v2_tests/test_app_client_clear_state.py b/legacy_v2_tests/test_app_client_clear_state.py deleted file mode 100644 index 1d2f6529..00000000 --- a/legacy_v2_tests/test_app_client_clear_state.py +++ /dev/null @@ -1,63 +0,0 @@ -import base64 -from typing import TYPE_CHECKING - -import pytest - -from algokit_utils import ( - Account, - ApplicationClient, - ApplicationSpecification, -) -from legacy_v2_tests.conftest import is_opted_in - -if TYPE_CHECKING: - from algosdk.v2client.algod import AlgodClient - from algosdk.v2client.indexer import IndexerClient - - -@pytest.fixture -def client_fixture( - algod_client: "AlgodClient", - indexer_client: "IndexerClient", - app_spec: ApplicationSpecification, - funded_account: Account, -) -> ApplicationClient: - client = ApplicationClient(algod_client, app_spec, creator=funded_account, indexer_client=indexer_client) - create_response = client.create("create") - assert create_response.tx_id - opt_in_response = client.opt_in("opt_in") - assert opt_in_response.tx_id - return client - - -def test_clear_state(client_fixture: ApplicationClient) -> None: - assert is_opted_in(client_fixture) - - close_out_response = client_fixture.clear_state() - assert close_out_response.tx_id - - assert not is_opted_in(client_fixture) - - -def test_clear_state_app_already_deleted(client_fixture: ApplicationClient) -> None: - assert is_opted_in(client_fixture) - - client_fixture.delete("delete") - assert is_opted_in(client_fixture) - - close_out_response = client_fixture.clear_state() - assert close_out_response.tx_id - - assert not is_opted_in(client_fixture) - - -def test_clear_state_app_args(client_fixture: ApplicationClient) -> None: - assert is_opted_in(client_fixture) - app_args = [b"test", b"data"] - - close_out_response = client_fixture.clear_state(app_args=app_args) - assert close_out_response.tx_id - - tx_info = client_fixture.algod_client.pending_transaction_info(close_out_response.tx_id) - assert isinstance(tx_info, dict) - assert [base64.b64decode(x) for x in tx_info["txn"]["txn"]["apaa"]] == app_args diff --git a/legacy_v2_tests/test_app_client_close_out.approvals/test_abi_close_out_args_fails.approved.txt b/legacy_v2_tests/test_app_client_close_out.approvals/test_abi_close_out_args_fails.approved.txt deleted file mode 100644 index 67386e7a..00000000 --- a/legacy_v2_tests/test_app_client_close_out.approvals/test_abi_close_out_args_fails.approved.txt +++ /dev/null @@ -1,12 +0,0 @@ -Txn {txn} had error 'assert failed pc=1228' at PC 1228 and Source Line 747: - - frame_dig -1 - extract 2 0 - bytec 4 // "Yes" - == - // passes close_out check - assert <-- Error - intc_1 // 1 - return - - // call_with_payment \ No newline at end of file diff --git a/legacy_v2_tests/test_app_client_close_out.py b/legacy_v2_tests/test_app_client_close_out.py deleted file mode 100644 index 81ac5ea9..00000000 --- a/legacy_v2_tests/test_app_client_close_out.py +++ /dev/null @@ -1,68 +0,0 @@ -from typing import TYPE_CHECKING - -import pytest - -from algokit_utils import ( - Account, - ApplicationClient, - ApplicationSpecification, - LogicError, -) -from legacy_v2_tests.conftest import check_output_stability, is_opted_in - -if TYPE_CHECKING: - from algosdk.v2client.algod import AlgodClient - from algosdk.v2client.indexer import IndexerClient - - -@pytest.fixture -def client_fixture( - algod_client: "AlgodClient", - indexer_client: "IndexerClient", - app_spec: ApplicationSpecification, - funded_account: Account, -) -> ApplicationClient: - client = ApplicationClient(algod_client, app_spec, creator=funded_account, indexer_client=indexer_client) - create_response = client.create("create") - assert create_response.tx_id - opt_in_response = client.opt_in("opt_in") - assert opt_in_response.tx_id - return client - - -def test_abi_close_out(client_fixture: ApplicationClient) -> None: - assert is_opted_in(client_fixture) - - close_out_response = client_fixture.close_out("close_out") - assert close_out_response.tx_id - - assert not is_opted_in(client_fixture) - - -def test_bare_close_out(client_fixture: ApplicationClient) -> None: - assert is_opted_in(client_fixture) - - close_out_response = client_fixture.close_out(call_abi_method=False) - assert close_out_response.tx_id - - assert not is_opted_in(client_fixture) - - -def test_abi_close_out_args(client_fixture: ApplicationClient) -> None: - assert is_opted_in(client_fixture) - - close_out_response = client_fixture.close_out("close_out_args", check="Yes") - assert close_out_response.tx_id - - assert not is_opted_in(client_fixture) - - -def test_abi_close_out_args_fails(client_fixture: ApplicationClient) -> None: - assert is_opted_in(client_fixture) - - with pytest.raises(LogicError) as ex: - client_fixture.close_out("close_out_args", check="No") - - check_output_stability(str(ex.value).replace(ex.value.transaction_id, "{txn}")) - - assert is_opted_in(client_fixture) diff --git a/legacy_v2_tests/test_app_client_create.approvals/test_create_auto_find_ambiguous.approved.txt b/legacy_v2_tests/test_app_client_create.approvals/test_create_auto_find_ambiguous.approved.txt deleted file mode 100644 index ddc62386..00000000 --- a/legacy_v2_tests/test_app_client_create.approvals/test_create_auto_find_ambiguous.approved.txt +++ /dev/null @@ -1 +0,0 @@ -Could not find an exact method to use for NoOpOC with call_config of CREATE, specify the exact method using abi_method and args parameters, considered: create()void, bare \ No newline at end of file diff --git a/legacy_v2_tests/test_app_client_create.py b/legacy_v2_tests/test_app_client_create.py deleted file mode 100644 index 00fd9691..00000000 --- a/legacy_v2_tests/test_app_client_create.py +++ /dev/null @@ -1,254 +0,0 @@ -import dataclasses -from typing import TYPE_CHECKING - -import pytest -from algosdk.atomic_transaction_composer import AccountTransactionSigner, AtomicTransactionComposer, TransactionSigner -from algosdk.transaction import ApplicationCallTxn, GenericSignedTransaction, OnComplete, Transaction - -from algokit_utils import ( - Account, - ApplicationClient, - ApplicationSpecification, - CreateCallParameters, - get_account, - get_app_id_from_tx_id, -) -from legacy_v2_tests.conftest import check_output_stability, get_unique_name - -if TYPE_CHECKING: - from algosdk.v2client.algod import AlgodClient - from algosdk.v2client.indexer import IndexerClient - - -@pytest.fixture(scope="module") -def client_fixture( - algod_client: "AlgodClient", - indexer_client: "IndexerClient", - app_spec: ApplicationSpecification, - funded_account: Account, -) -> ApplicationClient: - return ApplicationClient(algod_client, app_spec, creator=funded_account, indexer_client=indexer_client) - - -def test_bare_create(client_fixture: ApplicationClient) -> None: - client_fixture.create(call_abi_method=False) - - assert client_fixture.call("hello", name="test").return_value == "Hello Bare, test" - - -def test_abi_create(client_fixture: ApplicationClient) -> None: - client_fixture.create("create") - - assert client_fixture.call("hello", name="test").return_value == "Hello ABI, test" - - -@pytest.mark.parametrize("method", ["create_args", "create_args(string)void", True]) -def test_abi_create_args(method: str | bool, client_fixture: ApplicationClient) -> None: - client_fixture.create(method, greeting="ahoy") - - assert client_fixture.call("hello", name="test").return_value == "ahoy, test" - - -def test_create_auto_find(client_fixture: ApplicationClient) -> None: - client_fixture.create(transaction_parameters=CreateCallParameters(on_complete=OnComplete.OptInOC)) - - assert client_fixture.call("hello", name="test").return_value == "Opt In, test" - - -def test_create_auto_find_ambiguous(client_fixture: ApplicationClient) -> None: - with pytest.raises(Exception, match="Could not find an exact method to use") as ex: - client_fixture.create() - check_output_stability(str(ex.value)) - - -def test_abi_create_with_atc(client_fixture: ApplicationClient) -> None: - atc = AtomicTransactionComposer() - client_fixture.compose_create(atc, "create") - - create_result = atc.execute(client_fixture.algod_client, 4) - client_fixture.app_id = get_app_id_from_tx_id(client_fixture.algod_client, create_result.tx_ids[0]) - - assert client_fixture.call("hello", name="test").return_value == "Hello ABI, test" - - -def test_bare_create_with_atc(client_fixture: ApplicationClient) -> None: - atc = AtomicTransactionComposer() - client_fixture.compose_create(atc, call_abi_method=False) - - create_result = atc.execute(client_fixture.algod_client, 4) - client_fixture.app_id = get_app_id_from_tx_id(client_fixture.algod_client, create_result.tx_ids[0]) - - assert client_fixture.call("hello", name="test").return_value == "Hello Bare, test" - - -def test_create_parameters_lease(client_fixture: ApplicationClient) -> None: - lease = b"a" * 32 - - atc = AtomicTransactionComposer() - client_fixture.compose_create( - atc, - "create", - transaction_parameters=CreateCallParameters( - lease=lease, - ), - ) - - signed_txn = atc.txn_list[0] - assert signed_txn.txn.lease == lease - - -def test_create_parameters_note(client_fixture: ApplicationClient) -> None: - note = b"test note" - - atc = AtomicTransactionComposer() - client_fixture.compose_create( - atc, - "create", - transaction_parameters=CreateCallParameters( - note=note, - ), - ) - - signed_txn = atc.txn_list[0] - assert signed_txn.txn.note == note - - -def test_create_parameters_on_complete(client_fixture: ApplicationClient) -> None: - on_complete = OnComplete.OptInOC - - atc = AtomicTransactionComposer() - client_fixture.compose_create( - atc, "create", transaction_parameters=CreateCallParameters(on_complete=OnComplete.OptInOC) - ) - - signed_txn = atc.txn_list[0] - app_txn = signed_txn.txn - assert isinstance(app_txn, ApplicationCallTxn) - assert app_txn.on_complete == on_complete - - -def test_create_parameters_extra_pages(client_fixture: ApplicationClient) -> None: - extra_pages = 1 - - atc = AtomicTransactionComposer() - client_fixture.compose_create(atc, "create", transaction_parameters=CreateCallParameters(extra_pages=extra_pages)) - - signed_txn = atc.txn_list[0] - app_txn = signed_txn.txn - assert isinstance(app_txn, ApplicationCallTxn) - assert app_txn.extra_pages == extra_pages - - -def test_create_parameters_signer(client_fixture: ApplicationClient) -> None: - another_account_name = get_unique_name() - account = get_account(client_fixture.algod_client, another_account_name) - signer = AccountTransactionSigner(account.private_key) - - atc = AtomicTransactionComposer() - client_fixture.compose_create(atc, "create", transaction_parameters=CreateCallParameters(signer=signer)) - - signed_txn = atc.txn_list[0] - assert isinstance(signed_txn.signer, AccountTransactionSigner) - assert signed_txn.signer.private_key == signer.private_key - - -@dataclasses.dataclass -class DataclassTransactionSigner(TransactionSigner): - def sign_transactions(self, txn_group: list[Transaction], indexes: list[int]) -> list[GenericSignedTransaction]: - return self.transaction_signer.sign_transactions(txn_group, indexes) - - transaction_signer: TransactionSigner - - -def test_create_parameters_dataclass_signer(client_fixture: ApplicationClient) -> None: - another_account_name = get_unique_name() - account = get_account(client_fixture.algod_client, another_account_name) - signer = DataclassTransactionSigner(AccountTransactionSigner(account.private_key)) - - atc = AtomicTransactionComposer() - client_fixture.compose_create(atc, "create", transaction_parameters=CreateCallParameters(signer=signer)) - - signed_txn = atc.txn_list[0] - assert isinstance(signed_txn.signer, DataclassTransactionSigner) - - -def test_create_parameters_sender(client_fixture: ApplicationClient) -> None: - another_account_name = get_unique_name() - account = get_account(client_fixture.algod_client, another_account_name) - - atc = AtomicTransactionComposer() - client_fixture.compose_create(atc, "create", transaction_parameters=CreateCallParameters(sender=account.address)) - - signed_txn = atc.txn_list[0] - assert signed_txn.txn.sender == account.address - - -def test_create_parameters_rekey_to(client_fixture: ApplicationClient) -> None: - another_account_name = get_unique_name() - account = get_account(client_fixture.algod_client, another_account_name) - - atc = AtomicTransactionComposer() - client_fixture.compose_create(atc, "create", transaction_parameters=CreateCallParameters(rekey_to=account.address)) - - signed_txn = atc.txn_list[0] - assert signed_txn.txn.rekey_to == account.address - - -def test_create_parameters_suggested_params(client_fixture: ApplicationClient) -> None: - sp = client_fixture.algod_client.suggested_params() - sp.gen = "test-genesis" - - atc = AtomicTransactionComposer() - client_fixture.compose_create(atc, "create", transaction_parameters=CreateCallParameters(suggested_params=sp)) - - signed_txn = atc.txn_list[0] - assert signed_txn.txn.genesis_id == sp.gen - - -def test_create_parameters_boxes(client_fixture: ApplicationClient) -> None: - boxes = [(0, b"one"), (0, b"two")] - - atc = AtomicTransactionComposer() - client_fixture.compose_create(atc, "create", transaction_parameters=CreateCallParameters(boxes=boxes)) - - signed_txn = atc.txn_list[0] - assert isinstance(signed_txn.txn, ApplicationCallTxn) - assert [(b.app_index, b.name) for b in signed_txn.txn.boxes] == boxes - - -def test_create_parameters_accounts(client_fixture: ApplicationClient) -> None: - another_account_name = get_unique_name() - account = get_account(client_fixture.algod_client, another_account_name) - - atc = AtomicTransactionComposer() - client_fixture.compose_create( - atc, "create", transaction_parameters=CreateCallParameters(accounts=[account.address]) - ) - - signed_txn = atc.txn_list[0] - assert isinstance(signed_txn.txn, ApplicationCallTxn) - assert signed_txn.txn.accounts == [account.address] - - -def test_create_parameters_foreign_apps(client_fixture: ApplicationClient) -> None: - foreign_apps = [1, 2, 3] - - atc = AtomicTransactionComposer() - client_fixture.compose_create(atc, "create", transaction_parameters=CreateCallParameters(foreign_apps=foreign_apps)) - - signed_txn = atc.txn_list[0] - assert isinstance(signed_txn.txn, ApplicationCallTxn) - assert signed_txn.txn.foreign_apps == foreign_apps - - -def test_create_parameters_foreign_assets(client_fixture: ApplicationClient) -> None: - foreign_assets = [10, 20, 30] - - atc = AtomicTransactionComposer() - client_fixture.compose_create( - atc, "create", transaction_parameters=CreateCallParameters(foreign_assets=foreign_assets) - ) - - signed_txn = atc.txn_list[0] - assert isinstance(signed_txn.txn, ApplicationCallTxn) - assert signed_txn.txn.foreign_assets == foreign_assets diff --git a/legacy_v2_tests/test_app_client_delete.approvals/test_abi_delete_args_fails.approved.txt b/legacy_v2_tests/test_app_client_delete.approvals/test_abi_delete_args_fails.approved.txt deleted file mode 100644 index bc2e0eab..00000000 --- a/legacy_v2_tests/test_app_client_delete.approvals/test_abi_delete_args_fails.approved.txt +++ /dev/null @@ -1,12 +0,0 @@ -Txn {txn} had error 'assert failed pc=961' at PC 961 and Source Line 575: - - frame_dig -1 - extract 2 0 - bytec 4 // "Yes" - == - // passes delete check - assert <-- Error - intc 5 // deletable - // is deletable - assert - retsub \ No newline at end of file diff --git a/legacy_v2_tests/test_app_client_delete.py b/legacy_v2_tests/test_app_client_delete.py deleted file mode 100644 index d5df42cb..00000000 --- a/legacy_v2_tests/test_app_client_delete.py +++ /dev/null @@ -1,52 +0,0 @@ -from typing import TYPE_CHECKING - -import pytest - -from algokit_utils import ( - Account, - ApplicationClient, - ApplicationSpecification, - LogicError, -) -from legacy_v2_tests.conftest import check_output_stability - -if TYPE_CHECKING: - from algosdk.v2client.algod import AlgodClient - from algosdk.v2client.indexer import IndexerClient - - -@pytest.fixture -def client_fixture( - algod_client: "AlgodClient", - indexer_client: "IndexerClient", - funded_account: Account, - app_spec: ApplicationSpecification, -) -> ApplicationClient: - client = ApplicationClient(algod_client, app_spec, creator=funded_account, indexer_client=indexer_client) - client.create("create") - return client - - -def test_abi_delete(client_fixture: ApplicationClient) -> None: - delete_response = client_fixture.delete("delete") - - assert delete_response.tx_id - - -def test_bare_delete(client_fixture: ApplicationClient) -> None: - delete_response = client_fixture.delete(call_abi_method=False) - - assert delete_response.tx_id - - -def test_abi_delete_args(client_fixture: ApplicationClient) -> None: - delete_response = client_fixture.delete("delete_args", check="Yes") - - assert delete_response.tx_id - - -def test_abi_delete_args_fails(client_fixture: ApplicationClient) -> None: - with pytest.raises(LogicError) as ex: - client_fixture.delete("delete_args", check="No") - - check_output_stability(str(ex.value).replace(ex.value.transaction_id, "{txn}")) diff --git a/legacy_v2_tests/test_app_client_deploy.py b/legacy_v2_tests/test_app_client_deploy.py deleted file mode 100644 index e51392b4..00000000 --- a/legacy_v2_tests/test_app_client_deploy.py +++ /dev/null @@ -1,63 +0,0 @@ -from typing import TYPE_CHECKING - -import pytest - -from algokit_utils import ( - ABICreateCallArgs, - Account, - ApplicationClient, - ApplicationSpecification, - TransferParameters, - transfer, -) -from legacy_v2_tests.conftest import get_unique_name, read_spec - -if TYPE_CHECKING: - from algosdk.v2client.algod import AlgodClient - from algosdk.v2client.indexer import IndexerClient - - -@pytest.fixture -def client_fixture( - algod_client: "AlgodClient", - indexer_client: "IndexerClient", - funded_account: Account, -) -> ApplicationClient: - app_spec = read_spec("app_client_test.json", deletable=True, updatable=True, template_values={"VERSION": 1}) - return ApplicationClient( - algod_client, app_spec, creator=funded_account, indexer_client=indexer_client, app_name=get_unique_name() - ) - - -def test_deploy_with_create(client_fixture: ApplicationClient, creator: Account) -> None: - client_fixture.deploy( - "v1", - create_args=ABICreateCallArgs( - method="create", - ), - ) - - transfer( - client_fixture.algod_client, - TransferParameters(from_account=creator, to_address=client_fixture.app_address, micro_algos=100_000), - ) - - assert client_fixture.call("hello", name="test").return_value == "Hello ABI, test" - - -def test_deploy_with_create_args(client_fixture: ApplicationClient, app_spec: ApplicationSpecification) -> None: - create_args = next(m for m in app_spec.contract.methods if m.name == "create_args") - client_fixture.deploy("v1", create_args=ABICreateCallArgs(method=create_args, args={"greeting": "deployed"})) - - assert client_fixture.call("hello", name="test").return_value == "deployed, test" - - -def test_deploy_with_bare_create(client_fixture: ApplicationClient) -> None: - client_fixture.deploy( - "v1", - create_args=ABICreateCallArgs( - method=False, - ), - ) - - assert client_fixture.call("hello", name="test").return_value == "Hello Bare, test" diff --git a/legacy_v2_tests/test_app_client_opt_in.approvals/test_abi_update_args_fails.approved.txt b/legacy_v2_tests/test_app_client_opt_in.approvals/test_abi_update_args_fails.approved.txt deleted file mode 100644 index 3241c98f..00000000 --- a/legacy_v2_tests/test_app_client_opt_in.approvals/test_abi_update_args_fails.approved.txt +++ /dev/null @@ -1,12 +0,0 @@ -Txn {txn} had error 'assert failed pc=1187' at PC 1187 and Source Line 719: - - frame_dig -1 - extract 2 0 - bytec 4 // "Yes" - == - // passes opt_in check - assert <-- Error - txn Sender - bytec_3 // "last" - pushbytes 0x4f707420496e2041726773 // "Opt In Args" - app_local_put \ No newline at end of file diff --git a/legacy_v2_tests/test_app_client_opt_in.py b/legacy_v2_tests/test_app_client_opt_in.py deleted file mode 100644 index afc1fb1e..00000000 --- a/legacy_v2_tests/test_app_client_opt_in.py +++ /dev/null @@ -1,59 +0,0 @@ -from typing import TYPE_CHECKING - -import pytest - -from algokit_utils import ( - Account, - ApplicationClient, - ApplicationSpecification, - LogicError, -) -from legacy_v2_tests.conftest import check_output_stability, is_opted_in - -if TYPE_CHECKING: - from algosdk.v2client.algod import AlgodClient - from algosdk.v2client.indexer import IndexerClient - - -@pytest.fixture -def client_fixture( - algod_client: "AlgodClient", - indexer_client: "IndexerClient", - app_spec: ApplicationSpecification, - funded_account: Account, -) -> ApplicationClient: - client = ApplicationClient(algod_client, app_spec, creator=funded_account, indexer_client=indexer_client) - client.create("create") - return client - - -def test_abi_opt_in(client_fixture: ApplicationClient) -> None: - opt_in_response = client_fixture.opt_in("opt_in") - - assert opt_in_response.tx_id - assert client_fixture.call("get_last").return_value == "Opt In ABI" - assert is_opted_in(client_fixture) - - -def test_bare_opt_in(client_fixture: ApplicationClient) -> None: - opt_in_response = client_fixture.opt_in(call_abi_method=False) - - assert opt_in_response.tx_id - assert client_fixture.call("get_last").return_value == "Opt In Bare" - assert is_opted_in(client_fixture) - - -def test_abi_opt_in_args(client_fixture: ApplicationClient) -> None: - update_response = client_fixture.opt_in("opt_in_args", check="Yes") - - assert update_response.tx_id - assert client_fixture.call("get_last").return_value == "Opt In Args" - assert is_opted_in(client_fixture) - - -def test_abi_update_args_fails(client_fixture: ApplicationClient) -> None: - with pytest.raises(LogicError) as ex: - client_fixture.opt_in("opt_in_args", check="No") - - check_output_stability(str(ex.value).replace(ex.value.transaction_id, "{txn}")) - assert not is_opted_in(client_fixture) diff --git a/legacy_v2_tests/test_app_client_prepare.py b/legacy_v2_tests/test_app_client_prepare.py deleted file mode 100644 index affacd50..00000000 --- a/legacy_v2_tests/test_app_client_prepare.py +++ /dev/null @@ -1,50 +0,0 @@ -import base64 -from typing import TYPE_CHECKING - -from algosdk.atomic_transaction_composer import AccountTransactionSigner - -from algokit_utils import ( - ApplicationClient, - ApplicationSpecification, -) - -if TYPE_CHECKING: - from algosdk.v2client.algod import AlgodClient - - -def test_app_client_prepare_with_no_existing_or_new( - algod_client: "AlgodClient", app_spec: ApplicationSpecification -) -> None: - client = ApplicationClient(algod_client, app_spec) - - new_client = client.prepare() - assert new_client.signer is None - assert new_client.sender is None - - -def test_app_client_prepare_with_existing_signer_sender( - algod_client: "AlgodClient", app_spec: ApplicationSpecification -) -> None: - signer = AccountTransactionSigner(base64.b64encode(b"a" * 64).decode("utf-8")) - client = ApplicationClient(algod_client, app_spec, signer=signer, sender="a sender") - - new_client = client.prepare() - assert isinstance(new_client.signer, AccountTransactionSigner) - assert signer.private_key == new_client.signer.private_key - assert client.sender == new_client.sender - - -def test_app_client_prepare_with_new_sender(algod_client: "AlgodClient", app_spec: ApplicationSpecification) -> None: - client = ApplicationClient(algod_client, app_spec) - - new_client = client.prepare(sender="new_sender") - assert new_client.sender == "new_sender" - - -def test_app_client_prepare_with_new_signer(algod_client: "AlgodClient", app_spec: ApplicationSpecification) -> None: - signer = AccountTransactionSigner(base64.b64encode(b"a" * 64).decode("utf-8")) - client = ApplicationClient(algod_client, app_spec) - - new_client = client.prepare(signer=signer) - assert isinstance(new_client.signer, AccountTransactionSigner) - assert new_client.signer.private_key == signer.private_key diff --git a/legacy_v2_tests/test_app_client_resolve.py b/legacy_v2_tests/test_app_client_resolve.py deleted file mode 100644 index d7e8b1d1..00000000 --- a/legacy_v2_tests/test_app_client_resolve.py +++ /dev/null @@ -1,55 +0,0 @@ -from typing import TYPE_CHECKING - -from algokit_utils import ( - Account, - ApplicationClient, - DefaultArgumentDict, -) -from legacy_v2_tests.conftest import read_spec - -if TYPE_CHECKING: - from algosdk.v2client.algod import AlgodClient - - -def test_resolve(algod_client: "AlgodClient", creator: Account) -> None: - app_spec = read_spec("app_resolve.json") - client_fixture = ApplicationClient(algod_client, app_spec, signer=creator) - client_fixture.create() - client_fixture.opt_in() - - int_default_argument: DefaultArgumentDict = {"source": "constant", "data": 1} - assert client_fixture.resolve(int_default_argument) == 1 - - string_default_argument: DefaultArgumentDict = {"source": "constant", "data": "stringy"} - assert client_fixture.resolve(string_default_argument) == "stringy" - - global_state_int_default_argument: DefaultArgumentDict = { - "source": "global-state", - "data": "global_state_val_int", - } - assert client_fixture.resolve(global_state_int_default_argument) == 1 - - global_state_byte_default_argument: DefaultArgumentDict = { - "source": "global-state", - "data": "global_state_val_byte", - } - assert client_fixture.resolve(global_state_byte_default_argument) == b"test" - - local_state_int_default_argument: DefaultArgumentDict = { - "source": "local-state", - "data": "acct_state_val_int", - } - acct_state_val_int_value = 2 # defined in TEAL - assert client_fixture.resolve(local_state_int_default_argument) == acct_state_val_int_value - - local_state_byte_default_argument: DefaultArgumentDict = { - "source": "local-state", - "data": "acct_state_val_byte", - } - assert client_fixture.resolve(local_state_byte_default_argument) == b"local-test" - - method_default_argument: DefaultArgumentDict = { - "source": "abi-method", - "data": {"name": "dummy", "args": [], "returns": {"type": "string"}}, - } - assert client_fixture.resolve(method_default_argument) == "deadbeef" diff --git a/legacy_v2_tests/test_app_client_signer_sender.py b/legacy_v2_tests/test_app_client_signer_sender.py deleted file mode 100644 index cfdef0ac..00000000 --- a/legacy_v2_tests/test_app_client_signer_sender.py +++ /dev/null @@ -1,66 +0,0 @@ -import base64 -import contextlib -from typing import TYPE_CHECKING, Any - -import pytest -from algosdk.atomic_transaction_composer import AccountTransactionSigner, TransactionSigner - -from algokit_utils import ( - ApplicationClient, - ApplicationSpecification, - get_sender_from_signer, -) - -if TYPE_CHECKING: - from algosdk import transaction - from algosdk.transaction import GenericSignedTransaction - from algosdk.v2client.algod import AlgodClient - - -class CustomSigner(TransactionSigner): - def sign_transactions( - self, txn_group: list["transaction.Transaction"], indexes: list[int] - ) -> list["GenericSignedTransaction"]: - raise NotImplementedError - - -fake_key = base64.b64encode(b"a" * 64).decode("utf8") - - -@pytest.mark.parametrize("override_sender", ["override_sender", None]) -@pytest.mark.parametrize("override_signer", [CustomSigner(), AccountTransactionSigner(fake_key), None]) -@pytest.mark.parametrize("default_sender", ["default_sender", None]) -@pytest.mark.parametrize("default_signer", [CustomSigner(), AccountTransactionSigner(fake_key), None]) -def test_resolve_signer_sender( - *, - algod_client: "AlgodClient", - app_spec: ApplicationSpecification, - default_signer: TransactionSigner | None, - default_sender: str | None, - override_signer: TransactionSigner | None, - override_sender: str | None, -) -> None: - """Regression test against unexpected changes to signer/sender resolution in ApplicationClient""" - app_client = ApplicationClient(algod_client, app_spec, signer=default_signer, sender=default_sender) - - expected_signer = override_signer or default_signer - expected_sender = ( - override_sender - or get_sender_from_signer(override_signer) - or default_sender - or get_sender_from_signer(default_signer) - ) - - ctx: Any - if expected_signer is None: - ctx = pytest.raises(ValueError, match="No signer provided") - elif expected_sender is None: - ctx = pytest.raises(ValueError, match="No sender provided") - else: - ctx = contextlib.nullcontext() - - with ctx: - signer, sender = app_client.resolve_signer_sender(override_signer, override_sender) - - assert signer == expected_signer - assert sender == expected_sender diff --git a/legacy_v2_tests/test_app_client_template_values.py b/legacy_v2_tests/test_app_client_template_values.py deleted file mode 100644 index ae12a964..00000000 --- a/legacy_v2_tests/test_app_client_template_values.py +++ /dev/null @@ -1,148 +0,0 @@ -from typing import TYPE_CHECKING - -import pytest - -import algokit_utils -from legacy_v2_tests.conftest import get_unique_name, read_spec - -if TYPE_CHECKING: - from algosdk.v2client.algod import AlgodClient - from algosdk.v2client.indexer import IndexerClient - - -def test_create_with_all_template_values_on_initialize( - algod_client: "AlgodClient", - indexer_client: "IndexerClient", - funded_account: algokit_utils.Account, -) -> None: - app_spec = read_spec("app_client_test.json") - client = algokit_utils.ApplicationClient( - algod_client, - app_spec, - creator=funded_account, - indexer_client=indexer_client, - template_values={"VERSION": 1, "UPDATABLE": 1, "DELETABLE": 1}, - app_name=get_unique_name(), - ) - client.create("create") - - assert client.call("version").return_value == 1 - - -def test_create_with_some_template_values_on_initialize( - algod_client: "AlgodClient", - indexer_client: "IndexerClient", - funded_account: algokit_utils.Account, -) -> None: - app_spec = read_spec("app_client_test.json") - client = algokit_utils.ApplicationClient( - algod_client, - app_spec, - creator=funded_account, - indexer_client=indexer_client, - template_values={ - "VERSION": 1, - }, - app_name=get_unique_name(), - ) - - with pytest.raises( - expected_exception=algokit_utils.DeploymentFailedError, - match=r"allow_update must be specified if deploy time configuration of update is being used", - ): - client.create("create") - - -def test_deploy_with_some_template_values_on_initialize( - algod_client: "AlgodClient", - indexer_client: "IndexerClient", - funded_account: algokit_utils.Account, -) -> None: - app_spec = read_spec("app_client_test.json") - client = algokit_utils.ApplicationClient( - algod_client, - app_spec, - creator=funded_account, - indexer_client=indexer_client, - template_values={ - "VERSION": 1, - }, - app_name=get_unique_name(), - ) - - client.deploy(allow_delete=True, allow_update=True, create_args=algokit_utils.ABICreateCallArgs(method="create")) - assert client.call("version").return_value == 1 - - -def test_deploy_with_overriden_template_values( - algod_client: "AlgodClient", - indexer_client: "IndexerClient", - funded_account: algokit_utils.Account, -) -> None: - app_spec = read_spec("app_client_test.json") - client = algokit_utils.ApplicationClient( - algod_client, - app_spec, - creator=funded_account, - indexer_client=indexer_client, - template_values={ - "VERSION": 1, - }, - app_name=get_unique_name(), - ) - - new_version = 2 - client.deploy( - allow_delete=True, - allow_update=True, - template_values={"VERSION": new_version}, - create_args=algokit_utils.ABICreateCallArgs(method="create"), - ) - assert client.call("version").return_value == new_version - - -def test_deploy_with_no_initialize_template_values( - algod_client: "AlgodClient", - indexer_client: "IndexerClient", - funded_account: algokit_utils.Account, -) -> None: - app_spec = read_spec("app_client_test.json") - client = algokit_utils.ApplicationClient( - algod_client, - app_spec, - creator=funded_account, - indexer_client=indexer_client, - app_name=get_unique_name(), - ) - - new_version = 3 - client.deploy( - allow_delete=True, - allow_update=True, - template_values={"VERSION": new_version}, - create_args=algokit_utils.ABICreateCallArgs(method="create"), - ) - assert client.call("version").return_value == new_version - - -def test_deploy_with_missing_template_values( - algod_client: "AlgodClient", - indexer_client: "IndexerClient", - funded_account: algokit_utils.Account, -) -> None: - app_spec = read_spec("app_client_test.json") - client = algokit_utils.ApplicationClient( - algod_client, - app_spec, - creator=funded_account, - indexer_client=indexer_client, - app_name=get_unique_name(), - ) - - with pytest.raises( - expected_exception=algokit_utils.DeploymentFailedError, - match=r"The following template values were not provided: TMPL_VERSION", - ): - client.deploy( - allow_delete=True, allow_update=True, create_args=algokit_utils.ABICreateCallArgs(method="create") - ) diff --git a/legacy_v2_tests/test_app_client_update.approvals/test_abi_update_args_fails.approved.txt b/legacy_v2_tests/test_app_client_update.approvals/test_abi_update_args_fails.approved.txt deleted file mode 100644 index c48ed58e..00000000 --- a/legacy_v2_tests/test_app_client_update.approvals/test_abi_update_args_fails.approved.txt +++ /dev/null @@ -1,12 +0,0 @@ -Txn {txn} had error 'assert failed pc=897' at PC 897 and Source Line 527: - - frame_dig -1 - extract 2 0 - bytec 4 // "Yes" - == - // passes update check - assert <-- Error - intc 4 // updatable - // is updatable - assert - bytec_1 // "greeting" \ No newline at end of file diff --git a/legacy_v2_tests/test_app_client_update.py b/legacy_v2_tests/test_app_client_update.py deleted file mode 100644 index 4dc082e0..00000000 --- a/legacy_v2_tests/test_app_client_update.py +++ /dev/null @@ -1,55 +0,0 @@ -from typing import TYPE_CHECKING - -import pytest - -from algokit_utils import ( - Account, - ApplicationClient, - ApplicationSpecification, - LogicError, -) -from legacy_v2_tests.conftest import check_output_stability - -if TYPE_CHECKING: - from algosdk.v2client.algod import AlgodClient - from algosdk.v2client.indexer import IndexerClient - - -@pytest.fixture(scope="module") -def client_fixture( - algod_client: "AlgodClient", - indexer_client: "IndexerClient", - app_spec: ApplicationSpecification, - funded_account: Account, -) -> ApplicationClient: - client = ApplicationClient(algod_client, app_spec, creator=funded_account, indexer_client=indexer_client) - client.create("create") - return client - - -def test_abi_update(client_fixture: ApplicationClient) -> None: - update_response = client_fixture.update("update") - - assert update_response.tx_id - assert client_fixture.call("hello", name="test").return_value == "Updated ABI, test" - - -def test_bare_update(client_fixture: ApplicationClient) -> None: - update_response = client_fixture.update(call_abi_method=False) - - assert update_response.tx_id - assert client_fixture.call("hello", name="test").return_value == "Updated Bare, test" - - -def test_abi_update_args(client_fixture: ApplicationClient) -> None: - update_response = client_fixture.update("update_args", check="Yes") - - assert update_response.tx_id - assert client_fixture.call("hello", name="test").return_value == "Updated Args, test" - - -def test_abi_update_args_fails(client_fixture: ApplicationClient) -> None: - with pytest.raises(LogicError) as ex: - client_fixture.update("update_args", check="No") - - check_output_stability(str(ex.value).replace(ex.value.transaction_id, "{txn}")) diff --git a/legacy_v2_tests/test_asset.py b/legacy_v2_tests/test_asset.py deleted file mode 100644 index c26906ff..00000000 --- a/legacy_v2_tests/test_asset.py +++ /dev/null @@ -1,181 +0,0 @@ -import re -from typing import TYPE_CHECKING - -import pytest - -from algokit_utils import ( - Account, - EnsureBalanceParameters, - TransferAssetParameters, - create_kmd_wallet_account, - ensure_funded, - transfer_asset, -) -from algokit_utils.asset import opt_in, opt_out - -if TYPE_CHECKING: - from algosdk.kmd import KMDClient - from algosdk.v2client.algod import AlgodClient - -from legacy_v2_tests.conftest import assure_funds, generate_test_asset, get_unique_name - - -@pytest.fixture -def to_account(kmd_client: "KMDClient") -> Account: - return create_kmd_wallet_account(kmd_client, get_unique_name()) - - -def test_opt_in_assets_succeed(algod_client: "AlgodClient", to_account: Account, funded_account: Account) -> None: - dummy_asset_id = generate_test_asset(algod_client, funded_account, 1) - account_info = algod_client.account_info(to_account.address) - assert isinstance(account_info, dict) - assert account_info["total-assets-opted-in"] == 0 - - assure_funds(algod_client=algod_client, account=to_account) - opt_in(algod_client=algod_client, account=to_account, asset_ids=[dummy_asset_id]) - account_info_after_opt_in = algod_client.account_info(to_account.address) - - assert isinstance(account_info_after_opt_in, dict) - assert account_info_after_opt_in["total-assets-opted-in"] == 1 - - -def test_opt_in_assets_to_account_second_attempt_failed( - algod_client: "AlgodClient", to_account: Account, funded_account: Account -) -> None: - dummy_asset_id = generate_test_asset(algod_client, funded_account, 1) - account_info = algod_client.account_info(to_account.address) - assert isinstance(account_info, dict) - assert account_info["total-assets-opted-in"] == 0 - - assure_funds(algod_client=algod_client, account=to_account) - opt_in(algod_client=algod_client, account=to_account, asset_ids=[dummy_asset_id]) - account_info_after_opt_in = algod_client.account_info(to_account.address) - - assert isinstance(account_info_after_opt_in, dict) - assert account_info_after_opt_in["total-assets-opted-in"] == 1 - - with pytest.raises( - ValueError, - match=re.escape( - f"Assets {[dummy_asset_id]} cannot be opted in. Ensure that they are valid and " - "that the account has not previously opted into them." - ), - ): - opt_in(algod_client=algod_client, account=to_account, asset_ids=[dummy_asset_id]) - - -def test_opt_in_two_batches_of_assets_succeed( - algod_client: "AlgodClient", to_account: Account, funded_account: Account -) -> None: - account_info = algod_client.account_info(to_account.address) - assert isinstance(account_info, dict) - assert account_info["total-assets-opted-in"] == 0 - dummy_asset_ids = [] - for _ in range(20): - dummy_asset_id = generate_test_asset(algod_client, funded_account, 1) - dummy_asset_ids.append(dummy_asset_id) - - ensure_funded( - algod_client, - EnsureBalanceParameters( - account_to_fund=to_account, - min_spending_balance_micro_algos=3000000, - min_funding_increment_micro_algos=1, - ), - ) - opt_in(algod_client=algod_client, account=to_account, asset_ids=dummy_asset_ids) - account_info_after_opt_in = algod_client.account_info(to_account.address) - - assert isinstance(account_info_after_opt_in, dict) - assert account_info_after_opt_in["total-assets-opted-in"] == len(dummy_asset_ids) - - -def test_opt_out_asset_succeed(algod_client: "AlgodClient", to_account: Account, funded_account: Account) -> None: - dummy_asset_id = generate_test_asset(algod_client, funded_account, 100) - account_info = algod_client.account_info(to_account.address) - assert isinstance(account_info, dict) - assert account_info["total-assets-opted-in"] == 0 - - assure_funds(algod_client=algod_client, account=to_account) - opt_in(algod_client=algod_client, account=to_account, asset_ids=[dummy_asset_id]) - account_info_after_opt_in = algod_client.account_info(to_account.address) - - assert isinstance(account_info_after_opt_in, dict) - assert account_info_after_opt_in["total-assets-opted-in"] == 1 - - opt_out(algod_client=algod_client, account=to_account, asset_ids=[dummy_asset_id]) - - -def test_opt_out_two_batches_of_assets_succeed( - algod_client: "AlgodClient", to_account: Account, funded_account: Account -) -> None: - dummy_asset_ids = [] - for _ in range(20): - dummy_asset_id = generate_test_asset(algod_client, funded_account, 1) - dummy_asset_ids.append(dummy_asset_id) - - ensure_funded( - algod_client, - EnsureBalanceParameters( - account_to_fund=to_account, - min_spending_balance_micro_algos=3000000, - min_funding_increment_micro_algos=1, - ), - ) - opt_in(algod_client=algod_client, account=to_account, asset_ids=dummy_asset_ids) - account_info_after_opt_in = algod_client.account_info(to_account.address) - assert isinstance(account_info_after_opt_in, dict) - assert account_info_after_opt_in["total-assets-opted-in"] == len(dummy_asset_ids) - - opt_out(algod_client=algod_client, account=to_account, asset_ids=dummy_asset_ids) - account_info_after_opt_out = algod_client.account_info(to_account.address) - assert isinstance(account_info_after_opt_out, dict) - assert account_info_after_opt_out["total-assets-opted-in"] == 0 - - -def test_opt_out_of_not_opted_in_asset_failed( - algod_client: "AlgodClient", to_account: Account, funded_account: Account -) -> None: - dummy_asset_id = generate_test_asset(algod_client, funded_account, 1) - account_info = algod_client.account_info(to_account.address) - assert isinstance(account_info, dict) - assert account_info["total-assets-opted-in"] == 0 - - with pytest.raises( - ValueError, - match=re.escape( - f"Assets {[dummy_asset_id]} cannot be opted out. Ensure that their amount is zero " - "and that the account has previously opted into them." - ), - ): - opt_out(algod_client=algod_client, account=to_account, asset_ids=[dummy_asset_id]) - - -def test_opt_out_of_non_zero_balance_asset_failed( - algod_client: "AlgodClient", to_account: Account, funded_account: Account -) -> None: - dummy_asset_id = generate_test_asset(algod_client, funded_account, 100) - assure_funds(algod_client=algod_client, account=to_account) - opt_in(algod_client=algod_client, account=to_account, asset_ids=[dummy_asset_id]) - account_info_after_opt_in = algod_client.account_info(to_account.address) - assert isinstance(account_info_after_opt_in, dict) - assert account_info_after_opt_in["total-assets-opted-in"] == 1 - - transfer_asset( - algod_client, - TransferAssetParameters( - from_account=funded_account, - to_address=to_account.address, - asset_id=dummy_asset_id, - amount=5, - note=f"Transfer 5 assets wit id ${dummy_asset_id}", - ), - ) - with pytest.raises( - ValueError, - match=re.escape( - f"Assets {[dummy_asset_id]} cannot be opted out. Ensure that their amount is zero " - "and that the account has previously opted into them." - ), - ): - opt_out(algod_client=algod_client, account=to_account, asset_ids=[dummy_asset_id]) diff --git a/legacy_v2_tests/test_debug_utils.approvals/test_legacy_build_teal_sourcemaps.approved.txt b/legacy_v2_tests/test_debug_utils.approvals/test_legacy_build_teal_sourcemaps.approved.txt deleted file mode 100644 index bdedcb69..00000000 --- a/legacy_v2_tests/test_debug_utils.approvals/test_legacy_build_teal_sourcemaps.approved.txt +++ /dev/null @@ -1 +0,0 @@ -{"txn-group-sources": [{"sourcemap-location": "dummy", "hash": "EC1P8unO+zjVbdF8XZOs1rp+uaGNk7vXtZ/IYsN/sug="}, {"sourcemap-location": "dummy", "hash": "EC1P8unO+zjVbdF8XZOs1rp+uaGNk7vXtZ/IYsN/sug="}]} \ No newline at end of file diff --git a/legacy_v2_tests/test_debug_utils.approvals/test_legacy_build_teal_sourcemaps_without_sources.approved.txt b/legacy_v2_tests/test_debug_utils.approvals/test_legacy_build_teal_sourcemaps_without_sources.approved.txt deleted file mode 100644 index bdedcb69..00000000 --- a/legacy_v2_tests/test_debug_utils.approvals/test_legacy_build_teal_sourcemaps_without_sources.approved.txt +++ /dev/null @@ -1 +0,0 @@ -{"txn-group-sources": [{"sourcemap-location": "dummy", "hash": "EC1P8unO+zjVbdF8XZOs1rp+uaGNk7vXtZ/IYsN/sug="}, {"sourcemap-location": "dummy", "hash": "EC1P8unO+zjVbdF8XZOs1rp+uaGNk7vXtZ/IYsN/sug="}]} \ No newline at end of file diff --git a/legacy_v2_tests/test_debug_utils.py b/legacy_v2_tests/test_debug_utils.py deleted file mode 100644 index 13b4f518..00000000 --- a/legacy_v2_tests/test_debug_utils.py +++ /dev/null @@ -1,159 +0,0 @@ -import json -from typing import TYPE_CHECKING -from unittest.mock import Mock - -import pytest -from algosdk.atomic_transaction_composer import ( - AccountTransactionSigner, - AtomicTransactionComposer, - TransactionWithSigner, -) -from algosdk.transaction import PaymentTxn - -from algokit_utils._debugging import ( - PersistSourceMapInput, - persist_sourcemaps, - simulate_and_persist_response, -) -from algokit_utils._legacy_v2.account import get_account -from algokit_utils._legacy_v2.application_client import ApplicationClient -from algokit_utils._legacy_v2.application_specification import ApplicationSpecification -from algokit_utils._legacy_v2.models import Account -from algokit_utils.common import Program -from legacy_v2_tests.conftest import get_unique_name - -if TYPE_CHECKING: - from algosdk.v2client.algod import AlgodClient - - -@pytest.fixture -def client_fixture(algod_client: "AlgodClient", app_spec: ApplicationSpecification) -> ApplicationClient: - creator_name = get_unique_name() - creator = get_account(algod_client, creator_name) - client = ApplicationClient(algod_client, app_spec, signer=creator) - create_response = client.create("create") - assert create_response.tx_id - return client - - -def test_legacy_build_teal_sourcemaps(algod_client: "AlgodClient", tmp_path_factory: pytest.TempPathFactory) -> None: - cwd = tmp_path_factory.mktemp("cwd") - - approval = """ -#pragma version 9 -int 1 -""" - clear = """ -#pragma version 9 -int 1 -""" - sources = [ - PersistSourceMapInput(raw_teal=approval, app_name="cool_app", file_name="approval.teal"), - PersistSourceMapInput(raw_teal=clear, app_name="cool_app", file_name="clear"), - ] - - persist_sourcemaps(sources=sources, project_root=cwd, client=algod_client) - - root_path = cwd / ".algokit" / "sources" - sourcemap_file_path = root_path / "sources.avm.json" - app_output_path = root_path / "cool_app" - - assert not (sourcemap_file_path).exists() - assert (app_output_path / "approval.teal").exists() - assert (app_output_path / "approval.teal.map").exists() - assert (app_output_path / "clear.teal").exists() - assert (app_output_path / "clear.teal.map").exists() - - -def test_legacy_build_teal_sourcemaps_without_sources( - algod_client: "AlgodClient", tmp_path_factory: pytest.TempPathFactory -) -> None: - cwd = tmp_path_factory.mktemp("cwd") - - approval = """ -#pragma version 9 -int 1 -""" - clear = """ -#pragma version 9 -int 1 -""" - compiled_approval = Program(approval, algod_client) - compiled_clear = Program(clear, algod_client) - sources = [ - PersistSourceMapInput(compiled_teal=compiled_approval, app_name="cool_app", file_name="approval.teal"), - PersistSourceMapInput(compiled_teal=compiled_clear, app_name="cool_app", file_name="clear"), - ] - - persist_sourcemaps(sources=sources, project_root=cwd, client=algod_client, with_sources=False) - - root_path = cwd / ".algokit" / "sources" - sourcemap_file_path = root_path / "sources.avm.json" - app_output_path = root_path / "cool_app" - - assert not (sourcemap_file_path).exists() - assert not (app_output_path / "approval.teal").exists() - assert (app_output_path / "approval.teal.map").exists() - assert json.loads((app_output_path / "approval.teal.map").read_text())["sources"] == [] - assert not (app_output_path / "clear.teal").exists() - assert (app_output_path / "clear.teal.map").exists() - assert json.loads((app_output_path / "clear.teal.map").read_text())["sources"] == [] - - -def test_legacy_simulate_and_persist_response_via_app_call( - tmp_path_factory: pytest.TempPathFactory, - client_fixture: ApplicationClient, - mocker: Mock, -) -> None: - mock_config = mocker.patch("algokit_utils._legacy_v2.application_client.config") - mock_config.debug = True - mock_config.trace_all = True - mock_config.trace_buffer_size_mb = 256 - cwd = tmp_path_factory.mktemp("cwd") - mock_config.project_root = cwd - - client_fixture.call("hello", name="test") - - output_path = cwd / "debug_traces" - - content = list(output_path.iterdir()) - assert len(list(output_path.iterdir())) == 1 - trace_file_content = json.loads(content[0].read_text()) - simulated_txn = trace_file_content["txn-groups"][0]["txn-results"][0]["txn-result"]["txn"]["txn"] - assert simulated_txn["type"] == "appl" - assert simulated_txn["apid"] == client_fixture.app_id - - -def test_legacy_simulate_and_persist_response( - tmp_path_factory: pytest.TempPathFactory, client_fixture: ApplicationClient, mocker: Mock, funded_account: Account -) -> None: - mock_config = mocker.patch("algokit_utils._legacy_v2.application_client.config") - mock_config.debug = True - mock_config.trace_all = True - cwd = tmp_path_factory.mktemp("cwd") - mock_config.project_root = cwd - - payment = PaymentTxn( - sender=funded_account.address, - receiver=client_fixture.app_address, - amt=1_000_000, - note=b"Payment", - sp=client_fixture.algod_client.suggested_params(), - ) # type: ignore[no-untyped-call] - txn_with_signer = TransactionWithSigner(payment, AccountTransactionSigner(funded_account.private_key)) - atc = AtomicTransactionComposer() - atc.add_transaction(txn_with_signer) - - simulate_and_persist_response(atc, cwd, client_fixture.algod_client) - - output_path = cwd / "debug_traces" - content = list(output_path.iterdir()) - assert len(list(output_path.iterdir())) == 1 - trace_file_content = json.loads(content[0].read_text()) - simulated_txn = trace_file_content["txn-groups"][0]["txn-results"][0]["txn-result"]["txn"]["txn"] - assert simulated_txn["type"] == "pay" - - trace_file_path = content[0] - while trace_file_path.exists(): - tmp_atc = atc.clone() - simulate_and_persist_response(tmp_atc, cwd, client_fixture.algod_client, buffer_size_mb=0.01) diff --git a/legacy_v2_tests/test_deploy.approvals/test_comment_stripping.approved.txt b/legacy_v2_tests/test_deploy.approvals/test_comment_stripping.approved.txt deleted file mode 100644 index 3795ccbf..00000000 --- a/legacy_v2_tests/test_deploy.approvals/test_comment_stripping.approved.txt +++ /dev/null @@ -1,30 +0,0 @@ - - -op arg -op "arg" -op "//" -op " //comment " -op "\" //" -op "// \" //" -op "" - -op 123 -op 123 -op "" -op "//" -op "//" -pushbytes base64(//8=) -pushbytes b64(//8=) - -pushbytes base64(//8=) -pushbytes b64(//8=) -pushbytes "base64(//8=)" -pushbytes "b64(//8=)" - -pushbytes base64 //8= -pushbytes b64 //8= - -pushbytes base64 //8= -pushbytes b64 //8= -pushbytes "base64 //8=" -pushbytes "b64 //8=" diff --git a/legacy_v2_tests/test_deploy.approvals/test_template_substitution.approved.txt b/legacy_v2_tests/test_deploy.approvals/test_template_substitution.approved.txt deleted file mode 100644 index 6cbde085..00000000 --- a/legacy_v2_tests/test_deploy.approvals/test_template_substitution.approved.txt +++ /dev/null @@ -1,21 +0,0 @@ - -test 123 // TMPL_INT -test 123 -no change -test 0x414243 // TMPL_STR -0x414243 -0x414243 // TMPL_INT -0x414243 // foo // -0x414243 // bar -test "TMPL_STR" // not replaced -test "TMPL_STRING" // not replaced -test TMPL_STRING // not replaced -test TMPL_STRI // not replaced -test 0x414243 123 123 0x414243 // TMPL_STR TMPL_INT TMPL_INT TMPL_STR -test 123 0x414243 TMPL_STRING "TMPL_INT TMPL_STR TMPL_STRING" //TMPL_INT TMPL_STR TMPL_STRING -test 123 123 TMPL_STRING TMPL_STRING TMPL_STRING 123 TMPL_STRING //keep -0x414243 0x414243 0x414243 -TMPL_STRING -test NOTTMPL_STR // not replaced -NOTTMPL_STR // not replaced -0x414243 // replaced \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy.py b/legacy_v2_tests/test_deploy.py deleted file mode 100644 index 4d2cf8c0..00000000 --- a/legacy_v2_tests/test_deploy.py +++ /dev/null @@ -1,69 +0,0 @@ -from algokit_utils import ( - replace_template_variables, -) -from algokit_utils._legacy_v2.deploy import strip_comments -from legacy_v2_tests.conftest import check_output_stability - - -def test_template_substitution() -> None: - program = """ -test TMPL_INT // TMPL_INT -test TMPL_INT -no change -test TMPL_STR // TMPL_STR -TMPL_STR -TMPL_STR // TMPL_INT -TMPL_STR // foo // -TMPL_STR // bar -test "TMPL_STR" // not replaced -test "TMPL_STRING" // not replaced -test TMPL_STRING // not replaced -test TMPL_STRI // not replaced -test TMPL_STR TMPL_INT TMPL_INT TMPL_STR // TMPL_STR TMPL_INT TMPL_INT TMPL_STR -test TMPL_INT TMPL_STR TMPL_STRING "TMPL_INT TMPL_STR TMPL_STRING" //TMPL_INT TMPL_STR TMPL_STRING -test TMPL_INT TMPL_INT TMPL_STRING TMPL_STRING TMPL_STRING TMPL_INT TMPL_STRING //keep -TMPL_STR TMPL_STR TMPL_STR -TMPL_STRING -test NOTTMPL_STR // not replaced -NOTTMPL_STR // not replaced -TMPL_STR // replaced -""" - result = replace_template_variables(program, {"INT": 123, "STR": "ABC"}) - check_output_stability(result) - - -def test_comment_stripping() -> None: - program = r""" -//comment -op arg //comment -op "arg" //comment -op "//" //comment -op " //comment " //comment -op "\" //" //comment -op "// \" //" //comment -op "" //comment -// -op 123 -op 123 // something -op "" // more comments -op "//" //op "//" -op "//" -pushbytes base64(//8=) -pushbytes b64(//8=) - -pushbytes base64(//8=) // pushbytes base64(//8=) -pushbytes b64(//8=) // pushbytes b64(//8=) -pushbytes "base64(//8=)" // pushbytes "base64(//8=)" -pushbytes "b64(//8=)" // pushbytes "b64(//8=)" - -pushbytes base64 //8= -pushbytes b64 //8= - -pushbytes base64 //8= // pushbytes base64 //8= -pushbytes b64 //8= // pushbytes b64 //8= -pushbytes "base64 //8=" // pushbytes "base64 //8=" -pushbytes "b64 //8=" // pushbytes "b64 //8=" - -""" - result = strip_comments(program) - check_output_stability(result) diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_immutable_app_and_on_update_equals_replace_app_succeeds.approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_immutable_app_and_on_update_equals_replace_app_succeeds.approved.txt deleted file mode 100644 index c3bd7846..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_immutable_app_and_on_update_equals_replace_app_succeeds.approved.txt +++ /dev/null @@ -1,8 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -INFO: Detected a TEAL update in app id {app0} -WARNING: App is not updatable and on_update=ReplaceApp, will attempt to create new app and delete old app -INFO: Replacing SampleApp (1.0) with SampleApp (2.0) in {creator_account} account. -INFO: SampleApp (2.0) deployed successfully, with app id {app1}. -INFO: SampleApp (1.0) with app id {app0}, deleted successfully. \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_immutable_app_cannot_determine_if_updatable.approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_immutable_app_cannot_determine_if_updatable.approved.txt deleted file mode 100644 index 9e2b5d81..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_immutable_app_cannot_determine_if_updatable.approved.txt +++ /dev/null @@ -1,7 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (v1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=v1.0. -INFO: Detected a TEAL update in app id {app0} -WARNING: Cannot determine if App is updatable and on_update=UpdateApp, will attempt to update app -INFO: Updating SampleApp to v1.1 in {creator_account} account, with app id {app0} -ERROR: LogicError: assert failed pc=140 \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_immutable_app_fails.approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_immutable_app_fails.approved.txt deleted file mode 100644 index e727a83d..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_immutable_app_fails.approved.txt +++ /dev/null @@ -1,7 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -INFO: Detected a TEAL update in app id {app0} -WARNING: App is not updatable but on_update=UpdateApp, will attempt to update app, update will most likely fail -INFO: Updating SampleApp to 2.0 in {creator_account} account, with app id {app0} -ERROR: LogicException: assert failed pc=140 \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_permanent_app_and_on_schema_break_equals_replace_app_fails.approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_permanent_app_and_on_schema_break_equals_replace_app_fails.approved.txt deleted file mode 100644 index 9f4a0361..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_permanent_app_and_on_schema_break_equals_replace_app_fails.approved.txt +++ /dev/null @@ -1,7 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -WARNING: Detected a breaking app schema change: Global uints increased from 0 to 1 -WARNING: App is not deletable but on_schema_break=ReplaceApp, will attempt to delete app, delete will most likely fail -INFO: Replacing SampleApp (1.0) with SampleApp (3.0) in {creator_account} account. -ERROR: Deployment failed: assert failed pc=153 \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_permanent_app_cannot_determine_if_deletable.approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_permanent_app_cannot_determine_if_deletable.approved.txt deleted file mode 100644 index 0a8b6e1c..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_permanent_app_cannot_determine_if_deletable.approved.txt +++ /dev/null @@ -1,7 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (v1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=v1.0. -INFO: Detected a TEAL update in app id {app0} -WARNING: Cannot determine if App is updatable and on_update=ReplaceApp, will attempt to create new app and delete old app -INFO: Replacing SampleApp (v1.0) with SampleApp (v1.1) in {creator_account} account. -ERROR: LogicError: assert failed pc=153 \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_permanent_app_fails.approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_permanent_app_fails.approved.txt deleted file mode 100644 index cc5ea20d..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_permanent_app_fails.approved.txt +++ /dev/null @@ -1,5 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -WARNING: Detected a breaking app schema change: Global uints increased from 0 to 1 -ERROR: DeploymentFailedError: Schema break detected and on_schema_break=OnSchemaBreak.Fail, stopping deployment. If you want to try deleting and recreating the app then re-run with on_schema_break=OnSchemaBreak.ReplaceApp \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_permanent_app_on_update_equals_replace_app_fails_and_doesnt_create_2nd_app.approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_permanent_app_on_update_equals_replace_app_fails_and_doesnt_create_2nd_app.approved.txt deleted file mode 100644 index 36a5dfb3..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_permanent_app_on_update_equals_replace_app_fails_and_doesnt_create_2nd_app.approved.txt +++ /dev/null @@ -1,7 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -INFO: Detected a TEAL update in app id {app0} -WARNING: App is not updatable and on_update=ReplaceApp, will attempt to create new app and delete old app -INFO: Replacing SampleApp (1.0) with SampleApp (3.0) in {creator_account} account. -ERROR: DeploymentFailedError: assert failed pc=153 \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_updatable_app_succeeds.approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_updatable_app_succeeds.approved.txt deleted file mode 100644 index fd5abed5..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_existing_updatable_app_succeeds.approved.txt +++ /dev/null @@ -1,6 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -INFO: Detected a TEAL update in app id {app0} -INFO: App is updatable and on_update=UpdateApp, will update app -INFO: Updating SampleApp to 2.0 in {creator_account} account, with app id {app0} \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_no_existing_app_succeeds.approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_no_existing_app_succeeds.approved.txt deleted file mode 100644 index cfc36339..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_app_with_no_existing_app_succeeds.approved.txt +++ /dev/null @@ -1,2 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_templated_app_with_changing_parameters_succeeds.approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_templated_app_with_changing_parameters_succeeds.approved.txt deleted file mode 100644 index 188bdb14..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_templated_app_with_changing_parameters_succeeds.approved.txt +++ /dev/null @@ -1,26 +0,0 @@ -INFO: Deploy V1 as updatable, deletable -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1) deployed successfully, with app id {app0}. -INFO: Called hello: Hello, call_1 -INFO: Deploy V2 as immutable, deletable -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1. -INFO: Detected a TEAL update in app id {app0} -INFO: App is updatable and on_update=UpdateApp, will update app -INFO: Updating SampleApp to 2 in {creator_account} account, with app id {app0} -INFO: Called hello: Hello, call_2 -INFO: Attempt to deploy V3 as updatable, deletable, it will fail because V2 was immutable -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=2. -INFO: Detected a TEAL update in app id {app0} -WARNING: App is not updatable but on_update=UpdateApp, will attempt to update app, update will most likely fail -INFO: Updating SampleApp to 3 in {creator_account} account, with app id {app0} -ERROR: LogicException: assert failed pc=140 -INFO: Called hello: Hello, call_3 -INFO: 2nd Attempt to deploy V3 as updatable, deletable, it will succeed as on_update=OnUpdate.DeleteApp -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=2. -INFO: Detected a TEAL update in app id {app0} -WARNING: App is not updatable and on_update=ReplaceApp, will attempt to create new app and delete old app -INFO: Replacing SampleApp (2) with SampleApp (4) in {creator_account} account. -INFO: SampleApp (4) deployed successfully, with app id {app2}. -INFO: SampleApp (2) with app id {app0}, deleted successfully. -INFO: Called hello: Hello, call_4 -INFO: Called hello: Hello, call_5 \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.Fail-Updatable.No-Deletable.No].approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.Fail-Updatable.No-Deletable.No].approved.txt deleted file mode 100644 index cc5ea20d..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.Fail-Updatable.No-Deletable.No].approved.txt +++ /dev/null @@ -1,5 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -WARNING: Detected a breaking app schema change: Global uints increased from 0 to 1 -ERROR: DeploymentFailedError: Schema break detected and on_schema_break=OnSchemaBreak.Fail, stopping deployment. If you want to try deleting and recreating the app then re-run with on_schema_break=OnSchemaBreak.ReplaceApp \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.Fail-Updatable.No-Deletable.Yes].approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.Fail-Updatable.No-Deletable.Yes].approved.txt deleted file mode 100644 index cc5ea20d..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.Fail-Updatable.No-Deletable.Yes].approved.txt +++ /dev/null @@ -1,5 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -WARNING: Detected a breaking app schema change: Global uints increased from 0 to 1 -ERROR: DeploymentFailedError: Schema break detected and on_schema_break=OnSchemaBreak.Fail, stopping deployment. If you want to try deleting and recreating the app then re-run with on_schema_break=OnSchemaBreak.ReplaceApp \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.Fail-Updatable.Yes-Deletable.No].approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.Fail-Updatable.Yes-Deletable.No].approved.txt deleted file mode 100644 index cc5ea20d..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.Fail-Updatable.Yes-Deletable.No].approved.txt +++ /dev/null @@ -1,5 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -WARNING: Detected a breaking app schema change: Global uints increased from 0 to 1 -ERROR: DeploymentFailedError: Schema break detected and on_schema_break=OnSchemaBreak.Fail, stopping deployment. If you want to try deleting and recreating the app then re-run with on_schema_break=OnSchemaBreak.ReplaceApp \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.Fail-Updatable.Yes-Deletable.Yes].approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.Fail-Updatable.Yes-Deletable.Yes].approved.txt deleted file mode 100644 index cc5ea20d..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.Fail-Updatable.Yes-Deletable.Yes].approved.txt +++ /dev/null @@ -1,5 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -WARNING: Detected a breaking app schema change: Global uints increased from 0 to 1 -ERROR: DeploymentFailedError: Schema break detected and on_schema_break=OnSchemaBreak.Fail, stopping deployment. If you want to try deleting and recreating the app then re-run with on_schema_break=OnSchemaBreak.ReplaceApp \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.ReplaceApp-Updatable.No-Deletable.No].approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.ReplaceApp-Updatable.No-Deletable.No].approved.txt deleted file mode 100644 index d6059fe8..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.ReplaceApp-Updatable.No-Deletable.No].approved.txt +++ /dev/null @@ -1,7 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -WARNING: Detected a breaking app schema change: Global uints increased from 0 to 1 -WARNING: App is not deletable but on_schema_break=ReplaceApp, will attempt to delete app, delete will most likely fail -INFO: Replacing SampleApp (1.0) with SampleApp (3.0) in {creator_account} account. -ERROR: LogicException: assert failed pc=153 \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.ReplaceApp-Updatable.No-Deletable.Yes].approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.ReplaceApp-Updatable.No-Deletable.Yes].approved.txt deleted file mode 100644 index 5ffb7726..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.ReplaceApp-Updatable.No-Deletable.Yes].approved.txt +++ /dev/null @@ -1,8 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -WARNING: Detected a breaking app schema change: Global uints increased from 0 to 1 -INFO: App is deletable and on_schema_break=ReplaceApp, will attempt to create new app and delete old app -INFO: Replacing SampleApp (1.0) with SampleApp (3.0) in {creator_account} account. -INFO: SampleApp (3.0) deployed successfully, with app id {app1}. -INFO: SampleApp (1.0) with app id {app0}, deleted successfully. \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.ReplaceApp-Updatable.Yes-Deletable.No].approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.ReplaceApp-Updatable.Yes-Deletable.No].approved.txt deleted file mode 100644 index d6059fe8..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.ReplaceApp-Updatable.Yes-Deletable.No].approved.txt +++ /dev/null @@ -1,7 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -WARNING: Detected a breaking app schema change: Global uints increased from 0 to 1 -WARNING: App is not deletable but on_schema_break=ReplaceApp, will attempt to delete app, delete will most likely fail -INFO: Replacing SampleApp (1.0) with SampleApp (3.0) in {creator_account} account. -ERROR: LogicException: assert failed pc=153 \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.ReplaceApp-Updatable.Yes-Deletable.Yes].approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.ReplaceApp-Updatable.Yes-Deletable.Yes].approved.txt deleted file mode 100644 index 5ffb7726..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change[OnSchemaBreak.ReplaceApp-Updatable.Yes-Deletable.Yes].approved.txt +++ /dev/null @@ -1,8 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -WARNING: Detected a breaking app schema change: Global uints increased from 0 to 1 -INFO: App is deletable and on_schema_break=ReplaceApp, will attempt to create new app and delete old app -INFO: Replacing SampleApp (1.0) with SampleApp (3.0) in {creator_account} account. -INFO: SampleApp (3.0) deployed successfully, with app id {app1}. -INFO: SampleApp (1.0) with app id {app0}, deleted successfully. \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change_append.approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change_append.approved.txt deleted file mode 100644 index f92153d7..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_schema_breaking_change_append.approved.txt +++ /dev/null @@ -1,6 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -WARNING: Detected a breaking app schema change: Global uints increased from 0 to 1 -INFO: Schema break detected and on_schema_break=AppendApp, will attempt to create new app -INFO: SampleApp (2.0) deployed successfully, with app id {app1}. \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.Fail-Updatable.No-Deletable.No].approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.Fail-Updatable.No-Deletable.No].approved.txt deleted file mode 100644 index e1ddf36d..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.Fail-Updatable.No-Deletable.No].approved.txt +++ /dev/null @@ -1,5 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -INFO: Detected a TEAL update in app id {app0} -ERROR: DeploymentFailedError: Update detected and on_update=Fail, stopping deployment. If you want to try updating the app then re-run with on_update=UpdateApp \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.Fail-Updatable.No-Deletable.Yes].approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.Fail-Updatable.No-Deletable.Yes].approved.txt deleted file mode 100644 index e1ddf36d..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.Fail-Updatable.No-Deletable.Yes].approved.txt +++ /dev/null @@ -1,5 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -INFO: Detected a TEAL update in app id {app0} -ERROR: DeploymentFailedError: Update detected and on_update=Fail, stopping deployment. If you want to try updating the app then re-run with on_update=UpdateApp \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.Fail-Updatable.Yes-Deletable.No].approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.Fail-Updatable.Yes-Deletable.No].approved.txt deleted file mode 100644 index e1ddf36d..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.Fail-Updatable.Yes-Deletable.No].approved.txt +++ /dev/null @@ -1,5 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -INFO: Detected a TEAL update in app id {app0} -ERROR: DeploymentFailedError: Update detected and on_update=Fail, stopping deployment. If you want to try updating the app then re-run with on_update=UpdateApp \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.Fail-Updatable.Yes-Deletable.Yes].approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.Fail-Updatable.Yes-Deletable.Yes].approved.txt deleted file mode 100644 index e1ddf36d..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.Fail-Updatable.Yes-Deletable.Yes].approved.txt +++ /dev/null @@ -1,5 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -INFO: Detected a TEAL update in app id {app0} -ERROR: DeploymentFailedError: Update detected and on_update=Fail, stopping deployment. If you want to try updating the app then re-run with on_update=UpdateApp \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.ReplaceApp-Updatable.No-Deletable.No].approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.ReplaceApp-Updatable.No-Deletable.No].approved.txt deleted file mode 100644 index fc376b25..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.ReplaceApp-Updatable.No-Deletable.No].approved.txt +++ /dev/null @@ -1,7 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -INFO: Detected a TEAL update in app id {app0} -WARNING: App is not updatable and on_update=ReplaceApp, will attempt to create new app and delete old app -INFO: Replacing SampleApp (1.0) with SampleApp (2.0) in {creator_account} account. -ERROR: LogicException: assert failed pc=153 \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.ReplaceApp-Updatable.No-Deletable.Yes].approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.ReplaceApp-Updatable.No-Deletable.Yes].approved.txt deleted file mode 100644 index c3bd7846..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.ReplaceApp-Updatable.No-Deletable.Yes].approved.txt +++ /dev/null @@ -1,8 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -INFO: Detected a TEAL update in app id {app0} -WARNING: App is not updatable and on_update=ReplaceApp, will attempt to create new app and delete old app -INFO: Replacing SampleApp (1.0) with SampleApp (2.0) in {creator_account} account. -INFO: SampleApp (2.0) deployed successfully, with app id {app1}. -INFO: SampleApp (1.0) with app id {app0}, deleted successfully. \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.ReplaceApp-Updatable.Yes-Deletable.No].approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.ReplaceApp-Updatable.Yes-Deletable.No].approved.txt deleted file mode 100644 index 9041e080..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.ReplaceApp-Updatable.Yes-Deletable.No].approved.txt +++ /dev/null @@ -1,7 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -INFO: Detected a TEAL update in app id {app0} -WARNING: App is updatable but on_update=ReplaceApp, will attempt to create new app and delete old app -INFO: Replacing SampleApp (1.0) with SampleApp (2.0) in {creator_account} account. -ERROR: LogicException: assert failed pc=153 \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.ReplaceApp-Updatable.Yes-Deletable.Yes].approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.ReplaceApp-Updatable.Yes-Deletable.Yes].approved.txt deleted file mode 100644 index d9c61406..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.ReplaceApp-Updatable.Yes-Deletable.Yes].approved.txt +++ /dev/null @@ -1,8 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -INFO: Detected a TEAL update in app id {app0} -WARNING: App is updatable but on_update=ReplaceApp, will attempt to create new app and delete old app -INFO: Replacing SampleApp (1.0) with SampleApp (2.0) in {creator_account} account. -INFO: SampleApp (2.0) deployed successfully, with app id {app1}. -INFO: SampleApp (1.0) with app id {app0}, deleted successfully. \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.UpdateApp-Updatable.No-Deletable.No].approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.UpdateApp-Updatable.No-Deletable.No].approved.txt deleted file mode 100644 index e727a83d..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.UpdateApp-Updatable.No-Deletable.No].approved.txt +++ /dev/null @@ -1,7 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -INFO: Detected a TEAL update in app id {app0} -WARNING: App is not updatable but on_update=UpdateApp, will attempt to update app, update will most likely fail -INFO: Updating SampleApp to 2.0 in {creator_account} account, with app id {app0} -ERROR: LogicException: assert failed pc=140 \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.UpdateApp-Updatable.No-Deletable.Yes].approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.UpdateApp-Updatable.No-Deletable.Yes].approved.txt deleted file mode 100644 index e727a83d..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.UpdateApp-Updatable.No-Deletable.Yes].approved.txt +++ /dev/null @@ -1,7 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -INFO: Detected a TEAL update in app id {app0} -WARNING: App is not updatable but on_update=UpdateApp, will attempt to update app, update will most likely fail -INFO: Updating SampleApp to 2.0 in {creator_account} account, with app id {app0} -ERROR: LogicException: assert failed pc=140 \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.UpdateApp-Updatable.Yes-Deletable.No].approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.UpdateApp-Updatable.Yes-Deletable.No].approved.txt deleted file mode 100644 index fd5abed5..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.UpdateApp-Updatable.Yes-Deletable.No].approved.txt +++ /dev/null @@ -1,6 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -INFO: Detected a TEAL update in app id {app0} -INFO: App is updatable and on_update=UpdateApp, will update app -INFO: Updating SampleApp to 2.0 in {creator_account} account, with app id {app0} \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.UpdateApp-Updatable.Yes-Deletable.Yes].approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.UpdateApp-Updatable.Yes-Deletable.Yes].approved.txt deleted file mode 100644 index fd5abed5..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update[OnUpdate.UpdateApp-Updatable.Yes-Deletable.Yes].approved.txt +++ /dev/null @@ -1,6 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -INFO: Detected a TEAL update in app id {app0} -INFO: App is updatable and on_update=UpdateApp, will update app -INFO: Updating SampleApp to 2.0 in {creator_account} account, with app id {app0} \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update_append.approved.txt b/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update_append.approved.txt deleted file mode 100644 index 28975efd..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.approvals/test_deploy_with_update_append.approved.txt +++ /dev/null @@ -1,6 +0,0 @@ -INFO: SampleApp not found in {creator_account} account, deploying app. -INFO: SampleApp (1.0) deployed successfully, with app id {app0}. -DEBUG: SampleApp found in {creator_account} account, with app id {app0}, version=1.0. -INFO: Detected a TEAL update in app id {app0} -INFO: Update detected and on_update=AppendApp, will attempt to create new app -INFO: SampleApp (2.0) deployed successfully, with app id {app1}. \ No newline at end of file diff --git a/legacy_v2_tests/test_deploy_scenarios.py b/legacy_v2_tests/test_deploy_scenarios.py deleted file mode 100644 index c230ce37..00000000 --- a/legacy_v2_tests/test_deploy_scenarios.py +++ /dev/null @@ -1,448 +0,0 @@ -import logging -import re -import time -from collections.abc import Generator -from enum import Enum -from unittest.mock import Mock, patch - -import pytest - -from algokit_utils import ( - Account, - ApplicationClient, - ApplicationSpecification, - DeploymentFailedError, - LogicError, - OnSchemaBreak, - OnUpdate, - get_account, - get_algod_client, - get_indexer_client, - get_localnet_default_account, -) -from legacy_v2_tests.conftest import check_output_stability, get_specs, get_unique_name, read_spec - -logger = logging.getLogger(__name__) - - -# This fixture is automatically applied to all application deployment tests. -# If you need to run a test without debug mode, you can reference this mock within the test and disable it explicitly. -@pytest.fixture(autouse=True) -def mock_config(tmp_path_factory: pytest.TempPathFactory) -> Generator[Mock, None, None]: - with patch("algokit_utils._legacy_v2.application_client.config", new_callable=Mock) as mock_config: - mock_config.debug = True - cwd = tmp_path_factory.mktemp("cwd") - mock_config.project_root = cwd - mock_config.trace_all = True - mock_config.trace_buffer_size_mb = 256 - yield mock_config - - -class DeployFixture: - def __init__( - self, - *, - caplog: pytest.LogCaptureFixture, - request: pytest.FixtureRequest, - creator_name: str, - creator: Account, - ): - self.app_ids: list[int] = [] - self.caplog = caplog - self.request = request - self.algod_client = get_algod_client() - self.indexer_client = get_indexer_client() - self.creator_name = creator_name - self.creator = creator - self.app_name = get_unique_name() - - def deploy( - self, - app_spec: ApplicationSpecification, - *, - version: str | None = None, - on_update: OnUpdate = OnUpdate.UpdateApp, - on_schema_break: OnSchemaBreak = OnSchemaBreak.Fail, - allow_delete: bool | None = None, - allow_update: bool | None = None, - ) -> ApplicationClient: - app_client = ApplicationClient( - self.algod_client, - app_spec, - indexer_client=self.indexer_client, - creator=self.creator, - app_name=self.app_name, - ) - response = app_client.deploy( - version=version, - on_update=on_update, - on_schema_break=on_schema_break, - allow_update=allow_update, - allow_delete=allow_delete, - ) - self._wait_for_indexer_round(response.app.updated_round) - self.app_ids.append(app_client.app_id) - return app_client - - def check_log_stability(self, replacements: dict[str, str] | None = None, suffix: str = "") -> None: - if replacements is None: - replacements = {} - replacements[self.app_name] = "SampleApp" - records = self.caplog.get_records("call") - logs = "\n".join(f"{r.levelname}: {r.message}" for r in records) - logs = self._normalize_logs(logs) - for find, replace in (replacements or {}).items(): - logs = logs.replace(find, replace) - check_output_stability(logs, test_name=self.request.node.name + suffix) - - def _normalize_logs(self, logs: str) -> str: - dispenser = get_localnet_default_account(self.algod_client) - logs = logs.replace(self.creator_name, "{creator}") - logs = logs.replace(self.creator.address, "{creator_account}") - logs = logs.replace(dispenser.address, "{dispenser_account}") - for index, app_id in enumerate(self.app_ids): - logs = logs.replace(f"app id {app_id}", f"app id {{app{index}}}") - return re.sub(r"app id \d+", r"{appN_failed}", logs) - - def _wait_for_indexer_round(self, round_target: int, max_attempts: int = 100) -> None: - for _ in range(max_attempts): - health = self.indexer_client.health() # type: ignore[no-untyped-call] - - if health["round"] >= round_target: - break - - # With v3 indexer a small delay is needed - # not to exhaust attempts before target round is reached - # NOTE: setting lower timeout may result in algod throttling - # if run concurrently via pytest-xdist (which causes inconsistent snapshots) - time.sleep(1) - - -@pytest.fixture(scope="module") -def creator_name() -> str: - return get_unique_name() - - -@pytest.fixture(scope="module") -def creator(creator_name: str) -> Account: - return get_account(get_algod_client(), creator_name) - - -@pytest.fixture -def app_name() -> str: - return get_unique_name() - - -@pytest.fixture -def deploy_fixture( - caplog: pytest.LogCaptureFixture, request: pytest.FixtureRequest, creator_name: str, creator: Account -) -> DeployFixture: - caplog.set_level(logging.DEBUG) - return DeployFixture(caplog=caplog, request=request, creator_name=creator_name, creator=creator) - - -def test_deploy_app_with_no_existing_app_succeeds(deploy_fixture: DeployFixture) -> None: - v1, _, _ = get_specs() - - app = deploy_fixture.deploy(v1, version="1.0", allow_update=False, allow_delete=False) - - assert app.app_id - deploy_fixture.check_log_stability() - - -def test_deploy_app_with_existing_updatable_app_succeeds(deploy_fixture: DeployFixture) -> None: - v1, v2, _ = get_specs() - - app_v1 = deploy_fixture.deploy(v1, version="1.0", allow_update=True, allow_delete=False) - assert app_v1.app_id - - app_v2 = deploy_fixture.deploy(v2, version="2.0", allow_update=True, allow_delete=False) - - assert app_v1.app_id == app_v2.app_id - deploy_fixture.check_log_stability() - - -def test_deploy_app_with_existing_immutable_app_fails(deploy_fixture: DeployFixture) -> None: - v1, v2, _ = get_specs() - - app_v1 = deploy_fixture.deploy(v1, version="1.0", allow_update=False, allow_delete=False) - assert app_v1.app_id - - with pytest.raises(LogicError) as error: - deploy_fixture.deploy(v2, version="2.0", allow_update=False, allow_delete=False) - logger.error(f"LogicException: {error.value.message}") - - deploy_fixture.check_log_stability() - - -def test_deploy_app_with_existing_immutable_app_and_on_update_equals_replace_app_succeeds( - deploy_fixture: DeployFixture, -) -> None: - v1, v2, _ = get_specs() - - app_v1 = deploy_fixture.deploy(v1, version="1.0", allow_update=False, allow_delete=True) - assert app_v1.app_id - - app_v2 = deploy_fixture.deploy( - v2, version="2.0", allow_update=False, allow_delete=True, on_update=OnUpdate.ReplaceApp - ) - - assert app_v1.app_id != app_v2.app_id - deploy_fixture.check_log_stability() - - -def test_deploy_app_with_existing_permanent_app_fails(deploy_fixture: DeployFixture) -> None: - v1, _, v3 = get_specs() - - app_v1 = deploy_fixture.deploy(v1, version="1.0", allow_update=False, allow_delete=False) - assert app_v1.app_id - - with pytest.raises(DeploymentFailedError) as error: - deploy_fixture.deploy(v3, version="3.0", allow_update=False, allow_delete=False) - logger.error(f"DeploymentFailedError: {error.value}") - deploy_fixture.check_log_stability() - - -def test_deploy_app_with_existing_immutable_app_cannot_determine_if_updatable(deploy_fixture: DeployFixture) -> None: - v1, v2, _ = get_specs(updatable=False, deletable=False) - - app_v1 = deploy_fixture.deploy(v1) - assert app_v1.app_id - - with pytest.raises(LogicError) as error: - deploy_fixture.deploy(v2, on_update=OnUpdate.UpdateApp) - logger.error(f"LogicError: {error.value.message}") - deploy_fixture.check_log_stability() - - -def test_deploy_app_with_existing_permanent_app_cannot_determine_if_deletable(deploy_fixture: DeployFixture) -> None: - v1, v2, _ = get_specs(updatable=False, deletable=False) - - app_v1 = deploy_fixture.deploy(v1) - assert app_v1.app_id - - with pytest.raises(LogicError) as error: - deploy_fixture.deploy(v2, on_update=OnUpdate.ReplaceApp) - logger.error(f"LogicError: {error.value.message}") - deploy_fixture.check_log_stability() - - -def test_deploy_app_with_existing_permanent_app_on_update_equals_replace_app_fails_and_doesnt_create_2nd_app( - deploy_fixture: DeployFixture, -) -> None: - v1, v2, _ = get_specs() - - app_v1 = deploy_fixture.deploy(v1, version="1.0", allow_update=False, allow_delete=False) - assert app_v1.app_id - - apps_before = deploy_fixture.indexer_client.lookup_account_application_by_creator(deploy_fixture.creator.address) # type: ignore[no-untyped-call] - - with pytest.raises(LogicError) as error: - deploy_fixture.deploy(v2, version="3.0", allow_update=False, allow_delete=False, on_update=OnUpdate.ReplaceApp) - apps_after = deploy_fixture.indexer_client.lookup_account_application_by_creator(deploy_fixture.creator.address) # type: ignore[no-untyped-call] - - # ensure no other apps were created - assert len(apps_before["applications"]) == len(apps_after["applications"]) - - logger.error(f"DeploymentFailedError: {error.value.message}") - deploy_fixture.check_log_stability() - - -def test_deploy_app_with_existing_permanent_app_and_on_schema_break_equals_replace_app_fails( - deploy_fixture: DeployFixture, -) -> None: - v1, _, v3 = get_specs() - - app_v1 = deploy_fixture.deploy(v1, allow_update=False, allow_delete=False, version="1.0") - assert app_v1.app_id - - with pytest.raises(LogicError) as exc_info: - deploy_fixture.deploy( - v3, allow_update=False, allow_delete=False, version="3.0", on_schema_break=OnSchemaBreak.ReplaceApp - ) - - logger.error(f"Deployment failed: {exc_info.value.message}") - - deploy_fixture.check_log_stability() - - -def test_deploy_templated_app_with_changing_parameters_succeeds(deploy_fixture: DeployFixture) -> None: - app_spec = read_spec("app_v1.json") - - logger.info("Deploy V1 as updatable, deletable") - app_client = deploy_fixture.deploy( - app_spec, - version="1", - allow_delete=True, - allow_update=True, - ) - - response = app_client.call("hello", name="call_1") - logger.info(f"Called hello: {response.return_value}") - - logger.info("Deploy V2 as immutable, deletable") - app_client = deploy_fixture.deploy( - app_spec, - allow_delete=True, - allow_update=False, - ) - - response = app_client.call("hello", name="call_2") - logger.info(f"Called hello: {response.return_value}") - - logger.info("Attempt to deploy V3 as updatable, deletable, it will fail because V2 was immutable") - with pytest.raises(LogicError) as exc_info: - # try to make it updatable again - deploy_fixture.deploy( - app_spec, - allow_delete=True, - allow_update=True, - ) - - logger.error(f"LogicException: {exc_info.value.message}") - response = app_client.call("hello", name="call_3") - logger.info(f"Called hello: {response.return_value}") - - logger.info("2nd Attempt to deploy V3 as updatable, deletable, it will succeed as on_update=OnUpdate.DeleteApp") - # deploy with allow_delete=True, so we can replace it - app_client = deploy_fixture.deploy( - app_spec, - version="4", - on_update=OnUpdate.ReplaceApp, - allow_delete=True, - allow_update=True, - ) - response = app_client.call("hello", name="call_4") - logger.info(f"Called hello: {response.return_value}") - app_id = app_client.app_id - - app_client = ApplicationClient( - deploy_fixture.algod_client, - app_spec, - app_id=app_id, - signer=deploy_fixture.creator, - ) - response = app_client.call("hello", name="call_5") - logger.info(f"Called hello: {response.return_value}") - - deploy_fixture.check_log_stability() - - -class Deletable(Enum): - No = 0 - Yes = 1 - - -class Updatable(Enum): - No = 0 - Yes = 1 - - -@pytest.mark.parametrize("deletable", [Deletable.No, Deletable.Yes]) -@pytest.mark.parametrize("updatable", [Updatable.No, Updatable.Yes]) -@pytest.mark.parametrize("on_schema_break", [OnSchemaBreak.Fail, OnSchemaBreak.ReplaceApp]) -def test_deploy_with_schema_breaking_change( - deploy_fixture: DeployFixture, - *, - deletable: Deletable, - updatable: Updatable, - on_schema_break: OnSchemaBreak, -) -> None: - v1, _, v3 = get_specs() - - app_v1 = deploy_fixture.deploy( - v1, version="1.0", allow_delete=deletable == Deletable.Yes, allow_update=updatable == Updatable.Yes - ) - assert app_v1.app_id - - try: - deploy_fixture.deploy( - v3, - version="3.0", - allow_delete=deletable == Deletable.Yes, - allow_update=updatable == Updatable.Yes, - on_schema_break=on_schema_break, - ) - except DeploymentFailedError as error: - logger.error(f"DeploymentFailedError: {error}") - except LogicError as error: - logger.error(f"LogicException: {error.message}") - - deploy_fixture.check_log_stability() - - -@pytest.mark.parametrize("deletable", [Deletable.No, Deletable.Yes]) -@pytest.mark.parametrize("updatable", [Updatable.No, Updatable.Yes]) -@pytest.mark.parametrize("on_update", [OnUpdate.Fail, OnUpdate.UpdateApp, OnUpdate.ReplaceApp]) -def test_deploy_with_update( - deploy_fixture: DeployFixture, - *, - deletable: Deletable, - updatable: Updatable, - on_update: OnUpdate, -) -> None: - v1, v2, _ = get_specs() - - app_v1 = deploy_fixture.deploy( - v1, version="1.0", allow_delete=deletable == Deletable.Yes, allow_update=updatable == Updatable.Yes - ) - assert app_v1.app_id - - try: - deploy_fixture.deploy( - v2, - version="2.0", - allow_delete=deletable == Deletable.Yes, - allow_update=updatable == Updatable.Yes, - on_update=on_update, - ) - except DeploymentFailedError as error: - logger.error(f"DeploymentFailedError: {error}") - except LogicError as error: - logger.error(f"LogicException: {error.message}") - - deploy_fixture.check_log_stability() - - -def test_deploy_with_schema_breaking_change_append(deploy_fixture: DeployFixture) -> None: - v1, _, v3 = get_specs() - - app_v1 = deploy_fixture.deploy(v1, version="1.0", allow_delete=False, allow_update=False) - assert app_v1.app_id - - try: - deploy_fixture.deploy( - v3, - version="2.0", - allow_delete=False, - allow_update=False, - on_schema_break=OnSchemaBreak.AppendApp, - ) - except DeploymentFailedError as error: - logger.error(f"DeploymentFailedError: {error}") - except LogicError as error: - logger.error(f"LogicException: {error.message}") - - deploy_fixture.check_log_stability() - - -def test_deploy_with_update_append(deploy_fixture: DeployFixture) -> None: - v1, v2, _ = get_specs() - - app_v1 = deploy_fixture.deploy(v1, version="1.0", allow_delete=False, allow_update=False) - assert app_v1.app_id - - try: - deploy_fixture.deploy( - v2, - version="2.0", - allow_delete=False, - allow_update=False, - on_update=OnUpdate.AppendApp, - ) - except DeploymentFailedError as error: - logger.error(f"DeploymentFailedError: {error}") - except LogicError as error: - logger.error(f"LogicException: {error.message}") - - deploy_fixture.check_log_stability() diff --git a/legacy_v2_tests/test_dispenser_api_client.py b/legacy_v2_tests/test_dispenser_api_client.py deleted file mode 100644 index ac7fa0f8..00000000 --- a/legacy_v2_tests/test_dispenser_api_client.py +++ /dev/null @@ -1,76 +0,0 @@ -import json - -import pytest -from pytest_httpx import HTTPXMock - -from algokit_utils.dispenser_api import ( - DISPENSER_ASSETS, - DispenserApiConfig, - DispenserAssetName, - TestNetDispenserApiClient, -) - - -class TestDispenserApiTestnetClient: - def test_fund_account_with_algos_with_auth_token(self, httpx_mock: HTTPXMock) -> None: - mock_response = {"txID": "dummy_tx_id", "amount": 1} - httpx_mock.add_response( - url=f"{DispenserApiConfig.BASE_URL}/fund/{DispenserAssetName.ALGO}", - method="POST", - json=mock_response, - ) - dispenser_client = TestNetDispenserApiClient(auth_token="dummy_auth_token") - address = "dummy_address" - amount = 1 - asset_id = DispenserAssetName.ALGO - response = dispenser_client.fund(address, amount, asset_id) - assert response.tx_id == "dummy_tx_id" - assert response.amount == 1 - - def test_register_refund_with_auth_token(self, httpx_mock: HTTPXMock) -> None: - httpx_mock.add_response( - url=f"{DispenserApiConfig.BASE_URL}/refund", - method="POST", - json={}, - ) - dispenser_client = TestNetDispenserApiClient(auth_token="dummy_auth_token") - refund_txn_id = "dummy_txn_id" - dispenser_client.refund(refund_txn_id) - assert len(httpx_mock.get_requests()) == 1 - request = httpx_mock.get_requests()[0] - assert request.method == "POST" - assert request.url.path == "/refund" - assert request.headers["Authorization"] == f"Bearer {dispenser_client.auth_token}" - assert json.loads(request.read().decode()) == {"refundTransactionID": refund_txn_id} - - def test_limit_with_auth_token(self, httpx_mock: HTTPXMock) -> None: - amount = 10000000 - mock_response = {"amount": amount} - httpx_mock.add_response( - url=f"{DispenserApiConfig.BASE_URL}/fund/{DISPENSER_ASSETS[DispenserAssetName.ALGO].asset_id}/limit", - method="GET", - json=mock_response, - ) - dispenser_client = TestNetDispenserApiClient("dummy_auth_token") - address = "dummy_address" - response = dispenser_client.get_limit(address) - assert response.amount == amount - - def test_dispenser_api_init(self) -> None: - with pytest.raises( - Exception, - match="Can't init AlgoKit TestNet Dispenser API client because neither environment variable", - ): - TestNetDispenserApiClient() - - def test_dispenser_api_init_with_ci_(self, monkeypatch: pytest.MonkeyPatch) -> None: - monkeypatch.setenv("ALGOKIT_DISPENSER_ACCESS_TOKEN", "test_value") - - client = TestNetDispenserApiClient() - assert client.auth_token == "test_value" - - def test_dispenser_api_init_with_ci_and_arg(self, monkeypatch: pytest.MonkeyPatch) -> None: - monkeypatch.setenv("ALGOKIT_DISPENSER_ACCESS_TOKEN", "test_value") - - client = TestNetDispenserApiClient("test_value_2") - assert client.auth_token == "test_value_2" diff --git a/legacy_v2_tests/test_network_clients.py b/legacy_v2_tests/test_network_clients.py deleted file mode 100644 index c0edcb65..00000000 --- a/legacy_v2_tests/test_network_clients.py +++ /dev/null @@ -1,49 +0,0 @@ -import os -from unittest import mock - -from algokit_utils import ( - get_algod_client, - get_algonode_config, - get_default_localnet_config, - get_indexer_client, -) - -DEFAULT_TOKEN = "a" * 64 - - -def test_localnet_algod() -> None: - algod_client = get_algod_client(get_default_localnet_config("algod")) - health_response = algod_client.health() - assert health_response is None - - -def test_localnet_indexer() -> None: - indexer_client = get_indexer_client(get_default_localnet_config("indexer")) - health_response = indexer_client.health() # type: ignore[no-untyped-call] - assert isinstance(health_response, dict) - - -@mock.patch.dict( - os.environ, - { - "ALGOD_SERVER": "https://testnet-api.algonode.cloud", - "ALGOD_PORT": "443", - "ALGOD_TOKEN": DEFAULT_TOKEN, - }, -) -def test_environment_config() -> None: - algod_client = get_algod_client() - - assert algod_client.algod_address == "https://testnet-api.algonode.cloud:443" - - -def test_cloudnode_algod_headers() -> None: - algod_client = get_algod_client(get_algonode_config("testnet", "algod", DEFAULT_TOKEN)) - - assert algod_client.headers == {"X-Algo-API-Token": DEFAULT_TOKEN} - - -def test_cloudnode_indexer_headers() -> None: - indexer_client = get_indexer_client(get_algonode_config("testnet", "indexer", DEFAULT_TOKEN)) - - assert indexer_client.headers == {"X-Indexer-API-Token": DEFAULT_TOKEN} diff --git a/legacy_v2_tests/test_transfer.approvals/test_transfer_algo_max_fee_fails.approved.txt b/legacy_v2_tests/test_transfer.approvals/test_transfer_algo_max_fee_fails.approved.txt deleted file mode 100644 index ebb60988..00000000 --- a/legacy_v2_tests/test_transfer.approvals/test_transfer_algo_max_fee_fails.approved.txt +++ /dev/null @@ -1 +0,0 @@ -Cancelled transaction due to high network congestion fees. Algorand suggested fees would cause this transaction to cost 1000 µALGOs. Cap for this transaction is 123 µALGOs. \ No newline at end of file diff --git a/legacy_v2_tests/test_transfer.approvals/test_transfer_asset_max_fee_fails.approved.txt b/legacy_v2_tests/test_transfer.approvals/test_transfer_asset_max_fee_fails.approved.txt deleted file mode 100644 index ebb60988..00000000 --- a/legacy_v2_tests/test_transfer.approvals/test_transfer_asset_max_fee_fails.approved.txt +++ /dev/null @@ -1 +0,0 @@ -Cancelled transaction due to high network congestion fees. Algorand suggested fees would cause this transaction to cost 1000 µALGOs. Cap for this transaction is 123 µALGOs. \ No newline at end of file diff --git a/legacy_v2_tests/test_transfer.py b/legacy_v2_tests/test_transfer.py deleted file mode 100644 index bc1530f7..00000000 --- a/legacy_v2_tests/test_transfer.py +++ /dev/null @@ -1,449 +0,0 @@ -from typing import TYPE_CHECKING - -import algosdk -import httpx -import pytest -from algosdk.atomic_transaction_composer import AccountTransactionSigner -from algosdk.transaction import PaymentTxn -from algosdk.util import algos_to_microalgos -from pytest_httpx import HTTPXMock - -from algokit_utils import ( - Account, - EnsureBalanceParameters, - EnsureFundedResponse, - TestNetDispenserApiClient, - TransferAssetParameters, - TransferParameters, - create_kmd_wallet_account, - ensure_funded, - get_dispenser_account, - opt_in, - transfer, - transfer_asset, -) -from algokit_utils.dispenser_api import DispenserApiConfig -from algokit_utils.network_clients import get_algod_client, get_algonode_config -from legacy_v2_tests.conftest import assure_funds, check_output_stability, generate_test_asset, get_unique_name -from legacy_v2_tests.test_network_clients import DEFAULT_TOKEN - -if TYPE_CHECKING: - from algosdk.kmd import KMDClient - from algosdk.v2client.algod import AlgodClient - - -MINIMUM_BALANCE = 100_000 # see https://dev.algorand.co/concepts/smart-contracts/costs-constraints#mbr - - -@pytest.fixture -def to_account(kmd_client: "KMDClient") -> Account: - return create_kmd_wallet_account(kmd_client, get_unique_name()) - - -@pytest.fixture -def rekeyed_from_account(algod_client: "AlgodClient", kmd_client: "KMDClient") -> Account: - account = create_kmd_wallet_account(kmd_client, get_unique_name()) - rekey_account = create_kmd_wallet_account(kmd_client, get_unique_name()) - - ensure_funded( - algod_client, - EnsureBalanceParameters( - account_to_fund=account, - min_spending_balance_micro_algos=300000, - min_funding_increment_micro_algos=1, - ), - ) - - rekey_txn = PaymentTxn( - sender=account.address, - receiver=account.address, - amt=0, - note="rekey account", - rekey_to=rekey_account.address, - sp=algod_client.suggested_params(), - ) # type: ignore[no-untyped-call] - signed_rekey_txn = rekey_txn.sign(account.private_key) # type: ignore[no-untyped-call] - algod_client.send_transaction(signed_rekey_txn) - - return Account(address=account.address, private_key=rekey_account.private_key) - - -@pytest.fixture -def transaction_signer_from_account( - kmd_client: "KMDClient", - algod_client: "AlgodClient", -) -> AccountTransactionSigner: - account = create_kmd_wallet_account(kmd_client, get_unique_name()) - - ensure_funded( - algod_client, - EnsureBalanceParameters( - account_to_fund=account, - min_spending_balance_micro_algos=300000, - min_funding_increment_micro_algos=1, - ), - ) - - return AccountTransactionSigner(private_key=account.private_key) - - -@pytest.fixture -def clawback_account(kmd_client: "KMDClient") -> Account: - return create_kmd_wallet_account(kmd_client, get_unique_name()) - - -def test_transfer_algo(algod_client: "AlgodClient", to_account: Account, funded_account: Account) -> None: - requested_amount = 100_000 - transfer( - algod_client, - TransferParameters( - from_account=funded_account, - to_address=to_account.address, - micro_algos=requested_amount, - ), - ) - - to_account_info = algod_client.account_info(to_account.address) - assert isinstance(to_account_info, dict) - actual_amount = to_account_info.get("amount") - assert actual_amount == requested_amount - - -def test_transfer_algo_rekey_account( - algod_client: "AlgodClient", to_account: Account, rekeyed_from_account: Account -) -> None: - requested_amount = 100_000 - transfer( - algod_client, - TransferParameters( - from_account=rekeyed_from_account, - to_address=to_account.address, - micro_algos=requested_amount, - ), - ) - - to_account_info = algod_client.account_info(to_account.address) - assert isinstance(to_account_info, dict) - actual_amount = to_account_info.get("amount") - assert actual_amount == requested_amount - - -def test_transfer_algo_transaction_signer_account( - algod_client: "AlgodClient", to_account: Account, transaction_signer_from_account: AccountTransactionSigner -) -> None: - requested_amount = 100_000 - transfer( - algod_client, - TransferParameters( - from_account=transaction_signer_from_account, - to_address=to_account.address, - micro_algos=requested_amount, - ), - ) - - to_account_info = algod_client.account_info(to_account.address) - assert isinstance(to_account_info, dict) - actual_amount = to_account_info.get("amount") - assert actual_amount == requested_amount - - -def test_transfer_algo_max_fee_fails(algod_client: "AlgodClient", to_account: Account, funded_account: Account) -> None: - requested_amount = 100_000 - max_fee = 123 - - with pytest.raises(Exception, match="Cancelled transaction due to high network congestion fees") as ex: - transfer( - algod_client, - TransferParameters( - from_account=funded_account, - to_address=to_account.address, - micro_algos=requested_amount, - max_fee_micro_algos=max_fee, - ), - ) - - check_output_stability(str(ex.value)) - - -def test_transfer_algo_fee(algod_client: "AlgodClient", to_account: Account, funded_account: Account) -> None: - requested_amount = 100_000 - fee = 1234 - txn = transfer( - algod_client, - TransferParameters( - from_account=funded_account, - to_address=to_account.address, - micro_algos=requested_amount, - fee_micro_algos=fee, - ), - ) - - assert txn.fee == fee - - -def test_transfer_asa_receiver_not_optin( - algod_client: "AlgodClient", to_account: Account, funded_account: Account -) -> None: - dummy_asset_id = generate_test_asset(algod_client, funded_account, 100) - with pytest.raises(algosdk.error.AlgodHTTPError, match="receiver error: must optin"): - transfer_asset( - algod_client, - TransferAssetParameters( - from_account=funded_account, - to_address=to_account.address, - asset_id=dummy_asset_id, - amount=5, - note=f"Transfer 5 assets wit id ${dummy_asset_id}", - ), - ) - - -def test_transfer_asa_asset_doesnt_exist( - algod_client: "AlgodClient", to_account: Account, funded_account: Account -) -> None: - dummy_asset_id = generate_test_asset(algod_client, funded_account, 100) - assure_funds(algod_client=algod_client, account=to_account) - opt_in(algod_client=algod_client, account=to_account, asset_ids=[dummy_asset_id]) - - with pytest.raises(algosdk.error.AlgodHTTPError, match="asset 1 missing from"): - transfer_asset( - algod_client, - TransferAssetParameters( - from_account=funded_account, - to_address=to_account.address, - asset_id=1, - amount=5, - note=f"Transfer 5 assets wit id ${dummy_asset_id}", - ), - ) - - -def test_transfer_asa_asset_is_transfered( - algod_client: "AlgodClient", to_account: Account, funded_account: Account -) -> None: - dummy_asset_id = generate_test_asset(algod_client, funded_account, 100) - assure_funds(algod_client=algod_client, account=to_account) - opt_in(algod_client=algod_client, account=to_account, asset_ids=[dummy_asset_id]) - transfer_asset( - algod_client, - TransferAssetParameters( - from_account=funded_account, - to_address=to_account.address, - asset_id=dummy_asset_id, - amount=5, - note=f"Transfer 5 assets wit id ${dummy_asset_id}", - ), - ) - - to_account_info = algod_client.account_asset_info(to_account.address, dummy_asset_id) - assert isinstance(to_account_info, dict) - assert to_account_info["asset-holding"]["amount"] == 5 # noqa: PLR2004 - - funded_account_info = algod_client.account_asset_info(funded_account.address, dummy_asset_id) - assert isinstance(funded_account_info, dict) - assert funded_account_info["asset-holding"]["amount"] == 95 # noqa: PLR2004 - - -def test_transfer_asa_asset_is_transfered_from_revocation_target( - algod_client: "AlgodClient", to_account: Account, clawback_account: Account, funded_account: Account -) -> None: - dummy_asset_id = generate_test_asset(algod_client, funded_account, 100) - assure_funds(algod_client=algod_client, account=to_account) - opt_in(algod_client=algod_client, account=to_account, asset_ids=[dummy_asset_id]) - - assure_funds(algod_client=algod_client, account=clawback_account) - opt_in(algod_client=algod_client, account=clawback_account, asset_ids=[dummy_asset_id]) - - transfer_asset( - algod_client, - TransferAssetParameters( - from_account=funded_account, - to_address=clawback_account.address, - asset_id=dummy_asset_id, - amount=5, - note=f"Transfer 5 assets wit id ${dummy_asset_id}", - ), - ) - - clawback_account_info = algod_client.account_asset_info(clawback_account.address, dummy_asset_id) - assert isinstance(clawback_account_info, dict) - assert clawback_account_info["asset-holding"]["amount"] == 5 # noqa: PLR2004 - - transfer_asset( - algod_client, - TransferAssetParameters( - from_account=funded_account, - to_address=to_account.address, - clawback_from=clawback_account.address, - asset_id=dummy_asset_id, - amount=5, - note=f"Transfer 5 assets wit id ${dummy_asset_id}", - ), - ) - - to_account_info = algod_client.account_asset_info(to_account.address, dummy_asset_id) - assert isinstance(to_account_info, dict) - assert to_account_info["asset-holding"]["amount"] == 5 # noqa: PLR2004 - - clawback_account_info = algod_client.account_asset_info(clawback_account.address, dummy_asset_id) - assert isinstance(clawback_account_info, dict) - assert clawback_account_info["asset-holding"]["amount"] == 0 - - funded_account_info = algod_client.account_asset_info(funded_account.address, dummy_asset_id) - assert isinstance(funded_account_info, dict) - assert funded_account_info["asset-holding"]["amount"] == 95 # noqa: PLR2004 - - -def test_transfer_asset_max_fee_fails( - algod_client: "AlgodClient", to_account: Account, funded_account: Account -) -> None: - dummy_asset_id = generate_test_asset(algod_client, funded_account, 100) - with pytest.raises(Exception, match="Cancelled transaction due to high network congestion fees") as ex: - transfer_asset( - algod_client, - TransferAssetParameters( - from_account=funded_account, - to_address=to_account.address, - asset_id=dummy_asset_id, - amount=5, - note=f"Transfer 5 assets wit id ${dummy_asset_id}", - max_fee_micro_algos=123, - ), - ) - - check_output_stability(str(ex.value)) - - -def test_ensure_funded(algod_client: "AlgodClient", to_account: Account, funded_account: Account) -> None: - parameters = EnsureBalanceParameters( - funding_source=funded_account, - account_to_fund=to_account, - min_spending_balance_micro_algos=1, - ) - response = ensure_funded(algod_client, parameters) - assert response is not None - - to_account_info = algod_client.account_info(to_account.address) - assert isinstance(to_account_info, dict) - actual_amount = to_account_info.get("amount") - assert actual_amount == MINIMUM_BALANCE + 1 - - -def test_ensure_funded_uses_dispenser_by_default(algod_client: "AlgodClient", to_account: Account) -> None: - dispenser = get_dispenser_account(algod_client) - parameters = EnsureBalanceParameters( - account_to_fund=to_account, - min_spending_balance_micro_algos=1, - ) - response = ensure_funded(algod_client, parameters) - assert response is not None - assert isinstance(response, EnsureFundedResponse) - - txn_info = algod_client.pending_transaction_info(response.transaction_id) - assert isinstance(txn_info, dict) - assert txn_info["txn"]["txn"]["snd"] == dispenser.address - - to_account_info = algod_client.account_info(to_account.address) - assert isinstance(to_account_info, dict) - actual_amount = to_account_info.get("amount") - assert actual_amount == MINIMUM_BALANCE + 1 - - -def test_ensure_funded_correct_amount( - algod_client: "AlgodClient", to_account: Account, funded_account: Account -) -> None: - parameters = EnsureBalanceParameters( - funding_source=funded_account, - account_to_fund=to_account, - min_spending_balance_micro_algos=1, - ) - response = ensure_funded(algod_client, parameters) - assert response is not None - - to_account_info = algod_client.account_info(to_account.address) - assert isinstance(to_account_info, dict) - actual_amount = to_account_info.get("amount") - assert actual_amount == MINIMUM_BALANCE + 1 - - -def test_ensure_funded_respects_minimum_funding( - algod_client: "AlgodClient", to_account: Account, funded_account: Account -) -> None: - parameters = EnsureBalanceParameters( - funding_source=funded_account, - account_to_fund=to_account, - min_spending_balance_micro_algos=1, - min_funding_increment_micro_algos=algos_to_microalgos(1), # type: ignore[no-untyped-call] - ) - response = ensure_funded(algod_client, parameters) - assert response is not None - - to_account_info = algod_client.account_info(to_account.address) - assert isinstance(to_account_info, dict) - actual_amount = to_account_info.get("amount") - assert actual_amount == algos_to_microalgos(1) # type: ignore[no-untyped-call] - - -def test_ensure_funded_testnet_api_success( - to_account: Account, monkeypatch: pytest.MonkeyPatch, httpx_mock: HTTPXMock -) -> None: - monkeypatch.setenv( - "ALGOKIT_DISPENSER_ACCESS_TOKEN", - "dummy", - ) - httpx_mock.add_response( - url=f"{DispenserApiConfig.BASE_URL}/fund/0", - method="POST", - json={"amount": 1, "txID": "dummy_tx_id"}, - ) - - algod_client = get_algod_client(get_algonode_config("testnet", "algod", DEFAULT_TOKEN)) - - dispenser_client = TestNetDispenserApiClient() - parameters = EnsureBalanceParameters( - funding_source=dispenser_client, - account_to_fund=to_account, - min_spending_balance_micro_algos=1, - ) - response = ensure_funded(algod_client, parameters) - assert response is not None - assert response.transaction_id == "dummy_tx_id" - assert response.amount == 1 - - -def test_ensure_funded_testnet_api_bad_response( - to_account: Account, monkeypatch: pytest.MonkeyPatch, httpx_mock: HTTPXMock -) -> None: - monkeypatch.setenv( - "ALGOKIT_DISPENSER_ACCESS_TOKEN", - "dummy", - ) - httpx_mock.add_exception( - httpx.HTTPStatusError( - "Limit exceeded", - request=httpx.Request("POST", f"{DispenserApiConfig.BASE_URL}/fund"), - response=httpx.Response( - 400, - request=httpx.Request("POST", f"{DispenserApiConfig.BASE_URL}/fund"), - json={ - "code": "fund_limit_exceeded", - "limit": 10_000_000, - "resetsAt": "2023-09-19T10:07:34.024Z", - }, - ), - ), - url=f"{DispenserApiConfig.BASE_URL}/fund/0", - method="POST", - ) - - algod_client = get_algod_client(get_algonode_config("testnet", "algod", DEFAULT_TOKEN)) - - dispenser_client = TestNetDispenserApiClient() - parameters = EnsureBalanceParameters( - funding_source=dispenser_client, - account_to_fund=to_account, - min_spending_balance_micro_algos=1, - ) - - with pytest.raises(Exception, match="fund_limit_exceeded"): - ensure_funded(algod_client, parameters) diff --git a/poetry.lock b/poetry.lock deleted file mode 100644 index 79e92caa..00000000 --- a/poetry.lock +++ /dev/null @@ -1,2915 +0,0 @@ -# This file is automatically @generated by Poetry 2.2.1 and should not be changed by hand. - -[[package]] -name = "alabaster" -version = "1.0.0" -description = "A light, configurable Sphinx theme" -optional = false -python-versions = ">=3.10" -groups = ["dev"] -files = [ - {file = "alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b"}, - {file = "alabaster-1.0.0.tar.gz", hash = "sha256:c00dca57bca26fa62a6d7d0a9fcce65f3e026e9bfe33e9c538fd3fbb2144fd9e"}, -] - -[[package]] -name = "anyio" -version = "4.8.0" -description = "High level compatibility layer for multiple asynchronous event loop implementations" -optional = false -python-versions = ">=3.9" -groups = ["main", "dev"] -files = [ - {file = "anyio-4.8.0-py3-none-any.whl", hash = "sha256:b5011f270ab5eb0abf13385f851315585cc37ef330dd88e27ec3d34d651fd47a"}, - {file = "anyio-4.8.0.tar.gz", hash = "sha256:1d9fe889df5212298c0c0723fa20479d1b94883a2df44bd3897aa91083316f7a"}, -] - -[package.dependencies] -exceptiongroup = {version = ">=1.0.2", markers = "python_version < \"3.11\""} -idna = ">=2.8" -sniffio = ">=1.1" -typing_extensions = {version = ">=4.5", markers = "python_version < \"3.13\""} - -[package.extras] -doc = ["Sphinx (>=7.4,<8.0)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphinx_rtd_theme"] -test = ["anyio[trio]", "coverage[toml] (>=7)", "exceptiongroup (>=1.2.0)", "hypothesis (>=4.0)", "psutil (>=5.9)", "pytest (>=7.0)", "trustme", "truststore (>=0.9.1) ; python_version >= \"3.10\"", "uvloop (>=0.21) ; platform_python_implementation == \"CPython\" and platform_system != \"Windows\" and python_version < \"3.14\""] -trio = ["trio (>=0.26.1)"] - -[[package]] -name = "astroid" -version = "3.3.8" -description = "An abstract syntax tree for Python with inference support." -optional = false -python-versions = ">=3.9.0" -groups = ["dev"] -files = [ - {file = "astroid-3.3.8-py3-none-any.whl", hash = "sha256:187ccc0c248bfbba564826c26f070494f7bc964fd286b6d9fff4420e55de828c"}, - {file = "astroid-3.3.8.tar.gz", hash = "sha256:a88c7994f914a4ea8572fac479459f4955eeccc877be3f2d959a33273b0cf40b"}, -] - -[package.dependencies] -typing-extensions = {version = ">=4.0.0", markers = "python_version < \"3.11\""} - -[[package]] -name = "babel" -version = "2.16.0" -description = "Internationalization utilities" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "babel-2.16.0-py3-none-any.whl", hash = "sha256:368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b"}, - {file = "babel-2.16.0.tar.gz", hash = "sha256:d1f3554ca26605fe173f3de0c65f750f5a42f924499bf134de6423582298e316"}, -] - -[package.extras] -dev = ["freezegun (>=1.0,<2.0)", "pytest (>=6.0)", "pytest-cov"] - -[[package]] -name = "backports-tarfile" -version = "1.2.0" -description = "Backport of CPython tarfile module" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -markers = "python_version < \"3.12\"" -files = [ - {file = "backports.tarfile-1.2.0-py3-none-any.whl", hash = "sha256:77e284d754527b01fb1e6fa8a1afe577858ebe4e9dad8919e34c862cb399bc34"}, - {file = "backports_tarfile-1.2.0.tar.gz", hash = "sha256:d75e02c268746e1b8144c278978b6e98e85de6ad16f8e4b0844a154557eca991"}, -] - -[package.extras] -docs = ["furo", "jaraco.packaging (>=9.3)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] -testing = ["jaraco.test", "pytest (!=8.0.*)", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)"] - -[[package]] -name = "beautifulsoup4" -version = "4.12.3" -description = "Screen-scraping library" -optional = false -python-versions = ">=3.6.0" -groups = ["dev"] -files = [ - {file = "beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed"}, - {file = "beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051"}, -] - -[package.dependencies] -soupsieve = ">1.2" - -[package.extras] -cchardet = ["cchardet"] -chardet = ["chardet"] -charset-normalizer = ["charset-normalizer"] -html5lib = ["html5lib"] -lxml = ["lxml"] - -[[package]] -name = "boolean-py" -version = "4.0" -description = "Define boolean algebras, create and parse boolean expressions and create custom boolean DSL." -optional = false -python-versions = "*" -groups = ["dev"] -files = [ - {file = "boolean.py-4.0-py3-none-any.whl", hash = "sha256:2876f2051d7d6394a531d82dc6eb407faa0b01a0a0b3083817ccd7323b8d96bd"}, - {file = "boolean.py-4.0.tar.gz", hash = "sha256:17b9a181630e43dde1851d42bef546d616d5d9b4480357514597e78b203d06e4"}, -] - -[[package]] -name = "cachecontrol" -version = "0.14.2" -description = "httplib2 caching for requests" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "cachecontrol-0.14.2-py3-none-any.whl", hash = "sha256:ebad2091bf12d0d200dfc2464330db638c5deb41d546f6d7aca079e87290f3b0"}, - {file = "cachecontrol-0.14.2.tar.gz", hash = "sha256:7d47d19f866409b98ff6025b6a0fca8e4c791fb31abbd95f622093894ce903a2"}, -] - -[package.dependencies] -filelock = {version = ">=3.8.0", optional = true, markers = "extra == \"filecache\""} -msgpack = ">=0.5.2,<2.0.0" -requests = ">=2.16.0" - -[package.extras] -dev = ["CacheControl[filecache,redis]", "build", "cherrypy", "codespell[tomli]", "furo", "mypy", "pytest", "pytest-cov", "ruff", "sphinx", "sphinx-copybutton", "tox", "types-redis", "types-requests"] -filecache = ["filelock (>=3.8.0)"] -redis = ["redis (>=2.10.5)"] - -[[package]] -name = "certifi" -version = "2024.12.14" -description = "Python package for providing Mozilla's CA Bundle." -optional = false -python-versions = ">=3.6" -groups = ["main", "dev"] -files = [ - {file = "certifi-2024.12.14-py3-none-any.whl", hash = "sha256:1275f7a45be9464efc1173084eaa30f866fe2e47d389406136d332ed4967ec56"}, - {file = "certifi-2024.12.14.tar.gz", hash = "sha256:b650d30f370c2b724812bee08008be0c4163b163ddaec3f2546c1caf65f191db"}, -] - -[[package]] -name = "cffi" -version = "1.17.1" -description = "Foreign Function Interface for Python calling C code." -optional = false -python-versions = ">=3.8" -groups = ["main", "dev"] -files = [ - {file = "cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14"}, - {file = "cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67"}, - {file = "cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382"}, - {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702"}, - {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3"}, - {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6"}, - {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17"}, - {file = "cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8"}, - {file = "cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e"}, - {file = "cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be"}, - {file = "cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c"}, - {file = "cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15"}, - {file = "cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401"}, - {file = "cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf"}, - {file = "cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4"}, - {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41"}, - {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1"}, - {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6"}, - {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d"}, - {file = "cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6"}, - {file = "cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f"}, - {file = "cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b"}, - {file = "cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655"}, - {file = "cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0"}, - {file = "cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4"}, - {file = "cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c"}, - {file = "cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36"}, - {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5"}, - {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff"}, - {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99"}, - {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93"}, - {file = "cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3"}, - {file = "cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8"}, - {file = "cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65"}, - {file = "cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903"}, - {file = "cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e"}, - {file = "cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2"}, - {file = "cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3"}, - {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683"}, - {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5"}, - {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4"}, - {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd"}, - {file = "cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed"}, - {file = "cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9"}, - {file = "cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d"}, - {file = "cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a"}, - {file = "cffi-1.17.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:636062ea65bd0195bc012fea9321aca499c0504409f413dc88af450b57ffd03b"}, - {file = "cffi-1.17.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c7eac2ef9b63c79431bc4b25f1cd649d7f061a28808cbc6c47b534bd789ef964"}, - {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e221cf152cff04059d011ee126477f0d9588303eb57e88923578ace7baad17f9"}, - {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:31000ec67d4221a71bd3f67df918b1f88f676f1c3b535a7eb473255fdc0b83fc"}, - {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f17be4345073b0a7b8ea599688f692ac3ef23ce28e5df79c04de519dbc4912c"}, - {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e2b1fac190ae3ebfe37b979cc1ce69c81f4e4fe5746bb401dca63a9062cdaf1"}, - {file = "cffi-1.17.1-cp38-cp38-win32.whl", hash = "sha256:7596d6620d3fa590f677e9ee430df2958d2d6d6de2feeae5b20e82c00b76fbf8"}, - {file = "cffi-1.17.1-cp38-cp38-win_amd64.whl", hash = "sha256:78122be759c3f8a014ce010908ae03364d00a1f81ab5c7f4a7a5120607ea56e1"}, - {file = "cffi-1.17.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b2ab587605f4ba0bf81dc0cb08a41bd1c0a5906bd59243d56bad7668a6fc6c16"}, - {file = "cffi-1.17.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:28b16024becceed8c6dfbc75629e27788d8a3f9030691a1dbf9821a128b22c36"}, - {file = "cffi-1.17.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d599671f396c4723d016dbddb72fe8e0397082b0a77a4fab8028923bec050e8"}, - {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca74b8dbe6e8e8263c0ffd60277de77dcee6c837a3d0881d8c1ead7268c9e576"}, - {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f7f5baafcc48261359e14bcd6d9bff6d4b28d9103847c9e136694cb0501aef87"}, - {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98e3969bcff97cae1b2def8ba499ea3d6f31ddfdb7635374834cf89a1a08ecf0"}, - {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdf5ce3acdfd1661132f2a9c19cac174758dc2352bfe37d98aa7512c6b7178b3"}, - {file = "cffi-1.17.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:9755e4345d1ec879e3849e62222a18c7174d65a6a92d5b346b1863912168b595"}, - {file = "cffi-1.17.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f1e22e8c4419538cb197e4dd60acc919d7696e5ef98ee4da4e01d3f8cfa4cc5a"}, - {file = "cffi-1.17.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c03e868a0b3bc35839ba98e74211ed2b05d2119be4e8a0f224fba9384f1fe02e"}, - {file = "cffi-1.17.1-cp39-cp39-win32.whl", hash = "sha256:e31ae45bc2e29f6b2abd0de1cc3b9d5205aa847cafaecb8af1476a609a2f6eb7"}, - {file = "cffi-1.17.1-cp39-cp39-win_amd64.whl", hash = "sha256:d016c76bdd850f3c626af19b0542c9677ba156e4ee4fccfdd7848803533ef662"}, - {file = "cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824"}, -] -markers = {dev = "sys_platform == \"linux\" and platform_python_implementation != \"PyPy\""} - -[package.dependencies] -pycparser = "*" - -[[package]] -name = "cfgv" -version = "3.4.0" -description = "Validate configuration and produce human readable error messages." -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9"}, - {file = "cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560"}, -] - -[[package]] -name = "charset-normalizer" -version = "3.4.1" -description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." -optional = false -python-versions = ">=3.7" -groups = ["dev"] -files = [ - {file = "charset_normalizer-3.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:91b36a978b5ae0ee86c394f5a54d6ef44db1de0815eb43de826d41d21e4af3de"}, - {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7461baadb4dc00fd9e0acbe254e3d7d2112e7f92ced2adc96e54ef6501c5f176"}, - {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e218488cd232553829be0664c2292d3af2eeeb94b32bea483cf79ac6a694e037"}, - {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:80ed5e856eb7f30115aaf94e4a08114ccc8813e6ed1b5efa74f9f82e8509858f"}, - {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b010a7a4fd316c3c484d482922d13044979e78d1861f0e0650423144c616a46a"}, - {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4532bff1b8421fd0a320463030c7520f56a79c9024a4e88f01c537316019005a"}, - {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d973f03c0cb71c5ed99037b870f2be986c3c05e63622c017ea9816881d2dd247"}, - {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3a3bd0dcd373514dcec91c411ddb9632c0d7d92aed7093b8c3bbb6d69ca74408"}, - {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d9c3cdf5390dcd29aa8056d13e8e99526cda0305acc038b96b30352aff5ff2bb"}, - {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:2bdfe3ac2e1bbe5b59a1a63721eb3b95fc9b6817ae4a46debbb4e11f6232428d"}, - {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:eab677309cdb30d047996b36d34caeda1dc91149e4fdca0b1a039b3f79d9a807"}, - {file = "charset_normalizer-3.4.1-cp310-cp310-win32.whl", hash = "sha256:c0429126cf75e16c4f0ad00ee0eae4242dc652290f940152ca8c75c3a4b6ee8f"}, - {file = "charset_normalizer-3.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:9f0b8b1c6d84c8034a44893aba5e767bf9c7a211e313a9605d9c617d7083829f"}, - {file = "charset_normalizer-3.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8bfa33f4f2672964266e940dd22a195989ba31669bd84629f05fab3ef4e2d125"}, - {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:28bf57629c75e810b6ae989f03c0828d64d6b26a5e205535585f96093e405ed1"}, - {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f08ff5e948271dc7e18a35641d2f11a4cd8dfd5634f55228b691e62b37125eb3"}, - {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:234ac59ea147c59ee4da87a0c0f098e9c8d169f4dc2a159ef720f1a61bbe27cd"}, - {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd4ec41f914fa74ad1b8304bbc634b3de73d2a0889bd32076342a573e0779e00"}, - {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eea6ee1db730b3483adf394ea72f808b6e18cf3cb6454b4d86e04fa8c4327a12"}, - {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c96836c97b1238e9c9e3fe90844c947d5afbf4f4c92762679acfe19927d81d77"}, - {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4d86f7aff21ee58f26dcf5ae81a9addbd914115cdebcbb2217e4f0ed8982e146"}, - {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:09b5e6733cbd160dcc09589227187e242a30a49ca5cefa5a7edd3f9d19ed53fd"}, - {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:5777ee0881f9499ed0f71cc82cf873d9a0ca8af166dfa0af8ec4e675b7df48e6"}, - {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:237bdbe6159cff53b4f24f397d43c6336c6b0b42affbe857970cefbb620911c8"}, - {file = "charset_normalizer-3.4.1-cp311-cp311-win32.whl", hash = "sha256:8417cb1f36cc0bc7eaba8ccb0e04d55f0ee52df06df3ad55259b9a323555fc8b"}, - {file = "charset_normalizer-3.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7f50a1f8c450f3925cb367d011448c39239bb3eb4117c36a6d354794de4ce76"}, - {file = "charset_normalizer-3.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:73d94b58ec7fecbc7366247d3b0b10a21681004153238750bb67bd9012414545"}, - {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad3e487649f498dd991eeb901125411559b22e8d7ab25d3aeb1af367df5efd7"}, - {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c30197aa96e8eed02200a83fba2657b4c3acd0f0aa4bdc9f6c1af8e8962e0757"}, - {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2369eea1ee4a7610a860d88f268eb39b95cb588acd7235e02fd5a5601773d4fa"}, - {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc2722592d8998c870fa4e290c2eec2c1569b87fe58618e67d38b4665dfa680d"}, - {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffc9202a29ab3920fa812879e95a9e78b2465fd10be7fcbd042899695d75e616"}, - {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:804a4d582ba6e5b747c625bf1255e6b1507465494a40a2130978bda7b932c90b"}, - {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f55e69f030f7163dffe9fd0752b32f070566451afe180f99dbeeb81f511ad8d"}, - {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c4c3e6da02df6fa1410a7680bd3f63d4f710232d3139089536310d027950696a"}, - {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:5df196eb874dae23dcfb968c83d4f8fdccb333330fe1fc278ac5ceeb101003a9"}, - {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e358e64305fe12299a08e08978f51fc21fac060dcfcddd95453eabe5b93ed0e1"}, - {file = "charset_normalizer-3.4.1-cp312-cp312-win32.whl", hash = "sha256:9b23ca7ef998bc739bf6ffc077c2116917eabcc901f88da1b9856b210ef63f35"}, - {file = "charset_normalizer-3.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ff8a4a60c227ad87030d76e99cd1698345d4491638dfa6673027c48b3cd395f"}, - {file = "charset_normalizer-3.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:aabfa34badd18f1da5ec1bc2715cadc8dca465868a4e73a0173466b688f29dda"}, - {file = "charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22e14b5d70560b8dd51ec22863f370d1e595ac3d024cb8ad7d308b4cd95f8313"}, - {file = "charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8436c508b408b82d87dc5f62496973a1805cd46727c34440b0d29d8a2f50a6c9"}, - {file = "charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2d074908e1aecee37a7635990b2c6d504cd4766c7bc9fc86d63f9c09af3fa11b"}, - {file = "charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:955f8851919303c92343d2f66165294848d57e9bba6cf6e3625485a70a038d11"}, - {file = "charset_normalizer-3.4.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:44ecbf16649486d4aebafeaa7ec4c9fed8b88101f4dd612dcaf65d5e815f837f"}, - {file = "charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0924e81d3d5e70f8126529951dac65c1010cdf117bb75eb02dd12339b57749dd"}, - {file = "charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2967f74ad52c3b98de4c3b32e1a44e32975e008a9cd2a8cc8966d6a5218c5cb2"}, - {file = "charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c75cb2a3e389853835e84a2d8fb2b81a10645b503eca9bcb98df6b5a43eb8886"}, - {file = "charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:09b26ae6b1abf0d27570633b2b078a2a20419c99d66fb2823173d73f188ce601"}, - {file = "charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa88b843d6e211393a37219e6a1c1df99d35e8fd90446f1118f4216e307e48cd"}, - {file = "charset_normalizer-3.4.1-cp313-cp313-win32.whl", hash = "sha256:eb8178fe3dba6450a3e024e95ac49ed3400e506fd4e9e5c32d30adda88cbd407"}, - {file = "charset_normalizer-3.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:b1ac5992a838106edb89654e0aebfc24f5848ae2547d22c2c3f66454daa11971"}, - {file = "charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f30bf9fd9be89ecb2360c7d94a711f00c09b976258846efe40db3d05828e8089"}, - {file = "charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:97f68b8d6831127e4787ad15e6757232e14e12060bec17091b85eb1486b91d8d"}, - {file = "charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7974a0b5ecd505609e3b19742b60cee7aa2aa2fb3151bc917e6e2646d7667dcf"}, - {file = "charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc54db6c8593ef7d4b2a331b58653356cf04f67c960f584edb7c3d8c97e8f39e"}, - {file = "charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:311f30128d7d333eebd7896965bfcfbd0065f1716ec92bd5638d7748eb6f936a"}, - {file = "charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:7d053096f67cd1241601111b698f5cad775f97ab25d81567d3f59219b5f1adbd"}, - {file = "charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_i686.whl", hash = "sha256:807f52c1f798eef6cf26beb819eeb8819b1622ddfeef9d0977a8502d4db6d534"}, - {file = "charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_ppc64le.whl", hash = "sha256:dccbe65bd2f7f7ec22c4ff99ed56faa1e9f785482b9bbd7c717e26fd723a1d1e"}, - {file = "charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_s390x.whl", hash = "sha256:2fb9bd477fdea8684f78791a6de97a953c51831ee2981f8e4f583ff3b9d9687e"}, - {file = "charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:01732659ba9b5b873fc117534143e4feefecf3b2078b0a6a2e925271bb6f4cfa"}, - {file = "charset_normalizer-3.4.1-cp37-cp37m-win32.whl", hash = "sha256:7a4f97a081603d2050bfaffdefa5b02a9ec823f8348a572e39032caa8404a487"}, - {file = "charset_normalizer-3.4.1-cp37-cp37m-win_amd64.whl", hash = "sha256:7b1bef6280950ee6c177b326508f86cad7ad4dff12454483b51d8b7d673a2c5d"}, - {file = "charset_normalizer-3.4.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:ecddf25bee22fe4fe3737a399d0d177d72bc22be6913acfab364b40bce1ba83c"}, - {file = "charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c60ca7339acd497a55b0ea5d506b2a2612afb2826560416f6894e8b5770d4a9"}, - {file = "charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b7b2d86dd06bfc2ade3312a83a5c364c7ec2e3498f8734282c6c3d4b07b346b8"}, - {file = "charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dd78cfcda14a1ef52584dbb008f7ac81c1328c0f58184bf9a84c49c605002da6"}, - {file = "charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e27f48bcd0957c6d4cb9d6fa6b61d192d0b13d5ef563e5f2ae35feafc0d179c"}, - {file = "charset_normalizer-3.4.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:01ad647cdd609225c5350561d084b42ddf732f4eeefe6e678765636791e78b9a"}, - {file = "charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:619a609aa74ae43d90ed2e89bdd784765de0a25ca761b93e196d938b8fd1dbbd"}, - {file = "charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:89149166622f4db9b4b6a449256291dc87a99ee53151c74cbd82a53c8c2f6ccd"}, - {file = "charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:7709f51f5f7c853f0fb938bcd3bc59cdfdc5203635ffd18bf354f6967ea0f824"}, - {file = "charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:345b0426edd4e18138d6528aed636de7a9ed169b4aaf9d61a8c19e39d26838ca"}, - {file = "charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:0907f11d019260cdc3f94fbdb23ff9125f6b5d1039b76003b5b0ac9d6a6c9d5b"}, - {file = "charset_normalizer-3.4.1-cp38-cp38-win32.whl", hash = "sha256:ea0d8d539afa5eb2728aa1932a988a9a7af94f18582ffae4bc10b3fbdad0626e"}, - {file = "charset_normalizer-3.4.1-cp38-cp38-win_amd64.whl", hash = "sha256:329ce159e82018d646c7ac45b01a430369d526569ec08516081727a20e9e4af4"}, - {file = "charset_normalizer-3.4.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:b97e690a2118911e39b4042088092771b4ae3fc3aa86518f84b8cf6888dbdb41"}, - {file = "charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78baa6d91634dfb69ec52a463534bc0df05dbd546209b79a3880a34487f4b84f"}, - {file = "charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1a2bc9f351a75ef49d664206d51f8e5ede9da246602dc2d2726837620ea034b2"}, - {file = "charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:75832c08354f595c760a804588b9357d34ec00ba1c940c15e31e96d902093770"}, - {file = "charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0af291f4fe114be0280cdd29d533696a77b5b49cfde5467176ecab32353395c4"}, - {file = "charset_normalizer-3.4.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0167ddc8ab6508fe81860a57dd472b2ef4060e8d378f0cc555707126830f2537"}, - {file = "charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:2a75d49014d118e4198bcee5ee0a6f25856b29b12dbf7cd012791f8a6cc5c496"}, - {file = "charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:363e2f92b0f0174b2f8238240a1a30142e3db7b957a5dd5689b0e75fb717cc78"}, - {file = "charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:ab36c8eb7e454e34e60eb55ca5d241a5d18b2c6244f6827a30e451c42410b5f7"}, - {file = "charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:4c0907b1928a36d5a998d72d64d8eaa7244989f7aaaf947500d3a800c83a3fd6"}, - {file = "charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:04432ad9479fa40ec0f387795ddad4437a2b50417c69fa275e212933519ff294"}, - {file = "charset_normalizer-3.4.1-cp39-cp39-win32.whl", hash = "sha256:3bed14e9c89dcb10e8f3a29f9ccac4955aebe93c71ae803af79265c9ca5644c5"}, - {file = "charset_normalizer-3.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:49402233c892a461407c512a19435d1ce275543138294f7ef013f0b63d5d3765"}, - {file = "charset_normalizer-3.4.1-py3-none-any.whl", hash = "sha256:d98b1668f06378c6dbefec3b92299716b931cd4e6061f3c875a71ced1780ab85"}, - {file = "charset_normalizer-3.4.1.tar.gz", hash = "sha256:44251f18cd68a75b56585dd00dae26183e102cd5e0f9f1466e6df5da2ed64ea3"}, -] - -[[package]] -name = "click" -version = "8.1.8" -description = "Composable command line interface toolkit" -optional = false -python-versions = ">=3.7" -groups = ["dev"] -files = [ - {file = "click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2"}, - {file = "click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a"}, -] - -[package.dependencies] -colorama = {version = "*", markers = "platform_system == \"Windows\""} - -[[package]] -name = "click-log" -version = "0.4.0" -description = "Logging integration for Click" -optional = false -python-versions = "*" -groups = ["dev"] -files = [ - {file = "click-log-0.4.0.tar.gz", hash = "sha256:3970f8570ac54491237bcdb3d8ab5e3eef6c057df29f8c3d1151a51a9c23b975"}, - {file = "click_log-0.4.0-py2.py3-none-any.whl", hash = "sha256:a43e394b528d52112af599f2fc9e4b7cf3c15f94e53581f74fa6867e68c91756"}, -] - -[package.dependencies] -click = "*" - -[[package]] -name = "colorama" -version = "0.4.6" -description = "Cross-platform colored terminal text." -optional = false -python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" -groups = ["dev"] -files = [ - {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, - {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, -] - -[[package]] -name = "coverage" -version = "7.6.10" -description = "Code coverage measurement for Python" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "coverage-7.6.10-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5c912978f7fbf47ef99cec50c4401340436d200d41d714c7a4766f377c5b7b78"}, - {file = "coverage-7.6.10-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a01ec4af7dfeb96ff0078ad9a48810bb0cc8abcb0115180c6013a6b26237626c"}, - {file = "coverage-7.6.10-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3b204c11e2b2d883946fe1d97f89403aa1811df28ce0447439178cc7463448a"}, - {file = "coverage-7.6.10-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:32ee6d8491fcfc82652a37109f69dee9a830e9379166cb73c16d8dc5c2915165"}, - {file = "coverage-7.6.10-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:675cefc4c06e3b4c876b85bfb7c59c5e2218167bbd4da5075cbe3b5790a28988"}, - {file = "coverage-7.6.10-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f4f620668dbc6f5e909a0946a877310fb3d57aea8198bde792aae369ee1c23b5"}, - {file = "coverage-7.6.10-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:4eea95ef275de7abaef630c9b2c002ffbc01918b726a39f5a4353916ec72d2f3"}, - {file = "coverage-7.6.10-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e2f0280519e42b0a17550072861e0bc8a80a0870de260f9796157d3fca2733c5"}, - {file = "coverage-7.6.10-cp310-cp310-win32.whl", hash = "sha256:bc67deb76bc3717f22e765ab3e07ee9c7a5e26b9019ca19a3b063d9f4b874244"}, - {file = "coverage-7.6.10-cp310-cp310-win_amd64.whl", hash = "sha256:0f460286cb94036455e703c66988851d970fdfd8acc2a1122ab7f4f904e4029e"}, - {file = "coverage-7.6.10-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ea3c8f04b3e4af80e17bab607c386a830ffc2fb88a5484e1df756478cf70d1d3"}, - {file = "coverage-7.6.10-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:507a20fc863cae1d5720797761b42d2d87a04b3e5aeb682ef3b7332e90598f43"}, - {file = "coverage-7.6.10-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d37a84878285b903c0fe21ac8794c6dab58150e9359f1aaebbeddd6412d53132"}, - {file = "coverage-7.6.10-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a534738b47b0de1995f85f582d983d94031dffb48ab86c95bdf88dc62212142f"}, - {file = "coverage-7.6.10-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d7a2bf79378d8fb8afaa994f91bfd8215134f8631d27eba3e0e2c13546ce994"}, - {file = "coverage-7.6.10-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6713ba4b4ebc330f3def51df1d5d38fad60b66720948112f114968feb52d3f99"}, - {file = "coverage-7.6.10-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:ab32947f481f7e8c763fa2c92fd9f44eeb143e7610c4ca9ecd6a36adab4081bd"}, - {file = "coverage-7.6.10-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7bbd8c8f1b115b892e34ba66a097b915d3871db7ce0e6b9901f462ff3a975377"}, - {file = "coverage-7.6.10-cp311-cp311-win32.whl", hash = "sha256:299e91b274c5c9cdb64cbdf1b3e4a8fe538a7a86acdd08fae52301b28ba297f8"}, - {file = "coverage-7.6.10-cp311-cp311-win_amd64.whl", hash = "sha256:489a01f94aa581dbd961f306e37d75d4ba16104bbfa2b0edb21d29b73be83609"}, - {file = "coverage-7.6.10-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:27c6e64726b307782fa5cbe531e7647aee385a29b2107cd87ba7c0105a5d3853"}, - {file = "coverage-7.6.10-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c56e097019e72c373bae32d946ecf9858fda841e48d82df7e81c63ac25554078"}, - {file = "coverage-7.6.10-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c7827a5bc7bdb197b9e066cdf650b2887597ad124dd99777332776f7b7c7d0d0"}, - {file = "coverage-7.6.10-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:204a8238afe787323a8b47d8be4df89772d5c1e4651b9ffa808552bdf20e1d50"}, - {file = "coverage-7.6.10-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e67926f51821b8e9deb6426ff3164870976fe414d033ad90ea75e7ed0c2e5022"}, - {file = "coverage-7.6.10-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e78b270eadb5702938c3dbe9367f878249b5ef9a2fcc5360ac7bff694310d17b"}, - {file = "coverage-7.6.10-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:714f942b9c15c3a7a5fe6876ce30af831c2ad4ce902410b7466b662358c852c0"}, - {file = "coverage-7.6.10-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:abb02e2f5a3187b2ac4cd46b8ced85a0858230b577ccb2c62c81482ca7d18852"}, - {file = "coverage-7.6.10-cp312-cp312-win32.whl", hash = "sha256:55b201b97286cf61f5e76063f9e2a1d8d2972fc2fcfd2c1272530172fd28c359"}, - {file = "coverage-7.6.10-cp312-cp312-win_amd64.whl", hash = "sha256:e4ae5ac5e0d1e4edfc9b4b57b4cbecd5bc266a6915c500f358817a8496739247"}, - {file = "coverage-7.6.10-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:05fca8ba6a87aabdd2d30d0b6c838b50510b56cdcfc604d40760dae7153b73d9"}, - {file = "coverage-7.6.10-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9e80eba8801c386f72e0712a0453431259c45c3249f0009aff537a517b52942b"}, - {file = "coverage-7.6.10-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a372c89c939d57abe09e08c0578c1d212e7a678135d53aa16eec4430adc5e690"}, - {file = "coverage-7.6.10-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ec22b5e7fe7a0fa8509181c4aac1db48f3dd4d3a566131b313d1efc102892c18"}, - {file = "coverage-7.6.10-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26bcf5c4df41cad1b19c84af71c22cbc9ea9a547fc973f1f2cc9a290002c8b3c"}, - {file = "coverage-7.6.10-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4e4630c26b6084c9b3cb53b15bd488f30ceb50b73c35c5ad7871b869cb7365fd"}, - {file = "coverage-7.6.10-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2396e8116db77789f819d2bc8a7e200232b7a282c66e0ae2d2cd84581a89757e"}, - {file = "coverage-7.6.10-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:79109c70cc0882e4d2d002fe69a24aa504dec0cc17169b3c7f41a1d341a73694"}, - {file = "coverage-7.6.10-cp313-cp313-win32.whl", hash = "sha256:9e1747bab246d6ff2c4f28b4d186b205adced9f7bd9dc362051cc37c4a0c7bd6"}, - {file = "coverage-7.6.10-cp313-cp313-win_amd64.whl", hash = "sha256:254f1a3b1eef5f7ed23ef265eaa89c65c8c5b6b257327c149db1ca9d4a35f25e"}, - {file = "coverage-7.6.10-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2ccf240eb719789cedbb9fd1338055de2761088202a9a0b73032857e53f612fe"}, - {file = "coverage-7.6.10-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:0c807ca74d5a5e64427c8805de15b9ca140bba13572d6d74e262f46f50b13273"}, - {file = "coverage-7.6.10-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2bcfa46d7709b5a7ffe089075799b902020b62e7ee56ebaed2f4bdac04c508d8"}, - {file = "coverage-7.6.10-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4e0de1e902669dccbf80b0415fb6b43d27edca2fbd48c74da378923b05316098"}, - {file = "coverage-7.6.10-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f7b444c42bbc533aaae6b5a2166fd1a797cdb5eb58ee51a92bee1eb94a1e1cb"}, - {file = "coverage-7.6.10-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b330368cb99ef72fcd2dc3ed260adf67b31499584dc8a20225e85bfe6f6cfed0"}, - {file = "coverage-7.6.10-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:9a7cfb50515f87f7ed30bc882f68812fd98bc2852957df69f3003d22a2aa0abf"}, - {file = "coverage-7.6.10-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f93531882a5f68c28090f901b1d135de61b56331bba82028489bc51bdd818d2"}, - {file = "coverage-7.6.10-cp313-cp313t-win32.whl", hash = "sha256:89d76815a26197c858f53c7f6a656686ec392b25991f9e409bcef020cd532312"}, - {file = "coverage-7.6.10-cp313-cp313t-win_amd64.whl", hash = "sha256:54a5f0f43950a36312155dae55c505a76cd7f2b12d26abeebbe7a0b36dbc868d"}, - {file = "coverage-7.6.10-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:656c82b8a0ead8bba147de9a89bda95064874c91a3ed43a00e687f23cc19d53a"}, - {file = "coverage-7.6.10-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ccc2b70a7ed475c68ceb548bf69cec1e27305c1c2606a5eb7c3afff56a1b3b27"}, - {file = "coverage-7.6.10-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5e37dc41d57ceba70956fa2fc5b63c26dba863c946ace9705f8eca99daecdc4"}, - {file = "coverage-7.6.10-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0aa9692b4fdd83a4647eeb7db46410ea1322b5ed94cd1715ef09d1d5922ba87f"}, - {file = "coverage-7.6.10-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aa744da1820678b475e4ba3dfd994c321c5b13381d1041fe9c608620e6676e25"}, - {file = "coverage-7.6.10-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:c0b1818063dc9e9d838c09e3a473c1422f517889436dd980f5d721899e66f315"}, - {file = "coverage-7.6.10-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:59af35558ba08b758aec4d56182b222976330ef8d2feacbb93964f576a7e7a90"}, - {file = "coverage-7.6.10-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:7ed2f37cfce1ce101e6dffdfd1c99e729dd2ffc291d02d3e2d0af8b53d13840d"}, - {file = "coverage-7.6.10-cp39-cp39-win32.whl", hash = "sha256:4bcc276261505d82f0ad426870c3b12cb177752834a633e737ec5ee79bbdff18"}, - {file = "coverage-7.6.10-cp39-cp39-win_amd64.whl", hash = "sha256:457574f4599d2b00f7f637a0700a6422243b3565509457b2dbd3f50703e11f59"}, - {file = "coverage-7.6.10-pp39.pp310-none-any.whl", hash = "sha256:fd34e7b3405f0cc7ab03d54a334c17a9e802897580d964bd8c2001f4b9fd488f"}, - {file = "coverage-7.6.10.tar.gz", hash = "sha256:7fb105327c8f8f0682e29843e2ff96af9dcbe5bab8eeb4b398c6a33a16d80a23"}, -] - -[package.dependencies] -tomli = {version = "*", optional = true, markers = "python_full_version <= \"3.11.0a6\" and extra == \"toml\""} - -[package.extras] -toml = ["tomli ; python_full_version <= \"3.11.0a6\""] - -[[package]] -name = "cryptography" -version = "44.0.1" -description = "cryptography is a package which provides cryptographic recipes and primitives to Python developers." -optional = false -python-versions = "!=3.9.0,!=3.9.1,>=3.7" -groups = ["dev"] -markers = "sys_platform == \"linux\"" -files = [ - {file = "cryptography-44.0.1-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:bf688f615c29bfe9dfc44312ca470989279f0e94bb9f631f85e3459af8efc009"}, - {file = "cryptography-44.0.1-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dd7c7e2d71d908dc0f8d2027e1604102140d84b155e658c20e8ad1304317691f"}, - {file = "cryptography-44.0.1-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:887143b9ff6bad2b7570da75a7fe8bbf5f65276365ac259a5d2d5147a73775f2"}, - {file = "cryptography-44.0.1-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:322eb03ecc62784536bc173f1483e76747aafeb69c8728df48537eb431cd1911"}, - {file = "cryptography-44.0.1-cp37-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:21377472ca4ada2906bc313168c9dc7b1d7ca417b63c1c3011d0c74b7de9ae69"}, - {file = "cryptography-44.0.1-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:df978682c1504fc93b3209de21aeabf2375cb1571d4e61907b3e7a2540e83026"}, - {file = "cryptography-44.0.1-cp37-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:eb3889330f2a4a148abead555399ec9a32b13b7c8ba969b72d8e500eb7ef84cd"}, - {file = "cryptography-44.0.1-cp37-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:8e6a85a93d0642bd774460a86513c5d9d80b5c002ca9693e63f6e540f1815ed0"}, - {file = "cryptography-44.0.1-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:6f76fdd6fd048576a04c5210d53aa04ca34d2ed63336d4abd306d0cbe298fddf"}, - {file = "cryptography-44.0.1-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6c8acf6f3d1f47acb2248ec3ea261171a671f3d9428e34ad0357148d492c7864"}, - {file = "cryptography-44.0.1-cp37-abi3-win32.whl", hash = "sha256:24979e9f2040c953a94bf3c6782e67795a4c260734e5264dceea65c8f4bae64a"}, - {file = "cryptography-44.0.1-cp37-abi3-win_amd64.whl", hash = "sha256:fd0ee90072861e276b0ff08bd627abec29e32a53b2be44e41dbcdf87cbee2b00"}, - {file = "cryptography-44.0.1-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:a2d8a7045e1ab9b9f803f0d9531ead85f90c5f2859e653b61497228b18452008"}, - {file = "cryptography-44.0.1-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b8272f257cf1cbd3f2e120f14c68bff2b6bdfcc157fafdee84a1b795efd72862"}, - {file = "cryptography-44.0.1-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1e8d181e90a777b63f3f0caa836844a1182f1f265687fac2115fcf245f5fbec3"}, - {file = "cryptography-44.0.1-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:436df4f203482f41aad60ed1813811ac4ab102765ecae7a2bbb1dbb66dcff5a7"}, - {file = "cryptography-44.0.1-cp39-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4f422e8c6a28cf8b7f883eb790695d6d45b0c385a2583073f3cec434cc705e1a"}, - {file = "cryptography-44.0.1-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:72198e2b5925155497a5a3e8c216c7fb3e64c16ccee11f0e7da272fa93b35c4c"}, - {file = "cryptography-44.0.1-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:2a46a89ad3e6176223b632056f321bc7de36b9f9b93b2cc1cccf935a3849dc62"}, - {file = "cryptography-44.0.1-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:53f23339864b617a3dfc2b0ac8d5c432625c80014c25caac9082314e9de56f41"}, - {file = "cryptography-44.0.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:888fcc3fce0c888785a4876ca55f9f43787f4c5c1cc1e2e0da71ad481ff82c5b"}, - {file = "cryptography-44.0.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:00918d859aa4e57db8299607086f793fa7813ae2ff5a4637e318a25ef82730f7"}, - {file = "cryptography-44.0.1-cp39-abi3-win32.whl", hash = "sha256:9b336599e2cb77b1008cb2ac264b290803ec5e8e89d618a5e978ff5eb6f715d9"}, - {file = "cryptography-44.0.1-cp39-abi3-win_amd64.whl", hash = "sha256:e403f7f766ded778ecdb790da786b418a9f2394f36e8cc8b796cc056ab05f44f"}, - {file = "cryptography-44.0.1-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:1f9a92144fa0c877117e9748c74501bea842f93d21ee00b0cf922846d9d0b183"}, - {file = "cryptography-44.0.1-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:610a83540765a8d8ce0f351ce42e26e53e1f774a6efb71eb1b41eb01d01c3d12"}, - {file = "cryptography-44.0.1-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:5fed5cd6102bb4eb843e3315d2bf25fede494509bddadb81e03a859c1bc17b83"}, - {file = "cryptography-44.0.1-pp310-pypy310_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:f4daefc971c2d1f82f03097dc6f216744a6cd2ac0f04c68fb935ea2ba2a0d420"}, - {file = "cryptography-44.0.1-pp310-pypy310_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:94f99f2b943b354a5b6307d7e8d19f5c423a794462bde2bf310c770ba052b1c4"}, - {file = "cryptography-44.0.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d9c5b9f698a83c8bd71e0f4d3f9f839ef244798e5ffe96febfa9714717db7af7"}, - {file = "cryptography-44.0.1.tar.gz", hash = "sha256:f51f5705ab27898afda1aaa430f34ad90dc117421057782022edf0600bec5f14"}, -] - -[package.dependencies] -cffi = {version = ">=1.12", markers = "platform_python_implementation != \"PyPy\""} - -[package.extras] -docs = ["sphinx (>=5.3.0)", "sphinx-rtd-theme (>=3.0.0) ; python_version >= \"3.8\""] -docstest = ["pyenchant (>=3)", "readme-renderer (>=30.0)", "sphinxcontrib-spelling (>=7.3.1)"] -nox = ["nox (>=2024.4.15)", "nox[uv] (>=2024.3.2) ; python_version >= \"3.8\""] -pep8test = ["check-sdist ; python_version >= \"3.8\"", "click (>=8.0.1)", "mypy (>=1.4)", "ruff (>=0.3.6)"] -sdist = ["build (>=1.0.0)"] -ssh = ["bcrypt (>=3.1.5)"] -test = ["certifi (>=2024)", "cryptography-vectors (==44.0.1)", "pretend (>=0.7)", "pytest (>=7.4.0)", "pytest-benchmark (>=4.0)", "pytest-cov (>=2.10.1)", "pytest-xdist (>=3.5.0)"] -test-randomorder = ["pytest-randomly"] - -[[package]] -name = "cyclonedx-python-lib" -version = "7.6.2" -description = "Python library for CycloneDX" -optional = false -python-versions = "<4.0,>=3.8" -groups = ["dev"] -files = [ - {file = "cyclonedx_python_lib-7.6.2-py3-none-any.whl", hash = "sha256:c42fab352cc0f7418d1b30def6751d9067ebcf0e8e4be210fc14d6e742a9edcc"}, - {file = "cyclonedx_python_lib-7.6.2.tar.gz", hash = "sha256:31186c5725ac0cfcca433759a407b1424686cdc867b47cc86e6cf83691310903"}, -] - -[package.dependencies] -license-expression = ">=30,<31" -packageurl-python = ">=0.11,<2" -py-serializable = ">=1.1.0,<2.0.0" -sortedcontainers = ">=2.4.0,<3.0.0" - -[package.extras] -json-validation = ["jsonschema[format] (>=4.18,<5.0)"] -validation = ["jsonschema[format] (>=4.18,<5.0)", "lxml (>=4,<6)"] -xml-validation = ["lxml (>=4,<6)"] - -[[package]] -name = "defusedxml" -version = "0.7.1" -description = "XML bomb protection for Python stdlib modules" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" -groups = ["dev"] -files = [ - {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"}, - {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, -] - -[[package]] -name = "distlib" -version = "0.3.9" -description = "Distribution utilities" -optional = false -python-versions = "*" -groups = ["dev"] -files = [ - {file = "distlib-0.3.9-py2.py3-none-any.whl", hash = "sha256:47f8c22fd27c27e25a65601af709b38e4f0a45ea4fc2e710f65755fa8caaaf87"}, - {file = "distlib-0.3.9.tar.gz", hash = "sha256:a60f20dea646b8a33f3e7772f74dc0b2d0772d2837ee1342a00645c81edf9403"}, -] - -[[package]] -name = "docstring-parser-fork" -version = "0.0.12" -description = "Parse Python docstrings in reST, Google and Numpydoc format" -optional = false -python-versions = "<4.0,>=3.7" -groups = ["dev"] -files = [ - {file = "docstring_parser_fork-0.0.12-py3-none-any.whl", hash = "sha256:55d7cbbc8b367655efd64372b9a0b33a49bae930a8ddd5cdc4c6112312e28a87"}, - {file = "docstring_parser_fork-0.0.12.tar.gz", hash = "sha256:b44c5e0be64ae80f395385f01497d381bd094a57221fd9ff020987d06857b2a0"}, -] - -[[package]] -name = "docutils" -version = "0.21.2" -description = "Docutils -- Python Documentation Utilities" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "docutils-0.21.2-py3-none-any.whl", hash = "sha256:dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2"}, - {file = "docutils-0.21.2.tar.gz", hash = "sha256:3a6b18732edf182daa3cd12775bbb338cf5691468f91eeeb109deff6ebfa986f"}, -] - -[[package]] -name = "dotty-dict" -version = "1.3.1" -description = "Dictionary wrapper for quick access to deeply nested keys." -optional = false -python-versions = ">=3.5,<4.0" -groups = ["dev"] -files = [ - {file = "dotty_dict-1.3.1-py3-none-any.whl", hash = "sha256:5022d234d9922f13aa711b4950372a06a6d64cb6d6db9ba43d0ba133ebfce31f"}, - {file = "dotty_dict-1.3.1.tar.gz", hash = "sha256:4b016e03b8ae265539757a53eba24b9bfda506fb94fbce0bee843c6f05541a15"}, -] - -[[package]] -name = "exceptiongroup" -version = "1.2.2" -description = "Backport of PEP 654 (exception groups)" -optional = false -python-versions = ">=3.7" -groups = ["main", "dev"] -markers = "python_version == \"3.10\"" -files = [ - {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"}, - {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"}, -] - -[package.extras] -test = ["pytest (>=6)"] - -[[package]] -name = "execnet" -version = "2.1.1" -description = "execnet: rapid multi-Python deployment" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "execnet-2.1.1-py3-none-any.whl", hash = "sha256:26dee51f1b80cebd6d0ca8e74dd8745419761d3bef34163928cbebbdc4749fdc"}, - {file = "execnet-2.1.1.tar.gz", hash = "sha256:5189b52c6121c24feae288166ab41b32549c7e2348652736540b9e6e7d4e72e3"}, -] - -[package.extras] -testing = ["hatch", "pre-commit", "pytest", "tox"] - -[[package]] -name = "filelock" -version = "3.17.0" -description = "A platform independent file lock." -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "filelock-3.17.0-py3-none-any.whl", hash = "sha256:533dc2f7ba78dc2f0f531fc6c4940addf7b70a481e269a5a3b93be94ffbe8338"}, - {file = "filelock-3.17.0.tar.gz", hash = "sha256:ee4e77401ef576ebb38cd7f13b9b28893194acc20a8e68e18730ba9c0e54660e"}, -] - -[package.extras] -docs = ["furo (>=2024.8.6)", "sphinx (>=8.1.3)", "sphinx-autodoc-typehints (>=3)"] -testing = ["covdefaults (>=2.3)", "coverage (>=7.6.10)", "diff-cover (>=9.2.1)", "pytest (>=8.3.4)", "pytest-asyncio (>=0.25.2)", "pytest-cov (>=6)", "pytest-mock (>=3.14)", "pytest-timeout (>=2.3.1)", "virtualenv (>=20.28.1)"] -typing = ["typing-extensions (>=4.12.2) ; python_version < \"3.11\""] - -[[package]] -name = "furo" -version = "2024.8.6" -description = "A clean customisable Sphinx documentation theme." -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "furo-2024.8.6-py3-none-any.whl", hash = "sha256:6cd97c58b47813d3619e63e9081169880fbe331f0ca883c871ff1f3f11814f5c"}, - {file = "furo-2024.8.6.tar.gz", hash = "sha256:b63e4cee8abfc3136d3bc03a3d45a76a850bada4d6374d24c1716b0e01394a01"}, -] - -[package.dependencies] -beautifulsoup4 = "*" -pygments = ">=2.7" -sphinx = ">=6.0,<9.0" -sphinx-basic-ng = ">=1.0.0.beta2" - -[[package]] -name = "gitdb" -version = "4.0.12" -description = "Git Object Database" -optional = false -python-versions = ">=3.7" -groups = ["dev"] -files = [ - {file = "gitdb-4.0.12-py3-none-any.whl", hash = "sha256:67073e15955400952c6565cc3e707c554a4eea2e428946f7a4c162fab9bd9bcf"}, - {file = "gitdb-4.0.12.tar.gz", hash = "sha256:5ef71f855d191a3326fcfbc0d5da835f26b13fbcba60c32c21091c349ffdb571"}, -] - -[package.dependencies] -smmap = ">=3.0.1,<6" - -[[package]] -name = "gitpython" -version = "3.1.44" -description = "GitPython is a Python library used to interact with Git repositories" -optional = false -python-versions = ">=3.7" -groups = ["dev"] -files = [ - {file = "GitPython-3.1.44-py3-none-any.whl", hash = "sha256:9e0e10cda9bed1ee64bc9a6de50e7e38a9c9943241cd7f585f6df3ed28011110"}, - {file = "gitpython-3.1.44.tar.gz", hash = "sha256:c87e30b26253bf5418b01b0660f818967f3c503193838337fe5e573331249269"}, -] - -[package.dependencies] -gitdb = ">=4.0.1,<5" - -[package.extras] -doc = ["sphinx (>=7.1.2,<7.2)", "sphinx-autodoc-typehints", "sphinx_rtd_theme"] -test = ["coverage[toml]", "ddt (>=1.1.1,!=1.4.3)", "mock ; python_version < \"3.8\"", "mypy", "pre-commit", "pytest (>=7.3.1)", "pytest-cov", "pytest-instafail", "pytest-mock", "pytest-sugar", "typing-extensions ; python_version < \"3.11\""] - -[[package]] -name = "h11" -version = "0.16.0" -description = "A pure-Python, bring-your-own-I/O implementation of HTTP/1.1" -optional = false -python-versions = ">=3.8" -groups = ["main", "dev"] -files = [ - {file = "h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86"}, - {file = "h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1"}, -] - -[[package]] -name = "httpcore" -version = "1.0.9" -description = "A minimal low-level HTTP client." -optional = false -python-versions = ">=3.8" -groups = ["main", "dev"] -files = [ - {file = "httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55"}, - {file = "httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8"}, -] - -[package.dependencies] -certifi = "*" -h11 = ">=0.16" - -[package.extras] -asyncio = ["anyio (>=4.0,<5.0)"] -http2 = ["h2 (>=3,<5)"] -socks = ["socksio (==1.*)"] -trio = ["trio (>=0.22.0,<1.0)"] - -[[package]] -name = "httpx" -version = "0.28.1" -description = "The next generation HTTP client." -optional = false -python-versions = ">=3.8" -groups = ["main", "dev"] -files = [ - {file = "httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad"}, - {file = "httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc"}, -] - -[package.dependencies] -anyio = "*" -certifi = "*" -httpcore = "==1.*" -idna = "*" - -[package.extras] -brotli = ["brotli ; platform_python_implementation == \"CPython\"", "brotlicffi ; platform_python_implementation != \"CPython\""] -cli = ["click (==8.*)", "pygments (==2.*)", "rich (>=10,<14)"] -http2 = ["h2 (>=3,<5)"] -socks = ["socksio (==1.*)"] -zstd = ["zstandard (>=0.18.0)"] - -[[package]] -name = "identify" -version = "2.6.6" -description = "File identification library for Python" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "identify-2.6.6-py2.py3-none-any.whl", hash = "sha256:cbd1810bce79f8b671ecb20f53ee0ae8e86ae84b557de31d89709dc2a48ba881"}, - {file = "identify-2.6.6.tar.gz", hash = "sha256:7bec12768ed44ea4761efb47806f0a41f86e7c0a5fdf5950d4648c90eca7e251"}, -] - -[package.extras] -license = ["ukkonen"] - -[[package]] -name = "idna" -version = "3.10" -description = "Internationalized Domain Names in Applications (IDNA)" -optional = false -python-versions = ">=3.6" -groups = ["main", "dev"] -files = [ - {file = "idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"}, - {file = "idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9"}, -] - -[package.extras] -all = ["flake8 (>=7.1.1)", "mypy (>=1.11.2)", "pytest (>=8.3.2)", "ruff (>=0.6.2)"] - -[[package]] -name = "imagesize" -version = "1.4.1" -description = "Getting image size from png/jpeg/jpeg2000/gif file" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" -groups = ["dev"] -files = [ - {file = "imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b"}, - {file = "imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a"}, -] - -[[package]] -name = "importlib-metadata" -version = "8.6.1" -description = "Read metadata from Python packages" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "importlib_metadata-8.6.1-py3-none-any.whl", hash = "sha256:02a89390c1e15fdfdc0d7c6b25cb3e62650d0494005c97d6f148bf5b9787525e"}, - {file = "importlib_metadata-8.6.1.tar.gz", hash = "sha256:310b41d755445d74569f993ccfc22838295d9fe005425094fad953d7f15c8580"}, -] - -[package.dependencies] -zipp = ">=3.20" - -[package.extras] -check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\""] -cover = ["pytest-cov"] -doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] -enabler = ["pytest-enabler (>=2.2)"] -perf = ["ipython"] -test = ["flufl.flake8", "importlib_resources (>=1.3) ; python_version < \"3.9\"", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-perf (>=0.9.2)"] -type = ["pytest-mypy"] - -[[package]] -name = "iniconfig" -version = "2.0.0" -description = "brain-dead simple config-ini parsing" -optional = false -python-versions = ">=3.7" -groups = ["dev"] -files = [ - {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, - {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, -] - -[[package]] -name = "invoke" -version = "2.2.0" -description = "Pythonic task execution" -optional = false -python-versions = ">=3.6" -groups = ["dev"] -files = [ - {file = "invoke-2.2.0-py3-none-any.whl", hash = "sha256:6ea924cc53d4f78e3d98bc436b08069a03077e6f85ad1ddaa8a116d7dad15820"}, - {file = "invoke-2.2.0.tar.gz", hash = "sha256:ee6cbb101af1a859c7fe84f2a264c059020b0cb7fe3535f9424300ab568f6bd5"}, -] - -[[package]] -name = "jaraco-classes" -version = "3.4.0" -description = "Utility functions for Python class constructs" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "jaraco.classes-3.4.0-py3-none-any.whl", hash = "sha256:f662826b6bed8cace05e7ff873ce0f9283b5c924470fe664fff1c2f00f581790"}, - {file = "jaraco.classes-3.4.0.tar.gz", hash = "sha256:47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd"}, -] - -[package.dependencies] -more-itertools = "*" - -[package.extras] -docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] -testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-ruff (>=0.2.1)"] - -[[package]] -name = "jaraco-context" -version = "6.0.1" -description = "Useful decorators and context managers" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "jaraco.context-6.0.1-py3-none-any.whl", hash = "sha256:f797fc481b490edb305122c9181830a3a5b76d84ef6d1aef2fb9b47ab956f9e4"}, - {file = "jaraco_context-6.0.1.tar.gz", hash = "sha256:9bae4ea555cf0b14938dc0aee7c9f32ed303aa20a3b73e7dc80111628792d1b3"}, -] - -[package.dependencies] -"backports.tarfile" = {version = "*", markers = "python_version < \"3.12\""} - -[package.extras] -doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] -test = ["portend", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\""] - -[[package]] -name = "jaraco-functools" -version = "4.1.0" -description = "Functools like those found in stdlib" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "jaraco.functools-4.1.0-py3-none-any.whl", hash = "sha256:ad159f13428bc4acbf5541ad6dec511f91573b90fba04df61dafa2a1231cf649"}, - {file = "jaraco_functools-4.1.0.tar.gz", hash = "sha256:70f7e0e2ae076498e212562325e805204fc092d7b4c17e0e86c959e249701a9d"}, -] - -[package.dependencies] -more-itertools = "*" - -[package.extras] -check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\""] -cover = ["pytest-cov"] -doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] -enabler = ["pytest-enabler (>=2.2)"] -test = ["jaraco.classes", "pytest (>=6,!=8.1.*)"] -type = ["pytest-mypy"] - -[[package]] -name = "jeepney" -version = "0.8.0" -description = "Low-level, pure Python DBus protocol wrapper." -optional = false -python-versions = ">=3.7" -groups = ["dev"] -markers = "sys_platform == \"linux\"" -files = [ - {file = "jeepney-0.8.0-py3-none-any.whl", hash = "sha256:c0a454ad016ca575060802ee4d590dd912e35c122fa04e70306de3d076cce755"}, - {file = "jeepney-0.8.0.tar.gz", hash = "sha256:5efe48d255973902f6badc3ce55e2aa6c5c3b3bc642059ef3a91247bcfcc5806"}, -] - -[package.extras] -test = ["async-timeout", "pytest", "pytest-asyncio (>=0.17)", "pytest-trio", "testpath", "trio"] -trio = ["async_generator ; python_version == \"3.6\"", "trio"] - -[[package]] -name = "jinja2" -version = "3.1.6" -description = "A very fast and expressive template engine." -optional = false -python-versions = ">=3.7" -groups = ["dev"] -files = [ - {file = "jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67"}, - {file = "jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d"}, -] - -[package.dependencies] -MarkupSafe = ">=2.0" - -[package.extras] -i18n = ["Babel (>=2.7)"] - -[[package]] -name = "keyring" -version = "25.6.0" -description = "Store and access your passwords safely." -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "keyring-25.6.0-py3-none-any.whl", hash = "sha256:552a3f7af126ece7ed5c89753650eec89c7eaae8617d0aa4d9ad2b75111266bd"}, - {file = "keyring-25.6.0.tar.gz", hash = "sha256:0b39998aa941431eb3d9b0d4b2460bc773b9df6fed7621c2dfb291a7e0187a66"}, -] - -[package.dependencies] -importlib_metadata = {version = ">=4.11.4", markers = "python_version < \"3.12\""} -"jaraco.classes" = "*" -"jaraco.context" = "*" -"jaraco.functools" = "*" -jeepney = {version = ">=0.4.2", markers = "sys_platform == \"linux\""} -pywin32-ctypes = {version = ">=0.2.0", markers = "sys_platform == \"win32\""} -SecretStorage = {version = ">=3.2", markers = "sys_platform == \"linux\""} - -[package.extras] -check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\""] -completion = ["shtab (>=1.1.0)"] -cover = ["pytest-cov"] -doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] -enabler = ["pytest-enabler (>=2.2)"] -test = ["pyfakefs", "pytest (>=6,!=8.1.*)"] -type = ["pygobject-stubs", "pytest-mypy", "shtab", "types-pywin32"] - -[[package]] -name = "license-expression" -version = "30.4.1" -description = "license-expression is a comprehensive utility library to parse, compare, simplify and normalize license expressions (such as SPDX license expressions) using boolean logic." -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "license_expression-30.4.1-py3-none-any.whl", hash = "sha256:679646bc3261a17690494a3e1cada446e5ee342dbd87dcfa4a0c24cc5dce13ee"}, - {file = "license_expression-30.4.1.tar.gz", hash = "sha256:9f02105f9e0fcecba6a85dfbbed7d94ea1c3a70cf23ddbfb5adf3438a6f6fce0"}, -] - -[package.dependencies] -"boolean.py" = ">=4.0" - -[package.extras] -docs = ["Sphinx (>=5.0.2)", "doc8 (>=0.11.2)", "sphinx-autobuild", "sphinx-copybutton", "sphinx-reredirects (>=0.1.2)", "sphinx-rtd-dark-mode (>=1.3.0)", "sphinx-rtd-theme (>=1.0.0)", "sphinxcontrib-apidoc (>=0.4.0)"] -testing = ["black", "isort", "pytest (>=6,!=7.0.0)", "pytest-xdist (>=2)", "twine"] - -[[package]] -name = "linkify-it-py" -version = "2.0.3" -description = "Links recognition library with FULL unicode support." -optional = false -python-versions = ">=3.7" -groups = ["dev"] -files = [ - {file = "linkify-it-py-2.0.3.tar.gz", hash = "sha256:68cda27e162e9215c17d786649d1da0021a451bdc436ef9e0fa0ba5234b9b048"}, - {file = "linkify_it_py-2.0.3-py3-none-any.whl", hash = "sha256:6bcbc417b0ac14323382aef5c5192c0075bf8a9d6b41820a2b66371eac6b6d79"}, -] - -[package.dependencies] -uc-micro-py = "*" - -[package.extras] -benchmark = ["pytest", "pytest-benchmark"] -dev = ["black", "flake8", "isort", "pre-commit", "pyproject-flake8"] -doc = ["myst-parser", "sphinx", "sphinx-book-theme"] -test = ["coverage", "pytest", "pytest-cov"] - -[[package]] -name = "markdown-it-py" -version = "3.0.0" -description = "Python port of markdown-it. Markdown parsing, done right!" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb"}, - {file = "markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1"}, -] - -[package.dependencies] -mdurl = ">=0.1,<1.0" - -[package.extras] -benchmarking = ["psutil", "pytest", "pytest-benchmark"] -code-style = ["pre-commit (>=3.0,<4.0)"] -compare = ["commonmark (>=0.9,<1.0)", "markdown (>=3.4,<4.0)", "mistletoe (>=1.0,<2.0)", "mistune (>=2.0,<3.0)", "panflute (>=2.3,<3.0)"] -linkify = ["linkify-it-py (>=1,<3)"] -plugins = ["mdit-py-plugins"] -profiling = ["gprof2dot"] -rtd = ["jupyter_sphinx", "mdit-py-plugins", "myst-parser", "pyyaml", "sphinx", "sphinx-copybutton", "sphinx-design", "sphinx_book_theme"] -testing = ["coverage", "pytest", "pytest-cov", "pytest-regressions"] - -[[package]] -name = "markupsafe" -version = "3.0.2" -description = "Safely add untrusted strings to HTML/XML markup." -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "MarkupSafe-3.0.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7e94c425039cde14257288fd61dcfb01963e658efbc0ff54f5306b06054700f8"}, - {file = "MarkupSafe-3.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e2d922824181480953426608b81967de705c3cef4d1af983af849d7bd619158"}, - {file = "MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38a9ef736c01fccdd6600705b09dc574584b89bea478200c5fbf112a6b0d5579"}, - {file = "MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bbcb445fa71794da8f178f0f6d66789a28d7319071af7a496d4d507ed566270d"}, - {file = "MarkupSafe-3.0.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57cb5a3cf367aeb1d316576250f65edec5bb3be939e9247ae594b4bcbc317dfb"}, - {file = "MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3809ede931876f5b2ec92eef964286840ed3540dadf803dd570c3b7e13141a3b"}, - {file = "MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e07c3764494e3776c602c1e78e298937c3315ccc9043ead7e685b7f2b8d47b3c"}, - {file = "MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b424c77b206d63d500bcb69fa55ed8d0e6a3774056bdc4839fc9298a7edca171"}, - {file = "MarkupSafe-3.0.2-cp310-cp310-win32.whl", hash = "sha256:fcabf5ff6eea076f859677f5f0b6b5c1a51e70a376b0579e0eadef8db48c6b50"}, - {file = "MarkupSafe-3.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:6af100e168aa82a50e186c82875a5893c5597a0c1ccdb0d8b40240b1f28b969a"}, - {file = "MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9025b4018f3a1314059769c7bf15441064b2207cb3f065e6ea1e7359cb46db9d"}, - {file = "MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:93335ca3812df2f366e80509ae119189886b0f3c2b81325d39efdb84a1e2ae93"}, - {file = "MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2cb8438c3cbb25e220c2ab33bb226559e7afb3baec11c4f218ffa7308603c832"}, - {file = "MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a123e330ef0853c6e822384873bef7507557d8e4a082961e1defa947aa59ba84"}, - {file = "MarkupSafe-3.0.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e084f686b92e5b83186b07e8a17fc09e38fff551f3602b249881fec658d3eca"}, - {file = "MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8213e09c917a951de9d09ecee036d5c7d36cb6cb7dbaece4c71a60d79fb9798"}, - {file = "MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5b02fb34468b6aaa40dfc198d813a641e3a63b98c2b05a16b9f80b7ec314185e"}, - {file = "MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0bff5e0ae4ef2e1ae4fdf2dfd5b76c75e5c2fa4132d05fc1b0dabcd20c7e28c4"}, - {file = "MarkupSafe-3.0.2-cp311-cp311-win32.whl", hash = "sha256:6c89876f41da747c8d3677a2b540fb32ef5715f97b66eeb0c6b66f5e3ef6f59d"}, - {file = "MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:70a87b411535ccad5ef2f1df5136506a10775d267e197e4cf531ced10537bd6b"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-win32.whl", hash = "sha256:0f4ca02bea9a23221c0182836703cbf8930c5e9454bacce27e767509fa286a30"}, - {file = "MarkupSafe-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e06879fc22a25ca47312fbe7c8264eb0b662f6db27cb2d3bbbc74b1df4b9b87"}, - {file = "MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd"}, - {file = "MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430"}, - {file = "MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094"}, - {file = "MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396"}, - {file = "MarkupSafe-3.0.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3818cb119498c0678015754eba762e0d61e5b52d34c8b13d770f0719f7b1d79"}, - {file = "MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a"}, - {file = "MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cabc348d87e913db6ab4aa100f01b08f481097838bdddf7c7a84b7575b7309ca"}, - {file = "MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c"}, - {file = "MarkupSafe-3.0.2-cp313-cp313-win32.whl", hash = "sha256:bcf3e58998965654fdaff38e58584d8937aa3096ab5354d493c77d1fdd66d7a1"}, - {file = "MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f"}, - {file = "MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c"}, - {file = "MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb"}, - {file = "MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c"}, - {file = "MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d"}, - {file = "MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d16a81a06776313e817c951135cf7340a3e91e8c1ff2fac444cfd75fffa04afe"}, - {file = "MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5"}, - {file = "MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3d79d162e7be8f996986c064d1c7c817f6df3a77fe3d6859f6f9e7be4b8c213a"}, - {file = "MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9"}, - {file = "MarkupSafe-3.0.2-cp313-cp313t-win32.whl", hash = "sha256:ba8062ed2cf21c07a9e295d5b8a2a5ce678b913b45fdf68c32d95d6c1291e0b6"}, - {file = "MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f"}, - {file = "MarkupSafe-3.0.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:eaa0a10b7f72326f1372a713e73c3f739b524b3af41feb43e4921cb529f5929a"}, - {file = "MarkupSafe-3.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:48032821bbdf20f5799ff537c7ac3d1fba0ba032cfc06194faffa8cda8b560ff"}, - {file = "MarkupSafe-3.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a9d3f5f0901fdec14d8d2f66ef7d035f2157240a433441719ac9a3fba440b13"}, - {file = "MarkupSafe-3.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88b49a3b9ff31e19998750c38e030fc7bb937398b1f78cfa599aaef92d693144"}, - {file = "MarkupSafe-3.0.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cfad01eed2c2e0c01fd0ecd2ef42c492f7f93902e39a42fc9ee1692961443a29"}, - {file = "MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:1225beacc926f536dc82e45f8a4d68502949dc67eea90eab715dea3a21c1b5f0"}, - {file = "MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:3169b1eefae027567d1ce6ee7cae382c57fe26e82775f460f0b2778beaad66c0"}, - {file = "MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:eb7972a85c54febfb25b5c4b4f3af4dcc731994c7da0d8a0b4a6eb0640e1d178"}, - {file = "MarkupSafe-3.0.2-cp39-cp39-win32.whl", hash = "sha256:8c4e8c3ce11e1f92f6536ff07154f9d49677ebaaafc32db9db4620bc11ed480f"}, - {file = "MarkupSafe-3.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:6e296a513ca3d94054c2c881cc913116e90fd030ad1c656b3869762b754f5f8a"}, - {file = "markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0"}, -] - -[[package]] -name = "mdit-py-plugins" -version = "0.4.2" -description = "Collection of plugins for markdown-it-py" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "mdit_py_plugins-0.4.2-py3-none-any.whl", hash = "sha256:0c673c3f889399a33b95e88d2f0d111b4447bdfea7f237dab2d488f459835636"}, - {file = "mdit_py_plugins-0.4.2.tar.gz", hash = "sha256:5f2cd1fdb606ddf152d37ec30e46101a60512bc0e5fa1a7002c36647b09e26b5"}, -] - -[package.dependencies] -markdown-it-py = ">=1.0.0,<4.0.0" - -[package.extras] -code-style = ["pre-commit"] -rtd = ["myst-parser", "sphinx-book-theme"] -testing = ["coverage", "pytest", "pytest-cov", "pytest-regressions"] - -[[package]] -name = "mdurl" -version = "0.1.2" -description = "Markdown URL utilities" -optional = false -python-versions = ">=3.7" -groups = ["dev"] -files = [ - {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"}, - {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, -] - -[[package]] -name = "more-itertools" -version = "10.6.0" -description = "More routines for operating on iterables, beyond itertools" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "more-itertools-10.6.0.tar.gz", hash = "sha256:2cd7fad1009c31cc9fb6a035108509e6547547a7a738374f10bd49a09eb3ee3b"}, - {file = "more_itertools-10.6.0-py3-none-any.whl", hash = "sha256:6eb054cb4b6db1473f6e15fcc676a08e4732548acd47c708f0e179c2c7c01e89"}, -] - -[[package]] -name = "msgpack" -version = "1.1.0" -description = "MessagePack serializer" -optional = false -python-versions = ">=3.8" -groups = ["main", "dev"] -files = [ - {file = "msgpack-1.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7ad442d527a7e358a469faf43fda45aaf4ac3249c8310a82f0ccff9164e5dccd"}, - {file = "msgpack-1.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:74bed8f63f8f14d75eec75cf3d04ad581da6b914001b474a5d3cd3372c8cc27d"}, - {file = "msgpack-1.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:914571a2a5b4e7606997e169f64ce53a8b1e06f2cf2c3a7273aa106236d43dd5"}, - {file = "msgpack-1.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c921af52214dcbb75e6bdf6a661b23c3e6417f00c603dd2070bccb5c3ef499f5"}, - {file = "msgpack-1.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d8ce0b22b890be5d252de90d0e0d119f363012027cf256185fc3d474c44b1b9e"}, - {file = "msgpack-1.1.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:73322a6cc57fcee3c0c57c4463d828e9428275fb85a27aa2aa1a92fdc42afd7b"}, - {file = "msgpack-1.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e1f3c3d21f7cf67bcf2da8e494d30a75e4cf60041d98b3f79875afb5b96f3a3f"}, - {file = "msgpack-1.1.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:64fc9068d701233effd61b19efb1485587560b66fe57b3e50d29c5d78e7fef68"}, - {file = "msgpack-1.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:42f754515e0f683f9c79210a5d1cad631ec3d06cea5172214d2176a42e67e19b"}, - {file = "msgpack-1.1.0-cp310-cp310-win32.whl", hash = "sha256:3df7e6b05571b3814361e8464f9304c42d2196808e0119f55d0d3e62cd5ea044"}, - {file = "msgpack-1.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:685ec345eefc757a7c8af44a3032734a739f8c45d1b0ac45efc5d8977aa4720f"}, - {file = "msgpack-1.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3d364a55082fb2a7416f6c63ae383fbd903adb5a6cf78c5b96cc6316dc1cedc7"}, - {file = "msgpack-1.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:79ec007767b9b56860e0372085f8504db5d06bd6a327a335449508bbee9648fa"}, - {file = "msgpack-1.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6ad622bf7756d5a497d5b6836e7fc3752e2dd6f4c648e24b1803f6048596f701"}, - {file = "msgpack-1.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e59bca908d9ca0de3dc8684f21ebf9a690fe47b6be93236eb40b99af28b6ea6"}, - {file = "msgpack-1.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5e1da8f11a3dd397f0a32c76165cf0c4eb95b31013a94f6ecc0b280c05c91b59"}, - {file = "msgpack-1.1.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:452aff037287acb1d70a804ffd022b21fa2bb7c46bee884dbc864cc9024128a0"}, - {file = "msgpack-1.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8da4bf6d54ceed70e8861f833f83ce0814a2b72102e890cbdfe4b34764cdd66e"}, - {file = "msgpack-1.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:41c991beebf175faf352fb940bf2af9ad1fb77fd25f38d9142053914947cdbf6"}, - {file = "msgpack-1.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a52a1f3a5af7ba1c9ace055b659189f6c669cf3657095b50f9602af3a3ba0fe5"}, - {file = "msgpack-1.1.0-cp311-cp311-win32.whl", hash = "sha256:58638690ebd0a06427c5fe1a227bb6b8b9fdc2bd07701bec13c2335c82131a88"}, - {file = "msgpack-1.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:fd2906780f25c8ed5d7b323379f6138524ba793428db5d0e9d226d3fa6aa1788"}, - {file = "msgpack-1.1.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:d46cf9e3705ea9485687aa4001a76e44748b609d260af21c4ceea7f2212a501d"}, - {file = "msgpack-1.1.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:5dbad74103df937e1325cc4bfeaf57713be0b4f15e1c2da43ccdd836393e2ea2"}, - {file = "msgpack-1.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:58dfc47f8b102da61e8949708b3eafc3504509a5728f8b4ddef84bd9e16ad420"}, - {file = "msgpack-1.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4676e5be1b472909b2ee6356ff425ebedf5142427842aa06b4dfd5117d1ca8a2"}, - {file = "msgpack-1.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17fb65dd0bec285907f68b15734a993ad3fc94332b5bb21b0435846228de1f39"}, - {file = "msgpack-1.1.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a51abd48c6d8ac89e0cfd4fe177c61481aca2d5e7ba42044fd218cfd8ea9899f"}, - {file = "msgpack-1.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2137773500afa5494a61b1208619e3871f75f27b03bcfca7b3a7023284140247"}, - {file = "msgpack-1.1.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:398b713459fea610861c8a7b62a6fec1882759f308ae0795b5413ff6a160cf3c"}, - {file = "msgpack-1.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:06f5fd2f6bb2a7914922d935d3b8bb4a7fff3a9a91cfce6d06c13bc42bec975b"}, - {file = "msgpack-1.1.0-cp312-cp312-win32.whl", hash = "sha256:ad33e8400e4ec17ba782f7b9cf868977d867ed784a1f5f2ab46e7ba53b6e1e1b"}, - {file = "msgpack-1.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:115a7af8ee9e8cddc10f87636767857e7e3717b7a2e97379dc2054712693e90f"}, - {file = "msgpack-1.1.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:071603e2f0771c45ad9bc65719291c568d4edf120b44eb36324dcb02a13bfddf"}, - {file = "msgpack-1.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0f92a83b84e7c0749e3f12821949d79485971f087604178026085f60ce109330"}, - {file = "msgpack-1.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4a1964df7b81285d00a84da4e70cb1383f2e665e0f1f2a7027e683956d04b734"}, - {file = "msgpack-1.1.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:59caf6a4ed0d164055ccff8fe31eddc0ebc07cf7326a2aaa0dbf7a4001cd823e"}, - {file = "msgpack-1.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0907e1a7119b337971a689153665764adc34e89175f9a34793307d9def08e6ca"}, - {file = "msgpack-1.1.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:65553c9b6da8166e819a6aa90ad15288599b340f91d18f60b2061f402b9a4915"}, - {file = "msgpack-1.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7a946a8992941fea80ed4beae6bff74ffd7ee129a90b4dd5cf9c476a30e9708d"}, - {file = "msgpack-1.1.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4b51405e36e075193bc051315dbf29168d6141ae2500ba8cd80a522964e31434"}, - {file = "msgpack-1.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b4c01941fd2ff87c2a934ee6055bda4ed353a7846b8d4f341c428109e9fcde8c"}, - {file = "msgpack-1.1.0-cp313-cp313-win32.whl", hash = "sha256:7c9a35ce2c2573bada929e0b7b3576de647b0defbd25f5139dcdaba0ae35a4cc"}, - {file = "msgpack-1.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:bce7d9e614a04d0883af0b3d4d501171fbfca038f12c77fa838d9f198147a23f"}, - {file = "msgpack-1.1.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c40ffa9a15d74e05ba1fe2681ea33b9caffd886675412612d93ab17b58ea2fec"}, - {file = "msgpack-1.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f1ba6136e650898082d9d5a5217d5906d1e138024f836ff48691784bbe1adf96"}, - {file = "msgpack-1.1.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e0856a2b7e8dcb874be44fea031d22e5b3a19121be92a1e098f46068a11b0870"}, - {file = "msgpack-1.1.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:471e27a5787a2e3f974ba023f9e265a8c7cfd373632247deb225617e3100a3c7"}, - {file = "msgpack-1.1.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:646afc8102935a388ffc3914b336d22d1c2d6209c773f3eb5dd4d6d3b6f8c1cb"}, - {file = "msgpack-1.1.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:13599f8829cfbe0158f6456374e9eea9f44eee08076291771d8ae93eda56607f"}, - {file = "msgpack-1.1.0-cp38-cp38-win32.whl", hash = "sha256:8a84efb768fb968381e525eeeb3d92857e4985aacc39f3c47ffd00eb4509315b"}, - {file = "msgpack-1.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:879a7b7b0ad82481c52d3c7eb99bf6f0645dbdec5134a4bddbd16f3506947feb"}, - {file = "msgpack-1.1.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:53258eeb7a80fc46f62fd59c876957a2d0e15e6449a9e71842b6d24419d88ca1"}, - {file = "msgpack-1.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:7e7b853bbc44fb03fbdba34feb4bd414322180135e2cb5164f20ce1c9795ee48"}, - {file = "msgpack-1.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f3e9b4936df53b970513eac1758f3882c88658a220b58dcc1e39606dccaaf01c"}, - {file = "msgpack-1.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:46c34e99110762a76e3911fc923222472c9d681f1094096ac4102c18319e6468"}, - {file = "msgpack-1.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8a706d1e74dd3dea05cb54580d9bd8b2880e9264856ce5068027eed09680aa74"}, - {file = "msgpack-1.1.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:534480ee5690ab3cbed89d4c8971a5c631b69a8c0883ecfea96c19118510c846"}, - {file = "msgpack-1.1.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:8cf9e8c3a2153934a23ac160cc4cba0ec035f6867c8013cc6077a79823370346"}, - {file = "msgpack-1.1.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:3180065ec2abbe13a4ad37688b61b99d7f9e012a535b930e0e683ad6bc30155b"}, - {file = "msgpack-1.1.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:c5a91481a3cc573ac8c0d9aace09345d989dc4a0202b7fcb312c88c26d4e71a8"}, - {file = "msgpack-1.1.0-cp39-cp39-win32.whl", hash = "sha256:f80bc7d47f76089633763f952e67f8214cb7b3ee6bfa489b3cb6a84cfac114cd"}, - {file = "msgpack-1.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:4d1b7ff2d6146e16e8bd665ac726a89c74163ef8cd39fa8c1087d4e52d3a2325"}, - {file = "msgpack-1.1.0.tar.gz", hash = "sha256:dd432ccc2c72b914e4cb77afce64aab761c1137cc698be3984eee260bcb2896e"}, -] - -[[package]] -name = "mypy" -version = "1.15.0" -description = "Optional static typing for Python" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "mypy-1.15.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:979e4e1a006511dacf628e36fadfecbcc0160a8af6ca7dad2f5025529e082c13"}, - {file = "mypy-1.15.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c4bb0e1bd29f7d34efcccd71cf733580191e9a264a2202b0239da95984c5b559"}, - {file = "mypy-1.15.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be68172e9fd9ad8fb876c6389f16d1c1b5f100ffa779f77b1fb2176fcc9ab95b"}, - {file = "mypy-1.15.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7be1e46525adfa0d97681432ee9fcd61a3964c2446795714699a998d193f1a3"}, - {file = "mypy-1.15.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:2e2c2e6d3593f6451b18588848e66260ff62ccca522dd231cd4dd59b0160668b"}, - {file = "mypy-1.15.0-cp310-cp310-win_amd64.whl", hash = "sha256:6983aae8b2f653e098edb77f893f7b6aca69f6cffb19b2cc7443f23cce5f4828"}, - {file = "mypy-1.15.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2922d42e16d6de288022e5ca321cd0618b238cfc5570e0263e5ba0a77dbef56f"}, - {file = "mypy-1.15.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2ee2d57e01a7c35de00f4634ba1bbf015185b219e4dc5909e281016df43f5ee5"}, - {file = "mypy-1.15.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:973500e0774b85d9689715feeffcc980193086551110fd678ebe1f4342fb7c5e"}, - {file = "mypy-1.15.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a95fb17c13e29d2d5195869262f8125dfdb5c134dc8d9a9d0aecf7525b10c2c"}, - {file = "mypy-1.15.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1905f494bfd7d85a23a88c5d97840888a7bd516545fc5aaedff0267e0bb54e2f"}, - {file = "mypy-1.15.0-cp311-cp311-win_amd64.whl", hash = "sha256:c9817fa23833ff189db061e6d2eff49b2f3b6ed9856b4a0a73046e41932d744f"}, - {file = "mypy-1.15.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:aea39e0583d05124836ea645f412e88a5c7d0fd77a6d694b60d9b6b2d9f184fd"}, - {file = "mypy-1.15.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2f2147ab812b75e5b5499b01ade1f4a81489a147c01585cda36019102538615f"}, - {file = "mypy-1.15.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ce436f4c6d218a070048ed6a44c0bbb10cd2cc5e272b29e7845f6a2f57ee4464"}, - {file = "mypy-1.15.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8023ff13985661b50a5928fc7a5ca15f3d1affb41e5f0a9952cb68ef090b31ee"}, - {file = "mypy-1.15.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1124a18bc11a6a62887e3e137f37f53fbae476dc36c185d549d4f837a2a6a14e"}, - {file = "mypy-1.15.0-cp312-cp312-win_amd64.whl", hash = "sha256:171a9ca9a40cd1843abeca0e405bc1940cd9b305eaeea2dda769ba096932bb22"}, - {file = "mypy-1.15.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:93faf3fdb04768d44bf28693293f3904bbb555d076b781ad2530214ee53e3445"}, - {file = "mypy-1.15.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:811aeccadfb730024c5d3e326b2fbe9249bb7413553f15499a4050f7c30e801d"}, - {file = "mypy-1.15.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:98b7b9b9aedb65fe628c62a6dc57f6d5088ef2dfca37903a7d9ee374d03acca5"}, - {file = "mypy-1.15.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c43a7682e24b4f576d93072216bf56eeff70d9140241f9edec0c104d0c515036"}, - {file = "mypy-1.15.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:baefc32840a9f00babd83251560e0ae1573e2f9d1b067719479bfb0e987c6357"}, - {file = "mypy-1.15.0-cp313-cp313-win_amd64.whl", hash = "sha256:b9378e2c00146c44793c98b8d5a61039a048e31f429fb0eb546d93f4b000bedf"}, - {file = "mypy-1.15.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:e601a7fa172c2131bff456bb3ee08a88360760d0d2f8cbd7a75a65497e2df078"}, - {file = "mypy-1.15.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:712e962a6357634fef20412699a3655c610110e01cdaa6180acec7fc9f8513ba"}, - {file = "mypy-1.15.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f95579473af29ab73a10bada2f9722856792a36ec5af5399b653aa28360290a5"}, - {file = "mypy-1.15.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8f8722560a14cde92fdb1e31597760dc35f9f5524cce17836c0d22841830fd5b"}, - {file = "mypy-1.15.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:1fbb8da62dc352133d7d7ca90ed2fb0e9d42bb1a32724c287d3c76c58cbaa9c2"}, - {file = "mypy-1.15.0-cp39-cp39-win_amd64.whl", hash = "sha256:d10d994b41fb3497719bbf866f227b3489048ea4bbbb5015357db306249f7980"}, - {file = "mypy-1.15.0-py3-none-any.whl", hash = "sha256:5469affef548bd1895d86d3bf10ce2b44e33d86923c29e4d675b3e323437ea3e"}, - {file = "mypy-1.15.0.tar.gz", hash = "sha256:404534629d51d3efea5c800ee7c42b72a6554d6c400e6a79eafe15d11341fd43"}, -] - -[package.dependencies] -mypy_extensions = ">=1.0.0" -tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""} -typing_extensions = ">=4.6.0" - -[package.extras] -dmypy = ["psutil (>=4.0)"] -faster-cache = ["orjson"] -install-types = ["pip"] -mypyc = ["setuptools (>=50)"] -reports = ["lxml"] - -[[package]] -name = "mypy-extensions" -version = "1.0.0" -description = "Type system extensions for programs checked with the mypy type checker." -optional = false -python-versions = ">=3.5" -groups = ["dev"] -files = [ - {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"}, - {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"}, -] - -[[package]] -name = "myst-parser" -version = "4.0.1" -description = "An extended [CommonMark](https://spec.commonmark.org/) compliant parser," -optional = false -python-versions = ">=3.10" -groups = ["dev"] -files = [ - {file = "myst_parser-4.0.1-py3-none-any.whl", hash = "sha256:9134e88959ec3b5780aedf8a99680ea242869d012e8821db3126d427edc9c95d"}, - {file = "myst_parser-4.0.1.tar.gz", hash = "sha256:5cfea715e4f3574138aecbf7d54132296bfd72bb614d31168f48c477a830a7c4"}, -] - -[package.dependencies] -docutils = ">=0.19,<0.22" -jinja2 = "*" -markdown-it-py = ">=3.0,<4.0" -mdit-py-plugins = ">=0.4.1,<1.0" -pyyaml = "*" -sphinx = ">=7,<9" - -[package.extras] -code-style = ["pre-commit (>=4.0,<5.0)"] -linkify = ["linkify-it-py (>=2.0,<3.0)"] -rtd = ["ipython", "sphinx (>=7)", "sphinx-autodoc2 (>=0.5.0,<0.6.0)", "sphinx-book-theme (>=1.1,<2.0)", "sphinx-copybutton", "sphinx-design", "sphinx-pyscript", "sphinx-tippy (>=0.4.3)", "sphinx-togglebutton", "sphinxext-opengraph (>=0.9.0,<0.10.0)", "sphinxext-rediraffe (>=0.2.7,<0.3.0)"] -testing = ["beautifulsoup4", "coverage[toml]", "defusedxml", "pygments (<2.19)", "pytest (>=8,<9)", "pytest-cov", "pytest-param-files (>=0.6.0,<0.7.0)", "pytest-regressions", "sphinx-pytest"] -testing-docutils = ["pygments", "pytest (>=8,<9)", "pytest-param-files (>=0.6.0,<0.7.0)"] - -[[package]] -name = "nh3" -version = "0.2.20" -description = "Python binding to Ammonia HTML sanitizer Rust crate" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "nh3-0.2.20-cp313-cp313t-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:e1061a4ab6681f6bdf72b110eea0c4e1379d57c9de937db3be4202f7ad6043db"}, - {file = "nh3-0.2.20-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb4254b1dac4a1ee49919a5b3f1caf9803ea8dada1816d9e8289e63d3cd0dd9a"}, - {file = "nh3-0.2.20-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0ae9cbd713524cdb81e64663d0d6aae26f678db9f2cd9db0bf162606f1f9f20c"}, - {file = "nh3-0.2.20-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e1f7370b4e14cc03f5ae141ef30a1caf81fa5787711f80be9081418dd9eb79d2"}, - {file = "nh3-0.2.20-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:ac4d27dc836a476efffc6eb661994426b8b805c951b29c9cf2ff36bc9ad58bc5"}, - {file = "nh3-0.2.20-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:4fd2e9248725ebcedac3997a8d3da0d90a12a28c9179c6ba51f1658938ac30d0"}, - {file = "nh3-0.2.20-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f7d564871833ddbe54df3aa59053b1110729d3a800cb7628ae8f42adb3d75208"}, - {file = "nh3-0.2.20-cp313-cp313t-win32.whl", hash = "sha256:d2a176fd4306b6f0f178a3f67fac91bd97a3a8d8fafb771c9b9ef675ba5c8886"}, - {file = "nh3-0.2.20-cp313-cp313t-win_amd64.whl", hash = "sha256:6ed834c68452a600f517dd3e1534dbfaff1f67f98899fecf139a055a25d99150"}, - {file = "nh3-0.2.20-cp38-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:76e2f603b30c02ff6456b233a83fc377dedab6a50947b04e960a6b905637b776"}, - {file = "nh3-0.2.20-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:181063c581defe683bd4bb78188ac9936d208aebbc74c7f7c16b6a32ae2ebb38"}, - {file = "nh3-0.2.20-cp38-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:231addb7643c952cd6d71f1c8702d703f8fe34afcb20becb3efb319a501a12d7"}, - {file = "nh3-0.2.20-cp38-abi3-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:1b9a8340a0aab991c68a5ca938d35ef4a8a3f4bf1b455da8855a40bee1fa0ace"}, - {file = "nh3-0.2.20-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:10317cd96fe4bbd4eb6b95f3920b71c902157ad44fed103fdcde43e3b8ee8be6"}, - {file = "nh3-0.2.20-cp38-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8698db4c04b140800d1a1cd3067fda399e36e1e2b8fc1fe04292a907350a3e9b"}, - {file = "nh3-0.2.20-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3eb04b9c3deb13c3a375ea39fd4a3c00d1f92e8fb2349f25f1e3e4506751774b"}, - {file = "nh3-0.2.20-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:92f3f1c4f47a2c6f3ca7317b1d5ced05bd29556a75d3a4e2715652ae9d15c05d"}, - {file = "nh3-0.2.20-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ddefa9fd6794a87e37d05827d299d4b53a3ec6f23258101907b96029bfef138a"}, - {file = "nh3-0.2.20-cp38-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:ce3731c8f217685d33d9268362e5b4f770914e922bba94d368ab244a59a6c397"}, - {file = "nh3-0.2.20-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:09f037c02fc2c43b211ff1523de32801dcfb0918648d8e651c36ef890f1731ec"}, - {file = "nh3-0.2.20-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:813f1c8012dd64c990514b795508abb90789334f76a561fa0fd4ca32d2275330"}, - {file = "nh3-0.2.20-cp38-abi3-win32.whl", hash = "sha256:47b2946c0e13057855209daeffb45dc910bd0c55daf10190bb0b4b60e2999784"}, - {file = "nh3-0.2.20-cp38-abi3-win_amd64.whl", hash = "sha256:da87573f03084edae8eb87cfe811ec338606288f81d333c07d2a9a0b9b976c0b"}, - {file = "nh3-0.2.20.tar.gz", hash = "sha256:9705c42d7ff88a0bea546c82d7fe5e59135e3d3f057e485394f491248a1f8ed5"}, -] - -[[package]] -name = "nodeenv" -version = "1.9.1" -description = "Node.js virtual environment builder" -optional = false -python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" -groups = ["dev"] -files = [ - {file = "nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9"}, - {file = "nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f"}, -] - -[[package]] -name = "packageurl-python" -version = "0.16.0" -description = "A purl aka. Package URL parser and builder" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "packageurl_python-0.16.0-py3-none-any.whl", hash = "sha256:5c3872638b177b0f1cf01c3673017b7b27ebee485693ae12a8bed70fa7fa7c35"}, - {file = "packageurl_python-0.16.0.tar.gz", hash = "sha256:69e3bf8a3932fe9c2400f56aaeb9f86911ecee2f9398dbe1b58ec34340be365d"}, -] - -[package.extras] -build = ["setuptools", "wheel"] -lint = ["black", "isort", "mypy"] -sqlalchemy = ["sqlalchemy (>=2.0.0)"] -test = ["pytest"] - -[[package]] -name = "packaging" -version = "24.2" -description = "Core utilities for Python packages" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759"}, - {file = "packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f"}, -] - -[[package]] -name = "pastel" -version = "0.2.1" -description = "Bring colors to your terminal." -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" -groups = ["dev"] -files = [ - {file = "pastel-0.2.1-py2.py3-none-any.whl", hash = "sha256:4349225fcdf6c2bb34d483e523475de5bb04a5c10ef711263452cb37d7dd4364"}, - {file = "pastel-0.2.1.tar.gz", hash = "sha256:e6581ac04e973cac858828c6202c1e1e81fee1dc7de7683f3e1ffe0bfd8a573d"}, -] - -[[package]] -name = "pip" -version = "25.3" -description = "The PyPA recommended tool for installing Python packages." -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "pip-25.3-py3-none-any.whl", hash = "sha256:9655943313a94722b7774661c21049070f6bbb0a1516bf02f7c8d5d9201514cd"}, - {file = "pip-25.3.tar.gz", hash = "sha256:8d0538dbbd7babbd207f261ed969c65de439f6bc9e5dbd3b3b9a77f25d95f343"}, -] - -[[package]] -name = "pip-api" -version = "0.0.34" -description = "An unofficial, importable pip API" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "pip_api-0.0.34-py3-none-any.whl", hash = "sha256:8b2d7d7c37f2447373aa2cf8b1f60a2f2b27a84e1e9e0294a3f6ef10eb3ba6bb"}, - {file = "pip_api-0.0.34.tar.gz", hash = "sha256:9b75e958f14c5a2614bae415f2adf7eeb54d50a2cfbe7e24fd4826471bac3625"}, -] - -[package.dependencies] -pip = "*" - -[[package]] -name = "pip-audit" -version = "2.9.0" -description = "A tool for scanning Python environments for known vulnerabilities" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "pip_audit-2.9.0-py3-none-any.whl", hash = "sha256:348b16e60895749a0839875d7cc27ebd692e1584ebe5d5cb145941c8e25a80bd"}, - {file = "pip_audit-2.9.0.tar.gz", hash = "sha256:0b998410b58339d7a231e5aa004326a294e4c7c6295289cdc9d5e1ef07b1f44d"}, -] - -[package.dependencies] -CacheControl = {version = ">=0.13.0", extras = ["filecache"]} -cyclonedx-python-lib = ">=5,<10" -packaging = ">=23.0.0" -pip-api = ">=0.0.28" -pip-requirements-parser = ">=32.0.0" -platformdirs = ">=4.2.0" -requests = ">=2.31.0" -rich = ">=12.4" -toml = ">=0.10" - -[package.extras] -dev = ["build", "pip-audit[doc,lint,test]"] -doc = ["pdoc"] -lint = ["interrogate (>=1.6,<2.0)", "mypy", "ruff (>=0.9,<1.0)", "types-requests", "types-toml"] -test = ["coverage[toml] (>=7.0,!=7.3.3,<8.0)", "pretend", "pytest", "pytest-cov"] - -[[package]] -name = "pip-requirements-parser" -version = "32.0.1" -description = "pip requirements parser - a mostly correct pip requirements parsing library because it uses pip's own code." -optional = false -python-versions = ">=3.6.0" -groups = ["dev"] -files = [ - {file = "pip-requirements-parser-32.0.1.tar.gz", hash = "sha256:b4fa3a7a0be38243123cf9d1f3518da10c51bdb165a2b2985566247f9155a7d3"}, - {file = "pip_requirements_parser-32.0.1-py3-none-any.whl", hash = "sha256:4659bc2a667783e7a15d190f6fccf8b2486685b6dba4c19c3876314769c57526"}, -] - -[package.dependencies] -packaging = "*" -pyparsing = "*" - -[package.extras] -docs = ["Sphinx (>=3.3.1)", "doc8 (>=0.8.1)", "sphinx-rtd-theme (>=0.5.0)"] -testing = ["aboutcode-toolkit (>=6.0.0)", "black", "pytest (>=6,!=7.0.0)", "pytest-xdist (>=2)"] - -[[package]] -name = "pkginfo" -version = "1.12.0" -description = "Query metadata from sdists / bdists / installed packages." -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "pkginfo-1.12.0-py3-none-any.whl", hash = "sha256:dcd589c9be4da8973eceffa247733c144812759aa67eaf4bbf97016a02f39088"}, - {file = "pkginfo-1.12.0.tar.gz", hash = "sha256:8ad91a0445a036782b9366ef8b8c2c50291f83a553478ba8580c73d3215700cf"}, -] - -[package.extras] -testing = ["pytest", "pytest-cov", "wheel"] - -[[package]] -name = "platformdirs" -version = "4.3.6" -description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`." -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb"}, - {file = "platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907"}, -] - -[package.extras] -docs = ["furo (>=2024.8.6)", "proselint (>=0.14)", "sphinx (>=8.0.2)", "sphinx-autodoc-typehints (>=2.4)"] -test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=8.3.2)", "pytest-cov (>=5)", "pytest-mock (>=3.14)"] -type = ["mypy (>=1.11.2)"] - -[[package]] -name = "pluggy" -version = "1.5.0" -description = "plugin and hook calling mechanisms for python" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"}, - {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"}, -] - -[package.extras] -dev = ["pre-commit", "tox"] -testing = ["pytest", "pytest-benchmark"] - -[[package]] -name = "poethepoet" -version = "0.34.0" -description = "A task runner that works well with poetry." -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "poethepoet-0.34.0-py3-none-any.whl", hash = "sha256:c472d6f0fdb341b48d346f4ccd49779840c15b30dfd6bc6347a80d6274b5e34e"}, - {file = "poethepoet-0.34.0.tar.gz", hash = "sha256:86203acce555bbfe45cb6ccac61ba8b16a5784264484195874da457ddabf5850"}, -] - -[package.dependencies] -pastel = ">=0.2.1,<0.3.0" -pyyaml = ">=6.0.2,<7.0" -tomli = {version = ">=1.2.2", markers = "python_version < \"3.11\""} - -[package.extras] -poetry-plugin = ["poetry (>=1.2.0,<3.0.0) ; python_version < \"4.0\""] - -[[package]] -name = "pre-commit" -version = "3.8.0" -description = "A framework for managing and maintaining multi-language pre-commit hooks." -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "pre_commit-3.8.0-py2.py3-none-any.whl", hash = "sha256:9a90a53bf82fdd8778d58085faf8d83df56e40dfe18f45b19446e26bf1b3a63f"}, - {file = "pre_commit-3.8.0.tar.gz", hash = "sha256:8bb6494d4a20423842e198980c9ecf9f96607a07ea29549e180eef9ae80fe7af"}, -] - -[package.dependencies] -cfgv = ">=2.0.0" -identify = ">=1.0.0" -nodeenv = ">=0.11.1" -pyyaml = ">=5.1" -virtualenv = ">=20.10.0" - -[[package]] -name = "py-algorand-sdk" -version = "2.11.0" -description = "Algorand SDK in Python" -optional = false -python-versions = ">=3.10" -groups = ["main"] -files = [ - {file = "py_algorand_sdk-2.11.0-py3-none-any.whl", hash = "sha256:4076b06b522a56620dbed7e75db422358e05bce446917fd13c3e512583af5a72"}, - {file = "py_algorand_sdk-2.11.0.tar.gz", hash = "sha256:d243ac8291f8e1be1d430ac431954a4748240c37c3f3e0678757e1b62e2792f8"}, -] - -[package.dependencies] -msgpack = ">=1.0.0,<2" -pycryptodomex = ">=3.6.0,<4" -pynacl = ">=1.4.0,<2" - -[[package]] -name = "py-serializable" -version = "1.1.2" -description = "Library for serializing and deserializing Python Objects to and from JSON and XML." -optional = false -python-versions = "<4.0,>=3.8" -groups = ["dev"] -files = [ - {file = "py_serializable-1.1.2-py3-none-any.whl", hash = "sha256:801be61b0a1ba64c3861f7c624f1de5cfbbabf8b458acc9cdda91e8f7e5effa1"}, - {file = "py_serializable-1.1.2.tar.gz", hash = "sha256:89af30bc319047d4aa0d8708af412f6ce73835e18bacf1a080028bb9e2f42bdb"}, -] - -[package.dependencies] -defusedxml = ">=0.7.1,<0.8.0" - -[[package]] -name = "pycparser" -version = "2.22" -description = "C parser in Python" -optional = false -python-versions = ">=3.8" -groups = ["main", "dev"] -files = [ - {file = "pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc"}, - {file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"}, -] -markers = {dev = "sys_platform == \"linux\" and platform_python_implementation != \"PyPy\""} - -[[package]] -name = "pycryptodomex" -version = "3.21.0" -description = "Cryptographic library for Python" -optional = false -python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" -groups = ["main"] -files = [ - {file = "pycryptodomex-3.21.0-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:dbeb84a399373df84a69e0919c1d733b89e049752426041deeb30d68e9867822"}, - {file = "pycryptodomex-3.21.0-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:a192fb46c95489beba9c3f002ed7d93979423d1b2a53eab8771dbb1339eb3ddd"}, - {file = "pycryptodomex-3.21.0-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:1233443f19d278c72c4daae749872a4af3787a813e05c3561c73ab0c153c7b0f"}, - {file = "pycryptodomex-3.21.0-cp27-cp27m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bbb07f88e277162b8bfca7134b34f18b400d84eac7375ce73117f865e3c80d4c"}, - {file = "pycryptodomex-3.21.0-cp27-cp27m-musllinux_1_1_aarch64.whl", hash = "sha256:e859e53d983b7fe18cb8f1b0e29d991a5c93be2c8dd25db7db1fe3bd3617f6f9"}, - {file = "pycryptodomex-3.21.0-cp27-cp27m-win32.whl", hash = "sha256:ef046b2e6c425647971b51424f0f88d8a2e0a2a63d3531817968c42078895c00"}, - {file = "pycryptodomex-3.21.0-cp27-cp27m-win_amd64.whl", hash = "sha256:da76ebf6650323eae7236b54b1b1f0e57c16483be6e3c1ebf901d4ada47563b6"}, - {file = "pycryptodomex-3.21.0-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:c07e64867a54f7e93186a55bec08a18b7302e7bee1b02fd84c6089ec215e723a"}, - {file = "pycryptodomex-3.21.0-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:56435c7124dd0ce0c8bdd99c52e5d183a0ca7fdcd06c5d5509423843f487dd0b"}, - {file = "pycryptodomex-3.21.0-cp27-cp27mu-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:65d275e3f866cf6fe891411be9c1454fb58809ccc5de6d3770654c47197acd65"}, - {file = "pycryptodomex-3.21.0-cp27-cp27mu-musllinux_1_1_aarch64.whl", hash = "sha256:5241bdb53bcf32a9568770a6584774b1b8109342bd033398e4ff2da052123832"}, - {file = "pycryptodomex-3.21.0-cp36-abi3-macosx_10_9_universal2.whl", hash = "sha256:34325b84c8b380675fd2320d0649cdcbc9cf1e0d1526edbe8fce43ed858cdc7e"}, - {file = "pycryptodomex-3.21.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:103c133d6cd832ae7266feb0a65b69e3a5e4dbbd6f3a3ae3211a557fd653f516"}, - {file = "pycryptodomex-3.21.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77ac2ea80bcb4b4e1c6a596734c775a1615d23e31794967416afc14852a639d3"}, - {file = "pycryptodomex-3.21.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9aa0cf13a1a1128b3e964dc667e5fe5c6235f7d7cfb0277213f0e2a783837cc2"}, - {file = "pycryptodomex-3.21.0-cp36-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:46eb1f0c8d309da63a2064c28de54e5e614ad17b7e2f88df0faef58ce192fc7b"}, - {file = "pycryptodomex-3.21.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:cc7e111e66c274b0df5f4efa679eb31e23c7545d702333dfd2df10ab02c2a2ce"}, - {file = "pycryptodomex-3.21.0-cp36-abi3-musllinux_1_2_i686.whl", hash = "sha256:770d630a5c46605ec83393feaa73a9635a60e55b112e1fb0c3cea84c2897aa0a"}, - {file = "pycryptodomex-3.21.0-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:52e23a0a6e61691134aa8c8beba89de420602541afaae70f66e16060fdcd677e"}, - {file = "pycryptodomex-3.21.0-cp36-abi3-win32.whl", hash = "sha256:a3d77919e6ff56d89aada1bd009b727b874d464cb0e2e3f00a49f7d2e709d76e"}, - {file = "pycryptodomex-3.21.0-cp36-abi3-win_amd64.whl", hash = "sha256:b0e9765f93fe4890f39875e6c90c96cb341767833cfa767f41b490b506fa9ec0"}, - {file = "pycryptodomex-3.21.0-pp27-pypy_73-manylinux2010_x86_64.whl", hash = "sha256:feaecdce4e5c0045e7a287de0c4351284391fe170729aa9182f6bd967631b3a8"}, - {file = "pycryptodomex-3.21.0-pp27-pypy_73-win32.whl", hash = "sha256:365aa5a66d52fd1f9e0530ea97f392c48c409c2f01ff8b9a39c73ed6f527d36c"}, - {file = "pycryptodomex-3.21.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:3efddfc50ac0ca143364042324046800c126a1d63816d532f2e19e6f2d8c0c31"}, - {file = "pycryptodomex-3.21.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0df2608682db8279a9ebbaf05a72f62a321433522ed0e499bc486a6889b96bf3"}, - {file = "pycryptodomex-3.21.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5823d03e904ea3e53aebd6799d6b8ec63b7675b5d2f4a4bd5e3adcb512d03b37"}, - {file = "pycryptodomex-3.21.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:27e84eeff24250ffec32722334749ac2a57a5fd60332cd6a0680090e7c42877e"}, - {file = "pycryptodomex-3.21.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:8ef436cdeea794015263853311f84c1ff0341b98fc7908e8a70595a68cefd971"}, - {file = "pycryptodomex-3.21.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a1058e6dfe827f4209c5cae466e67610bcd0d66f2f037465daa2a29d92d952b"}, - {file = "pycryptodomex-3.21.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9ba09a5b407cbb3bcb325221e346a140605714b5e880741dc9a1e9ecf1688d42"}, - {file = "pycryptodomex-3.21.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:8a9d8342cf22b74a746e3c6c9453cb0cfbb55943410e3a2619bd9164b48dc9d9"}, - {file = "pycryptodomex-3.21.0.tar.gz", hash = "sha256:222d0bd05381dd25c32dd6065c071ebf084212ab79bab4599ba9e6a3e0009e6c"}, -] - -[[package]] -name = "pydoclint" -version = "0.6.6" -description = "A Python docstring linter that checks arguments, returns, yields, and raises sections" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "pydoclint-0.6.6-py2.py3-none-any.whl", hash = "sha256:7ce8ed36f60f9201bf1c1edacb32c55eb051af80fdd7304480c6419ee0ced43c"}, - {file = "pydoclint-0.6.6.tar.gz", hash = "sha256:22862a8494d05cdf22574d6533f4c47933c0ae1674b0f8b961d6ef42536eaa69"}, -] - -[package.dependencies] -click = ">=8.1.0" -docstring_parser_fork = ">=0.0.12" -tomli = {version = ">=2.0.1", markers = "python_version < \"3.11\""} - -[package.extras] -flake8 = ["flake8 (>=4)"] - -[[package]] -name = "pygments" -version = "2.19.1" -description = "Pygments is a syntax highlighting package written in Python." -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c"}, - {file = "pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f"}, -] - -[package.extras] -windows-terminal = ["colorama (>=0.4.6)"] - -[[package]] -name = "pynacl" -version = "1.5.0" -description = "Python binding to the Networking and Cryptography (NaCl) library" -optional = false -python-versions = ">=3.6" -groups = ["main"] -files = [ - {file = "PyNaCl-1.5.0-cp36-abi3-macosx_10_10_universal2.whl", hash = "sha256:401002a4aaa07c9414132aaed7f6836ff98f59277a234704ff66878c2ee4a0d1"}, - {file = "PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:52cb72a79269189d4e0dc537556f4740f7f0a9ec41c1322598799b0bdad4ef92"}, - {file = "PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a36d4a9dda1f19ce6e03c9a784a2921a4b726b02e1c736600ca9c22029474394"}, - {file = "PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:0c84947a22519e013607c9be43706dd42513f9e6ae5d39d3613ca1e142fba44d"}, - {file = "PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:06b8f6fa7f5de8d5d2f7573fe8c863c051225a27b61e6860fd047b1775807858"}, - {file = "PyNaCl-1.5.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:a422368fc821589c228f4c49438a368831cb5bbc0eab5ebe1d7fac9dded6567b"}, - {file = "PyNaCl-1.5.0-cp36-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:61f642bf2378713e2c2e1de73444a3778e5f0a38be6fee0fe532fe30060282ff"}, - {file = "PyNaCl-1.5.0-cp36-abi3-win32.whl", hash = "sha256:e46dae94e34b085175f8abb3b0aaa7da40767865ac82c928eeb9e57e1ea8a543"}, - {file = "PyNaCl-1.5.0-cp36-abi3-win_amd64.whl", hash = "sha256:20f42270d27e1b6a29f54032090b972d97f0a1b0948cc52392041ef7831fee93"}, - {file = "PyNaCl-1.5.0.tar.gz", hash = "sha256:8ac7448f09ab85811607bdd21ec2464495ac8b7c66d146bf545b0f08fb9220ba"}, -] - -[package.dependencies] -cffi = ">=1.4.1" - -[package.extras] -docs = ["sphinx (>=1.6.5)", "sphinx-rtd-theme"] -tests = ["hypothesis (>=3.27.0)", "pytest (>=3.2.1,!=3.3.0)"] - -[[package]] -name = "pyparsing" -version = "3.2.1" -description = "pyparsing module - Classes and methods to define and execute parsing grammars" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "pyparsing-3.2.1-py3-none-any.whl", hash = "sha256:506ff4f4386c4cec0590ec19e6302d3aedb992fdc02c761e90416f158dacf8e1"}, - {file = "pyparsing-3.2.1.tar.gz", hash = "sha256:61980854fd66de3a90028d679a954d5f2623e83144b5afe5ee86f43d762e5f0a"}, -] - -[package.extras] -diagrams = ["jinja2", "railroad-diagrams"] - -[[package]] -name = "pytest" -version = "8.3.5" -description = "pytest: simple powerful testing with Python" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "pytest-8.3.5-py3-none-any.whl", hash = "sha256:c69214aa47deac29fad6c2a4f590b9c4a9fdb16a403176fe154b79c0b4d4d820"}, - {file = "pytest-8.3.5.tar.gz", hash = "sha256:f4efe70cc14e511565ac476b57c279e12a855b11f48f212af1080ef2263d3845"}, -] - -[package.dependencies] -colorama = {version = "*", markers = "sys_platform == \"win32\""} -exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""} -iniconfig = "*" -packaging = "*" -pluggy = ">=1.5,<2" -tomli = {version = ">=1", markers = "python_version < \"3.11\""} - -[package.extras] -dev = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"] - -[[package]] -name = "pytest-cov" -version = "6.1.1" -description = "Pytest plugin for measuring coverage." -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "pytest_cov-6.1.1-py3-none-any.whl", hash = "sha256:bddf29ed2d0ab6f4df17b4c55b0a657287db8684af9c42ea546b21b1041b3dde"}, - {file = "pytest_cov-6.1.1.tar.gz", hash = "sha256:46935f7aaefba760e716c2ebfbe1c216240b9592966e7da99ea8292d4d3e2a0a"}, -] - -[package.dependencies] -coverage = {version = ">=7.5", extras = ["toml"]} -pytest = ">=4.6" - -[package.extras] -testing = ["fields", "hunter", "process-tests", "pytest-xdist", "virtualenv"] - -[[package]] -name = "pytest-httpx" -version = "0.35.0" -description = "Send responses to httpx." -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "pytest_httpx-0.35.0-py3-none-any.whl", hash = "sha256:ee11a00ffcea94a5cbff47af2114d34c5b231c326902458deed73f9c459fd744"}, - {file = "pytest_httpx-0.35.0.tar.gz", hash = "sha256:d619ad5d2e67734abfbb224c3d9025d64795d4b8711116b1a13f72a251ae511f"}, -] - -[package.dependencies] -httpx = "==0.28.*" -pytest = "==8.*" - -[package.extras] -testing = ["pytest-asyncio (==0.24.*)", "pytest-cov (==6.*)"] - -[[package]] -name = "pytest-mock" -version = "3.14.0" -description = "Thin-wrapper around the mock package for easier use with pytest" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "pytest-mock-3.14.0.tar.gz", hash = "sha256:2719255a1efeceadbc056d6bf3df3d1c5015530fb40cf347c0f9afac88410bd0"}, - {file = "pytest_mock-3.14.0-py3-none-any.whl", hash = "sha256:0b72c38033392a5f4621342fe11e9219ac11ec9d375f8e2a0c164539e0d70f6f"}, -] - -[package.dependencies] -pytest = ">=6.2.5" - -[package.extras] -dev = ["pre-commit", "pytest-asyncio", "tox"] - -[[package]] -name = "pytest-sugar" -version = "1.0.0" -description = "pytest-sugar is a plugin for pytest that changes the default look and feel of pytest (e.g. progressbar, show tests that fail instantly)." -optional = false -python-versions = "*" -groups = ["dev"] -files = [ - {file = "pytest-sugar-1.0.0.tar.gz", hash = "sha256:6422e83258f5b0c04ce7c632176c7732cab5fdb909cb39cca5c9139f81276c0a"}, - {file = "pytest_sugar-1.0.0-py3-none-any.whl", hash = "sha256:70ebcd8fc5795dc457ff8b69d266a4e2e8a74ae0c3edc749381c64b5246c8dfd"}, -] - -[package.dependencies] -packaging = ">=21.3" -pytest = ">=6.2.0" -termcolor = ">=2.1.0" - -[package.extras] -dev = ["black", "flake8", "pre-commit"] - -[[package]] -name = "pytest-xdist" -version = "3.6.1" -description = "pytest xdist plugin for distributed testing, most importantly across multiple CPUs" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "pytest_xdist-3.6.1-py3-none-any.whl", hash = "sha256:9ed4adfb68a016610848639bb7e02c9352d5d9f03d04809919e2dafc3be4cca7"}, - {file = "pytest_xdist-3.6.1.tar.gz", hash = "sha256:ead156a4db231eec769737f57668ef58a2084a34b2e55c4a8fa20d861107300d"}, -] - -[package.dependencies] -execnet = ">=2.1" -pytest = ">=7.0.0" - -[package.extras] -psutil = ["psutil (>=3.0)"] -setproctitle = ["setproctitle"] -testing = ["filelock"] - -[[package]] -name = "python-dotenv" -version = "1.1.0" -description = "Read key-value pairs from a .env file and set them as environment variables" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "python_dotenv-1.1.0-py3-none-any.whl", hash = "sha256:d7c01d9e2293916c18baf562d95698754b0dbbb5e74d457c45d4f6561fb9d55d"}, - {file = "python_dotenv-1.1.0.tar.gz", hash = "sha256:41f90bc6f5f177fb41f53e87666db362025010eb28f60a01c9143bfa33a2b2d5"}, -] - -[package.extras] -cli = ["click (>=5.0)"] - -[[package]] -name = "python-gitlab" -version = "3.15.0" -description = "Interact with GitLab API" -optional = false -python-versions = ">=3.7.0" -groups = ["dev"] -files = [ - {file = "python-gitlab-3.15.0.tar.gz", hash = "sha256:c9e65eb7612a9fbb8abf0339972eca7fd7a73d4da66c9b446ffe528930aff534"}, - {file = "python_gitlab-3.15.0-py3-none-any.whl", hash = "sha256:8f8d1c0d387f642eb1ac7bf5e8e0cd8b3dd49c6f34170cee3c7deb7d384611f3"}, -] - -[package.dependencies] -requests = ">=2.25.0" -requests-toolbelt = ">=0.10.1" - -[package.extras] -autocompletion = ["argcomplete (>=1.10.0,<3)"] -yaml = ["PyYaml (>=5.2)"] - -[[package]] -name = "python-semantic-release" -version = "7.34.6" -description = "Automatic Semantic Versioning for Python projects" -optional = false -python-versions = "*" -groups = ["dev"] -files = [ - {file = "python-semantic-release-7.34.6.tar.gz", hash = "sha256:e9b8fb788024ae9510a924136d573588415a16eeca31cc5240f2754a80a2e831"}, - {file = "python_semantic_release-7.34.6-py3-none-any.whl", hash = "sha256:7e3969ba4663d9b2087b02bf3ac140e202551377bf045c34e09bfe19753e19ab"}, -] - -[package.dependencies] -click = ">=7,<9" -click-log = ">=0.3,<1" -dotty-dict = ">=1.3.0,<2" -gitpython = ">=3.0.8,<4" -invoke = ">=1.4.1,<3" -packaging = "*" -python-gitlab = ">=2,<4" -requests = ">=2.25,<3" -semver = ">=2.10,<3" -tomlkit = ">=0.10,<1.0" -twine = ">=3,<4" -wheel = "*" - -[package.extras] -dev = ["black", "isort", "tox"] -docs = ["Jinja2 (==3.0.3)", "Sphinx (==1.8.6)"] -mypy = ["mypy", "types-requests"] -test = ["coverage (>=5,<6)", "mock (==1.3.0)", "pytest (>=7,<8)", "pytest-mock (>=2,<3)", "pytest-xdist (>=1,<2)", "responses (==0.13.3)"] - -[[package]] -name = "pywin32-ctypes" -version = "0.2.3" -description = "A (partial) reimplementation of pywin32 using ctypes/cffi" -optional = false -python-versions = ">=3.6" -groups = ["dev"] -markers = "sys_platform == \"win32\"" -files = [ - {file = "pywin32-ctypes-0.2.3.tar.gz", hash = "sha256:d162dc04946d704503b2edc4d55f3dba5c1d539ead017afa00142c38b9885755"}, - {file = "pywin32_ctypes-0.2.3-py3-none-any.whl", hash = "sha256:8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8"}, -] - -[[package]] -name = "pyyaml" -version = "6.0.2" -description = "YAML parser and emitter for Python" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086"}, - {file = "PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf"}, - {file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237"}, - {file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b"}, - {file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed"}, - {file = "PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180"}, - {file = "PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68"}, - {file = "PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99"}, - {file = "PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e"}, - {file = "PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774"}, - {file = "PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee"}, - {file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c"}, - {file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317"}, - {file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85"}, - {file = "PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4"}, - {file = "PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e"}, - {file = "PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5"}, - {file = "PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44"}, - {file = "PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab"}, - {file = "PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725"}, - {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5"}, - {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425"}, - {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476"}, - {file = "PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48"}, - {file = "PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b"}, - {file = "PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4"}, - {file = "PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8"}, - {file = "PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba"}, - {file = "PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1"}, - {file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133"}, - {file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484"}, - {file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5"}, - {file = "PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc"}, - {file = "PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652"}, - {file = "PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183"}, - {file = "PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563"}, - {file = "PyYAML-6.0.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:24471b829b3bf607e04e88d79542a9d48bb037c2267d7927a874e6c205ca7e9a"}, - {file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7fded462629cfa4b685c5416b949ebad6cec74af5e2d42905d41e257e0869f5"}, - {file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d84a1718ee396f54f3a086ea0a66d8e552b2ab2017ef8b420e92edbc841c352d"}, - {file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9056c1ecd25795207ad294bcf39f2db3d845767be0ea6e6a34d856f006006083"}, - {file = "PyYAML-6.0.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:82d09873e40955485746739bcb8b4586983670466c23382c19cffecbf1fd8706"}, - {file = "PyYAML-6.0.2-cp38-cp38-win32.whl", hash = "sha256:43fa96a3ca0d6b1812e01ced1044a003533c47f6ee8aca31724f78e93ccc089a"}, - {file = "PyYAML-6.0.2-cp38-cp38-win_amd64.whl", hash = "sha256:01179a4a8559ab5de078078f37e5c1a30d76bb88519906844fd7bdea1b7729ff"}, - {file = "PyYAML-6.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:688ba32a1cffef67fd2e9398a2efebaea461578b0923624778664cc1c914db5d"}, - {file = "PyYAML-6.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8786accb172bd8afb8be14490a16625cbc387036876ab6ba70912730faf8e1f"}, - {file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8e03406cac8513435335dbab54c0d385e4a49e4945d2909a581c83647ca0290"}, - {file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f753120cb8181e736c57ef7636e83f31b9c0d1722c516f7e86cf15b7aa57ff12"}, - {file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b1fdb9dc17f5a7677423d508ab4f243a726dea51fa5e70992e59a7411c89d19"}, - {file = "PyYAML-6.0.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0b69e4ce7a131fe56b7e4d770c67429700908fc0752af059838b1cfb41960e4e"}, - {file = "PyYAML-6.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a9f8c2e67970f13b16084e04f134610fd1d374bf477b17ec1599185cf611d725"}, - {file = "PyYAML-6.0.2-cp39-cp39-win32.whl", hash = "sha256:6395c297d42274772abc367baaa79683958044e5d3835486c16da75d2a694631"}, - {file = "PyYAML-6.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:39693e1f8320ae4f43943590b49779ffb98acb81f788220ea932a6b6c51004d8"}, - {file = "pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e"}, -] - -[[package]] -name = "readme-renderer" -version = "44.0" -description = "readme_renderer is a library for rendering readme descriptions for Warehouse" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "readme_renderer-44.0-py3-none-any.whl", hash = "sha256:2fbca89b81a08526aadf1357a8c2ae889ec05fb03f5da67f9769c9a592166151"}, - {file = "readme_renderer-44.0.tar.gz", hash = "sha256:8712034eabbfa6805cacf1402b4eeb2a73028f72d1166d6f5cb7f9c047c5d1e1"}, -] - -[package.dependencies] -docutils = ">=0.21.2" -nh3 = ">=0.2.14" -Pygments = ">=2.5.1" - -[package.extras] -md = ["cmarkgfm (>=0.8.0)"] - -[[package]] -name = "requests" -version = "2.32.4" -description = "Python HTTP for Humans." -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "requests-2.32.4-py3-none-any.whl", hash = "sha256:27babd3cda2a6d50b30443204ee89830707d396671944c998b5975b031ac2b2c"}, - {file = "requests-2.32.4.tar.gz", hash = "sha256:27d0316682c8a29834d3264820024b62a36942083d52caf2f14c0591336d3422"}, -] - -[package.dependencies] -certifi = ">=2017.4.17" -charset_normalizer = ">=2,<4" -idna = ">=2.5,<4" -urllib3 = ">=1.21.1,<3" - -[package.extras] -socks = ["PySocks (>=1.5.6,!=1.5.7)"] -use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] - -[[package]] -name = "requests-toolbelt" -version = "1.0.0" -description = "A utility belt for advanced users of python-requests" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" -groups = ["dev"] -files = [ - {file = "requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6"}, - {file = "requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06"}, -] - -[package.dependencies] -requests = ">=2.0.1,<3.0.0" - -[[package]] -name = "rfc3986" -version = "1.5.0" -description = "Validating URI References per RFC 3986" -optional = false -python-versions = "*" -groups = ["dev"] -files = [ - {file = "rfc3986-1.5.0-py2.py3-none-any.whl", hash = "sha256:a86d6e1f5b1dc238b218b012df0aa79409667bb209e58da56d0b94704e712a97"}, - {file = "rfc3986-1.5.0.tar.gz", hash = "sha256:270aaf10d87d0d4e095063c65bf3ddbc6ee3d0b226328ce21e036f946e421835"}, -] - -[package.extras] -idna2008 = ["idna"] - -[[package]] -name = "rich" -version = "13.9.4" -description = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal" -optional = false -python-versions = ">=3.8.0" -groups = ["dev"] -files = [ - {file = "rich-13.9.4-py3-none-any.whl", hash = "sha256:6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90"}, - {file = "rich-13.9.4.tar.gz", hash = "sha256:439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098"}, -] - -[package.dependencies] -markdown-it-py = ">=2.2.0" -pygments = ">=2.13.0,<3.0.0" -typing-extensions = {version = ">=4.0.0,<5.0", markers = "python_version < \"3.11\""} - -[package.extras] -jupyter = ["ipywidgets (>=7.5.1,<9)"] - -[[package]] -name = "ruff" -version = "0.11.8" -description = "An extremely fast Python linter and code formatter, written in Rust." -optional = false -python-versions = ">=3.7" -groups = ["dev"] -files = [ - {file = "ruff-0.11.8-py3-none-linux_armv6l.whl", hash = "sha256:896a37516c594805e34020c4a7546c8f8a234b679a7716a3f08197f38913e1a3"}, - {file = "ruff-0.11.8-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ab86d22d3d721a40dd3ecbb5e86ab03b2e053bc93c700dc68d1c3346b36ce835"}, - {file = "ruff-0.11.8-py3-none-macosx_11_0_arm64.whl", hash = "sha256:258f3585057508d317610e8a412788cf726efeefa2fec4dba4001d9e6f90d46c"}, - {file = "ruff-0.11.8-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:727d01702f7c30baed3fc3a34901a640001a2828c793525043c29f7614994a8c"}, - {file = "ruff-0.11.8-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3dca977cc4fc8f66e89900fa415ffe4dbc2e969da9d7a54bfca81a128c5ac219"}, - {file = "ruff-0.11.8-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c657fa987d60b104d2be8b052d66da0a2a88f9bd1d66b2254333e84ea2720c7f"}, - {file = "ruff-0.11.8-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:f2e74b021d0de5eceb8bd32919f6ff8a9b40ee62ed97becd44993ae5b9949474"}, - {file = "ruff-0.11.8-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f9b5ef39820abc0f2c62111f7045009e46b275f5b99d5e59dda113c39b7f4f38"}, - {file = "ruff-0.11.8-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c1dba3135ca503727aa4648152c0fa67c3b1385d3dc81c75cd8a229c4b2a1458"}, - {file = "ruff-0.11.8-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f024d32e62faad0f76b2d6afd141b8c171515e4fb91ce9fd6464335c81244e5"}, - {file = "ruff-0.11.8-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:d365618d3ad747432e1ae50d61775b78c055fee5936d77fb4d92c6f559741948"}, - {file = "ruff-0.11.8-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:4d9aaa91035bdf612c8ee7266153bcf16005c7c7e2f5878406911c92a31633cb"}, - {file = "ruff-0.11.8-py3-none-musllinux_1_2_i686.whl", hash = "sha256:0eba551324733efc76116d9f3a0d52946bc2751f0cd30661564117d6fd60897c"}, - {file = "ruff-0.11.8-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:161eb4cff5cfefdb6c9b8b3671d09f7def2f960cee33481dd898caf2bcd02304"}, - {file = "ruff-0.11.8-py3-none-win32.whl", hash = "sha256:5b18caa297a786465cc511d7f8be19226acf9c0a1127e06e736cd4e1878c3ea2"}, - {file = "ruff-0.11.8-py3-none-win_amd64.whl", hash = "sha256:6e70d11043bef637c5617297bdedec9632af15d53ac1e1ba29c448da9341b0c4"}, - {file = "ruff-0.11.8-py3-none-win_arm64.whl", hash = "sha256:304432e4c4a792e3da85b7699feb3426a0908ab98bf29df22a31b0cdd098fac2"}, - {file = "ruff-0.11.8.tar.gz", hash = "sha256:6d742d10626f9004b781f4558154bb226620a7242080e11caeffab1a40e99df8"}, -] - -[[package]] -name = "secretstorage" -version = "3.3.3" -description = "Python bindings to FreeDesktop.org Secret Service API" -optional = false -python-versions = ">=3.6" -groups = ["dev"] -markers = "sys_platform == \"linux\"" -files = [ - {file = "SecretStorage-3.3.3-py3-none-any.whl", hash = "sha256:f356e6628222568e3af06f2eba8df495efa13b3b63081dafd4f7d9a7b7bc9f99"}, - {file = "SecretStorage-3.3.3.tar.gz", hash = "sha256:2403533ef369eca6d2ba81718576c5e0f564d5cca1b58f73a8b23e7d4eeebd77"}, -] - -[package.dependencies] -cryptography = ">=2.0" -jeepney = ">=0.6" - -[[package]] -name = "semver" -version = "2.13.0" -description = "Python helper for Semantic Versioning (http://semver.org/)" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" -groups = ["dev"] -files = [ - {file = "semver-2.13.0-py2.py3-none-any.whl", hash = "sha256:ced8b23dceb22134307c1b8abfa523da14198793d9787ac838e70e29e77458d4"}, - {file = "semver-2.13.0.tar.gz", hash = "sha256:fa0fe2722ee1c3f57eac478820c3a5ae2f624af8264cbdf9000c980ff7f75e3f"}, -] - -[[package]] -name = "setuptools" -version = "80.9.0" -description = "Easily download, build, install, upgrade, and uninstall Python packages" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "setuptools-80.9.0-py3-none-any.whl", hash = "sha256:062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922"}, - {file = "setuptools-80.9.0.tar.gz", hash = "sha256:f36b47402ecde768dbfafc46e8e4207b4360c654f1f3bb84475f0a28628fb19c"}, -] - -[package.extras] -check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\"", "ruff (>=0.8.0) ; sys_platform != \"cygwin\""] -core = ["importlib_metadata (>=6) ; python_version < \"3.10\"", "jaraco.functools (>=4)", "jaraco.text (>=3.7)", "more_itertools", "more_itertools (>=8.8)", "packaging (>=24.2)", "platformdirs (>=4.2.2)", "tomli (>=2.0.1) ; python_version < \"3.11\"", "wheel (>=0.43.0)"] -cover = ["pytest-cov"] -doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "pyproject-hooks (!=1.1)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier", "towncrier (<24.7)"] -enabler = ["pytest-enabler (>=2.2)"] -test = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "ini2toml[lite] (>=0.14)", "jaraco.develop (>=7.21) ; python_version >= \"3.9\" and sys_platform != \"cygwin\"", "jaraco.envs (>=2.2)", "jaraco.path (>=3.7.2)", "jaraco.test (>=5.5)", "packaging (>=24.2)", "pip (>=19.1)", "pyproject-hooks (!=1.1)", "pytest (>=6,!=8.1.*)", "pytest-home (>=0.5)", "pytest-perf ; sys_platform != \"cygwin\"", "pytest-subprocess", "pytest-timeout", "pytest-xdist (>=3)", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel (>=0.44.0)"] -type = ["importlib_metadata (>=7.0.2) ; python_version < \"3.10\"", "jaraco.develop (>=7.21) ; sys_platform != \"cygwin\"", "mypy (==1.14.*)", "pytest-mypy"] - -[[package]] -name = "smmap" -version = "5.0.2" -description = "A pure Python implementation of a sliding window memory map manager" -optional = false -python-versions = ">=3.7" -groups = ["dev"] -files = [ - {file = "smmap-5.0.2-py3-none-any.whl", hash = "sha256:b30115f0def7d7531d22a0fb6502488d879e75b260a9db4d0819cfb25403af5e"}, - {file = "smmap-5.0.2.tar.gz", hash = "sha256:26ea65a03958fa0c8a1c7e8c7a58fdc77221b8910f6be2131affade476898ad5"}, -] - -[[package]] -name = "sniffio" -version = "1.3.1" -description = "Sniff out which async library your code is running under" -optional = false -python-versions = ">=3.7" -groups = ["main", "dev"] -files = [ - {file = "sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2"}, - {file = "sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc"}, -] - -[[package]] -name = "snowballstemmer" -version = "2.2.0" -description = "This package provides 29 stemmers for 28 languages generated from Snowball algorithms." -optional = false -python-versions = "*" -groups = ["dev"] -files = [ - {file = "snowballstemmer-2.2.0-py2.py3-none-any.whl", hash = "sha256:c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a"}, - {file = "snowballstemmer-2.2.0.tar.gz", hash = "sha256:09b16deb8547d3412ad7b590689584cd0fe25ec8db3be37788be3810cbf19cb1"}, -] - -[[package]] -name = "sortedcontainers" -version = "2.4.0" -description = "Sorted Containers -- Sorted List, Sorted Dict, Sorted Set" -optional = false -python-versions = "*" -groups = ["dev"] -files = [ - {file = "sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0"}, - {file = "sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88"}, -] - -[[package]] -name = "soupsieve" -version = "2.6" -description = "A modern CSS selector implementation for Beautiful Soup." -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9"}, - {file = "soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb"}, -] - -[[package]] -name = "sphinx" -version = "8.1.3" -description = "Python documentation generator" -optional = false -python-versions = ">=3.10" -groups = ["dev"] -files = [ - {file = "sphinx-8.1.3-py3-none-any.whl", hash = "sha256:09719015511837b76bf6e03e42eb7595ac8c2e41eeb9c29c5b755c6b677992a2"}, - {file = "sphinx-8.1.3.tar.gz", hash = "sha256:43c1911eecb0d3e161ad78611bc905d1ad0e523e4ddc202a58a821773dc4c927"}, -] - -[package.dependencies] -alabaster = ">=0.7.14" -babel = ">=2.13" -colorama = {version = ">=0.4.6", markers = "sys_platform == \"win32\""} -docutils = ">=0.20,<0.22" -imagesize = ">=1.3" -Jinja2 = ">=3.1" -packaging = ">=23.0" -Pygments = ">=2.17" -requests = ">=2.30.0" -snowballstemmer = ">=2.2" -sphinxcontrib-applehelp = ">=1.0.7" -sphinxcontrib-devhelp = ">=1.0.6" -sphinxcontrib-htmlhelp = ">=2.0.6" -sphinxcontrib-jsmath = ">=1.0.1" -sphinxcontrib-qthelp = ">=1.0.6" -sphinxcontrib-serializinghtml = ">=1.1.9" -tomli = {version = ">=2", markers = "python_version < \"3.11\""} - -[package.extras] -docs = ["sphinxcontrib-websupport"] -lint = ["flake8 (>=6.0)", "mypy (==1.11.1)", "pyright (==1.1.384)", "pytest (>=6.0)", "ruff (==0.6.9)", "sphinx-lint (>=0.9)", "tomli (>=2)", "types-Pillow (==10.2.0.20240822)", "types-Pygments (==2.18.0.20240506)", "types-colorama (==0.4.15.20240311)", "types-defusedxml (==0.7.0.20240218)", "types-docutils (==0.21.0.20241005)", "types-requests (==2.32.0.20240914)", "types-urllib3 (==1.26.25.14)"] -test = ["cython (>=3.0)", "defusedxml (>=0.7.1)", "pytest (>=8.0)", "setuptools (>=70.0)", "typing_extensions (>=4.9)"] - -[[package]] -name = "sphinx-autoapi" -version = "3.6.0" -description = "Sphinx API documentation generator" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "sphinx_autoapi-3.6.0-py3-none-any.whl", hash = "sha256:f3b66714493cab140b0e896d33ce7137654a16ac1edb6563edcbd47bf975f711"}, - {file = "sphinx_autoapi-3.6.0.tar.gz", hash = "sha256:c685f274e41d0842ae7e199460c322c4bd7fec816ccc2da8d806094b4f64af06"}, -] - -[package.dependencies] -astroid = [ - {version = ">=2.7", markers = "python_version < \"3.12\""}, - {version = ">=3", markers = "python_version >= \"3.12\""}, -] -Jinja2 = "*" -PyYAML = "*" -sphinx = ">=7.4.0" - -[[package]] -name = "sphinx-autobuild" -version = "2024.10.3" -description = "Rebuild Sphinx documentation on changes, with hot reloading in the browser." -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "sphinx_autobuild-2024.10.3-py3-none-any.whl", hash = "sha256:158e16c36f9d633e613c9aaf81c19b0fc458ca78b112533b20dafcda430d60fa"}, - {file = "sphinx_autobuild-2024.10.3.tar.gz", hash = "sha256:248150f8f333e825107b6d4b86113ab28fa51750e5f9ae63b59dc339be951fb1"}, -] - -[package.dependencies] -colorama = ">=0.4.6" -sphinx = "*" -starlette = ">=0.35" -uvicorn = ">=0.25" -watchfiles = ">=0.20" -websockets = ">=11" - -[package.extras] -test = ["httpx", "pytest (>=6)"] - -[[package]] -name = "sphinx-basic-ng" -version = "1.0.0b2" -description = "A modern skeleton for Sphinx themes." -optional = false -python-versions = ">=3.7" -groups = ["dev"] -files = [ - {file = "sphinx_basic_ng-1.0.0b2-py3-none-any.whl", hash = "sha256:eb09aedbabfb650607e9b4b68c9d240b90b1e1be221d6ad71d61c52e29f7932b"}, - {file = "sphinx_basic_ng-1.0.0b2.tar.gz", hash = "sha256:9ec55a47c90c8c002b5960c57492ec3021f5193cb26cebc2dc4ea226848651c9"}, -] - -[package.dependencies] -sphinx = ">=4.0" - -[package.extras] -docs = ["furo", "ipython", "myst-parser", "sphinx-copybutton", "sphinx-inline-tabs"] - -[[package]] -name = "sphinx-markdown-builder" -version = "0.6.8" -description = "A Sphinx extension to add markdown generation support." -optional = false -python-versions = ">=3.7" -groups = ["dev"] -files = [ - {file = "sphinx_markdown_builder-0.6.8-py3-none-any.whl", hash = "sha256:f04ab42d52449363228b9104569c56b778534f9c41a168af8cfc721a1e0e3edc"}, - {file = "sphinx_markdown_builder-0.6.8.tar.gz", hash = "sha256:6141b566bf18dd1cd515a0a90efd91c6c4d10fc638554fab2fd19cba66543dd7"}, -] - -[package.dependencies] -docutils = "*" -sphinx = ">=5.1.0" -tabulate = "*" - -[package.extras] -dev = ["black", "bumpver", "coveralls", "flake8", "isort", "pip-tools", "pylint", "pytest", "pytest-cov", "sphinx (>=5.3.0)", "sphinxcontrib-plantuml", "sphinxcontrib.httpdomain"] - -[[package]] -name = "sphinxcontrib-applehelp" -version = "2.0.0" -description = "sphinxcontrib-applehelp is a Sphinx extension which outputs Apple help books" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5"}, - {file = "sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1"}, -] - -[package.extras] -lint = ["mypy", "ruff (==0.5.5)", "types-docutils"] -standalone = ["Sphinx (>=5)"] -test = ["pytest"] - -[[package]] -name = "sphinxcontrib-devhelp" -version = "2.0.0" -description = "sphinxcontrib-devhelp is a sphinx extension which outputs Devhelp documents" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2"}, - {file = "sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad"}, -] - -[package.extras] -lint = ["mypy", "ruff (==0.5.5)", "types-docutils"] -standalone = ["Sphinx (>=5)"] -test = ["pytest"] - -[[package]] -name = "sphinxcontrib-htmlhelp" -version = "2.1.0" -description = "sphinxcontrib-htmlhelp is a sphinx extension which renders HTML help files" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8"}, - {file = "sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9"}, -] - -[package.extras] -lint = ["mypy", "ruff (==0.5.5)", "types-docutils"] -standalone = ["Sphinx (>=5)"] -test = ["html5lib", "pytest"] - -[[package]] -name = "sphinxcontrib-jsmath" -version = "1.0.1" -description = "A sphinx extension which renders display math in HTML via JavaScript" -optional = false -python-versions = ">=3.5" -groups = ["dev"] -files = [ - {file = "sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8"}, - {file = "sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178"}, -] - -[package.extras] -test = ["flake8", "mypy", "pytest"] - -[[package]] -name = "sphinxcontrib-qthelp" -version = "2.0.0" -description = "sphinxcontrib-qthelp is a sphinx extension which outputs QtHelp documents" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb"}, - {file = "sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab"}, -] - -[package.extras] -lint = ["mypy", "ruff (==0.5.5)", "types-docutils"] -standalone = ["Sphinx (>=5)"] -test = ["defusedxml (>=0.7.1)", "pytest"] - -[[package]] -name = "sphinxcontrib-serializinghtml" -version = "2.0.0" -description = "sphinxcontrib-serializinghtml is a sphinx extension which outputs \"serialized\" HTML files (json and pickle)" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331"}, - {file = "sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d"}, -] - -[package.extras] -lint = ["mypy", "ruff (==0.5.5)", "types-docutils"] -standalone = ["Sphinx (>=5)"] -test = ["pytest"] - -[[package]] -name = "starlette" -version = "0.50.0" -description = "The little ASGI library that shines." -optional = false -python-versions = ">=3.10" -groups = ["dev"] -files = [ - {file = "starlette-0.50.0-py3-none-any.whl", hash = "sha256:9e5391843ec9b6e472eed1365a78c8098cfceb7a74bfd4d6b1c0c0095efb3bca"}, - {file = "starlette-0.50.0.tar.gz", hash = "sha256:a2a17b22203254bcbc2e1f926d2d55f3f9497f769416b3190768befe598fa3ca"}, -] - -[package.dependencies] -anyio = ">=3.6.2,<5" -typing-extensions = {version = ">=4.10.0", markers = "python_version < \"3.13\""} - -[package.extras] -full = ["httpx (>=0.27.0,<0.29.0)", "itsdangerous", "jinja2", "python-multipart (>=0.0.18)", "pyyaml"] - -[[package]] -name = "tabulate" -version = "0.9.0" -description = "Pretty-print tabular data" -optional = false -python-versions = ">=3.7" -groups = ["dev"] -files = [ - {file = "tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f"}, - {file = "tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c"}, -] - -[package.extras] -widechars = ["wcwidth"] - -[[package]] -name = "termcolor" -version = "2.5.0" -description = "ANSI color formatting for output in terminal" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "termcolor-2.5.0-py3-none-any.whl", hash = "sha256:37b17b5fc1e604945c2642c872a3764b5d547a48009871aea3edd3afa180afb8"}, - {file = "termcolor-2.5.0.tar.gz", hash = "sha256:998d8d27da6d48442e8e1f016119076b690d962507531df4890fcd2db2ef8a6f"}, -] - -[package.extras] -tests = ["pytest", "pytest-cov"] - -[[package]] -name = "toml" -version = "0.10.2" -description = "Python Library for Tom's Obvious, Minimal Language" -optional = false -python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*" -groups = ["dev"] -files = [ - {file = "toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b"}, - {file = "toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"}, -] - -[[package]] -name = "tomli" -version = "2.2.1" -description = "A lil' TOML parser" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -markers = "python_full_version <= \"3.11.0a6\"" -files = [ - {file = "tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249"}, - {file = "tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6"}, - {file = "tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a"}, - {file = "tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee"}, - {file = "tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e"}, - {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4"}, - {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106"}, - {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8"}, - {file = "tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff"}, - {file = "tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b"}, - {file = "tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea"}, - {file = "tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8"}, - {file = "tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192"}, - {file = "tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222"}, - {file = "tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77"}, - {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6"}, - {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd"}, - {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e"}, - {file = "tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98"}, - {file = "tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4"}, - {file = "tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7"}, - {file = "tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c"}, - {file = "tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13"}, - {file = "tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281"}, - {file = "tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272"}, - {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140"}, - {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2"}, - {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744"}, - {file = "tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec"}, - {file = "tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69"}, - {file = "tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc"}, - {file = "tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff"}, -] - -[[package]] -name = "tomlkit" -version = "0.13.2" -description = "Style preserving TOML library" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "tomlkit-0.13.2-py3-none-any.whl", hash = "sha256:7a974427f6e119197f670fbbbeae7bef749a6c14e793db934baefc1b5f03efde"}, - {file = "tomlkit-0.13.2.tar.gz", hash = "sha256:fff5fe59a87295b278abd31bec92c15d9bc4a06885ab12bcea52c71119392e79"}, -] - -[[package]] -name = "tqdm" -version = "4.67.1" -description = "Fast, Extensible Progress Meter" -optional = false -python-versions = ">=3.7" -groups = ["dev"] -files = [ - {file = "tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2"}, - {file = "tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2"}, -] - -[package.dependencies] -colorama = {version = "*", markers = "platform_system == \"Windows\""} - -[package.extras] -dev = ["nbval", "pytest (>=6)", "pytest-asyncio (>=0.24)", "pytest-cov", "pytest-timeout"] -discord = ["requests"] -notebook = ["ipywidgets (>=6)"] -slack = ["slack-sdk"] -telegram = ["requests"] - -[[package]] -name = "twine" -version = "3.8.0" -description = "Collection of utilities for publishing packages on PyPI" -optional = false -python-versions = ">=3.6" -groups = ["dev"] -files = [ - {file = "twine-3.8.0-py3-none-any.whl", hash = "sha256:d0550fca9dc19f3d5e8eadfce0c227294df0a2a951251a4385797c8a6198b7c8"}, - {file = "twine-3.8.0.tar.gz", hash = "sha256:8efa52658e0ae770686a13b675569328f1fba9837e5de1867bfe5f46a9aefe19"}, -] - -[package.dependencies] -colorama = ">=0.4.3" -importlib-metadata = ">=3.6" -keyring = ">=15.1" -pkginfo = ">=1.8.1" -readme-renderer = ">=21.0" -requests = ">=2.20" -requests-toolbelt = ">=0.8.0,<0.9.0 || >0.9.0" -rfc3986 = ">=1.4.0" -tqdm = ">=4.14" -urllib3 = ">=1.26.0" - -[[package]] -name = "types-deprecated" -version = "1.2.15.20250304" -description = "Typing stubs for Deprecated" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "types_deprecated-1.2.15.20250304-py3-none-any.whl", hash = "sha256:86a65aa550ea8acf49f27e226b8953288cd851de887970fbbdf2239c116c3107"}, - {file = "types_deprecated-1.2.15.20250304.tar.gz", hash = "sha256:c329030553029de5cc6cb30f269c11f4e00e598c4241290179f63cda7d33f719"}, -] - -[[package]] -name = "typing-extensions" -version = "4.13.2" -description = "Backported and Experimental Type Hints for Python 3.8+" -optional = false -python-versions = ">=3.8" -groups = ["main", "dev"] -files = [ - {file = "typing_extensions-4.13.2-py3-none-any.whl", hash = "sha256:a439e7c04b49fec3e5d3e2beaa21755cadbbdc391694e28ccdd36ca4a1408f8c"}, - {file = "typing_extensions-4.13.2.tar.gz", hash = "sha256:e6c81219bd689f51865d9e372991c540bda33a0379d5573cddb9a3a23f7caaef"}, -] - -[[package]] -name = "uc-micro-py" -version = "1.0.3" -description = "Micro subset of unicode data files for linkify-it-py projects." -optional = false -python-versions = ">=3.7" -groups = ["dev"] -files = [ - {file = "uc-micro-py-1.0.3.tar.gz", hash = "sha256:d321b92cff673ec58027c04015fcaa8bb1e005478643ff4a500882eaab88c48a"}, - {file = "uc_micro_py-1.0.3-py3-none-any.whl", hash = "sha256:db1dffff340817673d7b466ec86114a9dc0e9d4d9b5ba229d9d60e5c12600cd5"}, -] - -[package.extras] -test = ["coverage", "pytest", "pytest-cov"] - -[[package]] -name = "urllib3" -version = "2.6.2" -description = "HTTP library with thread-safe connection pooling, file post, and more." -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "urllib3-2.6.2-py3-none-any.whl", hash = "sha256:ec21cddfe7724fc7cb4ba4bea7aa8e2ef36f607a4bab81aa6ce42a13dc3f03dd"}, - {file = "urllib3-2.6.2.tar.gz", hash = "sha256:016f9c98bb7e98085cb2b4b17b87d2c702975664e4f060c6532e64d1c1a5e797"}, -] - -[package.extras] -brotli = ["brotli (>=1.2.0) ; platform_python_implementation == \"CPython\"", "brotlicffi (>=1.2.0.0) ; platform_python_implementation != \"CPython\""] -h2 = ["h2 (>=4,<5)"] -socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"] -zstd = ["backports-zstd (>=1.0.0) ; python_version < \"3.14\""] - -[[package]] -name = "uvicorn" -version = "0.34.0" -description = "The lightning-fast ASGI server." -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "uvicorn-0.34.0-py3-none-any.whl", hash = "sha256:023dc038422502fa28a09c7a30bf2b6991512da7dcdb8fd35fe57cfc154126f4"}, - {file = "uvicorn-0.34.0.tar.gz", hash = "sha256:404051050cd7e905de2c9a7e61790943440b3416f49cb409f965d9dcd0fa73e9"}, -] - -[package.dependencies] -click = ">=7.0" -h11 = ">=0.8" -typing-extensions = {version = ">=4.0", markers = "python_version < \"3.11\""} - -[package.extras] -standard = ["colorama (>=0.4) ; sys_platform == \"win32\"", "httptools (>=0.6.3)", "python-dotenv (>=0.13)", "pyyaml (>=5.1)", "uvloop (>=0.14.0,!=0.15.0,!=0.15.1) ; sys_platform != \"win32\" and sys_platform != \"cygwin\" and platform_python_implementation != \"PyPy\"", "watchfiles (>=0.13)", "websockets (>=10.4)"] - -[[package]] -name = "virtualenv" -version = "20.29.1" -description = "Virtual Python Environment builder" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "virtualenv-20.29.1-py3-none-any.whl", hash = "sha256:4e4cb403c0b0da39e13b46b1b2476e505cb0046b25f242bee80f62bf990b2779"}, - {file = "virtualenv-20.29.1.tar.gz", hash = "sha256:b8b8970138d32fb606192cb97f6cd4bb644fa486be9308fb9b63f81091b5dc35"}, -] - -[package.dependencies] -distlib = ">=0.3.7,<1" -filelock = ">=3.12.2,<4" -platformdirs = ">=3.9.1,<5" - -[package.extras] -docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.2,!=7.3)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"] -test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8) ; platform_python_implementation == \"PyPy\" or platform_python_implementation == \"CPython\" and sys_platform == \"win32\" and python_version >= \"3.13\"", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10) ; platform_python_implementation == \"CPython\""] - -[[package]] -name = "watchfiles" -version = "1.0.4" -description = "Simple, modern and high performance file watching and code reload in python." -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "watchfiles-1.0.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:ba5bb3073d9db37c64520681dd2650f8bd40902d991e7b4cfaeece3e32561d08"}, - {file = "watchfiles-1.0.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9f25d0ba0fe2b6d2c921cf587b2bf4c451860086534f40c384329fb96e2044d1"}, - {file = "watchfiles-1.0.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:47eb32ef8c729dbc4f4273baece89398a4d4b5d21a1493efea77a17059f4df8a"}, - {file = "watchfiles-1.0.4-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:076f293100db3b0b634514aa0d294b941daa85fc777f9c698adb1009e5aca0b1"}, - {file = "watchfiles-1.0.4-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1eacd91daeb5158c598fe22d7ce66d60878b6294a86477a4715154990394c9b3"}, - {file = "watchfiles-1.0.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:13c2ce7b72026cfbca120d652f02c7750f33b4c9395d79c9790b27f014c8a5a2"}, - {file = "watchfiles-1.0.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:90192cdc15ab7254caa7765a98132a5a41471cf739513cc9bcf7d2ffcc0ec7b2"}, - {file = "watchfiles-1.0.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:278aaa395f405972e9f523bd786ed59dfb61e4b827856be46a42130605fd0899"}, - {file = "watchfiles-1.0.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:a462490e75e466edbb9fc4cd679b62187153b3ba804868452ef0577ec958f5ff"}, - {file = "watchfiles-1.0.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:8d0d0630930f5cd5af929040e0778cf676a46775753e442a3f60511f2409f48f"}, - {file = "watchfiles-1.0.4-cp310-cp310-win32.whl", hash = "sha256:cc27a65069bcabac4552f34fd2dce923ce3fcde0721a16e4fb1b466d63ec831f"}, - {file = "watchfiles-1.0.4-cp310-cp310-win_amd64.whl", hash = "sha256:8b1f135238e75d075359cf506b27bf3f4ca12029c47d3e769d8593a2024ce161"}, - {file = "watchfiles-1.0.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:2a9f93f8439639dc244c4d2902abe35b0279102bca7bbcf119af964f51d53c19"}, - {file = "watchfiles-1.0.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9eea33ad8c418847dd296e61eb683cae1c63329b6d854aefcd412e12d94ee235"}, - {file = "watchfiles-1.0.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:31f1a379c9dcbb3f09cf6be1b7e83b67c0e9faabed0471556d9438a4a4e14202"}, - {file = "watchfiles-1.0.4-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ab594e75644421ae0a2484554832ca5895f8cab5ab62de30a1a57db460ce06c6"}, - {file = "watchfiles-1.0.4-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fc2eb5d14a8e0d5df7b36288979176fbb39672d45184fc4b1c004d7c3ce29317"}, - {file = "watchfiles-1.0.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3f68d8e9d5a321163ddacebe97091000955a1b74cd43724e346056030b0bacee"}, - {file = "watchfiles-1.0.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f9ce064e81fe79faa925ff03b9f4c1a98b0bbb4a1b8c1b015afa93030cb21a49"}, - {file = "watchfiles-1.0.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b77d5622ac5cc91d21ae9c2b284b5d5c51085a0bdb7b518dba263d0af006132c"}, - {file = "watchfiles-1.0.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:1941b4e39de9b38b868a69b911df5e89dc43767feeda667b40ae032522b9b5f1"}, - {file = "watchfiles-1.0.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:4f8c4998506241dedf59613082d1c18b836e26ef2a4caecad0ec41e2a15e4226"}, - {file = "watchfiles-1.0.4-cp311-cp311-win32.whl", hash = "sha256:4ebbeca9360c830766b9f0df3640b791be569d988f4be6c06d6fae41f187f105"}, - {file = "watchfiles-1.0.4-cp311-cp311-win_amd64.whl", hash = "sha256:05d341c71f3d7098920f8551d4df47f7b57ac5b8dad56558064c3431bdfc0b74"}, - {file = "watchfiles-1.0.4-cp311-cp311-win_arm64.whl", hash = "sha256:32b026a6ab64245b584acf4931fe21842374da82372d5c039cba6bf99ef722f3"}, - {file = "watchfiles-1.0.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:229e6ec880eca20e0ba2f7e2249c85bae1999d330161f45c78d160832e026ee2"}, - {file = "watchfiles-1.0.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5717021b199e8353782dce03bd8a8f64438832b84e2885c4a645f9723bf656d9"}, - {file = "watchfiles-1.0.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0799ae68dfa95136dde7c472525700bd48777875a4abb2ee454e3ab18e9fc712"}, - {file = "watchfiles-1.0.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:43b168bba889886b62edb0397cab5b6490ffb656ee2fcb22dec8bfeb371a9e12"}, - {file = "watchfiles-1.0.4-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fb2c46e275fbb9f0c92e7654b231543c7bbfa1df07cdc4b99fa73bedfde5c844"}, - {file = "watchfiles-1.0.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:857f5fc3aa027ff5e57047da93f96e908a35fe602d24f5e5d8ce64bf1f2fc733"}, - {file = "watchfiles-1.0.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:55ccfd27c497b228581e2838d4386301227fc0cb47f5a12923ec2fe4f97b95af"}, - {file = "watchfiles-1.0.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c11ea22304d17d4385067588123658e9f23159225a27b983f343fcffc3e796a"}, - {file = "watchfiles-1.0.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:74cb3ca19a740be4caa18f238298b9d472c850f7b2ed89f396c00a4c97e2d9ff"}, - {file = "watchfiles-1.0.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:c7cce76c138a91e720d1df54014a047e680b652336e1b73b8e3ff3158e05061e"}, - {file = "watchfiles-1.0.4-cp312-cp312-win32.whl", hash = "sha256:b045c800d55bc7e2cadd47f45a97c7b29f70f08a7c2fa13241905010a5493f94"}, - {file = "watchfiles-1.0.4-cp312-cp312-win_amd64.whl", hash = "sha256:c2acfa49dd0ad0bf2a9c0bb9a985af02e89345a7189be1efc6baa085e0f72d7c"}, - {file = "watchfiles-1.0.4-cp312-cp312-win_arm64.whl", hash = "sha256:22bb55a7c9e564e763ea06c7acea24fc5d2ee5dfc5dafc5cfbedfe58505e9f90"}, - {file = "watchfiles-1.0.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:8012bd820c380c3d3db8435e8cf7592260257b378b649154a7948a663b5f84e9"}, - {file = "watchfiles-1.0.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:aa216f87594f951c17511efe5912808dfcc4befa464ab17c98d387830ce07b60"}, - {file = "watchfiles-1.0.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:62c9953cf85529c05b24705639ffa390f78c26449e15ec34d5339e8108c7c407"}, - {file = "watchfiles-1.0.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7cf684aa9bba4cd95ecb62c822a56de54e3ae0598c1a7f2065d51e24637a3c5d"}, - {file = "watchfiles-1.0.4-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f44a39aee3cbb9b825285ff979ab887a25c5d336e5ec3574f1506a4671556a8d"}, - {file = "watchfiles-1.0.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a38320582736922be8c865d46520c043bff350956dfc9fbaee3b2df4e1740a4b"}, - {file = "watchfiles-1.0.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:39f4914548b818540ef21fd22447a63e7be6e24b43a70f7642d21f1e73371590"}, - {file = "watchfiles-1.0.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f12969a3765909cf5dc1e50b2436eb2c0e676a3c75773ab8cc3aa6175c16e902"}, - {file = "watchfiles-1.0.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:0986902677a1a5e6212d0c49b319aad9cc48da4bd967f86a11bde96ad9676ca1"}, - {file = "watchfiles-1.0.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:308ac265c56f936636e3b0e3f59e059a40003c655228c131e1ad439957592303"}, - {file = "watchfiles-1.0.4-cp313-cp313-win32.whl", hash = "sha256:aee397456a29b492c20fda2d8961e1ffb266223625346ace14e4b6d861ba9c80"}, - {file = "watchfiles-1.0.4-cp313-cp313-win_amd64.whl", hash = "sha256:d6097538b0ae5c1b88c3b55afa245a66793a8fec7ada6755322e465fb1a0e8cc"}, - {file = "watchfiles-1.0.4-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:d3452c1ec703aa1c61e15dfe9d482543e4145e7c45a6b8566978fbb044265a21"}, - {file = "watchfiles-1.0.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:7b75fee5a16826cf5c46fe1c63116e4a156924d668c38b013e6276f2582230f0"}, - {file = "watchfiles-1.0.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e997802d78cdb02623b5941830ab06f8860038faf344f0d288d325cc9c5d2ff"}, - {file = "watchfiles-1.0.4-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e0611d244ce94d83f5b9aff441ad196c6e21b55f77f3c47608dcf651efe54c4a"}, - {file = "watchfiles-1.0.4-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9745a4210b59e218ce64c91deb599ae8775c8a9da4e95fb2ee6fe745fc87d01a"}, - {file = "watchfiles-1.0.4-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4810ea2ae622add560f4aa50c92fef975e475f7ac4900ce5ff5547b2434642d8"}, - {file = "watchfiles-1.0.4-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:740d103cd01458f22462dedeb5a3382b7f2c57d07ff033fbc9465919e5e1d0f3"}, - {file = "watchfiles-1.0.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdbd912a61543a36aef85e34f212e5d2486e7c53ebfdb70d1e0b060cc50dd0bf"}, - {file = "watchfiles-1.0.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0bc80d91ddaf95f70258cf78c471246846c1986bcc5fd33ccc4a1a67fcb40f9a"}, - {file = "watchfiles-1.0.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ab0311bb2ffcd9f74b6c9de2dda1612c13c84b996d032cd74799adb656af4e8b"}, - {file = "watchfiles-1.0.4-cp39-cp39-win32.whl", hash = "sha256:02a526ee5b5a09e8168314c905fc545c9bc46509896ed282aeb5a8ba9bd6ca27"}, - {file = "watchfiles-1.0.4-cp39-cp39-win_amd64.whl", hash = "sha256:a5ae5706058b27c74bac987d615105da17724172d5aaacc6c362a40599b6de43"}, - {file = "watchfiles-1.0.4-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:cdcc92daeae268de1acf5b7befcd6cfffd9a047098199056c72e4623f531de18"}, - {file = "watchfiles-1.0.4-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:d8d3d9203705b5797f0af7e7e5baa17c8588030aaadb7f6a86107b7247303817"}, - {file = "watchfiles-1.0.4-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bdef5a1be32d0b07dcea3318a0be95d42c98ece24177820226b56276e06b63b0"}, - {file = "watchfiles-1.0.4-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:342622287b5604ddf0ed2d085f3a589099c9ae8b7331df3ae9845571586c4f3d"}, - {file = "watchfiles-1.0.4-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:9fe37a2de80aa785d340f2980276b17ef697ab8db6019b07ee4fd28a8359d2f3"}, - {file = "watchfiles-1.0.4-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:9d1ef56b56ed7e8f312c934436dea93bfa3e7368adfcf3df4c0da6d4de959a1e"}, - {file = "watchfiles-1.0.4-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:95b42cac65beae3a362629950c444077d1b44f1790ea2772beaea95451c086bb"}, - {file = "watchfiles-1.0.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5e0227b8ed9074c6172cf55d85b5670199c99ab11fd27d2c473aa30aec67ee42"}, - {file = "watchfiles-1.0.4.tar.gz", hash = "sha256:6ba473efd11062d73e4f00c2b730255f9c1bdd73cd5f9fe5b5da8dbd4a717205"}, -] - -[package.dependencies] -anyio = ">=3.0.0" - -[[package]] -name = "websockets" -version = "14.2" -description = "An implementation of the WebSocket Protocol (RFC 6455 & 7692)" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "websockets-14.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e8179f95323b9ab1c11723e5d91a89403903f7b001828161b480a7810b334885"}, - {file = "websockets-14.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0d8c3e2cdb38f31d8bd7d9d28908005f6fa9def3324edb9bf336d7e4266fd397"}, - {file = "websockets-14.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:714a9b682deb4339d39ffa674f7b674230227d981a37d5d174a4a83e3978a610"}, - {file = "websockets-14.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2e53c72052f2596fb792a7acd9704cbc549bf70fcde8a99e899311455974ca3"}, - {file = "websockets-14.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e3fbd68850c837e57373d95c8fe352203a512b6e49eaae4c2f4088ef8cf21980"}, - {file = "websockets-14.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b27ece32f63150c268593d5fdb82819584831a83a3f5809b7521df0685cd5d8"}, - {file = "websockets-14.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4daa0faea5424d8713142b33825fff03c736f781690d90652d2c8b053345b0e7"}, - {file = "websockets-14.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:bc63cee8596a6ec84d9753fd0fcfa0452ee12f317afe4beae6b157f0070c6c7f"}, - {file = "websockets-14.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7a570862c325af2111343cc9b0257b7119b904823c675b22d4ac547163088d0d"}, - {file = "websockets-14.2-cp310-cp310-win32.whl", hash = "sha256:75862126b3d2d505e895893e3deac0a9339ce750bd27b4ba515f008b5acf832d"}, - {file = "websockets-14.2-cp310-cp310-win_amd64.whl", hash = "sha256:cc45afb9c9b2dc0852d5c8b5321759cf825f82a31bfaf506b65bf4668c96f8b2"}, - {file = "websockets-14.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3bdc8c692c866ce5fefcaf07d2b55c91d6922ac397e031ef9b774e5b9ea42166"}, - {file = "websockets-14.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c93215fac5dadc63e51bcc6dceca72e72267c11def401d6668622b47675b097f"}, - {file = "websockets-14.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1c9b6535c0e2cf8a6bf938064fb754aaceb1e6a4a51a80d884cd5db569886910"}, - {file = "websockets-14.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a52a6d7cf6938e04e9dceb949d35fbdf58ac14deea26e685ab6368e73744e4c"}, - {file = "websockets-14.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9f05702e93203a6ff5226e21d9b40c037761b2cfb637187c9802c10f58e40473"}, - {file = "websockets-14.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22441c81a6748a53bfcb98951d58d1af0661ab47a536af08920d129b4d1c3473"}, - {file = "websockets-14.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:efd9b868d78b194790e6236d9cbc46d68aba4b75b22497eb4ab64fa640c3af56"}, - {file = "websockets-14.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1a5a20d5843886d34ff8c57424cc65a1deda4375729cbca4cb6b3353f3ce4142"}, - {file = "websockets-14.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:34277a29f5303d54ec6468fb525d99c99938607bc96b8d72d675dee2b9f5bf1d"}, - {file = "websockets-14.2-cp311-cp311-win32.whl", hash = "sha256:02687db35dbc7d25fd541a602b5f8e451a238ffa033030b172ff86a93cb5dc2a"}, - {file = "websockets-14.2-cp311-cp311-win_amd64.whl", hash = "sha256:862e9967b46c07d4dcd2532e9e8e3c2825e004ffbf91a5ef9dde519ee2effb0b"}, - {file = "websockets-14.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1f20522e624d7ffbdbe259c6b6a65d73c895045f76a93719aa10cd93b3de100c"}, - {file = "websockets-14.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:647b573f7d3ada919fd60e64d533409a79dcf1ea21daeb4542d1d996519ca967"}, - {file = "websockets-14.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6af99a38e49f66be5a64b1e890208ad026cda49355661549c507152113049990"}, - {file = "websockets-14.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:091ab63dfc8cea748cc22c1db2814eadb77ccbf82829bac6b2fbe3401d548eda"}, - {file = "websockets-14.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b374e8953ad477d17e4851cdc66d83fdc2db88d9e73abf755c94510ebddceb95"}, - {file = "websockets-14.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a39d7eceeea35db85b85e1169011bb4321c32e673920ae9c1b6e0978590012a3"}, - {file = "websockets-14.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0a6f3efd47ffd0d12080594f434faf1cd2549b31e54870b8470b28cc1d3817d9"}, - {file = "websockets-14.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:065ce275e7c4ffb42cb738dd6b20726ac26ac9ad0a2a48e33ca632351a737267"}, - {file = "websockets-14.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e9d0e53530ba7b8b5e389c02282f9d2aa47581514bd6049d3a7cffe1385cf5fe"}, - {file = "websockets-14.2-cp312-cp312-win32.whl", hash = "sha256:20e6dd0984d7ca3037afcb4494e48c74ffb51e8013cac71cf607fffe11df7205"}, - {file = "websockets-14.2-cp312-cp312-win_amd64.whl", hash = "sha256:44bba1a956c2c9d268bdcdf234d5e5ff4c9b6dc3e300545cbe99af59dda9dcce"}, - {file = "websockets-14.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6f1372e511c7409a542291bce92d6c83320e02c9cf392223272287ce55bc224e"}, - {file = "websockets-14.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4da98b72009836179bb596a92297b1a61bb5a830c0e483a7d0766d45070a08ad"}, - {file = "websockets-14.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8a86a269759026d2bde227652b87be79f8a734e582debf64c9d302faa1e9f03"}, - {file = "websockets-14.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:86cf1aaeca909bf6815ea714d5c5736c8d6dd3a13770e885aafe062ecbd04f1f"}, - {file = "websockets-14.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a9b0f6c3ba3b1240f602ebb3971d45b02cc12bd1845466dd783496b3b05783a5"}, - {file = "websockets-14.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:669c3e101c246aa85bc8534e495952e2ca208bd87994650b90a23d745902db9a"}, - {file = "websockets-14.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eabdb28b972f3729348e632ab08f2a7b616c7e53d5414c12108c29972e655b20"}, - {file = "websockets-14.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2066dc4cbcc19f32c12a5a0e8cc1b7ac734e5b64ac0a325ff8353451c4b15ef2"}, - {file = "websockets-14.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ab95d357cd471df61873dadf66dd05dd4709cae001dd6342edafc8dc6382f307"}, - {file = "websockets-14.2-cp313-cp313-win32.whl", hash = "sha256:a9e72fb63e5f3feacdcf5b4ff53199ec8c18d66e325c34ee4c551ca748623bbc"}, - {file = "websockets-14.2-cp313-cp313-win_amd64.whl", hash = "sha256:b439ea828c4ba99bb3176dc8d9b933392a2413c0f6b149fdcba48393f573377f"}, - {file = "websockets-14.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7cd5706caec1686c5d233bc76243ff64b1c0dc445339bd538f30547e787c11fe"}, - {file = "websockets-14.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ec607328ce95a2f12b595f7ae4c5d71bf502212bddcea528290b35c286932b12"}, - {file = "websockets-14.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:da85651270c6bfb630136423037dd4975199e5d4114cae6d3066641adcc9d1c7"}, - {file = "websockets-14.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c3ecadc7ce90accf39903815697917643f5b7cfb73c96702318a096c00aa71f5"}, - {file = "websockets-14.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1979bee04af6a78608024bad6dfcc0cc930ce819f9e10342a29a05b5320355d0"}, - {file = "websockets-14.2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2dddacad58e2614a24938a50b85969d56f88e620e3f897b7d80ac0d8a5800258"}, - {file = "websockets-14.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:89a71173caaf75fa71a09a5f614f450ba3ec84ad9fca47cb2422a860676716f0"}, - {file = "websockets-14.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:6af6a4b26eea4fc06c6818a6b962a952441e0e39548b44773502761ded8cc1d4"}, - {file = "websockets-14.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:80c8efa38957f20bba0117b48737993643204645e9ec45512579132508477cfc"}, - {file = "websockets-14.2-cp39-cp39-win32.whl", hash = "sha256:2e20c5f517e2163d76e2729104abc42639c41cf91f7b1839295be43302713661"}, - {file = "websockets-14.2-cp39-cp39-win_amd64.whl", hash = "sha256:b4c8cef610e8d7c70dea92e62b6814a8cd24fbd01d7103cc89308d2bfe1659ef"}, - {file = "websockets-14.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:d7d9cafbccba46e768be8a8ad4635fa3eae1ffac4c6e7cb4eb276ba41297ed29"}, - {file = "websockets-14.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:c76193c1c044bd1e9b3316dcc34b174bbf9664598791e6fb606d8d29000e070c"}, - {file = "websockets-14.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fd475a974d5352390baf865309fe37dec6831aafc3014ffac1eea99e84e83fc2"}, - {file = "websockets-14.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2c6c0097a41968b2e2b54ed3424739aab0b762ca92af2379f152c1aef0187e1c"}, - {file = "websockets-14.2-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d7ff794c8b36bc402f2e07c0b2ceb4a2424147ed4785ff03e2a7af03711d60a"}, - {file = "websockets-14.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:dec254fcabc7bd488dab64846f588fc5b6fe0d78f641180030f8ea27b76d72c3"}, - {file = "websockets-14.2-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:bbe03eb853e17fd5b15448328b4ec7fb2407d45fb0245036d06a3af251f8e48f"}, - {file = "websockets-14.2-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:a3c4aa3428b904d5404a0ed85f3644d37e2cb25996b7f096d77caeb0e96a3b42"}, - {file = "websockets-14.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:577a4cebf1ceaf0b65ffc42c54856214165fb8ceeba3935852fc33f6b0c55e7f"}, - {file = "websockets-14.2-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ad1c1d02357b7665e700eca43a31d52814ad9ad9b89b58118bdabc365454b574"}, - {file = "websockets-14.2-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f390024a47d904613577df83ba700bd189eedc09c57af0a904e5c39624621270"}, - {file = "websockets-14.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:3c1426c021c38cf92b453cdf371228d3430acd775edee6bac5a4d577efc72365"}, - {file = "websockets-14.2-py3-none-any.whl", hash = "sha256:7a6ceec4ea84469f15cf15807a747e9efe57e369c384fa86e022b3bea679b79b"}, - {file = "websockets-14.2.tar.gz", hash = "sha256:5059ed9c54945efb321f097084b4c7e52c246f2c869815876a69d1efc4ad6eb5"}, -] - -[[package]] -name = "wheel" -version = "0.45.1" -description = "A built-package format for Python" -optional = false -python-versions = ">=3.8" -groups = ["dev"] -files = [ - {file = "wheel-0.45.1-py3-none-any.whl", hash = "sha256:708e7481cc80179af0e556bbf0cc00b8444c7321e2700b8d8580231d13017248"}, - {file = "wheel-0.45.1.tar.gz", hash = "sha256:661e1abd9198507b1409a20c02106d9670b2576e916d58f520316666abca6729"}, -] - -[package.extras] -test = ["pytest (>=6.0.0)", "setuptools (>=65)"] - -[[package]] -name = "zipp" -version = "3.21.0" -description = "Backport of pathlib-compatible object wrapper for zip files" -optional = false -python-versions = ">=3.9" -groups = ["dev"] -files = [ - {file = "zipp-3.21.0-py3-none-any.whl", hash = "sha256:ac1bbe05fd2991f160ebce24ffbac5f6d11d83dc90891255885223d42b3cd931"}, - {file = "zipp-3.21.0.tar.gz", hash = "sha256:2c9958f6430a2040341a52eb608ed6dd93ef4392e02ffe219417c1b28b5dd1f4"}, -] - -[package.extras] -check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\""] -cover = ["pytest-cov"] -doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] -enabler = ["pytest-enabler (>=2.2)"] -test = ["big-O", "importlib-resources ; python_version < \"3.9\"", "jaraco.functools", "jaraco.itertools", "jaraco.test", "more-itertools", "pytest (>=6,!=8.1.*)", "pytest-ignore-flaky"] -type = ["pytest-mypy"] - -[metadata] -lock-version = "2.1" -python-versions = "^3.10" -content-hash = "b0f11fb85ca1a323c83da742d875050f72bd4d54b8fe13637f06cfaf167efcd9" diff --git a/poetry.toml b/poetry.toml deleted file mode 100644 index ab1033bd..00000000 --- a/poetry.toml +++ /dev/null @@ -1,2 +0,0 @@ -[virtualenvs] -in-project = true diff --git a/pyproject.toml b/pyproject.toml index 74b5de3e..fafa1b72 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,45 +1,77 @@ -[tool.poetry] +[project] name = "algokit-utils" -version = "4.2.3" +version = "5.0.0-beta.5" description = "Utilities for Algorand development for use by AlgoKit" -authors = ["Algorand Foundation "] -license = "MIT" +authors = [ + { name = "Algorand Foundation", email = "contact@algorand.foundation" }, +] +requires-python = ">=3.10,<4" readme = "README.md" +license = "MIT" +dependencies = [ + "httpx>=0.23.1,<=0.28.1", + "msgpack>=1.0.0,<2", + "msgpack-types>=0.2.0,<=0.5.0", + "pynacl>=1.4.0,<2", + "pycryptodomex>=3.19,<4", + "typing-extensions>=4.6.0", + "xhd-wallet-api>=1.0.0", + "exceptiongroup>=1.3.1", +] -[tool.poetry.dependencies] -python = "^3.10" -py-algorand-sdk = "^2.11.0" -httpx = ">=0.23.1,<=0.28.1" -typing-extensions = ">=4.6.0" - -[tool.poetry.group.dev.dependencies] -pytest = "^8" -ruff = ">=0.1.6,<=0.11.8" -pip-audit = "^2.5.6" -pytest-mock = "^3.14" -mypy = "^1.5.1" -python-semantic-release = "^7.34.3" -pytest-cov = "^6" -pre-commit = "^3.4.0" -python-dotenv = "^1.0.0" -sphinx = "^8.0.0" -poethepoet = ">=0.19,<0.35" -pytest-httpx = "^0.35.0" -pytest-xdist = "^3.6.1" -linkify-it-py = "^2.0.3" -setuptools = "^80.9.0" -pydoclint = "^0.6.0" -pytest-sugar = "^1.0.0" -types-deprecated = "^1.2.15.20241117" -sphinx-autobuild = "^2024.10.3" -furo = "^2024.8.6" -myst-parser = "^4.0.0" -sphinx-autoapi = "^3.4.0" -sphinx-markdown-builder = "^0.6.8" +[dependency-groups] +cicd = [] +dev = [ + "pip>=26.0,<27", + "pydantic>=2.0.0,<3", + "pytest>=9.0.3,<10", + "ruff>=0.1.6,<=0.14.8", + "pip-audit>=2.5.6,<3", + "pytest-mock~=3.14", + "mypy>=1.5.1,<2", + "python-semantic-release>=10.5.0,<11", + "pytest-cov>=6,<7", + "pre-commit>=3.4.0,<4", + "python-dotenv>=1.0.0,<2", + "sphinx>=8.0.0,<9", + "poethepoet>=0.19,<0.39", + "pytest-httpx>=0.36.0,<0.37", + "pytest-xdist>=3.6.1,<4", + "linkify-it-py>=2.0.3,<3", + "setuptools>=80.9.0,<81", + "pydoclint>=0.6.0,<0.9", + "pytest-sugar>=1.0.0,<2", + "types-deprecated>=1.2.15.20241117,<2", + "furo>=2024.8.6,<2026", + "myst-parser>=4.0.0,<5", + "sphinx-autoapi>=3.4.0,<4", + "sphinx-markdown-builder>=0.6.8,<0.7", + "filelock>=3.12.0,<4", + "pygments>=2.20.0,<3", # Direct dev dependency to keep pip-audit from resolving a vulnerable version + "requests>=2.33.0,<3", # Direct dev dependency to keep pip-audit from resolving a vulnerable version + "syrupy>=5.0.0,<6", +] +api-generator = ["oas-generator"] [build-system] -requires = ["poetry-core"] -build-backend = "poetry.core.masonry.api" +requires = ["uv_build>=0.9.5,<0.11.0"] +build-backend = "uv_build" + +[tool.uv.build-backend] +module-name = [ + "algokit_abi", + "algokit_algo25", + "algokit_algod_client", + "algokit_common", + "algokit_crypto", + "algokit_indexer_client", + "algokit_kmd_client", + "algokit_transact", + "algokit_utils", +] + +[tool.uv.sources] +oas-generator = { path = "api/oas-generator", editable = true } [tool.ruff] line-length = 120 @@ -48,62 +80,63 @@ lint.select = [ # ones we don't want/need are commented out to make it clear # which have been omitted on purpose vs which ones get added # in new ruff releases and should be considered for enabling - "F", # pyflakes - "E", "W", # pycodestyle - "C90", # mccabe - "I", # isort - "N", # PEP8 naming - "UP", # pyupgrade - "YTT", # flake8-2020 - "ANN", # flake8-annotations + "F", # pyflakes + "E", + "W", # pycodestyle + "C90", # mccabe + "I", # isort + "N", # PEP8 naming + "UP", # pyupgrade + "YTT", # flake8-2020 + "ANN", # flake8-annotations # "S", # flake8-bandit # "BLE", # flake8-blind-except - "FBT", # flake8-boolean-trap - "B", # flake8-bugbear - "A", # flake8-builtins + "FBT", # flake8-boolean-trap + "B", # flake8-bugbear + "A", # flake8-builtins # "COM", # flake8-commas - "C4", # flake8-comprehensions - "DTZ", # flake8-datetimez - "T10", # flake8-debugger + "C4", # flake8-comprehensions + "DTZ", # flake8-datetimez + "T10", # flake8-debugger # "DJ", # flake8-django # "EM", # flake8-errmsg # "EXE", # flake8-executable - "ISC", # flake8-implicit-str-concat - "ICN", # flake8-import-conventions + "ISC", # flake8-implicit-str-concat + "ICN", # flake8-import-conventions # "G", # flake8-logging-format # "INP", # flake8-no-pep420 - "PIE", # flake8-pie - "T20", # flake8-print - "PYI", # flake8-pyi - "PT", # flake8-pytest-style - "Q", # flake8-quotes - "RSE", # flake8-raise - "RET", # flake8-return - "SLF", # flake8-self - "SIM", # flake8-simplify - "TID", # flake8-tidy-imports - "ARG", # flake8-unused-arguments - "PTH", # flake8-use-pathlib - "ERA", # eradicate + "PIE", # flake8-pie + "T20", # flake8-print + "PYI", # flake8-pyi + "PT", # flake8-pytest-style + "Q", # flake8-quotes + "RSE", # flake8-raise + "RET", # flake8-return + "SLF", # flake8-self + "SIM", # flake8-simplify + "TID", # flake8-tidy-imports + "ARG", # flake8-unused-arguments + "PTH", # flake8-use-pathlib + "ERA", # eradicate # "PD", # pandas-vet - "PGH", # pygrep-hooks - "PL", # pylint + "PGH", # pygrep-hooks + "PL", # pylint # "TRY", # tryceratops # "NPY", # NumPy-specific rules - "RUF", # Ruff-specific rules + "RUF", # Ruff-specific rules ] lint.ignore = [ "RET505", # allow else after return "SIM108", # allow if-else in place of ternary - "E111", # indentation is not a multiple of four - "E117", # over-indented + "E111", # indentation is not a multiple of four + "E117", # over-indented "ISC001", # single line implicit string concatenation "ISC002", # multi line implicit string concatenation - "Q000", # bad quotes inline string - "Q001", # bad quotes multiline string - "Q002", # bad quotes docstring - "Q003", # avoidable escaped quotes - "W191", # indentation contains tabs + "Q000", # bad quotes inline string + "Q001", # bad quotes multiline string + "Q002", # bad quotes docstring + "Q003", # avoidable escaped quotes + "W191", # indentation contains tabs "ERA001", # commented out code ] # Exclude a variety of commonly ignored directories. @@ -113,6 +146,7 @@ extend-exclude = [ ".mypy_cache", ".ruff_cache", "tests/artifacts", + "src/algokit_algosdk", ] # Assume Python 3.10. target-version = "py310" @@ -127,28 +161,163 @@ suppress-none-returning = true [tool.ruff.lint.per-file-ignores] "src/algokit_utils/applications/app_client.py" = ["SLF001"] "src/algokit_utils/applications/app_factory.py" = ["SLF001"] -"tests/clients/test_algorand_client.py" = ["ERA001"] -"src/algokit_utils/_legacy_v2/**/*" = ["E501"] -"tests/**/*" = ["PLR2004"] -"src/algokit_utils/__init__.py" = ["I001", "RUF022"] # Ignore import sorting for __init__.py +"tests/clients/test_algorand_client.py" = ["ERA001"] +"tests/**/*" = ["PLR2004"] +# Ignore lint rules for polytest auto-generated test stubs +"tests/modules/**/*" = ["E501", "W292", "I001"] +"src/algokit_crypto/signing.py" = ["C901", "PLR0912", "PLR0915"] +"src/algokit_utils/__init__.py" = [ + "I001", + "RUF022", +] # Ignore import sorting for __init__.py +# OAS generator has inherently complex schema-walking code +"api/oas-generator/src/oas_generator/builder.py" = ["C901", "PLR0911", "PLR0912", "E501", "ARG002", "ANN401", "FBT003"] +# Examples are validated separately; ignore local import/style-noise here +"examples/**/*" = ["E501", "PLC0415", "RUF100"] +"scripts/**/*" = ["T201"] # Allow print statements in CLI scripts +# Ignore lint rules for generated API clients +"src/algokit_algod_client/**/*" = ["F821", "N815", "E501"] +"src/algokit_indexer_client/**/*" = ["F821", "N815", "E501"] +"src/algokit_kmd_client/**/*" = ["F821", "N815", "E501", "N801"] + [tool.poe.tasks] -docs = ["docs-md-only"] -docs-md-only = "sphinx-build docs/source docs/markdown -b markdown" -docstrings-check = "pydoclint src --style sphinx --arg-type-hints-in-docstring false --check-return-types false --exclude src/algokit_utils/_legacy_v2" -docs-dev = "sphinx-autobuild --ignore '**/_build/**' --ignore '**/autoapi/**' --ignore '**/.doctrees/**' docs/source docs/_build" +docs-api = "python docs/api_build.py" +docs-dev = { shell = "python docs/api_build.py && pnpm --dir docs dev" } +docs-build = { shell = "python docs/api_build.py && pnpm --dir docs build" } +docs-preview = { shell = "pnpm --dir docs preview" } +docstrings-check = "pydoclint src --style sphinx --arg-type-hints-in-docstring false --check-return-types false" +# Polytest tasks for test generation and validation +# Uses --git flag to pull config from central polytest repo without storing jsonc files locally +# Test execution is done globally via pytest, polytest is only used for scaffolding and validation +polytest-generate-transact = "polytest --config test_configs/transact.jsonc --git 'https://github.com/algorandfoundation/algokit-polytest#main' generate -t pytest" +polytest-validate-transact = "polytest --config test_configs/transact.jsonc --git 'https://github.com/algorandfoundation/algokit-polytest#main' validate -t pytest" +polytest-generate-algod = "polytest --config test_configs/algod_client.jsonc --git 'https://github.com/algorandfoundation/algokit-polytest#main' generate -t pytest" +polytest-validate-algod = "polytest --config test_configs/algod_client.jsonc --git 'https://github.com/algorandfoundation/algokit-polytest#main' validate -t pytest" +polytest-generate-indexer = "polytest --config test_configs/indexer_client.jsonc --git 'https://github.com/algorandfoundation/algokit-polytest#main' generate -t pytest" +polytest-validate-indexer = "polytest --config test_configs/indexer_client.jsonc --git 'https://github.com/algorandfoundation/algokit-polytest#main' validate -t pytest" +polytest-generate-kmd = "polytest --config test_configs/kmd_client.jsonc --git 'https://github.com/algorandfoundation/algokit-polytest#main' generate -t pytest" +polytest-validate-kmd = "polytest --config test_configs/kmd_client.jsonc --git 'https://github.com/algorandfoundation/algokit-polytest#main' validate -t pytest" +polytest-generate-all = [ + "polytest-generate-transact", + "polytest-generate-algod", + "polytest-generate-indexer", + "polytest-generate-kmd", +] +polytest-validate-all = [ + "polytest-validate-transact", + "polytest-validate-algod", + "polytest-validate-indexer", + "polytest-validate-kmd", +] + +[tool.poe.tasks.ruff-check] +cmd = "ruff check src tests examples api" + +[tool.poe.tasks.mypy-check] +cmd = "mypy src" + +[tool.poe.tasks.lint] +sequence = ["ruff-check", "mypy-check"] +ignore_fail = "return_non_zero" + +[tool.poe.tasks.ruff-format] +cmd = "ruff format src tests examples api" + +[tool.poe.tasks.ruff-fix] +ref = "ruff-check --fix" + +[tool.poe.tasks.format] +sequence = ["ruff-format", "ruff-fix"] + +[tool.poe.tasks.check] +sequence = ["lint"] + +[tool.poe.tasks.test] +cmd = "pytest" + +[tool.poe.tasks.test-ci] +ref = """test \ + --cov=algokit_abi \ + --cov=algokit_algod_client \ + --cov=algokit_common \ + --cov=algokit_indexer_client \ + --cov=algokit_kmd_client \ + --cov=algokit_transact \ + --cov=algokit_utils \ + --cov-report=term-missing:skip-covered \ + --junitxml=pytest-junit.xml""" + +[tool.poe.tasks.generate-client] +sequence = [ + { cmd = "uv run --group api-generator oas-generator --spec https://raw.githubusercontent.com/algorandfoundation/algokit-oas-generator/${OAS_BRANCH}/specs/${SPEC}.oas3.json --out src --package algokit_${SPEC}_client" }, + { cmd = "ruff check --fix src/algokit_${SPEC}_client" }, + { cmd = "ruff format src/algokit_${SPEC}_client" }, +] +env.OAS_BRANCH = "main" + +[tool.poe.tasks.generate-algod-client] +ref = "generate-client" +env.SPEC = "algod" + +[tool.poe.tasks.generate-indexer-client] +ref = "generate-client" +env.SPEC = "indexer" + +[tool.poe.tasks.generate-kmd-client] +ref = "generate-client" +env.SPEC = "kmd" + +[tool.poe.tasks.generate-api-clients] +sequence = [ + "generate-algod-client", + "generate-indexer-client", + "generate-kmd-client", +] + +[tool.poe.tasks.generate-schemas] +sequence = [ + { cmd = "python scripts/generate_schemas.py" }, + { cmd = "ruff format tests/fixtures/schemas/algod.py tests/fixtures/schemas/indexer.py tests/fixtures/schemas/kmd.py" }, +] +help = "Generate Pydantic validation schemas from OpenAPI specs" + +[tool.poe.tasks.release-preview] +sequence = [ + { cmd = "semantic-release version --print" }, + { cmd = "semantic-release version --print --as-prerelease" }, +] +help = "Preview current and next prerelease version" + +[tool.poe.tasks.release-dry-run-beta] +shell = "semantic-release --noop version --as-prerelease --prerelease-token beta" +help = "Dry-run beta release (no changes made)" [tool.pytest.ini_options] -pythonpath = ["src", "tests"] -norecursedirs = ["src"] # Ignore test collection in source directory, otherwise picks up TestNet* prefixed abstractions -filterwarnings = [ - # Ignore deprecations in utils legacy v2 is removed - "ignore::DeprecationWarning", +pythonpath = ["src"] +testpaths = ["tests"] +markers = [ + "group_transaction_tests", + "group_transaction_group_tests", + "group_generic_transaction_tests", + "group_common_tests", + "localnet", ] +addopts = "-n auto" +norecursedirs = [ + "src", + ".*", + ".git", + ".venv", + "dist", + "build", + "docs", + ".references", +] # Ignore test collection in source directory and common hidden/build folders [tool.mypy] files = ["src", "tests"] -exclude = ["dist", "tests/artifacts", "src/algokit_utils/_legacy_v2"] +exclude = ["dist", "tests/artifacts", "tests/fixtures/schemas", "src/algokit_algosdk", "src/algokit_algod_client", "src/algokit_indexer_client", "src/algokit_kmd_client"] python_version = "3.10" warn_unused_ignores = true warn_redundant_casts = true @@ -160,26 +329,50 @@ disallow_untyped_decorators = true disallow_any_generics = false implicit_reexport = false show_error_codes = true +mypy_path = ["src"] -untyped_calls_exclude = [ - "algosdk", -] +untyped_calls_exclude = ["algokit_algosdk"] [[tool.mypy.overrides]] -module = ["algosdk", "algosdk.*"] +module = ["algokit_algosdk", "algokit_algosdk.*"] disallow_untyped_calls = false [[tool.mypy.overrides]] module = ["tests.transactions.test_transaction_composer"] disable_error_code = ["call-overload", "union-attr"] +[[tool.mypy.overrides]] +module = ["msgpack", "msgpack.*"] +ignore_missing_imports = true + [tool.semantic_release] -version_toml = "pyproject.toml:tool.poetry.version" -remove_dist = false -build_command = "poetry build --format wheel" -version_source = "tag" +version_toml = ["pyproject.toml:project.version"] +build_command = "uv build" major_on_zero = true -upload_to_repository = false -tag_commit = true -branch = "main" commit_message = "{version}\n\nskip-checks: true" +tag_format = "v{version}" + +[tool.semantic_release.branches.main] +match = "main" +prerelease_token = "beta" +prerelease = false + +[tool.semantic_release.commit_parser_options] +allowed_tags = [ + "build", + "chore", + "ci", + "docs", + "feat", + "fix", + "perf", + "style", + "refactor", + "test", +] +minor_tags = ["feat"] +patch_tags = ["fix", "perf", "build", "chore", "refactor"] + +[tool.semantic_release.remote] +type = "github" +token = { env = "GH_TOKEN" } diff --git a/scripts/generate_schemas.py b/scripts/generate_schemas.py new file mode 100755 index 00000000..09c39bcb --- /dev/null +++ b/scripts/generate_schemas.py @@ -0,0 +1,280 @@ +#!/usr/bin/env python3 +"""Generate Pydantic validation schemas from OpenAPI specs. + +Produces one Python module per API client (algod.py, kmd.py, indexer.py) +containing all Pydantic BaseModel schemas derived from the OpenAPI spec. +Schemas are topologically sorted so forward references are unnecessary. +""" + +import builtins +import json +import keyword +import re +import urllib.error +import urllib.request +from pathlib import Path +from typing import Any, cast + +# Algorand uses uint64 for amounts, rounds, etc. +UINT64_MAX = 2**64 - 1 # 18446744073709551615 + +# Replicates the OAS generator's IdentifierSanitizer.snake() logic +# to ensure schema field names match the generated dataclass field names. +_NON_WORD = re.compile(r"[^0-9a-zA-Z]+") +_ACRONYM_BOUNDARY = re.compile(r"([A-Z]+)([A-Z][a-z])") +_LOWER_TO_UPPER = re.compile(r"([a-z0-9])([A-Z])") +_PY_RESERVED = {*keyword.kwlist, *keyword.softkwlist, *dir(builtins), "self", "cls"} + +SPECS = { + "algod": "https://raw.githubusercontent.com/algorandfoundation/algokit-oas-generator/main/specs/algod.oas3.json", + "kmd": "https://raw.githubusercontent.com/algorandfoundation/algokit-oas-generator/main/specs/kmd.oas3.json", + "indexer": "https://raw.githubusercontent.com/algorandfoundation/algokit-oas-generator/main/specs/indexer.oas3.json", +} + +# Max docstring content: 120 (line) - 4 (indent) - 3 (open """) - 3 (...) - 3 (close """) = 107 +_MAX_DOC = 107 + + +def _to_snake(raw: str) -> str: + """Convert an OAS field name to the same snake_case the OAS generator produces.""" + cleaned = _NON_WORD.sub(" ", raw) + spaced = _ACRONYM_BOUNDARY.sub(r"\1 \2", cleaned) + spaced = _LOWER_TO_UPPER.sub(r"\1 \2", spaced) + parts = [part for part in spaced.strip().split() if part] + candidate = "_".join(word.lower() for word in parts) if parts else "value" + if candidate in _PY_RESERVED: + candidate += "_" + return candidate + + +def _sanitize_docstring(desc: str) -> str: + """Escape invalid sequences and truncate long docstrings.""" + # Escape bare backslashes (e.g. \[apar\] from OAS descriptions) + desc = desc.replace("\\", "\\\\") + # Truncate to avoid E501 + if len(desc) > _MAX_DOC: + desc = desc[:_MAX_DOC] + "..." + return desc + + +def _class_name(oas_name: str) -> str: + """Ensure OAS schema name starts with uppercase for PEP 8 class naming.""" + return oas_name[0].upper() + oas_name[1:] if oas_name else oas_name + + +def fetch_spec(url: str) -> dict[str, Any]: + """Fetch OpenAPI spec from URL.""" + try: + with urllib.request.urlopen(url, timeout=30) as response: + return cast(dict[str, Any], json.loads(response.read())) + except (urllib.error.URLError, json.JSONDecodeError) as e: + raise SystemExit(f"Failed to fetch spec from {url}: {e}") from e + + +# --------------------------------------------------------------------------- +# Dependency analysis & topological sort +# --------------------------------------------------------------------------- + + +def _collect_refs(schema: dict[str, Any]) -> set[str]: + """Collect all $ref schema names referenced by a schema.""" + refs: set[str] = set() + if "$ref" in schema: + refs.add(schema["$ref"].split("/")[-1]) + for key in ("properties", "items", "additionalProperties"): + val = schema.get(key) + if isinstance(val, dict): + if key == "properties": + for prop in val.values(): + refs |= _collect_refs(prop) + else: + refs |= _collect_refs(val) + return refs + + +def _topological_sort(schemas: dict[str, dict[str, Any]]) -> list[str]: + """Sort schema names so dependencies come before dependents.""" + deps = {name: _collect_refs(s) & schemas.keys() for name, s in schemas.items()} + sorted_names: list[str] = [] + visited: set[str] = set() + visiting: set[str] = set() + + def visit(name: str) -> None: + if name in visited or name in visiting: + return # circular deps handled by `from __future__ import annotations` + visiting.add(name) + for dep in sorted(deps.get(name, set())): + visit(dep) + visiting.discard(name) + visited.add(name) + sorted_names.append(name) + + for name in sorted(schemas): + visit(name) + return sorted_names + + +# --------------------------------------------------------------------------- +# Type mapping +# --------------------------------------------------------------------------- + + +def map_type(details: dict[str, Any], *, required: bool) -> str: + """Map OpenAPI type to Python type hint.""" + if "$ref" in details: + ref = _class_name(details["$ref"].split("/")[-1]) + "Schema" + return ref if required else f"{ref} | None" + + match details.get("type"): + case "array": + item = map_type(details.get("items", {}), required=True) + base = f"list[{item}]" + return base if required else f"{base} | None" + case "object": + if "additionalProperties" in details: + val = map_type(details["additionalProperties"], required=True) + base = f"dict[str, {val}]" + else: + base = "dict[str, Any]" + return base if required else f"{base} | None" + case "string": + base = "str" + case "integer": + base = "int" + case "number": + base = "float" + case "boolean": + base = "bool" + case _: + base = "Any" + + return base if required else f"{base} | None" + + +# --------------------------------------------------------------------------- +# Schema class generation +# --------------------------------------------------------------------------- + + +def _is_byte_array(schema: dict[str, Any]) -> bool: + """Check if schema is an array of uint8 (byte array).""" + items = schema.get("items", {}) + return schema.get("type") == "array" and items.get("type") == "integer" and items.get("format") == "uint8" + + +def build_field(prop: str, details: dict[str, Any], *, required: bool) -> str: + """Build a Pydantic field definition line.""" + rename = details.get("x-algokit-field-rename") + field_name = _to_snake(rename) if rename else _to_snake(prop) + + if field_name in {"model_config", "model_fields", "model_computed_fields", "schema"}: + field_name += "_" + + field_type = map_type(details, required=required) + + constraints = [] if required else ["default=None"] + if details.get("format") == "uint64": + constraints.extend(["ge=0", f"le={UINT64_MAX}"]) + if "minimum" in details: + constraints.append(f"ge={details['minimum']}") + if "maximum" in details: + constraints.append(f"le={details['maximum']}") + + parts = [*constraints, f'alias="{prop}"'] + return f" {field_name}: {field_type} = Field({', '.join(parts)})" + + +def _docstring(schema: dict[str, Any]) -> str: + """Generate an indented docstring line, or empty string if no description.""" + raw = schema.get("description", "") + if not raw: + return "" + return f' """{_sanitize_docstring(raw)}"""\n\n' + + +def generate_class(name: str, schema: dict[str, Any]) -> str: + """Generate a single schema class definition (no imports).""" + cls = _class_name(name) + desc = _docstring(schema) + + # String, byte array, or opaque schema → RootModel[str] + is_string = schema.get("type") == "string" + is_opaque = not schema.get("properties") and not schema.get("type") + if is_string or _is_byte_array(schema) or is_opaque: + body = desc if desc else " pass\n" + return f"class {cls}Schema(RootModel[str]):\n{body}" + + # Array schema → RootModel[list[...]] + if schema.get("type") == "array": + item = map_type(schema.get("items", {}), required=True) + body = desc if desc else " pass\n" + return f"class {cls}Schema(RootModel[list[{item}]]):\n{body}" + + properties = schema.get("properties", {}) + + # Empty object schema + if not properties: + return ( + f"class {cls}Schema(BaseModel):\n{desc}" + ' model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True, extra="allow")\n' + ) + + # Regular object schema + required_fields = schema.get("required", []) + fields = [build_field(p, d, required=p in required_fields) for p, d in properties.items()] + fields_str = "\n".join(fields) + return ( + f"class {cls}Schema(BaseModel):\n{desc}" + " model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True)\n\n" + f"{fields_str}\n" + ) + + +# --------------------------------------------------------------------------- +# Module assembly +# --------------------------------------------------------------------------- + + +def generate_module(schemas: dict[str, dict[str, Any]]) -> str: + """Generate a complete Python module containing all schemas for one client.""" + sorted_names = _topological_sort(schemas) + classes = [generate_class(name, schemas[name]) for name in sorted_names] + needs_any = any("dict[str, Any]" in code for code in classes) + + # Build header + lines = ['"""Generated Pydantic validation schemas from OpenAPI spec."""\n\n'] + lines.append("from __future__ import annotations\n\n") + if needs_any: + lines.append("from typing import Any\n\n") + lines.append("from pydantic import BaseModel, ConfigDict, Field, RootModel\n") + + for code in classes: + lines.append(f"\n\n{code}") + + return "".join(lines) + + +def write_module(client: str, content: str) -> None: + """Write a single schema module file.""" + output_dir = Path("tests/fixtures/schemas") + output_dir.mkdir(parents=True, exist_ok=True) + (output_dir / f"{client}.py").write_text(content) + + +def main() -> None: + """Generate schemas from OpenAPI specs.""" + total = 0 + for client, url in SPECS.items(): + print(f"\n{client.upper()}: ", end="", flush=True) + spec = fetch_spec(url) + schemas = spec["components"]["schemas"] + content = generate_module(schemas) + write_module(client, content) + total += len(schemas) + print(f"{len(schemas)} schemas") + + print(f"\nTotal: {total} schemas ✓") + + +if __name__ == "__main__": + main() diff --git a/src/algokit_abi/__init__.py b/src/algokit_abi/__init__.py new file mode 100644 index 00000000..f1609a7a --- /dev/null +++ b/src/algokit_abi/__init__.py @@ -0,0 +1,9 @@ +from algokit_abi import abi, arc32, arc56 +from algokit_abi._arc32_to_arc56 import arc32_to_arc56 + +__all__ = [ + "abi", + "arc32", + "arc32_to_arc56", + "arc56", +] diff --git a/src/algokit_abi/_arc32_to_arc56.py b/src/algokit_abi/_arc32_to_arc56.py new file mode 100644 index 00000000..ba1591f9 --- /dev/null +++ b/src/algokit_abi/_arc32_to_arc56.py @@ -0,0 +1,242 @@ +from __future__ import annotations + +import base64 +import json +from base64 import b64encode +from collections.abc import Mapping, Sequence +from enum import Enum +from typing import Any, Literal, overload + +from algokit_abi import abi, arc32, arc56 +from algokit_common import from_wire + + +class _ActionType(str, Enum): + CALL = "CALL" + CREATE = "CREATE" + + +_ARG_ALIASES: Mapping[str, arc56.ReferenceType | arc56.TransactionType] = { + **{r.value: r for r in arc56.ReferenceType}, + **{t.value: t for t in arc56.TransactionType}, +} + + +__all__ = ["arc32_to_arc56"] + + +def arc32_to_arc56(arc32_application_spec: str | arc32.Arc32Contract) -> arc56.Arc56Contract: + """Convert an ARC-32 application specification to ARC-56.""" + + arc32_json = ( + arc32_application_spec.to_json() + if isinstance(arc32_application_spec, arc32.Arc32Contract) + else arc32_application_spec + ) + return _Arc32ToArc56Converter(arc32_json).convert() + + +class _Arc32ToArc56Converter: + def __init__(self, arc32_application_spec: str): + self.arc32 = json.loads(arc32_application_spec) + + def convert(self) -> arc56.Arc56Contract: + source_data = self.arc32.get("source") + methods, structs = self._convert_methods(self.arc32) + return arc56.Arc56Contract( + name=self.arc32["contract"]["name"], + desc=self.arc32["contract"].get("desc"), + arcs=[], + methods=methods, + structs=structs, + state=self._convert_state(self.arc32), + source=arc56.Source(**source_data) if source_data else None, + bare_actions=arc56.Actions( + call=self._convert_actions(self.arc32.get("bare_call_config"), _ActionType.CALL), + create=self._convert_actions(self.arc32.get("bare_call_config"), _ActionType.CREATE), + ), + ) + + def _convert_storage_keys(self, schema: dict) -> dict[str, arc56.StorageKey]: + """Convert ARC32 schema declared fields to ARC56 storage keys.""" + + return { + name: arc56.StorageKey( + key=b64encode(field["key"].encode()).decode(), + _key_type=arc56.AVMType.STRING, + _value_type=arc56.AVMType.UINT64 if field["type"] == "uint64" else arc56.AVMType.BYTES, + desc=field.get("descr"), + ) + for name, field in schema.items() + } + + def _convert_state(self, arc32: dict) -> arc56.State: + """Convert ARC32 state and schema to ARC56 state specification.""" + state_data = arc32.get("state", {}) + return arc56.State( + schema=arc56.Schema( + global_state=arc56.Global( + ints=state_data.get("global", {}).get("num_uints", 0), + bytes=state_data.get("global", {}).get("num_byte_slices", 0), + ), + local_state=arc56.Local( + ints=state_data.get("local", {}).get("num_uints", 0), + bytes=state_data.get("local", {}).get("num_byte_slices", 0), + ), + ), + keys=arc56.Keys( + global_state=self._convert_storage_keys(arc32.get("schema", {}).get("global", {}).get("declared", {})), + local_state=self._convert_storage_keys(arc32.get("schema", {}).get("local", {}).get("declared", {})), + box={}, + ), + maps=arc56.Maps(global_state={}, local_state={}, box={}), + ) + + def _convert_default_value(self, default_arg: dict[str, Any] | None) -> arc56.DefaultValue | None: + """Convert ARC32 default argument to ARC56 format.""" + if not default_arg or not default_arg.get("source"): + return None + + source_mapping = { + "constant": "literal", + "global-state": "global", + "local-state": "local", + "abi-method": "method", + } + + mapped_source = source_mapping.get(default_arg["source"]) + if not mapped_source: + return None + arg_data = default_arg["data"] + if mapped_source == "method": + method = from_wire(arc56.Method, arg_data) + return arc56.DefaultValue( + source=mapped_source, # type: ignore[arg-type] + data=method.signature, + ) + + default_value_type: abi.ABIType | arc56.AVMType | None = None + if mapped_source == "literal": + if isinstance(arg_data, int): + default_value_type = abi.UintType(64) + arg_data = default_value_type.encode(arg_data) + elif isinstance(arg_data, str): + default_value_type = arc56.AVMType.STRING + else: + raise ValueError(f"Invalid default argument data type: {type(arg_data)}") + if isinstance(arg_data, str): + arg_data = arg_data.encode("utf-8") + return arc56.DefaultValue( + source=mapped_source, # type: ignore[arg-type] + data=base64.b64encode(arg_data).decode("utf-8"), + type=default_value_type, + ) + + @overload + def _convert_actions(self, config: dict | None, action_type: Literal[_ActionType.CALL]) -> list[arc56.CallEnum]: ... + + @overload + def _convert_actions( + self, config: dict | None, action_type: Literal[_ActionType.CREATE] + ) -> list[arc56.CreateEnum]: ... + + def _convert_actions( + self, config: dict | None, action_type: _ActionType + ) -> Sequence[arc56.CallEnum | arc56.CreateEnum]: + """Extract supported actions from call config.""" + if not config: + return [] + + actions = list[arc56.CallEnum | arc56.CreateEnum]() + mappings = { + "no_op": (arc56.CallEnum.NO_OP, arc56.CreateEnum.NO_OP), + "opt_in": (arc56.CallEnum.OPT_IN, arc56.CreateEnum.OPT_IN), + "close_out": (arc56.CallEnum.CLOSE_OUT, None), + "delete_application": (arc56.CallEnum.DELETE_APPLICATION, arc56.CreateEnum.DELETE_APPLICATION), + "update_application": (arc56.CallEnum.UPDATE_APPLICATION, None), + } + + for action, (call_enum, create_enum) in mappings.items(): + if action in config and config[action] in ["ALL", action_type]: + if action_type == "CALL" and call_enum: + actions.append(call_enum) + elif action_type == "CREATE" and create_enum: + actions.append(create_enum) + + return actions + + def _convert_method_actions(self, hint: dict | None) -> arc56.Actions: + """Convert method call config to ARC56 actions.""" + config = hint.get("call_config", {}) if hint else {} + return arc56.Actions( + call=self._convert_actions(config, _ActionType.CALL), + create=self._convert_actions(config, _ActionType.CREATE), + ) + + def _convert_methods(self, arc32: dict) -> tuple[list[arc56.Method], dict[str, abi.StructType]]: + """Convert ARC32 methods to ARC56 format.""" + methods = [] + contract = arc32["contract"] + hints = arc32.get("hints", {}) + structs = {} + for method in contract["methods"]: + args_sig = ",".join(a["type"] for a in method["args"]) + signature = f"{method['name']}({args_sig}){method['returns']['type']}" + hint = hints.get(signature, {}) + method_structs = hint.get("structs", {}) + method_args = [] + for arg in method["args"]: + name = arg.get("name") + struct_name = None + if struct := method_structs.get(name): + struct_type = _convert_struct(struct) + struct_name = struct_type.display_name + structs[struct_name] = struct_type + arg_type: abi.ABIType | arc56.ReferenceType | arc56.TransactionType = struct_type + elif alias := _ARG_ALIASES.get(arg["type"]): + arg_type = alias + else: + arg_type = abi.ABIType.from_string(arg["type"]) + method_args.append( + arc56.Argument( + type=arg_type, + name=name, + desc=arg.get("desc"), + default_value=self._convert_default_value( + hint.get("default_arguments", {}).get(arg.get("name")) + ), + struct=struct_name, + ) + ) + returns = method["returns"] + struct_name = None + if struct := method_structs.get("output"): + struct_type = _convert_struct(struct) + struct_name = struct_type.display_name + structs[struct_name] = struct_type + return_type: abi.ABIType | arc56.VoidType = struct_type + elif returns["type"] == arc56.Void: + return_type = arc56.Void + else: + return_type = abi.ABIType.from_string(returns["type"]) + methods.append( + arc56.Method( + name=method["name"], + desc=method.get("desc"), + readonly=hint.get("read_only"), + args=method_args, + returns=arc56.Returns( + return_type, + desc=returns.get("desc"), + struct=struct_name, + ), + actions=self._convert_method_actions(hint), + events=[], # ARC32 doesn't specify events + ) + ) + return methods, structs + + +def _convert_struct(struct: dict) -> abi.StructType: + fields = {name: abi.ABIType.from_string(typ) for name, typ in struct["elements"]} + return abi.StructType(struct_name=struct["name"], fields=fields) diff --git a/src/algokit_abi/_arc56_serde.py b/src/algokit_abi/_arc56_serde.py new file mode 100644 index 00000000..fdb8f97a --- /dev/null +++ b/src/algokit_abi/_arc56_serde.py @@ -0,0 +1,161 @@ +import base64 +import typing +from collections.abc import Callable, Mapping, Sequence +from dataclasses import dataclass, field + +from algokit_abi import abi +from algokit_common import from_wire, to_wire, wire + +_Metadata = Mapping[str, object] +_T = typing.TypeVar("_T") + + +def base64_encoded_bytes(alias: str) -> _Metadata: + return wire( + alias, + encode=lambda v: base64.b64encode(v).decode("ascii"), + decode=base64.b64decode, + ) + + +def sequence(alias: str, typ: Callable[..., object], *, omit_empty_seq: bool = True) -> _Metadata: + def decode(payload: list) -> object: + return [typ(v) for v in payload] + + return wire(alias, decode=decode, omit_empty_seq=omit_empty_seq) + + +def nested_sequence(alias: str, typ: type[_T]) -> _Metadata: + def encode(val: list | None) -> object: + if val is None: + return None + return [to_wire(v) for v in val] + + def decode(payload: list | None) -> object: + if payload is None: + return None + return [from_wire(typ, v) for v in payload] + + return wire(alias, encode=encode, decode=decode, omit_empty_seq=False, omit_if_none=True) + + +def mapping(alias: str, typ: type[_T]) -> _Metadata: + def encode(value: Mapping) -> Mapping: + return {k: to_wire(v) for k, v in value.items()} + + def decode(payload: Mapping) -> Mapping: + return {k: from_wire(typ, v) for k, v in payload.items()} + + return wire(alias, decode=decode, encode=encode) + + +def abi_type(alias: str) -> _Metadata: + def encode(value: object) -> str: + if isinstance(value, abi.ABIType): + return value.name + else: + return str(value) + + def decode(value: str) -> object: + from algokit_abi import arc56 + + try: + return arc56.ENUM_ALIASES[value] + except KeyError: + return abi.ABIType.from_string(value) + + return wire(alias, encode=encode, decode=decode) + + +def storage(alias: str) -> _Metadata: + def encode(value: object) -> str: + if isinstance(value, abi.ABIType): + return value.name + else: + return str(value) + + def decode(value: str) -> object: + from algokit_abi import arc56 + + try: + return arc56.AVMType(value) + except ValueError: + pass + try: + return abi.ABIType.from_string(value) + except ValueError: + return str(value) + + return wire(alias, encode=encode, decode=decode) + + +class _StructField(typing.TypedDict): + name: str + type: "str | list[_StructField]" + + +_StructFieldJson = dict[str, list[_StructField]] + + +@dataclass +class _StructDecoder: + _struct_json: _StructFieldJson + result: dict[str, abi.StructType] = field(default_factory=dict) + + @classmethod + def decode(cls, struct_json: _StructFieldJson) -> dict[str, abi.StructType]: + decoder = cls(struct_json) + decoder._process() + return decoder.result + + def _process(self) -> None: + # add known struct names + for struct_name, struct_json in self._struct_json.items(): + self._get_or_add(struct_name, struct_json) + + def _get_or_add(self, name: str, fields: Sequence[_StructField]) -> abi.StructType: + try: + return self.result[name] + except KeyError: + pass + self.result[name] = struct = self._decode_struct(name, fields) + return struct + + def _decode_struct(self, name: str, fields: Sequence[_StructField]) -> abi.StructType: + abi_fields = dict[str, abi.ABIType]() + for field_ in fields: + field_name = field_["name"] + field_type = field_["type"] + if isinstance(field_type, Sequence) and not isinstance(field_type, str): # anonymous inner struct + inner_struct_name = f"{name}_{field_name}" + field_abi_type: abi.ABIType = self._decode_struct(inner_struct_name, field_type) + elif (field_struct_json := self._struct_json.get(field_type)) is not None: # named struct + field_abi_type = self._get_or_add(field_type, field_struct_json) + else: + field_abi_type = abi.ABIType.from_string(field_type) + abi_fields[field_name] = field_abi_type + return abi.StructType(struct_name=name, fields=abi_fields) + + +def _encode_structs(structs: dict[str, abi.StructType]) -> dict: + return {name: _encode_struct(structs, struct) for name, struct in structs.items()} + + +def _encode_struct(structs: dict[str, abi.StructType], struct: abi.StructType) -> list: + fields = [] + for field_name, field_type in struct.fields.items(): + fields.append(_StructField(name=field_name, type=_encode_struct_field(structs, field_type))) + return fields + + +def _encode_struct_field(structs: dict[str, abi.StructType], field_type: abi.ABIType) -> str | list: + if isinstance(field_type, abi.StructType): + if field_type.display_name in structs: + return field_type.display_name + else: + return _encode_struct(structs, field_type) + else: + return field_type.name + + +struct_metadata = wire("structs", encode=_encode_structs, decode=_StructDecoder.decode) diff --git a/src/algokit_abi/abi.py b/src/algokit_abi/abi.py new file mode 100644 index 00000000..9438bd37 --- /dev/null +++ b/src/algokit_abi/abi.py @@ -0,0 +1,667 @@ +import abc +import dataclasses +import decimal +import typing +from collections.abc import Iterator, Mapping, Sequence +from functools import cached_property + +from algokit_common import address_from_public_key, public_key_from_address + +BytesLike = bytes | bytearray | memoryview + + +_ABI_BOOL_TRUE_UINT = 0x80 +_ABI_BOOL_TRUE = _ABI_BOOL_TRUE_UINT.to_bytes(length=1, byteorder="big") +_ABI_BOOL_FALSE = b"\x00" +_MAX_UINT_N = 512 +_U16_NUM_BYTES = 2 +_MAX_U16 = 2**16 - 1 + + +class ABIType(abc.ABC): + @property + def display_name(self) -> str: + return self.name + + @property + @abc.abstractmethod + def name(self) -> str: ... + + @abc.abstractmethod + def encode(self, value: typing.Any) -> bytes: ... # noqa: ANN401 + + @abc.abstractmethod + def decode(self, value: BytesLike) -> typing.Any: ... # noqa: ANN401 + + def is_dynamic(self) -> bool: + return self.byte_len() is None + + @abc.abstractmethod + def byte_len(self) -> int | None: ... + + @classmethod + def from_string(cls, value: str) -> "ABIType": + try: + return _COMMON_TYPES[value] + except KeyError: + pass + if value.startswith("(") and value.endswith(")"): + tup_inner = value[1:-1] + tup_elements = [cls.from_string(t) for t in split_tuple_str(tup_inner)] + return TupleType(tup_elements) + if value.endswith("[]"): + element = cls.from_string(value[:-2]) + return DynamicArrayType(element) + if value.endswith("]"): + array_start = value.rindex("[") + size_str = value[array_start + 1 : -1] + try: + size = int(size_str) + except ValueError: + pass # fall through to error + else: + element = cls.from_string(value[:array_start]) + return StaticArrayType(element, size) + elif value.startswith("ufixed"): + n_m_str = value.removeprefix("ufixed") + try: + n, m = map(int, n_m_str.split("x")) + except ValueError: + pass # fall through to error + else: + return UfixedType(n, m) + raise ValueError(f"unknown abi type: {value}") + + def __eq__(self, other: object) -> bool: + if isinstance(other, StructType): + # structs can only equal structs + return False + if isinstance(other, ABIType): + return self.name == other.name + else: + return False + + def __hash__(self) -> int: + return hash(self.display_name) + + def __str__(self) -> str: + return self.display_name + + def _check_num_bytes(self, value: BytesLike) -> None: + expected_bytes_len = self.byte_len() + if expected_bytes_len is not None and len(value) != expected_bytes_len: + raise ValueError(f"expected {expected_bytes_len} bytes for {self.display_name}, got {len(value)} bytes") + + +@typing.final +class BoolType(ABIType): + @property + def name(self) -> str: + return "bool" + + def byte_len(self) -> int: + return 1 + + def encode(self, value: bool) -> bytes: # noqa: FBT001 + # note: bool in an array or tuple is handled separately + # intentionally comparing to True and False to handle invalid types + if value is True: + return _ABI_BOOL_TRUE + elif value is False: + return _ABI_BOOL_FALSE + else: + raise ValueError(f"expected a bool, got: {_error_str(value)}") + + def decode(self, value: BytesLike) -> bool: + if value == _ABI_BOOL_TRUE: + return True + elif value == _ABI_BOOL_FALSE: + return False + else: + raise ValueError(f"bool value could not be decoded: {_error_str(value)}") + + +@typing.final +@dataclasses.dataclass(frozen=True) +class UintType(ABIType): + bit_size: int = dataclasses.field() + + def __post_init__(self) -> None: + if ( + not isinstance(self.bit_size, int) + or self.bit_size <= 0 + or self.bit_size > _MAX_UINT_N + or self.bit_size % 8 != 0 + ): + raise ValueError(f"bit_size must be between 8 and {_MAX_UINT_N} and divisible by 8") + + @property + def name(self) -> str: + return f"uint{self.bit_size}" + + def byte_len(self) -> int: + return self.bit_size // 8 + + def encode(self, value: int) -> bytes: + if not isinstance(value, int): + raise TypeError("expected int") + return value.to_bytes(self.byte_len(), byteorder="big", signed=False) + + def decode(self, value: BytesLike) -> int: + self._check_num_bytes(value) + return int.from_bytes(value, byteorder="big", signed=False) + + +_MAX_PRECISION = 160 + + +@typing.final +@dataclasses.dataclass(frozen=True) +class UfixedType(ABIType): + bit_size: int + precision: int + + def __post_init__(self) -> None: + if ( + not isinstance(self.bit_size, int) + or self.bit_size <= 0 + or self.bit_size > _MAX_UINT_N + or self.bit_size % 8 != 0 + ): + raise ValueError(f"bit_size must be between 8 and {_MAX_UINT_N} and divisible by 8") + if not isinstance(self.precision, int) or self.precision <= 0 or self.precision > _MAX_PRECISION: + raise ValueError(f"precision must be between 0 and {_MAX_PRECISION}") + + @property + def name(self) -> str: + return f"ufixed{self.bit_size}x{self.precision}" + + def byte_len(self) -> int: + return self._int_type.byte_len() + + @cached_property + def _int_type(self) -> UintType: + return UintType(bit_size=self.bit_size) + + def encode(self, value: decimal.Decimal | int) -> bytes: + if isinstance(value, decimal.Decimal): + value = value.normalize() + decimal_tuple = value.as_tuple() + exponent = decimal_tuple.exponent + if not isinstance(exponent, int): + raise ValueError(f"unsupported decimal: {_error_str(value)}") + if -exponent > self.precision: + raise ValueError(f"precision exceeds {self.precision}: {_error_str(value)}") + value_int = int(value * 10**self.precision) + else: + value_int = value + return self._int_type.encode(value_int) + + def decode(self, value: BytesLike) -> decimal.Decimal: + int_value = self._int_type.decode(value) + int_str = str(int_value).zfill(self.precision) + decimal_str = int_str[: -self.precision] + "." + int_str[-self.precision :] + return decimal.Decimal(decimal_str) + + +@typing.final +@dataclasses.dataclass(frozen=True) +class ByteType(ABIType): + _uint_type: UintType = dataclasses.field(default=UintType(bit_size=8), init=False) + + @property + def name(self) -> str: + return "byte" + + def byte_len(self) -> int: + return self._uint_type.byte_len() + + def encode(self, value: int | bytes | bytearray) -> bytes: + if isinstance(value, int): + return self._uint_type.encode(value) + elif len(value) == 1: + return bytes(value) + else: + raise ValueError(f"expected 1 byte: {_error_str(value)}") + + def decode(self, value: BytesLike) -> bytes: + self._check_num_bytes(value) + return bytes(value) + + +@dataclasses.dataclass(frozen=True) +class DynamicArrayType(ABIType): + element: ABIType + + @property + def display_name(self) -> str: + return f"{self.element.display_name}[]" + + @property + def name(self) -> str: + return f"{self.element.name}[]" + + def byte_len(self) -> None: + return None + + def encode(self, value: Sequence | bytes | bytearray) -> bytes: + static_type = StaticArrayType(element=self.element, size=len(value)) + try: + len_bytes = _int_to_u16_bytes(len(value)) + except OverflowError: + raise ValueError(f"array length exceeds {_MAX_U16}") from None + return len_bytes + static_type.encode(value) + + def decode(self, value: BytesLike) -> list | bytes: + data = memoryview(value) + if data.nbytes < _U16_NUM_BYTES: + raise ValueError(f"not enough bytes to decode {self}: {_error_str(value)}") + + array_len = int.from_bytes(data[:_U16_NUM_BYTES], byteorder="big") + + static_type = StaticArrayType(element=self.element, size=array_len) + return static_type.decode(data[_U16_NUM_BYTES:]) + + +@dataclasses.dataclass(frozen=True) +class _RepeatedSequence(Sequence[ABIType]): + element: ABIType + size: int + + def __len__(self) -> int: + return self.size + + def __iter__(self) -> Iterator[ABIType]: + for _ in range(self.size): + yield self.element + + def __getitem__(self, item: int) -> ABIType: # type: ignore[override] + if item >= self.size or -item > self.size: + raise IndexError("index out of range") + return self.element + + def __contains__(self, x: object, /) -> bool: + return x == self.element + + +@typing.final +@dataclasses.dataclass(frozen=True) +class StaticArrayType(ABIType): + element: ABIType + size: int + + @property + def display_name(self) -> str: + return f"{self.element.display_name}[{self.size}]" + + @property + def name(self) -> str: + return f"{self.element.name}[{self.size}]" + + @cached_property + def _tuple_type(self) -> "TupleType": + return TupleType(elements=_RepeatedSequence(self.element, self.size)) + + def byte_len(self) -> int | None: + return self._tuple_type.byte_len() + + def encode(self, value: Sequence | bytes | bytearray) -> bytes: + return self._tuple_type.encode(value) + + def decode(self, value: BytesLike) -> list | bytes: + result = self._tuple_type.decode(value) + if isinstance(result, bytes): + return result + else: + return list(result) + + +@typing.final +@dataclasses.dataclass(frozen=True) +class TupleType(ABIType): + elements: Sequence[ABIType] + + @cached_property + def display_name(self) -> str: + if self._homogenous_element: + return f"{self._homogenous_element.display_name}[{len(self.elements)}]" + else: + return f"({','.join(v.display_name for v in self.elements)})" + + @cached_property + def name(self) -> str: + return f"({','.join(v.name for v in self.elements)})" + + def byte_len(self) -> int | None: + return self._byte_len + + @cached_property + def _byte_len(self) -> int | None: + total_bits = 0 + for el in self.elements: + if el.name == "bool": + total_bits += 1 + else: + el_byte_len = el.byte_len() + if el_byte_len is None: + return None + total_bits = _round_bits_to_nearest_byte(total_bits) + el_byte_len * 8 + if self._homogenous_element: + total_bits *= len(self.elements) + break + return _bits_to_byte(total_bits) + + @cached_property + def _homogenous_element(self) -> ABIType | None: + if isinstance(self.elements, _RepeatedSequence): + return self.elements.element + elif len({e.name for e in self.elements}) == 1: + return next(iter(self.elements)) + else: + return None + + @cached_property + def _head_num_bytes(self) -> int: + num_bits = 0 + for element in self.elements: + if _is_bool(element): + num_bits += 1 + else: + num_bits = _round_bits_to_nearest_byte(num_bits) + el_byte_len = element.byte_len() + if el_byte_len is None: + el_byte_len = _U16_NUM_BYTES + num_bits += el_byte_len * 8 + if self._homogenous_element: + num_bits *= len(self.elements) + break + return _bits_to_byte(num_bits) + + def encode(self, value: Sequence | bytes | bytearray) -> bytes: + if len(value) != len(self.elements): + raise ValueError(f"expected {len(self.elements)} elements: {_error_str(value)}") + if _is_byte(self._homogenous_element): + return bytes(value) + head = bytearray() + tail = bytearray() + bit_index = 0 + tail_offset = self._head_num_bytes + for el, el_type in zip(value, self.elements, strict=True): + # there are 3 kinds of elements to consider when encoding a tuple + # 1. bool, these require packing consecutive values into a byte in the head + # 2. dynamically sized types, these require a pointer in the head and the actual data in the tail + # 3. statically sized types, these are stored directly in the head + if _is_bool(el_type): + # append a new value if start of a new byte + if bit_index % 8 == 0: + head.append(0) + if el is True: + head[-1] = _set_bit(head[-1], bit_index % 8) + elif el is False: + pass + else: + raise ValueError("expected bool") + bit_index += 1 + else: + bit_index = 0 + el_bytes = el_type.encode(el) + if el_type.is_dynamic(): + try: + head.extend(_int_to_u16_bytes(tail_offset)) + except OverflowError: + raise ValueError(f"encoded bytes length exceeds {_MAX_U16}") from None + tail_offset += len(el_bytes) + tail.extend(el_bytes) + else: + head.extend(el_bytes) + return bytes((*head, *tail)) + + @cached_property + def _tuple_head_offsets(self) -> Mapping[int, int]: + offsets = {} + num_bits = 0 + for idx, element in enumerate(self.elements): + if element.is_dynamic(): + offsets[idx] = _bits_to_byte(num_bits) + if _is_bool(element): + num_bits += 1 + else: + num_bits = _round_bits_to_nearest_byte(num_bits) + el_byte_len = element.byte_len() + if el_byte_len is None: + el_byte_len = _U16_NUM_BYTES + num_bits += el_byte_len * 8 + return offsets + + def _get_next_dynamic_head_offset(self, index: int, value: memoryview) -> int | None: + # the last element reads to end + if index == len(self.elements) - 1: + return None + if self._homogenous_element: + assert self._homogenous_element.is_dynamic() + next_head_offset = _U16_NUM_BYTES * (index + 1) + else: + for idx in range(index + 1, len(self.elements)): + try: + next_head_offset = self._tuple_head_offsets[idx] + except KeyError: + continue + else: + break + else: + return None + return _u16_bytes_to_int(value[next_head_offset : next_head_offset + _U16_NUM_BYTES]) + + def decode(self, value: BytesLike) -> tuple | bytes: + self._check_num_bytes(value) + if _is_byte(self._homogenous_element): + return bytes(value) + + value = memoryview(value) + result = [] + head_offset = 0 + bit_index = 0 + expected_tail_offset = self._head_num_bytes + for el_idx, el_type in enumerate(self.elements): + if _is_bool(el_type): + current_byte = value[head_offset + bit_index // 8] + bool_value = _get_bit(current_byte, bit_index % 8) + result.append(bool_value) + bit_index += 1 + else: + head_offset += _bits_to_byte(bit_index) + bit_index = 0 + el_byte_len = el_type.byte_len() + if el_byte_len is None: + el_offset = _u16_bytes_to_int(value[head_offset : head_offset + _U16_NUM_BYTES]) + if el_offset != expected_tail_offset: + raise ValueError(f"expected tail offset of {expected_tail_offset} got: {el_offset}") + head_offset += _U16_NUM_BYTES + next_el_offset = self._get_next_dynamic_head_offset(el_idx, value) + el_bytes = value[el_offset:next_el_offset] + expected_tail_offset += len(el_bytes) + result.append(el_type.decode(el_bytes)) + else: + result.append(el_type.decode(value[head_offset : head_offset + el_byte_len])) + head_offset += el_byte_len + if self.is_dynamic() and expected_tail_offset != len(value): + raise ValueError(f"expected {expected_tail_offset} bytes for {self.display_name}, got {len(value)} bytes") + return tuple(result) + + +@typing.final +@dataclasses.dataclass(frozen=True, kw_only=True) +class StructType(ABIType): + struct_name: str + fields: Mapping[str, ABIType] + decode_type: type = dataclasses.field(default=dict) + + @property + def display_name(self) -> str: + return self.struct_name + + @cached_property + def name(self) -> str: + return self._tuple_type.name + + @cached_property + def _tuple_type(self) -> TupleType: + return TupleType(elements=tuple(self.fields.values())) + + def byte_len(self) -> int | None: + return self._tuple_type.byte_len() + + def encode(self, value: dict[str, typing.Any] | tuple | object) -> bytes: + if isinstance(value, dict): # structs as a dictionary mapped by field name + field_values = tuple(value[field_name] for field_name in self.fields) + elif isinstance(value, tuple): # structs that have already been converted to a tuple + field_values = value + else: # objects with struct field names + field_values = tuple(getattr(value, field_name) for field_name in self.fields) + return self._tuple_type.encode(field_values) + + def decode(self, value: BytesLike) -> typing.Any: # noqa: ANN401 + field_values = self._tuple_type.decode(value) + fields = dict(zip(self.fields, field_values, strict=True)) + return self.decode_type(**fields) + + def __hash__(self) -> int: + return hash(self.display_name) + + def __eq__(self, other: object) -> bool: + if not isinstance(other, StructType): + return False + return ( + self.display_name == other.display_name + and self.fields.keys() == other.fields.keys() + and self._tuple_type == other._tuple_type + ) + + +@typing.final +@dataclasses.dataclass(frozen=True) +class StringType(ABIType): + _array_type: DynamicArrayType = dataclasses.field(default=DynamicArrayType(element=ByteType()), init=False) + + @property + def name(self) -> str: + return "string" + + def byte_len(self) -> None: + return None + + def encode(self, value: str) -> bytes: + if not isinstance(value, str): + raise TypeError("expected str") + return self._array_type.encode(value.encode("utf-8")) + + def decode(self, value: BytesLike) -> str: + bytes_ = self._array_type.decode(value) + assert isinstance(bytes_, bytes) + return bytes_.decode("utf-8") + + +@typing.final +@dataclasses.dataclass(frozen=True) +class AddressType(ABIType): + _array_type: StaticArrayType = dataclasses.field(default=StaticArrayType(element=ByteType(), size=32), init=False) + + @property + def name(self) -> str: + return "address" + + def byte_len(self) -> int | None: + return self._array_type.byte_len() + + def encode(self, value: str | bytes | bytearray) -> bytes: + if isinstance(value, str): + value = public_key_from_address(value) + return self._array_type.encode(value) + + def decode(self, value: BytesLike) -> str: + public_key = self._array_type.decode(value) + assert isinstance(public_key, bytes) + return address_from_public_key(public_key) + + +def _is_bool(typ: ABIType | None) -> bool: + return type(typ) is BoolType + + +def _is_byte(typ: ABIType | None) -> bool: + return type(typ) is ByteType + + +_COMMON_TYPES = { + **{f"uint{n}": UintType(n) for n in range(8, _MAX_UINT_N + 1, 8)}, + "byte": ByteType(), + "bool": BoolType(), + "address": AddressType(), + "string": StringType(), +} + + +def split_tuple_str(s: str) -> Iterator[str]: + """ + Split a well-formed tuple into it's top level elements + + e.g. "(uint64,(bool,uint8),uint32)" + """ + if not s: + return + + if s.startswith(",") or s.endswith(","): + raise ValueError(f"cannot have leading or trailing commas in ({s})") + + depth = 0 + current_element = "" + for char in s: + if char == "(": + depth += 1 + elif char == ")": + depth -= 1 + elif char == "," and depth == 0: + # yield only top level tuple elements, nested elements will be recursively parsed + if not current_element: + raise ValueError(f"commas must follow a tuple element: ({s})") + yield current_element + current_element = "" + continue + current_element += char + if current_element: + yield current_element + if depth != 0: + raise ValueError(f"parenthesis mismatch: ({s})") + + +def _set_bit(value: int, bit_index: int) -> int: + return value | (_ABI_BOOL_TRUE_UINT >> bit_index) + + +def _get_bit(value: int, bit_index: int) -> bool: + return (value & (_ABI_BOOL_TRUE_UINT >> bit_index)) != 0 + + +def _int_to_u16_bytes(value: int) -> bytes: + return value.to_bytes(length=_U16_NUM_BYTES, byteorder="big", signed=False) + + +def _u16_bytes_to_int(value: memoryview) -> int: + if value.nbytes != _U16_NUM_BYTES: + raise ValueError("expected uint16 bytes") + return int.from_bytes(value, byteorder="big", signed=False) + + +def _bits_to_byte(bits: int) -> int: + return (bits + 7) // 8 + + +def _round_bits_to_nearest_byte(bits: int) -> int: + return _bits_to_byte(bits) * 8 + + +def _error_str(value: object) -> str: + if isinstance(value, bytes | bytearray | memoryview): + return f"0x{value.hex()}" + else: + return str(value) diff --git a/src/algokit_utils/applications/app_spec/arc32.py b/src/algokit_abi/arc32.py similarity index 93% rename from src/algokit_utils/applications/app_spec/arc32.py rename to src/algokit_abi/arc32.py index ff3b8f6b..7561fdcc 100644 --- a/src/algokit_utils/applications/app_spec/arc32.py +++ b/src/algokit_abi/arc32.py @@ -5,9 +5,9 @@ from pathlib import Path from typing import Any, Literal, TypeAlias, TypedDict -from algosdk.abi import Contract -from algosdk.abi.method import MethodDict -from algosdk.transaction import StateSchema +from typing_extensions import deprecated + +from algokit_transact.models.common import StateSchema __all__ = [ "AppSpecStateDict", @@ -22,13 +22,15 @@ "StructArgDict", ] +from algokit_abi import arc56 AppSpecStateDict: TypeAlias = dict[str, dict[str, dict]] """Type defining Application Specification state entries""" class CallConfig(IntFlag): - """Describes the type of calls a method can be used for based on {py:class}`algosdk.transaction.OnComplete` type""" + """Describes the type of calls a method can be used for based + on {py:class}`algosdk.transaction.OnApplicationComplete` type""" NEVER = 0 """Never handle the specified on completion type""" @@ -62,7 +64,7 @@ class DefaultArgumentDict(TypedDict): """ source: DefaultArgumentType - data: int | str | bytes | MethodDict + data: int | str | bytes | dict StateDict = TypedDict( # need to use function-form of TypedDict here since "global" is a reserved keyword @@ -138,6 +140,7 @@ def _decode_state_schema(data: dict[str, int]) -> StateSchema: ) +@deprecated("Arc32Contract is deprecated and will be removed in a future release; migrate to Arc56Contract.") @dataclasses.dataclass(kw_only=True) class Arc32Contract: """ARC-0032 application specification @@ -146,7 +149,7 @@ class Arc32Contract: approval_program: str clear_program: str - contract: Contract + contract: arc56.Arc56Contract # only contains ARC-4 subset of ARC-56 hints: dict[str, MethodHints] schema: StateDict global_state_schema: StateSchema @@ -181,7 +184,7 @@ def from_json(application_spec: str) -> "Arc32Contract": schema=json_spec["schema"], global_state_schema=_decode_state_schema(json_spec["state"]["global"]), local_state_schema=_decode_state_schema(json_spec["state"]["local"]), - contract=Contract.undictify(json_spec["contract"]), + contract=arc56.Arc56Contract.from_dict(json_spec["contract"]), hints={k: MethodHints.undictify(v) for k, v in json_spec["hints"].items()}, bare_call_config=_decode_method_config(json_spec.get("bare_call_config", {})), ) diff --git a/src/algokit_abi/arc56.py b/src/algokit_abi/arc56.py new file mode 100644 index 00000000..68205898 --- /dev/null +++ b/src/algokit_abi/arc56.py @@ -0,0 +1,821 @@ +import base64 +import enum +import json +import typing +from collections.abc import Callable, Mapping, Sequence +from dataclasses import dataclass, field, replace +from functools import cached_property + +from Cryptodome.Hash import SHA512 +from typing_extensions import deprecated + +from algokit_abi import _arc56_serde as serde +from algokit_abi import abi +from algokit_common import from_wire, nested, to_wire, wire + +if typing.TYPE_CHECKING: + from algokit_abi import arc32 + +__all__ = [ + "ENUM_ALIASES", + "AVMType", + "Actions", + "Arc56Contract", + "Argument", + "Boxes", + "ByteCode", + "CallEnum", + "Compiler", + "CompilerInfo", + "CompilerVersion", + "CreateEnum", + "DefaultValue", + "Event", + "EventArg", + "Global", + "Keys", + "Local", + "Maps", + "Method", + "Network", + "PcOffsetMethod", + "ProgramSourceInfo", + "Recommendations", + "ReferenceType", + "Returns", + "Schema", + "ScratchVariables", + "Source", + "SourceInfo", + "SourceInfoModel", + "State", + "StorageKey", + "StorageMap", + "TemplateVariables", + "TransactionType", + "Void", + "VoidType", +] + + +@typing.final +@enum.unique +class AVMType(str, enum.Enum): + """Enum representing native AVM types""" + + BYTES = "AVMBytes" + STRING = "AVMString" + UINT64 = "AVMUint64" + + def __str__(self) -> str: + return self.value + + +@typing.final +@enum.unique +class CallEnum(str, enum.Enum): + """Enum representing different call types for application transactions.""" + + CLEAR_STATE = "ClearState" + CLOSE_OUT = "CloseOut" + DELETE_APPLICATION = "DeleteApplication" + NO_OP = "NoOp" + OPT_IN = "OptIn" + UPDATE_APPLICATION = "UpdateApplication" + + def __str__(self) -> str: + return self.value + + +@typing.final +@enum.unique +class CreateEnum(str, enum.Enum): + """Enum representing different create types for application transactions.""" + + DELETE_APPLICATION = "DeleteApplication" + NO_OP = "NoOp" + OPT_IN = "OptIn" + + def __str__(self) -> str: + return self.value + + +@typing.final +@enum.unique +class ReferenceType(str, enum.Enum): + ASSET = "asset" + ACCOUNT = "account" + APPLICATION = "application" + + def __str__(self) -> str: + return self.value + + +@typing.final +@enum.unique +class TransactionType(str, enum.Enum): + ANY = "txn" + """Any transaction""" + PAY = "pay" + """Payment transaction""" + KEYREG = "keyreg" + "Key registration transaction" + ACFG = "acfg" + """Asset configuration transaction""" + AXFER = "axfer" + """Asset transfer transaction""" + AFRZ = "afrz" + """Asset freeze transaction""" + APPL = "appl" + """App call transaction, allows creating, deleting, and interacting with an application""" + + def __str__(self) -> str: + return self.value + + +VoidType = typing.Literal["void"] +Void: VoidType = "void" + +ENUM_ALIASES: Mapping[str, ReferenceType | TransactionType | VoidType | AVMType] = { + **{r.value: r for r in ReferenceType}, + **{t.value: t for t in TransactionType}, + **{a.value: a for a in AVMType}, + Void: Void, +} + + +class _StorageTypePropertyDescriptor: + def __set_name__(self, owner: type, name: str) -> None: + self._backing_field = f"_{name}" + self._resolved_field = f"_{name}_resolved" + + def __get__(self, instance: object, owner: type) -> abi.ABIType | AVMType: + try: + value = getattr(instance, self._resolved_field) + except AttributeError: + raise AttributeError("resolved types not available until contract is initialized") from None + return typing.cast(abi.ABIType | AVMType, value) + + def __set__(self, instance: object, value: abi.ABIType | AVMType) -> None: + assert isinstance(value, abi.ABIType | AVMType), "expected ABIType or AVMType" + setattr(instance, self._resolved_field, value) + + +@dataclass(frozen=True) +class DefaultValue: + """Default value information for method arguments.""" + + data: str + """The default value data""" + source: typing.Literal["box", "global", "local", "literal", "method"] + """The source of the default value""" + type: AVMType | abi.ABIType | None = field(default=None, metadata=serde.abi_type("type")) + """The optional type of the default value""" + + +@dataclass +class Argument: + """ + Represents an argument for an ABI method + + Args: + type (ABIType | ReferenceType | TransactionType | str): ABI type, reference type or transaction type + name (string, optional): name of this argument + desc (string, optional): description of this argument + """ + + type: abi.ABIType | ReferenceType | TransactionType = field(metadata=serde.abi_type("type")) + default_value: DefaultValue | None = field(default=None, metadata=nested("defaultValue", DefaultValue)) + desc: str | None = None + name: str | None = None + struct: str | None = None + + def __str__(self) -> str: + if isinstance(self.type, abi.ABIType): + return self.type.name + else: + return self.type + + +@dataclass +class Returns: + """ + Represents a return type for an ABI method + + Args: + type (ABIType | VoidType | str): ABI type of this return argument + desc (string, optional): description of this return argument + """ + + type: abi.ABIType | VoidType = field(metadata=serde.abi_type("type")) + desc: str | None = None + struct: str | None = None + + def __str__(self) -> str: + if isinstance(self.type, abi.ABIType): + return self.type.name + else: + return self.type + + +@dataclass +class Actions: + """Method actions information.""" + + call: Sequence[CallEnum] = field(default=(), metadata=serde.sequence("call", CallEnum, omit_empty_seq=False)) + """The optional list of allowed call actions""" + create: Sequence[CreateEnum] = field( + default=(), metadata=serde.sequence("create", CreateEnum, omit_empty_seq=False) + ) + """The optional list of allowed create actions""" + + +@dataclass +class EventArg: + """Event argument information.""" + + type: abi.ABIType = field(metadata=serde.abi_type("type")) + """The type of the event argument""" + name: str | None = None + """The optional name of the argument""" + desc: str | None = None + """The optional description of the argument""" + struct: str | None = None + """The struct name, references a struct defined on the contract""" + + +@dataclass +class Event: + """Event information.""" + + args: Sequence[EventArg] = field(metadata=serde.nested_sequence("args", EventArg)) + """The list of event arguments""" + name: str + """The name of the event""" + desc: str | None = None + """The optional description of the event""" + + +@dataclass +class Boxes: + """Box storage requirements.""" + + key: str + """The box key""" + read_bytes: int + """The number of bytes to read""" + write_bytes: int + """The number of bytes to write""" + app: int | None = None + """The optional application ID""" + + +@dataclass(frozen=True) +class Recommendations: + """Method execution recommendations.""" + + accounts: list[str] = field(default_factory=list, metadata=serde.sequence("accounts", str)) + """The optional list of accounts""" + apps: list[int] = field(default_factory=list, metadata=serde.sequence("apps", int)) + """The optional list of applications""" + assets: list[int] = field(default_factory=list, metadata=serde.sequence("assets", int)) + """The optional list of assets""" + boxes: Boxes | None = None + """The optional box storage requirements""" + inner_transaction_count: int | None = field(default=None, metadata=wire("innerTransactionCount")) + """The optional inner transaction count""" + + +@dataclass(kw_only=True) +class Method: + """ + Represents an ABI method description. + + Args: + name (string): name of the method + args (tuple): tuplet of Argument objects with type, name, and optional description + returns (Returns): a Returns object with a type and optional description + desc (string, optional): optional description of the method + """ + + actions: Actions = field(default_factory=Actions) + """The allowed actions""" + args: Sequence[Argument] = field(metadata=serde.nested_sequence("args", Argument)) + """The method arguments""" + name: str + """The method name""" + returns: Returns + """The return information""" + desc: str | None = None + """The optional description""" + events: Sequence[Event] = field(default=(), metadata=serde.nested_sequence("events", Event)) + """The events the method can raise""" + readonly: bool | None = field(default=None, metadata=wire("readonly", keep_false=True)) + """The flag indicating if method is readonly, None if unknown""" + recommendations: Recommendations | None = field( + default=None, metadata=nested("recommendations", Recommendations, omit_empty_seq=False) + ) + """The execution recommendations""" + + def get_txn_calls(self) -> int: + return sum(1 for a in self.args if isinstance(a.type, TransactionType)) + + @cached_property + def signature(self) -> str: + args_str = ",".join(map(str, self.args)) + return f"{self.name}({args_str}){self.returns}" + + @cached_property + def selector(self) -> bytes: + """ + Returns the ABI method signature, which is the first four bytes of the + SHA-512/256 hash of the method signature. + + Returns: + bytes: first four bytes of the method signature hash + """ + sha_512_256 = SHA512.new(truncate="256") + sha_512_256.update(self.signature.encode("utf-8")) + return sha_512_256.digest()[:4] + + def __str__(self) -> str: + return self.signature + + def get_selector(self) -> bytes: + """Compatibility helper matching algosdk ABI Method API.""" + + return self.selector + + def get_signature(self) -> str: + """Compatibility helper matching algosdk ABI Method API.""" + + return self.signature + + @staticmethod + def from_signature(s: str) -> "Method": + name, args_str, returns_str = _parse_method_string(s) + + args = [] + for arg_str in abi.split_tuple_str(args_str): + try: + alias = ENUM_ALIASES[arg_str] + except KeyError: + arg_type: abi.ABIType | ReferenceType | TransactionType = abi.ABIType.from_string(arg_str) + else: + if not isinstance(alias, ReferenceType | TransactionType): + raise ValueError(f"invalid arg: {args_str}") + arg_type = alias + args.append(Argument(arg_type)) + + if returns_str == Void: + returns = Returns(Void) + else: + returns = Returns(abi.ABIType.from_string(returns_str)) + return Method(name=name, args=tuple(args), returns=returns, actions=Actions(call=(), create=())) + + +def _parse_method_string(value: str) -> tuple[str, str, str]: + # Parses a method signature into three tokens, (name,args,returns) + # e.g. 'a(b,c)d' -> ('a', 'b,c', 'd') + stack = [] + for i, char in enumerate(value): + if char == "(": + stack.append(i) + elif char == ")": + if not stack: + break + left_index = stack.pop() + if not stack: + return value[:left_index], value[left_index + 1 : i], value[i + 1 :] + + raise ValueError(f"ABI method string has mismatched parentheses: {value}") + + +class Compiler(str, enum.Enum): + """Enum representing different compiler types.""" + + ALGOD = "algod" + PUYA = "puya" + + +@dataclass +class ByteCode: + """Represents the approval and clear program bytecode.""" + + approval: bytes = field(metadata=serde.base64_encoded_bytes("approval")) + """The approval program bytecode""" + clear: bytes = field(metadata=serde.base64_encoded_bytes("clear")) + """The clear program bytecode""" + + +@dataclass +class CompilerVersion: + """Represents compiler version information.""" + + commit_hash: str | None = field(default=None, metadata=wire("commitHash")) + """The git commit hash of the compiler""" + major: int | None = None + """The major version number""" + minor: int | None = None + """The minor version number""" + patch: int | None = None + """The patch version number""" + + +@dataclass +class CompilerInfo: + """Information about the compiler used.""" + + # TODO: make this just a str? + compiler: Compiler = field(metadata=wire("compiler", encode=Compiler)) + """The type of compiler used""" + compiler_version: CompilerVersion = field(metadata=nested("compilerVersion", CompilerVersion)) + """Version information for the compiler""" + + +@dataclass +class Network: + """Network-specific application information.""" + + app_id: int = field(metadata=wire("appId")) + """The application ID on the network""" + + +@dataclass +class ScratchVariables: + """Information about scratch space variables.""" + + slot: int + """The scratch slot number""" + _type: abi.ABIType | AVMType | str = field(metadata=serde.storage("type")) + type = _StorageTypePropertyDescriptor() + """The type of the scratch variable""" + + +@dataclass +class Source: + """Source code for approval and clear programs.""" + + approval: str + """The base64 encoded approval program source""" + clear: str + """The base64 encoded clear program source""" + + # TODO: just make this the source properties? + def get_decoded_approval(self) -> str: + """Get decoded approval program source. + + :return: Decoded approval program source code + """ + return self._decode_source(self.approval) + + def get_decoded_clear(self) -> str: + """Get decoded clear program source. + + :return: Decoded clear program source code + """ + return self._decode_source(self.clear) + + def _decode_source(self, b64_text: str) -> str: + return base64.b64decode(b64_text).decode("utf-8") + + +@dataclass +class Global: + """Global state schema.""" + + bytes: int = field(default=0, metadata=wire("bytes", keep_zero=True)) + """The number of byte slices in global state""" + ints: int = field(default=0, metadata=wire("ints", keep_zero=True)) + """The number of integers in global state""" + + +@dataclass +class Local: + """Local state schema.""" + + bytes: int = field(default=0, metadata=wire("bytes", keep_zero=True)) + """The number of byte slices in local state""" + ints: int = field(default=0, metadata=wire("ints", keep_zero=True)) + """The number of integers in local state""" + + +@dataclass +class Schema: + """Application state schema.""" + + global_state: Global = field(default_factory=Global, metadata=nested("global", Global)) + """The global state schema""" + local_state: Local = field(default_factory=Local, metadata=nested("local", Local)) + """The local state schema""" + + +@dataclass +class TemplateVariables: + """Template variable information.""" + + _type: abi.ABIType | AVMType | str = field(metadata=serde.storage("type")) + type = _StorageTypePropertyDescriptor() + """The type of the template variable""" + value: str | None = None + """The optional value of the template variable""" + + +class PcOffsetMethod(str, enum.Enum): + """PC offset method types.""" + + CBLOCKS = "cblocks" + NONE = "none" + + +@dataclass +class SourceInfo: + """Source code location information.""" + + pc: list[int] = field(metadata=serde.sequence("pc", int)) + """The list of program counter values""" + error_message: str | None = field(default=None, metadata=wire("errorMessage")) + """The optional error message""" + source: str | None = None + """The optional source code""" + teal: int | None = None + """The optional TEAL version""" + + +@dataclass +class StorageKey: + """Storage key information.""" + + key: str + """The storage key""" + _key_type: abi.ABIType | AVMType | str = field(metadata=serde.storage("keyType")) + """The type of the key""" + _value_type: abi.ABIType | AVMType | str = field(metadata=serde.storage("valueType")) + """The type of the value""" + desc: str | None = None + """The optional description""" + + key_type = _StorageTypePropertyDescriptor() + value_type = _StorageTypePropertyDescriptor() + + +@dataclass +class StorageMap: + """Storage map information.""" + + _key_type: abi.ABIType | AVMType | str = field(metadata=serde.storage("keyType")) + """The type of the map keys""" + _value_type: abi.ABIType | AVMType | str = field(metadata=serde.storage("valueType")) + """The type of the map values""" + desc: str | None = None + """The optional description""" + prefix: str | None = None + """The optional key prefix""" + key_type = _StorageTypePropertyDescriptor() + value_type = _StorageTypePropertyDescriptor() + + +@dataclass +class Keys: + """Storage keys for different storage types.""" + + box: dict[str, StorageKey] = field(default_factory=dict, metadata=serde.mapping("box", StorageKey)) + """The box storage keys""" + global_state: dict[str, StorageKey] = field(default_factory=dict, metadata=serde.mapping("global", StorageKey)) + """The global state storage keys""" + local_state: dict[str, StorageKey] = field(default_factory=dict, metadata=serde.mapping("local", StorageKey)) + """The local state storage keys""" + + +@dataclass +class Maps: + """Storage maps for different storage types.""" + + box: dict[str, StorageMap] = field(default_factory=dict, metadata=serde.mapping("box", StorageMap)) + """The box storage maps""" + global_state: dict[str, StorageMap] = field(default_factory=dict, metadata=serde.mapping("global", StorageMap)) + """The global state storage maps""" + local_state: dict[str, StorageMap] = field(default_factory=dict, metadata=serde.mapping("local", StorageMap)) + """The local state storage maps""" + + +@dataclass +class State: + """Application state information.""" + + keys: Keys = field(default_factory=Keys) + """The storage keys""" + maps: Maps = field(default_factory=Maps) + """The storage maps""" + schema: Schema = field(default_factory=Schema) + """The state schema""" + + +@dataclass +class ProgramSourceInfo: + """Program source information.""" + + pc_offset_method: PcOffsetMethod = field(metadata=wire("pcOffsetMethod")) + """The PC offset method""" + source_info: list[SourceInfo] = field(metadata=serde.nested_sequence("sourceInfo", SourceInfo)) + """The list of source info entries""" + + +@dataclass +class SourceInfoModel: + """Source information for approval and clear programs.""" + + approval: ProgramSourceInfo + """The approval program source info""" + clear: ProgramSourceInfo + """The clear program source info""" + + +_HasStructField = Argument | Returns | EventArg + + +@dataclass(kw_only=True) +class Arc56Contract: + """ARC-0056 application specification. + + See https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0056.md + """ + + arcs: list[int] = field(default_factory=list, metadata=serde.sequence("arcs", int, omit_empty_seq=False)) + """The list of supported ARC version numbers""" + bare_actions: Actions = field(default_factory=Actions, metadata=nested("bareActions", Actions)) + """The bare call and create actions""" + methods: list[Method] = field(metadata=serde.nested_sequence("methods", Method)) + """The list of contract methods""" + name: str + """The contract name""" + state: State = field(default_factory=State) + """The contract state information""" + structs: dict[str, abi.StructType] = field(default_factory=dict, metadata=serde.struct_metadata) + """The contract struct definitions""" + byte_code: ByteCode | None = field(default=None, metadata=nested("byteCode", ByteCode)) + """The optional bytecode for approval and clear programs""" + compiler_info: CompilerInfo | None = field(default=None, metadata=nested("compilerInfo", CompilerInfo)) + """The optional compiler information""" + desc: str | None = None + """The optional contract description""" + events: list[Event] | None = field(default=None, metadata=serde.nested_sequence("events", Event)) + """The optional list of contract events""" + networks: dict[str, Network] | None = field(default=None, metadata=serde.mapping("networks", Network)) + """The optional network deployment information""" + scratch_variables: dict[str, ScratchVariables] | None = field( + default=None, metadata=serde.mapping("scratchVariables", ScratchVariables) + ) + """The optional scratch variable information""" + source: Source | None = None + """The optional source code""" + source_info: SourceInfoModel | None = field(default=None, metadata=nested("sourceInfo", SourceInfoModel)) + """The optional source code information""" + template_variables: dict[str, TemplateVariables] | None = field( + default=None, metadata=serde.mapping("templateVariables", TemplateVariables) + ) + """The optional template variable information""" + + def __post_init__(self) -> None: + self._update_contract_structs() + + def apply_decode_types(self, resolve_struct_type: Callable[[abi.StructType], type]) -> "Arc56Contract": + """ + Returns a new contract specification where each StructType's decode_type + is updated with the result of resolve_struct_type, useful for supplying custom types used in + struct decoding + + :param resolve_struct_type: Callback that can be used to supply custom types for any Struct types + :return: Arc56Contract instance + """ + return replace( + self, + structs={ + struct_name: _apply_struct_types(struct_type, resolve_struct_type) + for struct_name, struct_type in self.structs.items() + }, + ) + + @classmethod + def from_dict( + cls, application_spec: dict, resolve_struct_type: Callable[[abi.StructType], type] | None = None + ) -> "Arc56Contract": + """Create Arc56Contract from dictionary. + + :param application_spec: Dictionary containing contract specification + :param resolve_struct_type: Optional callback that can be used to supply custom types for any Struct types + :return: Arc56Contract instance + """ + contract = from_wire(cls, application_spec) + if resolve_struct_type is not None: + contract = contract.apply_decode_types(resolve_struct_type) + return contract + + @staticmethod + def from_json( + application_spec: str, resolve_struct_type: Callable[[abi.StructType], type] | None = None + ) -> "Arc56Contract": + """ + Creates an instance from an ARC-56 application spec + + :param application_spec: Dictionary containing contract specification + :param resolve_struct_type: Optional callback that can be used to supply custom types for any Struct types + :return: Arc56Contract instance + """ + return Arc56Contract.from_dict(json.loads(application_spec), resolve_struct_type) + + @staticmethod + @deprecated("Arc32 contracts are being deprecated; prefer converting to Arc56 instead.") + def from_arc32(arc32_application_spec: typing.Union[str, "arc32.Arc32Contract"]) -> "Arc56Contract": + from algokit_abi import arc32_to_arc56 + + return arc32_to_arc56(arc32_application_spec) + + def to_json(self, indent: int | None = None) -> str: + return json.dumps(self.dictify(), indent=indent) + + def dictify(self) -> dict: + return to_wire(self) + + def get_abi_method(self, method_name_or_signature: str) -> Method: + if "(" in method_name_or_signature: + methods = [m for m in self.methods if m.signature == method_name_or_signature] + else: + methods = [m for m in self.methods if m.name == method_name_or_signature] + + if not methods: + raise ValueError(f"Unable to find method {method_name_or_signature} in {self.name} contract.") + try: + (method,) = methods + except ValueError: + signatures = [m.signature for m in methods] + raise ValueError( + f"Received a call to method {method_name_or_signature} in contract {self.name}, " + f"but this resolved to multiple methods; please pass in an ABI signature instead: " + f"{', '.join(signatures)}" + ) from None + return method + + def _update_contract_structs(self) -> None: + for method in self.methods: + for arg in method.args: + self._maybe_update_struct(arg) + self._maybe_update_struct(method.returns) + for event in method.events or []: + for event_arg in event.args: + self._maybe_update_struct(event_arg) + for event in self.events or []: + for event_arg in event.args: + self._maybe_update_struct(event_arg) + self._replace_state_structs() + for template in (self.template_variables or {}).values(): + self._maybe_update_abi_struct_type(template, "type") + for scratch in (self.scratch_variables or {}).values(): + self._maybe_update_abi_struct_type(scratch, "type") + + def _replace_state_structs(self) -> None: + keys = self.state.keys + maps = self.state.maps + for storage_maps in ( + keys.box, + keys.global_state, + keys.local_state, + maps.box, + maps.global_state, + maps.local_state, + ): + for storage in storage_maps.values(): + self._maybe_update_abi_struct_type(storage, "key_type", "value_type") + + def _maybe_update_struct(self, has_struct: _HasStructField) -> None: + if has_struct.struct is not None: + has_struct.type = self.structs[has_struct.struct] + + def _maybe_update_abi_struct_type(self, storage: object, *names: str) -> None: + for name in names: + backing_type = getattr(storage, f"_{name}") + if type(backing_type) is str: # only match str exactly, so enums are not used + resolved_type = self.structs[backing_type] + else: + resolved_type = backing_type + setattr(storage, name, resolved_type) + + +_TABIType = typing.TypeVar("_TABIType", bound=abi.ABIType) + + +def _apply_struct_types(abi_type: _TABIType, resolve_type: Callable[[abi.StructType], type]) -> _TABIType: + if isinstance(abi_type, abi.StructType): + return replace( + abi_type, + decode_type=resolve_type(abi_type), + fields={ + field_name: _apply_struct_types(field_type, resolve_type) + for field_name, field_type in abi_type.fields.items() + }, + ) + elif isinstance(abi_type, abi.StaticArrayType | abi.DynamicArrayType): + return replace(abi_type, element=_apply_struct_types(abi_type.element, resolve_type)) + elif isinstance(abi_type, abi.TupleType): + return replace(abi_type, elements=tuple(_apply_struct_types(e, resolve_type) for e in abi_type.elements)) + return abi_type diff --git a/src/algokit_abi/py.typed b/src/algokit_abi/py.typed new file mode 100644 index 00000000..e69de29b diff --git a/src/algokit_algo25/__init__.py b/src/algokit_algo25/__init__.py new file mode 100644 index 00000000..c440419a --- /dev/null +++ b/src/algokit_algo25/__init__.py @@ -0,0 +1,41 @@ +"""Algorand 25-word mnemonic encoding/decoding (algokit-algo25).""" + +from algokit_algo25.exceptions import ( + FAIL_TO_DECODE_MNEMONIC_ERROR_MSG, + NOT_IN_WORDS_LIST_ERROR_MSG, + InvalidMnemonicError, + InvalidSeedLengthError, + MnemonicError, + WordNotFoundError, +) +from algokit_algo25.mnemonic import ( + KEY_LEN_BYTES, + MNEMONIC_LEN, + WrappedLegacyMnemonic, + master_derivation_key_to_mnemonic, + mnemonic_from_seed, + mnemonic_to_master_derivation_key, + secret_key_to_mnemonic, + seed_from_mnemonic, +) + +__all__ = [ + # Constants + "FAIL_TO_DECODE_MNEMONIC_ERROR_MSG", + "KEY_LEN_BYTES", + "MNEMONIC_LEN", + "NOT_IN_WORDS_LIST_ERROR_MSG", + # Exceptions + "InvalidMnemonicError", + "InvalidSeedLengthError", + "MnemonicError", + "WordNotFoundError", + # Protocols + "WrappedLegacyMnemonic", + # Functions + "master_derivation_key_to_mnemonic", + "mnemonic_from_seed", + "mnemonic_to_master_derivation_key", + "secret_key_to_mnemonic", + "seed_from_mnemonic", +] diff --git a/src/algokit_algo25/_encoding.py b/src/algokit_algo25/_encoding.py new file mode 100644 index 00000000..ee7548d3 --- /dev/null +++ b/src/algokit_algo25/_encoding.py @@ -0,0 +1,46 @@ +"""11-bit encoding utilities for mnemonic conversion.""" + +from typing import Final + +BITS_PER_WORD: Final[int] = 11 +BITS_PER_BYTE: Final[int] = 8 + + +def bytes_to_11bit_indices(data: bytes) -> list[int]: + """Convert bytes to list of 11-bit indices. + + 32 bytes (256 bits) -> 24 x 11-bit values (264 bits, 8 padding zeros). + """ + buffer = 0 + num_bits = 0 + indices: list[int] = [] + for byte in data: + buffer |= byte << num_bits + num_bits += BITS_PER_BYTE + while num_bits >= BITS_PER_WORD: + indices.append(buffer & 0x7FF) + buffer >>= BITS_PER_WORD + num_bits -= BITS_PER_WORD + if num_bits > 0: + indices.append(buffer & 0x7FF) + return indices + + +def indices_11bit_to_bytes(indices: list[int]) -> bytes: + """Convert 11-bit indices to bytes. + + 24 x 11-bit values (264 bits) -> 33 bytes (last byte is padding). + """ + buffer = 0 + num_bits = 0 + output: list[int] = [] + for idx in indices: + buffer |= idx << num_bits + num_bits += BITS_PER_WORD + while num_bits >= BITS_PER_BYTE: + output.append(buffer & 0xFF) + buffer >>= BITS_PER_BYTE + num_bits -= BITS_PER_BYTE + if num_bits > 0: + output.append(buffer & 0xFF) + return bytes(output) diff --git a/src/algokit_algo25/_wordlist.py b/src/algokit_algo25/_wordlist.py new file mode 100644 index 00000000..914c24f8 --- /dev/null +++ b/src/algokit_algo25/_wordlist.py @@ -0,0 +1,2065 @@ +# BIP39 English wordlist +# Source: https://github.com/bitcoin/bips/blob/master/bip-0039/english.txt + +from typing import Final + +WORDLIST: Final[tuple[str, ...]] = ( + "abandon", + "ability", + "able", + "about", + "above", + "absent", + "absorb", + "abstract", + "absurd", + "abuse", + "access", + "accident", + "account", + "accuse", + "achieve", + "acid", + "acoustic", + "acquire", + "across", + "act", + "action", + "actor", + "actress", + "actual", + "adapt", + "add", + "addict", + "address", + "adjust", + "admit", + "adult", + "advance", + "advice", + "aerobic", + "affair", + "afford", + "afraid", + "again", + "age", + "agent", + "agree", + "ahead", + "aim", + "air", + "airport", + "aisle", + "alarm", + "album", + "alcohol", + "alert", + "alien", + "all", + "alley", + "allow", + "almost", + "alone", + "alpha", + "already", + "also", + "alter", + "always", + "amateur", + "amazing", + "among", + "amount", + "amused", + "analyst", + "anchor", + "ancient", + "anger", + "angle", + "angry", + "animal", + "ankle", + "announce", + "annual", + "another", + "answer", + "antenna", + "antique", + "anxiety", + "any", + "apart", + "apology", + "appear", + "apple", + "approve", + "april", + "arch", + "arctic", + "area", + "arena", + "argue", + "arm", + "armed", + "armor", + "army", + "around", + "arrange", + "arrest", + "arrive", + "arrow", + "art", + "artefact", + "artist", + "artwork", + "ask", + "aspect", + "assault", + "asset", + "assist", + "assume", + "asthma", + "athlete", + "atom", + "attack", + "attend", + "attitude", + "attract", + "auction", + "audit", + "august", + "aunt", + "author", + "auto", + "autumn", + "average", + "avocado", + "avoid", + "awake", + "aware", + "away", + "awesome", + "awful", + "awkward", + "axis", + "baby", + "bachelor", + "bacon", + "badge", + "bag", + "balance", + "balcony", + "ball", + "bamboo", + "banana", + "banner", + "bar", + "barely", + "bargain", + "barrel", + "base", + "basic", + "basket", + "battle", + "beach", + "bean", + "beauty", + "because", + "become", + "beef", + "before", + "begin", + "behave", + "behind", + "believe", + "below", + "belt", + "bench", + "benefit", + "best", + "betray", + "better", + "between", + "beyond", + "bicycle", + "bid", + "bike", + "bind", + "biology", + "bird", + "birth", + "bitter", + "black", + "blade", + "blame", + "blanket", + "blast", + "bleak", + "bless", + "blind", + "blood", + "blossom", + "blouse", + "blue", + "blur", + "blush", + "board", + "boat", + "body", + "boil", + "bomb", + "bone", + "bonus", + "book", + "boost", + "border", + "boring", + "borrow", + "boss", + "bottom", + "bounce", + "box", + "boy", + "bracket", + "brain", + "brand", + "brass", + "brave", + "bread", + "breeze", + "brick", + "bridge", + "brief", + "bright", + "bring", + "brisk", + "broccoli", + "broken", + "bronze", + "broom", + "brother", + "brown", + "brush", + "bubble", + "buddy", + "budget", + "buffalo", + "build", + "bulb", + "bulk", + "bullet", + "bundle", + "bunker", + "burden", + "burger", + "burst", + "bus", + "business", + "busy", + "butter", + "buyer", + "buzz", + "cabbage", + "cabin", + "cable", + "cactus", + "cage", + "cake", + "call", + "calm", + "camera", + "camp", + "can", + "canal", + "cancel", + "candy", + "cannon", + "canoe", + "canvas", + "canyon", + "capable", + "capital", + "captain", + "car", + "carbon", + "card", + "cargo", + "carpet", + "carry", + "cart", + "case", + "cash", + "casino", + "castle", + "casual", + "cat", + "catalog", + "catch", + "category", + "cattle", + "caught", + "cause", + "caution", + "cave", + "ceiling", + "celery", + "cement", + "census", + "century", + "cereal", + "certain", + "chair", + "chalk", + "champion", + "change", + "chaos", + "chapter", + "charge", + "chase", + "chat", + "cheap", + "check", + "cheese", + "chef", + "cherry", + "chest", + "chicken", + "chief", + "child", + "chimney", + "choice", + "choose", + "chronic", + "chuckle", + "chunk", + "churn", + "cigar", + "cinnamon", + "circle", + "citizen", + "city", + "civil", + "claim", + "clap", + "clarify", + "claw", + "clay", + "clean", + "clerk", + "clever", + "click", + "client", + "cliff", + "climb", + "clinic", + "clip", + "clock", + "clog", + "close", + "cloth", + "cloud", + "clown", + "club", + "clump", + "cluster", + "clutch", + "coach", + "coast", + "coconut", + "code", + "coffee", + "coil", + "coin", + "collect", + "color", + "column", + "combine", + "come", + "comfort", + "comic", + "common", + "company", + "concert", + "conduct", + "confirm", + "congress", + "connect", + "consider", + "control", + "convince", + "cook", + "cool", + "copper", + "copy", + "coral", + "core", + "corn", + "correct", + "cost", + "cotton", + "couch", + "country", + "couple", + "course", + "cousin", + "cover", + "coyote", + "crack", + "cradle", + "craft", + "cram", + "crane", + "crash", + "crater", + "crawl", + "crazy", + "cream", + "credit", + "creek", + "crew", + "cricket", + "crime", + "crisp", + "critic", + "crop", + "cross", + "crouch", + "crowd", + "crucial", + "cruel", + "cruise", + "crumble", + "crunch", + "crush", + "cry", + "crystal", + "cube", + "culture", + "cup", + "cupboard", + "curious", + "current", + "curtain", + "curve", + "cushion", + "custom", + "cute", + "cycle", + "dad", + "damage", + "damp", + "dance", + "danger", + "daring", + "dash", + "daughter", + "dawn", + "day", + "deal", + "debate", + "debris", + "decade", + "december", + "decide", + "decline", + "decorate", + "decrease", + "deer", + "defense", + "define", + "defy", + "degree", + "delay", + "deliver", + "demand", + "demise", + "denial", + "dentist", + "deny", + "depart", + "depend", + "deposit", + "depth", + "deputy", + "derive", + "describe", + "desert", + "design", + "desk", + "despair", + "destroy", + "detail", + "detect", + "develop", + "device", + "devote", + "diagram", + "dial", + "diamond", + "diary", + "dice", + "diesel", + "diet", + "differ", + "digital", + "dignity", + "dilemma", + "dinner", + "dinosaur", + "direct", + "dirt", + "disagree", + "discover", + "disease", + "dish", + "dismiss", + "disorder", + "display", + "distance", + "divert", + "divide", + "divorce", + "dizzy", + "doctor", + "document", + "dog", + "doll", + "dolphin", + "domain", + "donate", + "donkey", + "donor", + "door", + "dose", + "double", + "dove", + "draft", + "dragon", + "drama", + "drastic", + "draw", + "dream", + "dress", + "drift", + "drill", + "drink", + "drip", + "drive", + "drop", + "drum", + "dry", + "duck", + "dumb", + "dune", + "during", + "dust", + "dutch", + "duty", + "dwarf", + "dynamic", + "eager", + "eagle", + "early", + "earn", + "earth", + "easily", + "east", + "easy", + "echo", + "ecology", + "economy", + "edge", + "edit", + "educate", + "effort", + "egg", + "eight", + "either", + "elbow", + "elder", + "electric", + "elegant", + "element", + "elephant", + "elevator", + "elite", + "else", + "embark", + "embody", + "embrace", + "emerge", + "emotion", + "employ", + "empower", + "empty", + "enable", + "enact", + "end", + "endless", + "endorse", + "enemy", + "energy", + "enforce", + "engage", + "engine", + "enhance", + "enjoy", + "enlist", + "enough", + "enrich", + "enroll", + "ensure", + "enter", + "entire", + "entry", + "envelope", + "episode", + "equal", + "equip", + "era", + "erase", + "erode", + "erosion", + "error", + "erupt", + "escape", + "essay", + "essence", + "estate", + "eternal", + "ethics", + "evidence", + "evil", + "evoke", + "evolve", + "exact", + "example", + "excess", + "exchange", + "excite", + "exclude", + "excuse", + "execute", + "exercise", + "exhaust", + "exhibit", + "exile", + "exist", + "exit", + "exotic", + "expand", + "expect", + "expire", + "explain", + "expose", + "express", + "extend", + "extra", + "eye", + "eyebrow", + "fabric", + "face", + "faculty", + "fade", + "faint", + "faith", + "fall", + "false", + "fame", + "family", + "famous", + "fan", + "fancy", + "fantasy", + "farm", + "fashion", + "fat", + "fatal", + "father", + "fatigue", + "fault", + "favorite", + "feature", + "february", + "federal", + "fee", + "feed", + "feel", + "female", + "fence", + "festival", + "fetch", + "fever", + "few", + "fiber", + "fiction", + "field", + "figure", + "file", + "film", + "filter", + "final", + "find", + "fine", + "finger", + "finish", + "fire", + "firm", + "first", + "fiscal", + "fish", + "fit", + "fitness", + "fix", + "flag", + "flame", + "flash", + "flat", + "flavor", + "flee", + "flight", + "flip", + "float", + "flock", + "floor", + "flower", + "fluid", + "flush", + "fly", + "foam", + "focus", + "fog", + "foil", + "fold", + "follow", + "food", + "foot", + "force", + "forest", + "forget", + "fork", + "fortune", + "forum", + "forward", + "fossil", + "foster", + "found", + "fox", + "fragile", + "frame", + "frequent", + "fresh", + "friend", + "fringe", + "frog", + "front", + "frost", + "frown", + "frozen", + "fruit", + "fuel", + "fun", + "funny", + "furnace", + "fury", + "future", + "gadget", + "gain", + "galaxy", + "gallery", + "game", + "gap", + "garage", + "garbage", + "garden", + "garlic", + "garment", + "gas", + "gasp", + "gate", + "gather", + "gauge", + "gaze", + "general", + "genius", + "genre", + "gentle", + "genuine", + "gesture", + "ghost", + "giant", + "gift", + "giggle", + "ginger", + "giraffe", + "girl", + "give", + "glad", + "glance", + "glare", + "glass", + "glide", + "glimpse", + "globe", + "gloom", + "glory", + "glove", + "glow", + "glue", + "goat", + "goddess", + "gold", + "good", + "goose", + "gorilla", + "gospel", + "gossip", + "govern", + "gown", + "grab", + "grace", + "grain", + "grant", + "grape", + "grass", + "gravity", + "great", + "green", + "grid", + "grief", + "grit", + "grocery", + "group", + "grow", + "grunt", + "guard", + "guess", + "guide", + "guilt", + "guitar", + "gun", + "gym", + "habit", + "hair", + "half", + "hammer", + "hamster", + "hand", + "happy", + "harbor", + "hard", + "harsh", + "harvest", + "hat", + "have", + "hawk", + "hazard", + "head", + "health", + "heart", + "heavy", + "hedgehog", + "height", + "hello", + "helmet", + "help", + "hen", + "hero", + "hidden", + "high", + "hill", + "hint", + "hip", + "hire", + "history", + "hobby", + "hockey", + "hold", + "hole", + "holiday", + "hollow", + "home", + "honey", + "hood", + "hope", + "horn", + "horror", + "horse", + "hospital", + "host", + "hotel", + "hour", + "hover", + "hub", + "huge", + "human", + "humble", + "humor", + "hundred", + "hungry", + "hunt", + "hurdle", + "hurry", + "hurt", + "husband", + "hybrid", + "ice", + "icon", + "idea", + "identify", + "idle", + "ignore", + "ill", + "illegal", + "illness", + "image", + "imitate", + "immense", + "immune", + "impact", + "impose", + "improve", + "impulse", + "inch", + "include", + "income", + "increase", + "index", + "indicate", + "indoor", + "industry", + "infant", + "inflict", + "inform", + "inhale", + "inherit", + "initial", + "inject", + "injury", + "inmate", + "inner", + "innocent", + "input", + "inquiry", + "insane", + "insect", + "inside", + "inspire", + "install", + "intact", + "interest", + "into", + "invest", + "invite", + "involve", + "iron", + "island", + "isolate", + "issue", + "item", + "ivory", + "jacket", + "jaguar", + "jar", + "jazz", + "jealous", + "jeans", + "jelly", + "jewel", + "job", + "join", + "joke", + "journey", + "joy", + "judge", + "juice", + "jump", + "jungle", + "junior", + "junk", + "just", + "kangaroo", + "keen", + "keep", + "ketchup", + "key", + "kick", + "kid", + "kidney", + "kind", + "kingdom", + "kiss", + "kit", + "kitchen", + "kite", + "kitten", + "kiwi", + "knee", + "knife", + "knock", + "know", + "lab", + "label", + "labor", + "ladder", + "lady", + "lake", + "lamp", + "language", + "laptop", + "large", + "later", + "latin", + "laugh", + "laundry", + "lava", + "law", + "lawn", + "lawsuit", + "layer", + "lazy", + "leader", + "leaf", + "learn", + "leave", + "lecture", + "left", + "leg", + "legal", + "legend", + "leisure", + "lemon", + "lend", + "length", + "lens", + "leopard", + "lesson", + "letter", + "level", + "liar", + "liberty", + "library", + "license", + "life", + "lift", + "light", + "like", + "limb", + "limit", + "link", + "lion", + "liquid", + "list", + "little", + "live", + "lizard", + "load", + "loan", + "lobster", + "local", + "lock", + "logic", + "lonely", + "long", + "loop", + "lottery", + "loud", + "lounge", + "love", + "loyal", + "lucky", + "luggage", + "lumber", + "lunar", + "lunch", + "luxury", + "lyrics", + "machine", + "mad", + "magic", + "magnet", + "maid", + "mail", + "main", + "major", + "make", + "mammal", + "man", + "manage", + "mandate", + "mango", + "mansion", + "manual", + "maple", + "marble", + "march", + "margin", + "marine", + "market", + "marriage", + "mask", + "mass", + "master", + "match", + "material", + "math", + "matrix", + "matter", + "maximum", + "maze", + "meadow", + "mean", + "measure", + "meat", + "mechanic", + "medal", + "media", + "melody", + "melt", + "member", + "memory", + "mention", + "menu", + "mercy", + "merge", + "merit", + "merry", + "mesh", + "message", + "metal", + "method", + "middle", + "midnight", + "milk", + "million", + "mimic", + "mind", + "minimum", + "minor", + "minute", + "miracle", + "mirror", + "misery", + "miss", + "mistake", + "mix", + "mixed", + "mixture", + "mobile", + "model", + "modify", + "mom", + "moment", + "monitor", + "monkey", + "monster", + "month", + "moon", + "moral", + "more", + "morning", + "mosquito", + "mother", + "motion", + "motor", + "mountain", + "mouse", + "move", + "movie", + "much", + "muffin", + "mule", + "multiply", + "muscle", + "museum", + "mushroom", + "music", + "must", + "mutual", + "myself", + "mystery", + "myth", + "naive", + "name", + "napkin", + "narrow", + "nasty", + "nation", + "nature", + "near", + "neck", + "need", + "negative", + "neglect", + "neither", + "nephew", + "nerve", + "nest", + "net", + "network", + "neutral", + "never", + "news", + "next", + "nice", + "night", + "noble", + "noise", + "nominee", + "noodle", + "normal", + "north", + "nose", + "notable", + "note", + "nothing", + "notice", + "novel", + "now", + "nuclear", + "number", + "nurse", + "nut", + "oak", + "obey", + "object", + "oblige", + "obscure", + "observe", + "obtain", + "obvious", + "occur", + "ocean", + "october", + "odor", + "off", + "offer", + "office", + "often", + "oil", + "okay", + "old", + "olive", + "olympic", + "omit", + "once", + "one", + "onion", + "online", + "only", + "open", + "opera", + "opinion", + "oppose", + "option", + "orange", + "orbit", + "orchard", + "order", + "ordinary", + "organ", + "orient", + "original", + "orphan", + "ostrich", + "other", + "outdoor", + "outer", + "output", + "outside", + "oval", + "oven", + "over", + "own", + "owner", + "oxygen", + "oyster", + "ozone", + "pact", + "paddle", + "page", + "pair", + "palace", + "palm", + "panda", + "panel", + "panic", + "panther", + "paper", + "parade", + "parent", + "park", + "parrot", + "party", + "pass", + "patch", + "path", + "patient", + "patrol", + "pattern", + "pause", + "pave", + "payment", + "peace", + "peanut", + "pear", + "peasant", + "pelican", + "pen", + "penalty", + "pencil", + "people", + "pepper", + "perfect", + "permit", + "person", + "pet", + "phone", + "photo", + "phrase", + "physical", + "piano", + "picnic", + "picture", + "piece", + "pig", + "pigeon", + "pill", + "pilot", + "pink", + "pioneer", + "pipe", + "pistol", + "pitch", + "pizza", + "place", + "planet", + "plastic", + "plate", + "play", + "please", + "pledge", + "pluck", + "plug", + "plunge", + "poem", + "poet", + "point", + "polar", + "pole", + "police", + "pond", + "pony", + "pool", + "popular", + "portion", + "position", + "possible", + "post", + "potato", + "pottery", + "poverty", + "powder", + "power", + "practice", + "praise", + "predict", + "prefer", + "prepare", + "present", + "pretty", + "prevent", + "price", + "pride", + "primary", + "print", + "priority", + "prison", + "private", + "prize", + "problem", + "process", + "produce", + "profit", + "program", + "project", + "promote", + "proof", + "property", + "prosper", + "protect", + "proud", + "provide", + "public", + "pudding", + "pull", + "pulp", + "pulse", + "pumpkin", + "punch", + "pupil", + "puppy", + "purchase", + "purity", + "purpose", + "purse", + "push", + "put", + "puzzle", + "pyramid", + "quality", + "quantum", + "quarter", + "question", + "quick", + "quit", + "quiz", + "quote", + "rabbit", + "raccoon", + "race", + "rack", + "radar", + "radio", + "rail", + "rain", + "raise", + "rally", + "ramp", + "ranch", + "random", + "range", + "rapid", + "rare", + "rate", + "rather", + "raven", + "raw", + "razor", + "ready", + "real", + "reason", + "rebel", + "rebuild", + "recall", + "receive", + "recipe", + "record", + "recycle", + "reduce", + "reflect", + "reform", + "refuse", + "region", + "regret", + "regular", + "reject", + "relax", + "release", + "relief", + "rely", + "remain", + "remember", + "remind", + "remove", + "render", + "renew", + "rent", + "reopen", + "repair", + "repeat", + "replace", + "report", + "require", + "rescue", + "resemble", + "resist", + "resource", + "response", + "result", + "retire", + "retreat", + "return", + "reunion", + "reveal", + "review", + "reward", + "rhythm", + "rib", + "ribbon", + "rice", + "rich", + "ride", + "ridge", + "rifle", + "right", + "rigid", + "ring", + "riot", + "ripple", + "risk", + "ritual", + "rival", + "river", + "road", + "roast", + "robot", + "robust", + "rocket", + "romance", + "roof", + "rookie", + "room", + "rose", + "rotate", + "rough", + "round", + "route", + "royal", + "rubber", + "rude", + "rug", + "rule", + "run", + "runway", + "rural", + "sad", + "saddle", + "sadness", + "safe", + "sail", + "salad", + "salmon", + "salon", + "salt", + "salute", + "same", + "sample", + "sand", + "satisfy", + "satoshi", + "sauce", + "sausage", + "save", + "say", + "scale", + "scan", + "scare", + "scatter", + "scene", + "scheme", + "school", + "science", + "scissors", + "scorpion", + "scout", + "scrap", + "screen", + "script", + "scrub", + "sea", + "search", + "season", + "seat", + "second", + "secret", + "section", + "security", + "seed", + "seek", + "segment", + "select", + "sell", + "seminar", + "senior", + "sense", + "sentence", + "series", + "service", + "session", + "settle", + "setup", + "seven", + "shadow", + "shaft", + "shallow", + "share", + "shed", + "shell", + "sheriff", + "shield", + "shift", + "shine", + "ship", + "shiver", + "shock", + "shoe", + "shoot", + "shop", + "short", + "shoulder", + "shove", + "shrimp", + "shrug", + "shuffle", + "shy", + "sibling", + "sick", + "side", + "siege", + "sight", + "sign", + "silent", + "silk", + "silly", + "silver", + "similar", + "simple", + "since", + "sing", + "siren", + "sister", + "situate", + "six", + "size", + "skate", + "sketch", + "ski", + "skill", + "skin", + "skirt", + "skull", + "slab", + "slam", + "sleep", + "slender", + "slice", + "slide", + "slight", + "slim", + "slogan", + "slot", + "slow", + "slush", + "small", + "smart", + "smile", + "smoke", + "smooth", + "snack", + "snake", + "snap", + "sniff", + "snow", + "soap", + "soccer", + "social", + "sock", + "soda", + "soft", + "solar", + "soldier", + "solid", + "solution", + "solve", + "someone", + "song", + "soon", + "sorry", + "sort", + "soul", + "sound", + "soup", + "source", + "south", + "space", + "spare", + "spatial", + "spawn", + "speak", + "special", + "speed", + "spell", + "spend", + "sphere", + "spice", + "spider", + "spike", + "spin", + "spirit", + "split", + "spoil", + "sponsor", + "spoon", + "sport", + "spot", + "spray", + "spread", + "spring", + "spy", + "square", + "squeeze", + "squirrel", + "stable", + "stadium", + "staff", + "stage", + "stairs", + "stamp", + "stand", + "start", + "state", + "stay", + "steak", + "steel", + "stem", + "step", + "stereo", + "stick", + "still", + "sting", + "stock", + "stomach", + "stone", + "stool", + "story", + "stove", + "strategy", + "street", + "strike", + "strong", + "struggle", + "student", + "stuff", + "stumble", + "style", + "subject", + "submit", + "subway", + "success", + "such", + "sudden", + "suffer", + "sugar", + "suggest", + "suit", + "summer", + "sun", + "sunny", + "sunset", + "super", + "supply", + "supreme", + "sure", + "surface", + "surge", + "surprise", + "surround", + "survey", + "suspect", + "sustain", + "swallow", + "swamp", + "swap", + "swarm", + "swear", + "sweet", + "swift", + "swim", + "swing", + "switch", + "sword", + "symbol", + "symptom", + "syrup", + "system", + "table", + "tackle", + "tag", + "tail", + "talent", + "talk", + "tank", + "tape", + "target", + "task", + "taste", + "tattoo", + "taxi", + "teach", + "team", + "tell", + "ten", + "tenant", + "tennis", + "tent", + "term", + "test", + "text", + "thank", + "that", + "theme", + "then", + "theory", + "there", + "they", + "thing", + "this", + "thought", + "three", + "thrive", + "throw", + "thumb", + "thunder", + "ticket", + "tide", + "tiger", + "tilt", + "timber", + "time", + "tiny", + "tip", + "tired", + "tissue", + "title", + "toast", + "tobacco", + "today", + "toddler", + "toe", + "together", + "toilet", + "token", + "tomato", + "tomorrow", + "tone", + "tongue", + "tonight", + "tool", + "tooth", + "top", + "topic", + "topple", + "torch", + "tornado", + "tortoise", + "toss", + "total", + "tourist", + "toward", + "tower", + "town", + "toy", + "track", + "trade", + "traffic", + "tragic", + "train", + "transfer", + "trap", + "trash", + "travel", + "tray", + "treat", + "tree", + "trend", + "trial", + "tribe", + "trick", + "trigger", + "trim", + "trip", + "trophy", + "trouble", + "truck", + "true", + "truly", + "trumpet", + "trust", + "truth", + "try", + "tube", + "tuition", + "tumble", + "tuna", + "tunnel", + "turkey", + "turn", + "turtle", + "twelve", + "twenty", + "twice", + "twin", + "twist", + "two", + "type", + "typical", + "ugly", + "umbrella", + "unable", + "unaware", + "uncle", + "uncover", + "under", + "undo", + "unfair", + "unfold", + "unhappy", + "uniform", + "unique", + "unit", + "universe", + "unknown", + "unlock", + "until", + "unusual", + "unveil", + "update", + "upgrade", + "uphold", + "upon", + "upper", + "upset", + "urban", + "urge", + "usage", + "use", + "used", + "useful", + "useless", + "usual", + "utility", + "vacant", + "vacuum", + "vague", + "valid", + "valley", + "valve", + "van", + "vanish", + "vapor", + "various", + "vast", + "vault", + "vehicle", + "velvet", + "vendor", + "venture", + "venue", + "verb", + "verify", + "version", + "very", + "vessel", + "veteran", + "viable", + "vibrant", + "vicious", + "victory", + "video", + "view", + "village", + "vintage", + "violin", + "virtual", + "virus", + "visa", + "visit", + "visual", + "vital", + "vivid", + "vocal", + "voice", + "void", + "volcano", + "volume", + "vote", + "voyage", + "wage", + "wagon", + "wait", + "walk", + "wall", + "walnut", + "want", + "warfare", + "warm", + "warrior", + "wash", + "wasp", + "waste", + "water", + "wave", + "way", + "wealth", + "weapon", + "wear", + "weasel", + "weather", + "web", + "wedding", + "weekend", + "weird", + "welcome", + "west", + "wet", + "whale", + "what", + "wheat", + "wheel", + "when", + "where", + "whip", + "whisper", + "wide", + "width", + "wife", + "wild", + "will", + "win", + "window", + "wine", + "wing", + "wink", + "winner", + "winter", + "wire", + "wisdom", + "wise", + "wish", + "witness", + "wolf", + "woman", + "wonder", + "wood", + "wool", + "word", + "work", + "world", + "worry", + "worth", + "wrap", + "wreck", + "wrestle", + "wrist", + "write", + "wrong", + "yard", + "year", + "yellow", + "you", + "young", + "youth", + "zebra", + "zero", + "zone", + "zoo", +) + +# Build lookup dictionaries +WORD_TO_INDEX: dict[str, int] = {} +for _idx, _word in enumerate(WORDLIST): + WORD_TO_INDEX[_word] = _idx + # Add 4+ character prefixes (guaranteed unique in BIP39) + for _len in range(4, len(_word)): + WORD_TO_INDEX[_word[:_len]] = _idx + +INDEX_TO_WORD: dict[int, str] = dict(enumerate(WORDLIST)) diff --git a/src/algokit_algo25/exceptions.py b/src/algokit_algo25/exceptions.py new file mode 100644 index 00000000..18b7cc42 --- /dev/null +++ b/src/algokit_algo25/exceptions.py @@ -0,0 +1,29 @@ +"""Exceptions for mnemonic operations.""" + +__all__ = [ + "FAIL_TO_DECODE_MNEMONIC_ERROR_MSG", + "NOT_IN_WORDS_LIST_ERROR_MSG", + "InvalidMnemonicError", + "InvalidSeedLengthError", + "MnemonicError", + "WordNotFoundError", +] + +FAIL_TO_DECODE_MNEMONIC_ERROR_MSG = "failed to decode mnemonic" +NOT_IN_WORDS_LIST_ERROR_MSG = "the mnemonic contains a word that is not in the wordlist" + + +class MnemonicError(Exception): + """Base exception for mnemonic operations.""" + + +class InvalidMnemonicError(MnemonicError): + """Invalid mnemonic format or checksum.""" + + +class InvalidSeedLengthError(MnemonicError): + """Seed length is not 32 bytes.""" + + +class WordNotFoundError(InvalidMnemonicError): + """Word not found in wordlist.""" diff --git a/src/algokit_algo25/mnemonic.py b/src/algokit_algo25/mnemonic.py new file mode 100644 index 00000000..38880dfa --- /dev/null +++ b/src/algokit_algo25/mnemonic.py @@ -0,0 +1,148 @@ +"""Algorand mnemonic encoding/decoding (25-word BIP39 format).""" + +from typing import Final, Protocol, runtime_checkable + +from algokit_algo25._encoding import bytes_to_11bit_indices, indices_11bit_to_bytes +from algokit_algo25._wordlist import INDEX_TO_WORD, WORD_TO_INDEX +from algokit_algo25.exceptions import ( + FAIL_TO_DECODE_MNEMONIC_ERROR_MSG, + NOT_IN_WORDS_LIST_ERROR_MSG, + InvalidMnemonicError, + InvalidSeedLengthError, + WordNotFoundError, +) +from algokit_common import sha512_256 + +KEY_LEN_BYTES: Final[int] = 32 +MNEMONIC_LEN: Final[int] = 25 + + +def _compute_checksum_index(seed: bytes) -> int: + """Compute checksum word index: first 11 bits of SHA512/256(seed).""" + hash_bytes = sha512_256(seed) + return bytes_to_11bit_indices(hash_bytes[:2])[0] + + +def mnemonic_from_seed(seed: bytes) -> str: + """Convert 32-byte seed to 25-word mnemonic. + + Args: + seed: 32-byte seed/key + + Returns: + 25-word mnemonic string (space-separated) + + Raises: + InvalidSeedLengthError: If seed is not 32 bytes + """ + if len(seed) != KEY_LEN_BYTES: + raise InvalidSeedLengthError(f"seed must be {KEY_LEN_BYTES} bytes, got {len(seed)}") + + indices = bytes_to_11bit_indices(seed) + words = [INDEX_TO_WORD[i] for i in indices] + checksum_idx = _compute_checksum_index(seed) + words.append(INDEX_TO_WORD[checksum_idx]) + return " ".join(words) + + +def seed_from_mnemonic(mnemonic: str) -> bytes: + """Convert 25-word mnemonic to 32-byte seed. + + Args: + mnemonic: 25-word mnemonic string (space-separated) + + Returns: + 32-byte seed + + Raises: + InvalidMnemonicError: If word count, checksum, or padding invalid + WordNotFoundError: If word not in wordlist + """ + words = mnemonic.lower().split() + if len(words) != MNEMONIC_LEN: + raise InvalidMnemonicError( + f"{FAIL_TO_DECODE_MNEMONIC_ERROR_MSG}: expected {MNEMONIC_LEN} words, got {len(words)}" + ) + + try: + indices = [WORD_TO_INDEX[w] for w in words[:-1]] + checksum_idx = WORD_TO_INDEX[words[-1]] + except KeyError as e: + raise WordNotFoundError(f"{NOT_IN_WORDS_LIST_ERROR_MSG}: {e.args[0]}") from e + + data = indices_11bit_to_bytes(indices) + + # Verify padding (last byte must be 0) + if data[-1] != 0: + raise InvalidMnemonicError(f"{FAIL_TO_DECODE_MNEMONIC_ERROR_MSG}: invalid padding") + + seed = data[:KEY_LEN_BYTES] + + # Verify checksum + expected_checksum = _compute_checksum_index(seed) + if checksum_idx != expected_checksum: + raise InvalidMnemonicError(f"{FAIL_TO_DECODE_MNEMONIC_ERROR_MSG}: checksum mismatch") + + return seed + + +def secret_key_to_mnemonic(secret_key: bytes) -> str: + """Convert 64-byte secret key to mnemonic. + + The first 32 bytes of an Algorand secret key are the seed. + + Args: + secret_key: 64-byte secret key (seed || public_key) + + Returns: + 25-word mnemonic + """ + return mnemonic_from_seed(secret_key[:KEY_LEN_BYTES]) + + +def mnemonic_to_master_derivation_key(mnemonic: str) -> bytes: + """Convert mnemonic to master derivation key. + + Alias for seed_from_mnemonic (MDK = seed). + + Args: + mnemonic: 25-word mnemonic string + + Returns: + 32-byte master derivation key + """ + return seed_from_mnemonic(mnemonic) + + +def master_derivation_key_to_mnemonic(key: bytes) -> str: + """Convert master derivation key to mnemonic. + + Alias for mnemonic_from_seed (MDK = seed). + + Args: + key: 32-byte master derivation key + + Returns: + 25-word mnemonic string + """ + return mnemonic_from_seed(key) + + +@runtime_checkable +class WrappedLegacyMnemonic(Protocol): + """Represents a legacy 25-word Algorand mnemonic phrase. + + This is the standard Algorand mnemonic format used for encoding 32-byte seeds. + The mnemonic can be converted back to a seed using seed_from_mnemonic. + + The ``wrap`` method is optional for implementations where wrapping is handled automatically + (e.g., hardware wallets, keyring services). + """ + + def unwrap_legacy_mnemonic(self) -> str: ... + def wrap_legacy_mnemonic(self) -> None: + """Optional method to re-wrap the mnemonic after use. + + Defaults to no-op if not implemented. + """ + ... diff --git a/src/algokit_algo25/py.typed b/src/algokit_algo25/py.typed new file mode 100644 index 00000000..e69de29b diff --git a/src/algokit_algod_client/__init__.py b/src/algokit_algod_client/__init__.py new file mode 100644 index 00000000..6949288c --- /dev/null +++ b/src/algokit_algod_client/__init__.py @@ -0,0 +1,10 @@ +# AUTO-GENERATED: oas_generator + + +from .client import AlgodClient +from .config import ClientConfig + +__all__ = [ + "AlgodClient", + "ClientConfig", +] diff --git a/src/algokit_algod_client/client.py b/src/algokit_algod_client/client.py new file mode 100644 index 00000000..c634deef --- /dev/null +++ b/src/algokit_algod_client/client.py @@ -0,0 +1,1585 @@ +# AUTO-GENERATED: oas_generator +import random +import time +from base64 import b64encode +from collections.abc import Sequence +from dataclasses import is_dataclass +from typing import Any, Literal, TypeVar, overload + +import httpx +import msgpack + +from algokit_common.serde import from_wire, to_wire + +from . import models +from .config import ClientConfig +from .exceptions import UnexpectedStatusError +from .types import Headers + +# HTTP status codes that warrant a retry (aligned with algokit-utils-ts) +_RETRY_STATUS_CODES: frozenset[int] = frozenset({408, 413, 429, 500, 502, 503, 504}) +# Network error codes that warrant a retry (aligned with algokit-utils-ts) +_RETRY_ERROR_CODES: frozenset[str] = frozenset( + { + "ETIMEDOUT", + "ECONNRESET", + "EADDRINUSE", + "ECONNREFUSED", + "EPIPE", + "ENOTFOUND", + "ENETUNREACH", + "EAI_AGAIN", + "EPROTO", + } +) +_MAX_BACKOFF_MS: float = 10_000.0 +_DEFAULT_MAX_TRIES: int = 5 + +ModelT = TypeVar("ModelT") +ListModelT = TypeVar("ListModelT") +PrimitiveT = TypeVar("PrimitiveT") + +# Prefixed markers used when converting unhashable msgpack map keys into hashable tuples +_UNHASHABLE_PREFIXES: dict[str, str] = { + "dict": "__dict_key__", + "list": "__list_key__", + "set": "__set_key__", + "generic": "__unhashable__", +} + + +class AlgodClient: + def __init__(self, config: ClientConfig | None = None, *, http_client: httpx.Client | None = None) -> None: + self._config = config or ClientConfig() + # Track whether a custom HTTP client was provided to avoid retry conflicts + self._uses_custom_client = http_client is not None + self._client = http_client or httpx.Client( + base_url=self._config.base_url, + timeout=self._config.timeout, + verify=self._config.verify, + ) + + def close(self) -> None: + self._client.close() + + def _calculate_max_tries(self) -> int: + """Calculate maximum number of tries from config.max_retries.""" + max_retries = self._config.max_retries + if not isinstance(max_retries, int) or max_retries < 0: + return _DEFAULT_MAX_TRIES + return max_retries + 1 + + def _should_retry(self, error: Exception | None, status_code: int | None, attempt: int, max_tries: int) -> bool: + """Determine if a request should be retried based on error/status and attempt count.""" + if attempt >= max_tries: + return False + + # Check HTTP status code + if status_code is not None and status_code in _RETRY_STATUS_CODES: + return True + + # Check network error codes (aligned with algokit-utils-ts) + if error is not None: + error_code = self._extract_error_code(error) + if error_code and error_code in _RETRY_ERROR_CODES: + return True + + return False + + def _extract_error_code(self, error: BaseException) -> str | None: + """Extract error code from exception, checking common attributes.""" + # Check for 'code' attribute (common in OS/network errors) + if hasattr(error, "code") and isinstance(error.code, str): + return error.code + # Check for errno attribute + if hasattr(error, "errno") and error.errno is not None: + import errno as errno_module + + try: + return errno_module.errorcode.get(error.errno) + except (TypeError, AttributeError): + pass + # Check __cause__ for wrapped errors + if error.__cause__ is not None: + return self._extract_error_code(error.__cause__) + return None + + def _request_with_retry(self, request_kwargs: dict[str, Any]) -> httpx.Response: + """Execute request with exponential backoff retry for transient failures. + + When a custom HTTP client is provided, retries are disabled to avoid + conflicts with any retry mechanism the custom client may implement. + """ + # Disable retries when using a custom HTTP client to avoid conflicts + # with the client's own retry mechanism + if self._uses_custom_client: + return self._client.request(**request_kwargs) + + max_tries = self._calculate_max_tries() + attempt = 1 + last_error: Exception | None = None + + while attempt <= max_tries: + status_code: int | None = None + try: + response = self._client.request(**request_kwargs) + status_code = response.status_code + if not self._should_retry(None, status_code, attempt, max_tries): + return response + except httpx.TransportError as exc: + last_error = exc + if not self._should_retry(exc, None, attempt, max_tries): + raise + + if attempt == 1: + backoff_ms = 0.0 + else: + base_backoff = min(1000.0 * (2 ** (attempt - 1)), _MAX_BACKOFF_MS) + jitter = 0.5 + random.random() # Random value between 0.5 and 1.5 + backoff_ms = base_backoff * jitter + if backoff_ms > 0: + time.sleep(backoff_ms / 1000.0) + attempt += 1 + + # Should not reach here, but satisfy type checker + if last_error: + raise last_error + raise RuntimeError(f"Request failed after {max_tries} attempt(s)") + + # public + + def _application_box_by_name( + self, + application_id: int, + name: str, + ) -> models.Box: + """ + Get box information for a given application. + """ + + path = "/v2/applications/{application-id}/box" + path = path.replace("{application-id}", str(application_id)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if name is not None: + params["name"] = name + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.Box) + + raise UnexpectedStatusError(response.status_code, response.text) + + def _raw_transaction( + self, + body: bytes, + ) -> models.PostTransactionsResponse: + """ + Broadcasts a raw transaction or transaction group to the network. + """ + + path = "/v2/transactions" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/x-binary"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "is_binary": True, + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.PostTransactionsResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def _transaction_params( + self, + ) -> models.TransactionParametersResponse: + """ + Get parameters for constructing a new transaction + """ + + path = "/v2/transactions/params" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.TransactionParametersResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def account_application_information( + self, + address: str, + application_id: int, + *, + response_format: Literal["json", "msgpack"] | None = None, + ) -> models.AccountApplicationResponse: + """ + Get account information about a given app. + """ + + path = "/v2/accounts/{address}/applications/{application-id}" + path = path.replace("{address}", str(address)) + + path = path.replace("{application-id}", str(application_id)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + selected_format = response_format + + if selected_format == "msgpack": + params["format"] = "msgpack" + accept_value = "application/msgpack" + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.AccountApplicationResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def account_asset_information( + self, + address: str, + asset_id: int, + ) -> models.AccountAssetResponse: + """ + Get account information about a given asset. + """ + + path = "/v2/accounts/{address}/assets/{asset-id}" + path = path.replace("{address}", str(address)) + + path = path.replace("{asset-id}", str(asset_id)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.AccountAssetResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def account_information( + self, + address: str, + *, + exclude: str | None = None, + ) -> models.Account: + """ + Get account information. + """ + + path = "/v2/accounts/{address}" + path = path.replace("{address}", str(address)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if exclude is not None: + params["exclude"] = exclude + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.Account) + + raise UnexpectedStatusError(response.status_code, response.text) + + def application_boxes( + self, + application_id: int, + *, + max_: int | None = None, + ) -> models.BoxesResponse: + """ + Get all box names for a given application. + """ + + path = "/v2/applications/{application-id}/boxes" + path = path.replace("{application-id}", str(application_id)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if max_ is not None: + params["max"] = max_ + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.BoxesResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def application_by_id( + self, + application_id: int, + ) -> models.Application: + """ + Get application information. + """ + + path = "/v2/applications/{application-id}" + path = path.replace("{application-id}", str(application_id)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.Application) + + raise UnexpectedStatusError(response.status_code, response.text) + + def asset_by_id( + self, + asset_id: int, + ) -> models.Asset: + """ + Get asset information. + """ + + path = "/v2/assets/{asset-id}" + path = path.replace("{asset-id}", str(asset_id)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.Asset) + + raise UnexpectedStatusError(response.status_code, response.text) + + def block( + self, + round_: int, + *, + header_only: bool | None = None, + ) -> models.BlockResponse: + """ + Get the block for the given round. + """ + + path = "/v2/blocks/{round}" + path = path.replace("{round}", str(round_)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if header_only is not None: + params["header-only"] = header_only + + accept_value: str | None = None + + params["format"] = "msgpack" + accept_value = "application/msgpack" + + headers.setdefault("accept", accept_value or "application/msgpack") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.BlockResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def block_hash( + self, + round_: int, + ) -> models.BlockHashResponse: + """ + Get the block hash for the block on the given round. + """ + + path = "/v2/blocks/{round}/hash" + path = path.replace("{round}", str(round_)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.BlockHashResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def block_time_stamp_offset( + self, + ) -> models.GetBlockTimeStampOffsetResponse: + """ + Returns the timestamp offset. Timestamp offsets can only be set in dev mode. + """ + + path = "/v2/devmode/blocks/offset" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.GetBlockTimeStampOffsetResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def block_tx_ids( + self, + round_: int, + ) -> models.BlockTxidsResponse: + """ + Get the top level transaction IDs for the block on the given round. + """ + + path = "/v2/blocks/{round}/txids" + path = path.replace("{round}", str(round_)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.BlockTxidsResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def genesis( + self, + ) -> models.GenesisFileInJson: + """ + Gets the genesis information. + """ + + path = "/genesis" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.GenesisFileInJson) + + raise UnexpectedStatusError(response.status_code, response.text) + + def health_check( + self, + ) -> None: + """ + Returns OK if healthy. + """ + + path = "/health" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return + + raise UnexpectedStatusError(response.status_code, response.text) + + def ledger_state_delta( + self, + round_: int, + ) -> models.LedgerStateDelta: + """ + Get a LedgerStateDelta object for a given round + """ + + path = "/v2/deltas/{round}" + path = path.replace("{round}", str(round_)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + params["format"] = "msgpack" + accept_value = "application/msgpack" + + headers.setdefault("accept", accept_value or "application/msgpack") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.LedgerStateDelta) + + raise UnexpectedStatusError(response.status_code, response.text) + + def ledger_state_delta_for_transaction_group( + self, + id_: str, + ) -> models.LedgerStateDelta: + """ + Get a LedgerStateDelta object for a given transaction group + """ + + path = "/v2/deltas/txn/group/{id}" + path = path.replace("{id}", str(id_)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + params["format"] = "msgpack" + accept_value = "application/msgpack" + + headers.setdefault("accept", accept_value or "application/msgpack") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.LedgerStateDelta) + + raise UnexpectedStatusError(response.status_code, response.text) + + def light_block_header_proof( + self, + round_: int, + ) -> models.LightBlockHeaderProof: + """ + Gets a proof for a given light block header inside a state proof commitment + """ + + path = "/v2/blocks/{round}/lightheader/proof" + path = path.replace("{round}", str(round_)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.LightBlockHeaderProof) + + raise UnexpectedStatusError(response.status_code, response.text) + + def pending_transaction_information( + self, + txid: str, + ) -> models.PendingTransactionResponse: + """ + Get a specific pending transaction. + """ + + path = "/v2/transactions/pending/{txid}" + path = path.replace("{txid}", str(txid)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + params["format"] = "msgpack" + accept_value = "application/msgpack" + + headers.setdefault("accept", accept_value or "application/msgpack") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.PendingTransactionResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def pending_transactions( + self, + *, + max_: int | None = None, + ) -> models.PendingTransactionsResponse: + """ + Get a list of unconfirmed transactions currently in the transaction pool. + """ + + path = "/v2/transactions/pending" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if max_ is not None: + params["max"] = max_ + + accept_value: str | None = None + + params["format"] = "msgpack" + accept_value = "application/msgpack" + + headers.setdefault("accept", accept_value or "application/msgpack") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.PendingTransactionsResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def pending_transactions_by_address( + self, + address: str, + *, + max_: int | None = None, + ) -> models.PendingTransactionsResponse: + """ + Get a list of unconfirmed transactions currently in the transaction pool by address. + """ + + path = "/v2/accounts/{address}/transactions/pending" + path = path.replace("{address}", str(address)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if max_ is not None: + params["max"] = max_ + + accept_value: str | None = None + + params["format"] = "msgpack" + accept_value = "application/msgpack" + + headers.setdefault("accept", accept_value or "application/msgpack") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.PendingTransactionsResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def ready( + self, + ) -> None: + """ + Returns OK if healthy and fully caught up. + """ + + path = "/ready" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return + + raise UnexpectedStatusError(response.status_code, response.text) + + def set_block_time_stamp_offset( + self, + offset: int, + ) -> None: + """ + Given a timestamp offset in seconds, adds the offset to every subsequent block header's + timestamp. + """ + + path = "/v2/devmode/blocks/offset/{offset}" + path = path.replace("{offset}", str(offset)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return + + raise UnexpectedStatusError(response.status_code, response.text) + + def set_sync_round( + self, + round_: int, + ) -> None: + """ + Given a round, tells the ledger to keep that round in its cache. + """ + + path = "/v2/ledger/sync/{round}" + path = path.replace("{round}", str(round_)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return + + raise UnexpectedStatusError(response.status_code, response.text) + + def simulate_transactions( + self, + body: models.SimulateRequest, + ) -> models.SimulateResponse: + """ + Simulates a raw transaction or transaction group as it would be evaluated on the + network. The simulation will use blockchain state from the latest committed round. + """ + + path = "/v2/transactions/simulate" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/msgpack"] + + params["format"] = "msgpack" + accept_value = "application/msgpack" + + if "application/msgpack" in body_media_types: + body_media_types = ["application/msgpack"] + + headers.setdefault("accept", accept_value or "application/msgpack") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "SimulateRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.SimulateResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def state_proof( + self, + round_: int, + ) -> models.StateProof: + """ + Get a state proof that covers a given round + """ + + path = "/v2/stateproofs/{round}" + path = path.replace("{round}", str(round_)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.StateProof) + + raise UnexpectedStatusError(response.status_code, response.text) + + def status( + self, + ) -> models.NodeStatusResponse: + """ + Gets the current node status. + """ + + path = "/v2/status" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.NodeStatusResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def status_after_block( + self, + round_: int, + ) -> models.NodeStatusResponse: + """ + Gets the node status after waiting for a round after the given round. + """ + + path = "/v2/status/wait-for-block-after/{round}" + path = path.replace("{round}", str(round_)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.NodeStatusResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def supply( + self, + ) -> models.SupplyResponse: + """ + Get the current supply reported by the ledger. + """ + + path = "/v2/ledger/supply" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.SupplyResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def sync_round( + self, + ) -> models.GetSyncRoundResponse: + """ + Returns the minimum sync round the ledger is keeping in cache. + """ + + path = "/v2/ledger/sync" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.GetSyncRoundResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def teal_compile( + self, + body: bytes, + *, + sourcemap: bool | None = None, + ) -> models.CompileResponse: + """ + Compile TEAL source code to binary, produce its hash + """ + + path = "/v2/teal/compile" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if sourcemap is not None: + params["sourcemap"] = sourcemap + + accept_value: str | None = None + + body_media_types = ["text/plain"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "is_binary": True, + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.CompileResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def teal_disassemble( + self, + body: bytes, + ) -> models.DisassembleResponse: + """ + Disassemble program bytes into the TEAL source code. + """ + + path = "/v2/teal/disassemble" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/x-binary"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "is_binary": True, + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.DisassembleResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def transaction_group_ledger_state_deltas_for_round( + self, + round_: int, + ) -> models.TransactionGroupLedgerStateDeltasForRound: + """ + Get LedgerStateDelta objects for all transaction groups in a given round + """ + + path = "/v2/deltas/{round}/txn/group" + path = path.replace("{round}", str(round_)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + params["format"] = "msgpack" + accept_value = "application/msgpack" + + headers.setdefault("accept", accept_value or "application/msgpack") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.TransactionGroupLedgerStateDeltasForRound) + + raise UnexpectedStatusError(response.status_code, response.text) + + def transaction_proof( + self, + round_: int, + txid: str, + *, + response_format: Literal["json", "msgpack"] | None = None, + hashtype: str | None = None, + ) -> models.TransactionProof: + """ + Get a proof for a transaction in a block. + """ + + path = "/v2/blocks/{round}/transactions/{txid}/proof" + path = path.replace("{round}", str(round_)) + + path = path.replace("{txid}", str(txid)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if hashtype is not None: + params["hashtype"] = hashtype + + accept_value: str | None = None + + selected_format = response_format + + if selected_format == "msgpack": + params["format"] = "msgpack" + accept_value = "application/msgpack" + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.TransactionProof) + + raise UnexpectedStatusError(response.status_code, response.text) + + def unset_sync_round( + self, + ) -> None: + """ + Removes minimum sync round restriction from the ledger. + """ + + path = "/v2/ledger/sync" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "DELETE", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return + + raise UnexpectedStatusError(response.status_code, response.text) + + def version( + self, + ) -> models.VersionContainsTheCurrentAlgodVersion: + """ + Retrieves the supported API versions, binary build versions, and genesis information. + """ + + path = "/versions" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.VersionContainsTheCurrentAlgodVersion) + + raise UnexpectedStatusError(response.status_code, response.text) + + def send_raw_transaction( + self, + stx_or_stxs: bytes | bytearray | memoryview | Sequence[bytes | bytearray | memoryview], + ) -> models.PostTransactionsResponse: + """ + Send a signed transaction or array of signed transactions to the network. + """ + + payload: bytes + if isinstance(stx_or_stxs, bytes | bytearray | memoryview): + payload = bytes(stx_or_stxs) + elif isinstance(stx_or_stxs, Sequence): + segments: list[bytes] = [] + for value in stx_or_stxs: + if not isinstance(value, bytes | bytearray | memoryview): + raise TypeError("All sequence elements must be bytes-like") + segments.append(bytes(value)) + payload = b"".join(segments) + else: + raise TypeError("stx_or_stxs must be bytes or a sequence of bytes-like values") + + return self._raw_transaction(payload) + + def application_box_by_name( + self, + application_id: int, + box_name: bytes | bytearray | memoryview | str, + ) -> models.Box: + """ + Given an application ID and box name, return the corresponding box details. + """ + + box_bytes = box_name.encode() if isinstance(box_name, str) else bytes(box_name) + encoded_name = "b64:" + b64encode(box_bytes).decode("ascii") + return self._application_box_by_name(application_id, name=encoded_name) + + def suggested_params(self) -> models.SuggestedParams: + """ + Return the common parameters required for assembling a transaction. + """ + + txn_params = self._transaction_params() + last_round = txn_params.last_round + return models.SuggestedParams( + consensus_version=txn_params.consensus_version, + fee=txn_params.fee, + genesis_hash=txn_params.genesis_hash, + genesis_id=txn_params.genesis_id, + min_fee=txn_params.min_fee, + flat_fee=False, + first_valid=last_round, + last_valid=last_round + 1000, + ) + + def _assign_body( + self, + request_kwargs: dict[str, Any], + payload: object, + descriptor: dict[str, object], + media_types: list[str], + ) -> None: + encoded = self._encode_payload(payload, descriptor) + binary_types = {"application/x-binary", "application/octet-stream"} + if bool(descriptor.get("is_binary")) or any(mt in binary_types for mt in media_types): + if encoded is None: + return + request_kwargs["content"] = encoded + if media_types: + request_kwargs.setdefault("headers", {})["content-type"] = media_types[0] + else: + request_kwargs.setdefault("headers", {})["content-type"] = "application/octet-stream" + elif "application/json" in media_types: + request_kwargs["json"] = encoded + elif "application/msgpack" in media_types: + request_kwargs["content"] = msgpack.packb(encoded, use_bin_type=True) + request_kwargs.setdefault("headers", {})["content-type"] = "application/msgpack" + else: + request_kwargs["json"] = encoded + + def _encode_payload(self, payload: object, descriptor: dict[str, object]) -> object: + if payload is None: + return None + if is_dataclass(payload): + return to_wire(payload) + list_model = descriptor.get("list_model") + if list_model and isinstance(payload, list): + return [to_wire(item) if is_dataclass(item) else item for item in payload] + return payload + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + model: type[ModelT], + is_binary: bool = False, + raw_msgpack: bool = False, + ) -> ModelT: ... + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + list_model: type[ListModelT], + is_binary: bool = False, + raw_msgpack: bool = False, + ) -> list[ListModelT]: ... + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + type_: type[PrimitiveT], + is_binary: bool = False, + raw_msgpack: bool = False, + ) -> PrimitiveT: ... + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + is_binary: Literal[True], + raw_msgpack: bool = False, + ) -> bytes: ... + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + raw_msgpack: Literal[True], + ) -> bytes: ... + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + type_: None = None, + is_binary: bool = False, + raw_msgpack: bool = False, + ) -> object: ... + + def _decode_response( + self, + response: httpx.Response, + *, + model: type[Any] | None = None, + list_model: type[Any] | None = None, + type_: type[Any] | None = None, + is_binary: bool = False, + raw_msgpack: bool = False, + ) -> object: + if is_binary or raw_msgpack: + return response.content + content_type = response.headers.get("content-type", "application/json") + if "msgpack" in content_type: + # Handle msgpack unpacking with support for unhashable keys + # Use Unpacker for more control over the unpacking process + unpacker = msgpack.Unpacker( + raw=True, + strict_map_key=False, + object_pairs_hook=self._msgpack_pairs_hook, + ) + unpacker.feed(response.content) + try: + data = unpacker.unpack() + except TypeError: + # If unpacking fails due to unhashable keys, try without the hook + # and handle in normalization + unpacker = msgpack.Unpacker(raw=True, strict_map_key=False) + unpacker.feed(response.content) + data = unpacker.unpack() + data = self._normalize_msgpack(data) + elif content_type.startswith("application/json"): + data = response.json() + else: + data = response.text + if model is not None: + return from_wire(model, data) + if list_model is not None: + return [from_wire(list_model, item) for item in data] + if type_ is not None: + return data + return data + + def _normalize_msgpack(self, value: object) -> object: + # Handle pairs returned from msgpack_pairs_hook when keys are unhashable + _pair_length = 2 + if isinstance(value, list) and value and isinstance(value[0], tuple | list) and len(value[0]) == _pair_length: + # Convert to dict with normalized keys + pairs_dict: dict[object, object] = {} + for pair in value: + if isinstance(pair, tuple | list) and len(pair) == _pair_length: + k, v = pair + # For unhashable keys (like dict keys), use a tuple representation + try: + normalized_key = self._coerce_msgpack_key(k) + pairs_dict[normalized_key] = self._normalize_msgpack(v) + except TypeError: + # Key is unhashable - use tuple representation + normalized_key = ("__unhashable__", id(k), str(k)) + pairs_dict[normalized_key] = self._normalize_msgpack(v) + return pairs_dict + if isinstance(value, dict): + # Safely normalize maps: coerce string/bytes keys, but tolerate complex/unhashable keys + try: + normalized_dict: dict[object, object] = {} + for key, item in value.items(): + normalized_dict[self._coerce_msgpack_key(key)] = self._normalize_msgpack(item) + return normalized_dict + except TypeError: + # Some maps can decode to object/dict keys; keep original keys and + # only normalize values to avoid "unhashable type: 'dict'" errors. + for k, item in list(value.items()): + value[k] = self._normalize_msgpack(item) + return value + if isinstance(value, list): + return [self._normalize_msgpack(item) for item in value] + return value + + def _coerce_msgpack_key(self, key: object) -> object: + if isinstance(key, bytes): + try: + return key.decode("utf-8", errors="strict") + except UnicodeDecodeError: + return key + return key + + def _msgpack_pairs_hook(self, pairs: list[tuple[object, object]] | list[list[object]]) -> dict[object, object]: + # Convert pairs to dict, handling unhashable keys by converting them to hashable tuples + out: dict[object, object] = {} + _hashable_type_tuple = (str, int, float, bool, type(None), bytes) + + for k, v in pairs: + if isinstance(k, dict | list | set): + # Convert unhashable key to hashable tuple + hashable_key: tuple[str, object] + if isinstance(k, dict): + try: + hashable_key = (_UNHASHABLE_PREFIXES["dict"], tuple(sorted(k.items()))) + except TypeError: + hashable_key = (_UNHASHABLE_PREFIXES["dict"], str(k)) + elif isinstance(k, list): + prefix = _UNHASHABLE_PREFIXES["list"] + hashable_key = (prefix, tuple(k) if all(isinstance(x, _hashable_type_tuple) for x in k) else str(k)) + else: # set + prefix = _UNHASHABLE_PREFIXES["set"] + if all(isinstance(x, _hashable_type_tuple) for x in k): + hashable_key = (prefix, tuple(sorted(k))) + else: + hashable_key = (prefix, str(k)) + out[hashable_key] = v + else: + # Key should be hashable, use as-is + try: + out[k] = v + except TypeError: + # Unexpected unhashable type, convert to tuple + out[(_UNHASHABLE_PREFIXES["generic"], str(type(k).__name__), str(k))] = v + return out diff --git a/src/algokit_algod_client/config.py b/src/algokit_algod_client/config.py new file mode 100644 index 00000000..425567b5 --- /dev/null +++ b/src/algokit_algod_client/config.py @@ -0,0 +1,36 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + + +@dataclass(slots=True) +class ClientConfig: + """Runtime configuration for AlgodClient. + + Attributes: + base_url: Base URL for the API endpoint. + token: Optional authentication token. + token_header: Header name for the authentication token. + timeout: Request timeout in seconds. Set to None for no timeout. + verify: SSL certificate verification. Can be a boolean or path to CA bundle. + extra_headers: Additional headers to include in all requests. + max_retries: Maximum number of retry attempts for transient failures. + Set to 0 to disable retries. Default is 4 (5 total attempts). + Note: Retries are automatically disabled when a custom http_client + is provided to avoid conflicts with the client's own retry mechanism. + """ + + base_url: str = "http://localhost:4001" + token: str | None = None + token_header: str = "X-Algo-API-Token" + timeout: float | None = 30.0 + verify: bool | str = True + extra_headers: dict[str, str] = field(default_factory=dict) + max_retries: int = 4 + + def resolve_headers(self) -> dict[str, str]: + headers = dict(self.extra_headers) + if self.token: + headers[self.token_header] = self.token + return headers diff --git a/src/algokit_algod_client/exceptions.py b/src/algokit_algod_client/exceptions.py new file mode 100644 index 00000000..06e4b129 --- /dev/null +++ b/src/algokit_algod_client/exceptions.py @@ -0,0 +1,59 @@ +# AUTO-GENERATED: oas_generator + +from http import HTTPStatus +from json import JSONDecodeError, loads + + +class ApiError(RuntimeError): + """Base exception for errors raised by generated clients.""" + + +def _format_payload(payload: object) -> str | None: # noqa: C901, PLR0912 + """Extract a human-friendly message from a payload.""" + if payload is None: + return None + + text: str | None = None + if isinstance(payload, (bytes | bytearray | memoryview)): + try: + text = bytes(payload).decode("utf-8", errors="ignore") + except Exception: + text = None + if text is None: + text = str(payload) + + result = text.strip() + if not result: + return None + + try: + decoded = loads(result) + except (JSONDecodeError, TypeError): + return result + + if isinstance(decoded, dict): + for key in ("message", "msg", "error", "detail", "description", "data"): + value = decoded.get(key) + if isinstance(value, str): + candidate = value.strip() + if candidate: + result = candidate + break + + if isinstance(decoded, list) and decoded: + first = decoded[0] + if isinstance(first, str): + candidate = first.strip() + if candidate: + result = candidate + + return result + + +class UnexpectedStatusError(ApiError): + def __init__(self, status_code: int, payload: object) -> None: + message = _format_payload(payload) + description = f" {message}" if message else "" + super().__init__(f"Unexpected status code {status_code}{description}") + self.status_code = HTTPStatus(status_code) + self.payload = payload diff --git a/src/algokit_algod_client/models/__init__.py b/src/algokit_algod_client/models/__init__.py new file mode 100644 index 00000000..8b48cad0 --- /dev/null +++ b/src/algokit_algod_client/models/__init__.py @@ -0,0 +1,229 @@ +# AUTO-GENERATED: oas_generator + + +from algokit_transact.models.app_call import BoxReference, HoldingReference, LocalsReference +from algokit_transact.models.signed_transaction import SignedTransaction + +from ._account import Account +from ._account_application_response import AccountApplicationResponse +from ._account_asset_response import AccountAssetResponse +from ._account_participation import AccountParticipation +from ._account_state_delta import AccountStateDelta +from ._allocations_for_genesis_file import AllocationsForGenesisFile +from ._allocations_for_genesis_file_state_model import AllocationsForGenesisFileStateModel +from ._application import Application +from ._application_initial_states import ApplicationInitialStates +from ._application_kv_storage import ApplicationKvStorage +from ._application_local_state import ApplicationLocalState +from ._application_params import ApplicationParams +from ._application_state_operation import ApplicationStateOperation +from ._application_state_schema import ApplicationStateSchema +from ._asset import Asset +from ._asset_holding import AssetHolding +from ._asset_params import AssetParams +from ._avm_key_value import AvmKeyValue +from ._avm_value import AvmValue +from ._block import ( + ApplyData, + Block, + BlockAccountStateDelta, + BlockAppEvalDelta, + BlockEvalDelta, + BlockHeader, + BlockResponse, + BlockStateDelta, + BlockStateProofTracking, + BlockStateProofTrackingData, + ParticipationUpdates, + RewardState, + SignedTxnInBlock, + SignedTxnWithAD, + TxnCommitments, + UpgradeState, + UpgradeVote, +) +from ._block_hash_response import BlockHashResponse +from ._block_txids_response import BlockTxidsResponse +from ._box import Box +from ._box_descriptor import BoxDescriptor +from ._boxes_response import BoxesResponse +from ._build_version_contains_the_current_algod_build_version_information import ( + BuildVersionContainsTheCurrentAlgodBuildVersionInformation, +) +from ._compile_response import CompileResponse +from ._disassemble_response import DisassembleResponse +from ._error_response import ErrorResponse +from ._eval_delta import EvalDelta +from ._eval_delta_key_value import EvalDeltaKeyValue +from ._genesis_file_in_json import GenesisFileInJson +from ._get_block_time_stamp_offset_response import GetBlockTimeStampOffsetResponse +from ._get_sync_round_response import GetSyncRoundResponse +from ._ledger_state_delta import ( + LedgerAccountBaseData, + LedgerAccountData, + LedgerAccountDeltas, + LedgerAccountTotals, + LedgerAlgoCount, + LedgerAppLocalState, + LedgerAppLocalStateDelta, + LedgerAppParams, + LedgerAppParamsDelta, + LedgerAppResourceRecord, + LedgerAssetHolding, + LedgerAssetHoldingDelta, + LedgerAssetParams, + LedgerAssetParamsDelta, + LedgerAssetResourceRecord, + LedgerBalanceRecord, + LedgerIncludedTransactions, + LedgerKvValueDelta, + LedgerModifiedCreatable, + LedgerStateDelta, + LedgerStateDeltaForTransactionGroup, + LedgerStateSchema, + LedgerTealValue, + LedgerVotingData, + TransactionGroupLedgerStateDeltasForRound, +) +from ._light_block_header_proof import LightBlockHeaderProof +from ._node_status_response import NodeStatusResponse +from ._pending_transaction_response import PendingTransactionResponse +from ._pending_transactions_response import PendingTransactionsResponse +from ._post_transactions_response import PostTransactionsResponse +from ._scratch_change import ScratchChange +from ._simulate_initial_states import SimulateInitialStates +from ._simulate_request import SimulateRequest +from ._simulate_request_transaction_group import SimulateRequestTransactionGroup +from ._simulate_response import SimulateResponse +from ._simulate_trace_config import SimulateTraceConfig +from ._simulate_transaction_group_result import SimulateTransactionGroupResult +from ._simulate_transaction_result import SimulateTransactionResult +from ._simulate_unnamed_resources_accessed import SimulateUnnamedResourcesAccessed +from ._simulation_eval_overrides import SimulationEvalOverrides +from ._simulation_opcode_trace_unit import SimulationOpcodeTraceUnit +from ._simulation_transaction_exec_trace import SimulationTransactionExecTrace +from ._source_map import SourceMap +from ._state_delta import StateDelta +from ._state_proof import StateProof +from ._state_proof_message import StateProofMessage +from ._supply_response import SupplyResponse +from ._teal_key_value import TealKeyValue +from ._teal_key_value_store import TealKeyValueStore +from ._teal_value import TealValue +from ._transaction_group_ledger_state_deltas_for_round_response import TransactionGroupLedgerStateDeltasForRoundResponse +from ._transaction_parameters_response import TransactionParametersResponse +from ._transaction_proof import TransactionProof +from ._version_contains_the_current_algod_version import VersionContainsTheCurrentAlgodVersion +from .suggested_params import SuggestedParams + +__all__ = [ + "Account", + "AccountApplicationResponse", + "AccountAssetResponse", + "AccountParticipation", + "AccountStateDelta", + "AllocationsForGenesisFile", + "AllocationsForGenesisFileStateModel", + "Application", + "ApplicationInitialStates", + "ApplicationKvStorage", + "ApplicationLocalState", + "ApplicationParams", + "ApplicationStateOperation", + "ApplicationStateSchema", + "ApplyData", + "Asset", + "AssetHolding", + "AssetParams", + "AvmKeyValue", + "AvmValue", + "Block", + "BlockAccountStateDelta", + "BlockAppEvalDelta", + "BlockEvalDelta", + "BlockHashResponse", + "BlockHeader", + "BlockResponse", + "BlockStateDelta", + "BlockStateProofTracking", + "BlockStateProofTrackingData", + "BlockTxidsResponse", + "Box", + "BoxDescriptor", + "BoxReference", + "BoxesResponse", + "BuildVersionContainsTheCurrentAlgodBuildVersionInformation", + "CompileResponse", + "DisassembleResponse", + "ErrorResponse", + "EvalDelta", + "EvalDeltaKeyValue", + "GenesisFileInJson", + "GetBlockTimeStampOffsetResponse", + "GetSyncRoundResponse", + "HoldingReference", + "LedgerAccountBaseData", + "LedgerAccountData", + "LedgerAccountDeltas", + "LedgerAccountTotals", + "LedgerAlgoCount", + "LedgerAppLocalState", + "LedgerAppLocalStateDelta", + "LedgerAppParams", + "LedgerAppParamsDelta", + "LedgerAppResourceRecord", + "LedgerAssetHolding", + "LedgerAssetHoldingDelta", + "LedgerAssetParams", + "LedgerAssetParamsDelta", + "LedgerAssetResourceRecord", + "LedgerBalanceRecord", + "LedgerIncludedTransactions", + "LedgerKvValueDelta", + "LedgerModifiedCreatable", + "LedgerStateDelta", + "LedgerStateDeltaForTransactionGroup", + "LedgerStateSchema", + "LedgerTealValue", + "LedgerVotingData", + "LightBlockHeaderProof", + "LocalsReference", + "NodeStatusResponse", + "ParticipationUpdates", + "PendingTransactionResponse", + "PendingTransactionsResponse", + "PostTransactionsResponse", + "RewardState", + "ScratchChange", + "SignedTransaction", + "SignedTxnInBlock", + "SignedTxnWithAD", + "SimulateInitialStates", + "SimulateRequest", + "SimulateRequestTransactionGroup", + "SimulateResponse", + "SimulateTraceConfig", + "SimulateTransactionGroupResult", + "SimulateTransactionResult", + "SimulateUnnamedResourcesAccessed", + "SimulationEvalOverrides", + "SimulationOpcodeTraceUnit", + "SimulationTransactionExecTrace", + "SourceMap", + "StateDelta", + "StateProof", + "StateProofMessage", + "SuggestedParams", + "SupplyResponse", + "TealKeyValue", + "TealKeyValueStore", + "TealValue", + "TransactionGroupLedgerStateDeltasForRound", + "TransactionGroupLedgerStateDeltasForRoundResponse", + "TransactionParametersResponse", + "TransactionProof", + "TxnCommitments", + "UpgradeState", + "UpgradeVote", + "VersionContainsTheCurrentAlgodVersion", +] diff --git a/src/algokit_algod_client/models/_account.py b/src/algokit_algod_client/models/_account.py new file mode 100644 index 00000000..1a6805cb --- /dev/null +++ b/src/algokit_algod_client/models/_account.py @@ -0,0 +1,150 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.constants import ZERO_ADDRESS +from algokit_common.serde import nested, wire + +from ._account_participation import AccountParticipation +from ._application import Application +from ._application_local_state import ApplicationLocalState +from ._application_state_schema import ApplicationStateSchema +from ._asset import Asset +from ._asset_holding import AssetHolding +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class Account: + """ + Account information at a given round. + + Definition: + data/basics/userBalance.go : AccountData + """ + + address: str = field( + default=ZERO_ADDRESS, + metadata=wire("address"), + ) + amount: int = field( + default=0, + metadata=wire("amount"), + ) + amount_without_pending_rewards: int = field( + default=0, + metadata=wire("amount-without-pending-rewards"), + ) + min_balance: int = field( + default=0, + metadata=wire("min-balance"), + ) + pending_rewards: int = field( + default=0, + metadata=wire("pending-rewards"), + ) + rewards: int = field( + default=0, + metadata=wire("rewards"), + ) + round_: int = field( + default=0, + metadata=wire("round"), + ) + status: str = field( + default="", + metadata=wire("status"), + ) + total_apps_opted_in: int = field( + default=0, + metadata=wire("total-apps-opted-in"), + ) + total_assets_opted_in: int = field( + default=0, + metadata=wire("total-assets-opted-in"), + ) + total_created_apps: int = field( + default=0, + metadata=wire("total-created-apps"), + ) + total_created_assets: int = field( + default=0, + metadata=wire("total-created-assets"), + ) + apps_local_state: list[ApplicationLocalState] | None = field( + default=None, + metadata=wire( + "apps-local-state", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: ApplicationLocalState, raw), + ), + ) + apps_total_extra_pages: int | None = field( + default=None, + metadata=wire("apps-total-extra-pages"), + ) + apps_total_schema: ApplicationStateSchema | None = field( + default=None, + metadata=nested("apps-total-schema", lambda: ApplicationStateSchema), + ) + assets: list[AssetHolding] | None = field( + default=None, + metadata=wire( + "assets", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: AssetHolding, raw), + ), + ) + auth_addr: str | None = field( + default=None, + metadata=wire("auth-addr"), + ) + created_apps: list[Application] | None = field( + default=None, + metadata=wire( + "created-apps", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: Application, raw), + ), + ) + created_assets: list[Asset] | None = field( + default=None, + metadata=wire( + "created-assets", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: Asset, raw), + ), + ) + incentive_eligible: bool | None = field( + default=None, + metadata=wire("incentive-eligible"), + ) + last_heartbeat: int | None = field( + default=None, + metadata=wire("last-heartbeat"), + ) + last_proposed: int | None = field( + default=None, + metadata=wire("last-proposed"), + ) + participation: AccountParticipation | None = field( + default=None, + metadata=nested("participation", lambda: AccountParticipation), + ) + reward_base: int | None = field( + default=None, + metadata=wire("reward-base"), + ) + sig_type: str | None = field( + default=None, + metadata=wire("sig-type"), + ) + total_box_bytes: int | None = field( + default=None, + metadata=wire("total-box-bytes"), + ) + total_boxes: int | None = field( + default=None, + metadata=wire("total-boxes"), + ) diff --git a/src/algokit_algod_client/models/_account_application_response.py b/src/algokit_algod_client/models/_account_application_response.py new file mode 100644 index 00000000..1bfdd352 --- /dev/null +++ b/src/algokit_algod_client/models/_account_application_response.py @@ -0,0 +1,25 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._application_local_state import ApplicationLocalState +from ._application_params import ApplicationParams + + +@dataclass(slots=True) +class AccountApplicationResponse: + round_: int = field( + default=0, + metadata=wire("round"), + ) + app_local_state: ApplicationLocalState | None = field( + default=None, + metadata=nested("app-local-state", lambda: ApplicationLocalState), + ) + created_app: ApplicationParams | None = field( + default=None, + metadata=nested("created-app", lambda: ApplicationParams), + ) diff --git a/src/algokit_algod_client/models/_account_asset_response.py b/src/algokit_algod_client/models/_account_asset_response.py new file mode 100644 index 00000000..416a2eba --- /dev/null +++ b/src/algokit_algod_client/models/_account_asset_response.py @@ -0,0 +1,25 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._asset_holding import AssetHolding +from ._asset_params import AssetParams + + +@dataclass(slots=True) +class AccountAssetResponse: + round_: int = field( + default=0, + metadata=wire("round"), + ) + asset_holding: AssetHolding | None = field( + default=None, + metadata=nested("asset-holding", lambda: AssetHolding), + ) + created_asset: AssetParams | None = field( + default=None, + metadata=nested("created-asset", lambda: AssetParams), + ) diff --git a/src/algokit_algod_client/models/_account_participation.py b/src/algokit_algod_client/models/_account_participation.py new file mode 100644 index 00000000..33353c94 --- /dev/null +++ b/src/algokit_algod_client/models/_account_participation.py @@ -0,0 +1,53 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_fixed_bytes, encode_fixed_bytes + + +@dataclass(slots=True) +class AccountParticipation: + """ + AccountParticipation describes the parameters used by this account in consensus + protocol. + """ + + selection_participation_key: bytes = field( + default=b"", + metadata=wire( + "selection-participation-key", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) + vote_first_valid: int = field( + default=0, + metadata=wire("vote-first-valid"), + ) + vote_key_dilution: int = field( + default=0, + metadata=wire("vote-key-dilution"), + ) + vote_last_valid: int = field( + default=0, + metadata=wire("vote-last-valid"), + ) + vote_participation_key: bytes = field( + default=b"", + metadata=wire( + "vote-participation-key", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) + state_proof_key: bytes | None = field( + default=None, + metadata=wire( + "state-proof-key", + encode=lambda v: encode_fixed_bytes(v, 64), + decode=lambda raw: decode_fixed_bytes(raw, 64), + ), + ) diff --git a/src/algokit_algod_client/models/_account_state_delta.py b/src/algokit_algod_client/models/_account_state_delta.py new file mode 100644 index 00000000..c2d0b473 --- /dev/null +++ b/src/algokit_algod_client/models/_account_state_delta.py @@ -0,0 +1,30 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.constants import ZERO_ADDRESS +from algokit_common.serde import wire + +from ._eval_delta_key_value import EvalDeltaKeyValue +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class AccountStateDelta: + """ + Application state delta. + """ + + address: str = field( + default=ZERO_ADDRESS, + metadata=wire("address"), + ) + delta: list[EvalDeltaKeyValue] = field( + default_factory=list, + metadata=wire( + "delta", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: EvalDeltaKeyValue, raw), + ), + ) diff --git a/src/algokit_algod_client/models/_allocations_for_genesis_file.py b/src/algokit_algod_client/models/_allocations_for_genesis_file.py new file mode 100644 index 00000000..4d43a742 --- /dev/null +++ b/src/algokit_algod_client/models/_allocations_for_genesis_file.py @@ -0,0 +1,23 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._allocations_for_genesis_file_state_model import AllocationsForGenesisFileStateModel + + +@dataclass(slots=True) +class AllocationsForGenesisFile: + state: AllocationsForGenesisFileStateModel = field( + metadata=nested("state", lambda: AllocationsForGenesisFileStateModel, required=True), + ) + addr: str = field( + default="", + metadata=wire("addr"), + ) + comment: str = field( + default="", + metadata=wire("comment"), + ) diff --git a/src/algokit_algod_client/models/_allocations_for_genesis_file_state_model.py b/src/algokit_algod_client/models/_allocations_for_genesis_file_state_model.py new file mode 100644 index 00000000..20fd9c05 --- /dev/null +++ b/src/algokit_algod_client/models/_allocations_for_genesis_file_state_model.py @@ -0,0 +1,42 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class AllocationsForGenesisFileStateModel: + algo: int = field( + default=0, + metadata=wire("algo"), + ) + onl: int = field( + default=0, + metadata=wire("onl"), + ) + sel: str | None = field( + default=None, + metadata=wire("sel"), + ) + stprf: str | None = field( + default=None, + metadata=wire("stprf"), + ) + vote: str | None = field( + default=None, + metadata=wire("vote"), + ) + vote_fst: int | None = field( + default=None, + metadata=wire("voteFst"), + ) + vote_kd: int | None = field( + default=None, + metadata=wire("voteKD"), + ) + vote_lst: int | None = field( + default=None, + metadata=wire("voteLst"), + ) diff --git a/src/algokit_algod_client/models/_application.py b/src/algokit_algod_client/models/_application.py new file mode 100644 index 00000000..da4c3736 --- /dev/null +++ b/src/algokit_algod_client/models/_application.py @@ -0,0 +1,23 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._application_params import ApplicationParams + + +@dataclass(slots=True) +class Application: + """ + Application index and its parameters + """ + + params: ApplicationParams = field( + metadata=nested("params", lambda: ApplicationParams, required=True), + ) + id_: int = field( + default=0, + metadata=wire("id"), + ) diff --git a/src/algokit_algod_client/models/_application_initial_states.py b/src/algokit_algod_client/models/_application_initial_states.py new file mode 100644 index 00000000..f60bc2a3 --- /dev/null +++ b/src/algokit_algod_client/models/_application_initial_states.py @@ -0,0 +1,37 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._application_kv_storage import ApplicationKvStorage +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class ApplicationInitialStates: + """ + An application's initial global/local/box states that were accessed during simulation. + """ + + id_: int = field( + default=0, + metadata=wire("id"), + ) + app_boxes: ApplicationKvStorage | None = field( + default=None, + metadata=nested("app-boxes", lambda: ApplicationKvStorage), + ) + app_globals: ApplicationKvStorage | None = field( + default=None, + metadata=nested("app-globals", lambda: ApplicationKvStorage), + ) + app_locals: list[ApplicationKvStorage] | None = field( + default=None, + metadata=wire( + "app-locals", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: ApplicationKvStorage, raw), + ), + ) diff --git a/src/algokit_algod_client/models/_application_kv_storage.py b/src/algokit_algod_client/models/_application_kv_storage.py new file mode 100644 index 00000000..b6654589 --- /dev/null +++ b/src/algokit_algod_client/models/_application_kv_storage.py @@ -0,0 +1,29 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._avm_key_value import AvmKeyValue +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class ApplicationKvStorage: + """ + An application's global/local/box state. + """ + + kvs: list[AvmKeyValue] = field( + default_factory=list, + metadata=wire( + "kvs", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: AvmKeyValue, raw), + ), + ) + account: str | None = field( + default=None, + metadata=wire("account"), + ) diff --git a/src/algokit_algod_client/models/_application_local_state.py b/src/algokit_algod_client/models/_application_local_state.py new file mode 100644 index 00000000..b4f4231b --- /dev/null +++ b/src/algokit_algod_client/models/_application_local_state.py @@ -0,0 +1,33 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._application_state_schema import ApplicationStateSchema +from ._serde_helpers import decode_model_sequence, encode_model_sequence +from ._teal_key_value import TealKeyValue + + +@dataclass(slots=True) +class ApplicationLocalState: + """ + Stores local state associated with an application. + """ + + schema: ApplicationStateSchema = field( + metadata=nested("schema", lambda: ApplicationStateSchema, required=True), + ) + id_: int = field( + default=0, + metadata=wire("id"), + ) + key_value: list[TealKeyValue] | None = field( + default=None, + metadata=wire( + "key-value", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: TealKeyValue, raw), + ), + ) diff --git a/src/algokit_algod_client/models/_application_params.py b/src/algokit_algod_client/models/_application_params.py new file mode 100644 index 00000000..92f5c26e --- /dev/null +++ b/src/algokit_algod_client/models/_application_params.py @@ -0,0 +1,63 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.constants import ZERO_ADDRESS +from algokit_common.serde import nested, wire + +from ._application_state_schema import ApplicationStateSchema +from ._serde_helpers import decode_bytes, decode_model_sequence, encode_bytes, encode_model_sequence +from ._teal_key_value import TealKeyValue + + +@dataclass(slots=True) +class ApplicationParams: + """ + Stores the global information associated with an application. + """ + + approval_program: bytes = field( + default=b"", + metadata=wire( + "approval-program", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + clear_state_program: bytes = field( + default=b"", + metadata=wire( + "clear-state-program", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + creator: str = field( + default=ZERO_ADDRESS, + metadata=wire("creator"), + ) + extra_program_pages: int | None = field( + default=None, + metadata=wire("extra-program-pages"), + ) + global_state: list[TealKeyValue] | None = field( + default=None, + metadata=wire( + "global-state", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: TealKeyValue, raw), + ), + ) + global_state_schema: ApplicationStateSchema | None = field( + default=None, + metadata=nested("global-state-schema", lambda: ApplicationStateSchema), + ) + local_state_schema: ApplicationStateSchema | None = field( + default=None, + metadata=nested("local-state-schema", lambda: ApplicationStateSchema), + ) + version: int | None = field( + default=None, + metadata=wire("version"), + ) diff --git a/src/algokit_algod_client/models/_application_state_operation.py b/src/algokit_algod_client/models/_application_state_operation.py new file mode 100644 index 00000000..047da4dd --- /dev/null +++ b/src/algokit_algod_client/models/_application_state_operation.py @@ -0,0 +1,41 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._avm_value import AvmValue +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class ApplicationStateOperation: + """ + An operation against an application's global/local/box state. + """ + + app_state_type: str = field( + default="", + metadata=wire("app-state-type"), + ) + key: bytes = field( + default=b"", + metadata=wire( + "key", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + operation: str = field( + default="", + metadata=wire("operation"), + ) + account: str | None = field( + default=None, + metadata=wire("account"), + ) + new_value: AvmValue | None = field( + default=None, + metadata=nested("new-value", lambda: AvmValue), + ) diff --git a/src/algokit_algod_client/models/_application_state_schema.py b/src/algokit_algod_client/models/_application_state_schema.py new file mode 100644 index 00000000..293f7b50 --- /dev/null +++ b/src/algokit_algod_client/models/_application_state_schema.py @@ -0,0 +1,22 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class ApplicationStateSchema: + """ + Specifies maximums on the number of each type that may be stored. + """ + + num_byte_slices: int = field( + default=0, + metadata=wire("num-byte-slice"), + ) + num_uints: int = field( + default=0, + metadata=wire("num-uint"), + ) diff --git a/src/algokit_algod_client/models/_asset.py b/src/algokit_algod_client/models/_asset.py new file mode 100644 index 00000000..20429de7 --- /dev/null +++ b/src/algokit_algod_client/models/_asset.py @@ -0,0 +1,23 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._asset_params import AssetParams + + +@dataclass(slots=True) +class Asset: + """ + Specifies both the unique identifier and the parameters for an asset + """ + + params: AssetParams = field( + metadata=nested("params", lambda: AssetParams, required=True), + ) + id_: int = field( + default=0, + metadata=wire("index"), + ) diff --git a/src/algokit_algod_client/models/_asset_holding.py b/src/algokit_algod_client/models/_asset_holding.py new file mode 100644 index 00000000..80ec4ddd --- /dev/null +++ b/src/algokit_algod_client/models/_asset_holding.py @@ -0,0 +1,29 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class AssetHolding: + """ + Describes an asset held by an account. + + Definition: + data/basics/userBalance.go : AssetHolding + """ + + amount: int = field( + default=0, + metadata=wire("amount"), + ) + asset_id: int = field( + default=0, + metadata=wire("asset-id"), + ) + is_frozen: bool = field( + default=False, + metadata=wire("is-frozen"), + ) diff --git a/src/algokit_algod_client/models/_asset_params.py b/src/algokit_algod_client/models/_asset_params.py new file mode 100644 index 00000000..adb7944b --- /dev/null +++ b/src/algokit_algod_client/models/_asset_params.py @@ -0,0 +1,97 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, decode_fixed_bytes, encode_bytes, encode_fixed_bytes + + +@dataclass(slots=True) +class AssetParams: + r""" + AssetParams specifies the parameters for an asset. + + \[apar\] when part of an AssetConfig transaction. + + Definition: + data/transactions/asset.go : AssetParams + """ + + creator: str = field( + default="", + metadata=wire("creator"), + ) + decimals: int = field( + default=0, + metadata=wire("decimals"), + ) + total: int = field( + default=0, + metadata=wire("total"), + ) + clawback: str | None = field( + default=None, + metadata=wire("clawback"), + ) + default_frozen: bool | None = field( + default=None, + metadata=wire("default-frozen"), + ) + freeze: str | None = field( + default=None, + metadata=wire("freeze"), + ) + manager: str | None = field( + default=None, + metadata=wire("manager"), + ) + metadata_hash: bytes | None = field( + default=None, + metadata=wire( + "metadata-hash", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) + name: str | None = field( + default=None, + metadata=wire("name"), + ) + name_b64: bytes | None = field( + default=None, + metadata=wire( + "name-b64", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + reserve: str | None = field( + default=None, + metadata=wire("reserve"), + ) + unit_name: str | None = field( + default=None, + metadata=wire("unit-name"), + ) + unit_name_b64: bytes | None = field( + default=None, + metadata=wire( + "unit-name-b64", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + url: str | None = field( + default=None, + metadata=wire("url"), + ) + url_b64: bytes | None = field( + default=None, + metadata=wire( + "url-b64", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_algod_client/models/_avm_key_value.py b/src/algokit_algod_client/models/_avm_key_value.py new file mode 100644 index 00000000..1760d733 --- /dev/null +++ b/src/algokit_algod_client/models/_avm_key_value.py @@ -0,0 +1,28 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._avm_value import AvmValue +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class AvmKeyValue: + """ + Represents an AVM key-value pair in an application store. + """ + + value: AvmValue = field( + metadata=nested("value", lambda: AvmValue, required=True), + ) + key: bytes = field( + default=b"", + metadata=wire( + "key", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_algod_client/models/_avm_value.py b/src/algokit_algod_client/models/_avm_value.py new file mode 100644 index 00000000..56063872 --- /dev/null +++ b/src/algokit_algod_client/models/_avm_value.py @@ -0,0 +1,32 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class AvmValue: + """ + Represents an AVM value. + """ + + type_: int = field( + default=0, + metadata=wire("type"), + ) + bytes_: bytes | None = field( + default=None, + metadata=wire( + "bytes", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + uint: int | None = field( + default=None, + metadata=wire("uint"), + ) diff --git a/src/algokit_algod_client/models/_block.py b/src/algokit_algod_client/models/_block.py new file mode 100644 index 00000000..0cacf24a --- /dev/null +++ b/src/algokit_algod_client/models/_block.py @@ -0,0 +1,364 @@ +# AUTO-GENERATED: oas_generator +from collections.abc import Mapping +from dataclasses import dataclass, field +from typing import cast + +from algokit_common import ZERO_ADDRESS +from algokit_common.serde import addr, addr_seq, flatten, nested, wire +from algokit_transact.models.signed_transaction import SignedTransaction + +from ._serde_helpers import ( + decode_bytes_map_key, + decode_model_mapping, + decode_model_sequence, + decode_optional_bool, + encode_bytes, + encode_model_mapping, + encode_model_sequence, + mapping_decoder, + mapping_encoder, +) + +__all__ = [ + "ApplyData", + "Block", + "BlockAccountStateDelta", + "BlockAppEvalDelta", + "BlockEvalDelta", + "BlockHeader", + "BlockResponse", + "BlockStateDelta", + "BlockStateProofTracking", + "BlockStateProofTrackingData", + "ParticipationUpdates", + "RewardState", + "SignedTxnInBlock", + "SignedTxnWithAD", + "TxnCommitments", + "UpgradeState", + "UpgradeVote", +] + +BlockStateDelta = dict[bytes, "BlockEvalDelta"] +BlockStateProofTracking = dict[int, "BlockStateProofTrackingData"] + + +def _encode_block_state_delta(value: BlockStateDelta | None) -> dict[str, object] | None: + if value is None: + return None + return encode_model_mapping( + lambda: BlockEvalDelta, + cast(Mapping[object, object], value), + key_encoder=_encode_state_delta_key, + ) + + +def _encode_state_delta_key(key: object) -> str: + if isinstance(key, bytes): + return encode_bytes(key) + if isinstance(key, memoryview): + return encode_bytes(bytes(key)) + if isinstance(key, bytearray): + return encode_bytes(bytes(key)) + raise TypeError("State delta keys must be bytes-like") + + +def _decode_state_proof_tracking_key(key: object) -> int: + if isinstance(key, int): + return key + if isinstance(key, str): + return int(key) + raise TypeError("State proof tracking keys must be numeric") + + +def _decode_block_state_delta(raw: object) -> BlockStateDelta | None: + decoded = decode_model_mapping(lambda: BlockEvalDelta, raw, key_decoder=decode_bytes_map_key) + return decoded or None + + +def _encode_local_delta_index_key(key: object) -> str: + if isinstance(key, bool): + return str(int(key)) + if isinstance(key, int): + return str(key) + if isinstance(key, str): + return str(int(key)) + raise TypeError("Local delta keys must be numeric") + + +def _encode_local_deltas(mapping: Mapping[int, BlockStateDelta] | None) -> dict[str, object] | None: + if mapping is None: + return None + out: dict[str, object] = {} + for key, value in mapping.items(): + encoded = _encode_block_state_delta(value) + if encoded: + out[_encode_local_delta_index_key(key)] = encoded + return out or None + + +def _decode_local_deltas(raw: object) -> dict[int, BlockStateDelta] | None: + if not isinstance(raw, Mapping): + return None + out: dict[int, BlockStateDelta] = {} + for key, value in raw.items(): + decoded = _decode_block_state_delta(value) + if decoded is not None: + out[_decode_local_delta_index_key(key)] = decoded + return out or None + + +def _decode_local_delta_index_key(key: object) -> int: + if isinstance(key, int): + return key + if isinstance(key, str): + return int(key) + raise TypeError("Local delta keys must be numeric") + + +@dataclass(slots=True) +class BlockEvalDelta: + """Represents a TEAL value delta within block state changes.""" + + action: int = field(metadata=wire("at", required=True)) + bytes_: bytes | None = field(default=None, metadata=wire("bs")) + uint: int | None = field(default=None, metadata=wire("ui")) + + +@dataclass(slots=True) +class BlockAccountStateDelta: + """Associates an account address with its state delta.""" + + address: str = field(metadata=wire("address", required=True)) + delta: BlockStateDelta = field( + metadata=wire( + "delta", + encode=_encode_block_state_delta, + decode=_decode_block_state_delta, + ) + ) + + +@dataclass(slots=True) +class BlockStateProofTrackingData: + """Tracking metadata for a specific state proof type.""" + + state_proof_voters_commitment: bytes | None = field( + default=None, + metadata=wire("v"), + ) + state_proof_online_total_weight: int | None = field( + default=None, + metadata=wire("t"), + ) + state_proof_next_round: int | None = field( + default=None, + metadata=wire("n"), + ) + + +@dataclass(slots=True) +class ApplyData: + """Transaction execution apply data containing state changes and rewards.""" + + closing_amount: int | None = field(default=None, metadata=wire("ca")) + asset_closing_amount: int | None = field(default=None, metadata=wire("aca")) + sender_rewards: int | None = field(default=None, metadata=wire("rs")) + receiver_rewards: int | None = field(default=None, metadata=wire("rr")) + close_rewards: int | None = field(default=None, metadata=wire("rc")) + eval_delta: "BlockAppEvalDelta | None" = field( + default=None, + metadata=nested("dt", lambda: BlockAppEvalDelta), + ) + config_asset: int | None = field(default=None, metadata=wire("caid")) + application_id: int | None = field(default=None, metadata=wire("apid")) + + +@dataclass(slots=True) +class SignedTxnWithAD: + """Signed transaction with associated apply data.""" + + signed_transaction: SignedTransaction = field(metadata=flatten(lambda: SignedTransaction)) + apply_data: ApplyData | None = field(default=None, metadata=flatten(lambda: ApplyData)) + + +@dataclass(slots=True) +class TxnCommitments: + """Transaction commitment hashes for the block.""" + + native_sha512_256_commitment: bytes = field(default_factory=lambda: bytes(32), metadata=wire("txn")) + """Root of transaction merkle tree using SHA512_256.""" + sha256_commitment: bytes | None = field(default_factory=lambda: bytes(32), metadata=wire("txn256")) + """Root of transaction vector commitment using SHA256.""" + sha512_commitment: bytes | None = field(default_factory=lambda: bytes(64), metadata=wire("txn512")) + """Root of transaction vector commitment using SHA512.""" + + +@dataclass(slots=True) +class RewardState: + """Reward distribution state for the block.""" + + fee_sink: str = field(default=ZERO_ADDRESS, metadata=addr("fees")) + rewards_pool: str = field(default=ZERO_ADDRESS, metadata=addr("rwd")) + rewards_level: int = field(default=0, metadata=wire("earn")) + rewards_rate: int = field(default=0, metadata=wire("rate")) + rewards_residue: int = field(default=0, metadata=wire("frac")) + rewards_recalculation_round: int = field(default=0, metadata=wire("rwcalr")) + + +@dataclass(slots=True) +class UpgradeState: + """Protocol upgrade state for the block.""" + + current_protocol: str = field(default="", metadata=wire("proto", required=True)) + next_protocol: str | None = field(default=None, metadata=wire("nextproto")) + next_protocol_approvals: int | None = field(default=None, metadata=wire("nextyes")) + next_protocol_vote_before: int | None = field(default=None, metadata=wire("nextbefore")) + next_protocol_switch_on: int | None = field(default=None, metadata=wire("nextswitch")) + + +@dataclass(slots=True) +class UpgradeVote: + """Protocol upgrade vote parameters for the block.""" + + upgrade_propose: str | None = field(default=None, metadata=wire("upgradeprop")) + upgrade_delay: int | None = field(default=None, metadata=wire("upgradedelay")) + upgrade_approve: bool | None = field(default=None, metadata=wire("upgradeyes")) + + +@dataclass(slots=True) +class ParticipationUpdates: + """Participation account updates embedded in a block.""" + + expired_participation_accounts: tuple[str, ...] = field(default=(), metadata=addr_seq("partupdrmv")) + absent_participation_accounts: tuple[str, ...] = field(default=(), metadata=addr_seq("partupdabs")) + + +@dataclass(slots=True) +class SignedTxnInBlock: + """Signed transaction details with block-specific apply data.""" + + signed_transaction: SignedTxnWithAD = field(metadata=flatten(lambda: SignedTxnWithAD)) + has_genesis_id: bool | None = field(default=None, metadata=wire("hgi", decode=decode_optional_bool)) + has_genesis_hash: bool | None = field(default=None, metadata=wire("hgh", decode=decode_optional_bool)) + + +@dataclass(slots=True) +class BlockAppEvalDelta: + """State changes produced by an application execution during block evaluation.""" + + global_delta: BlockStateDelta | None = field( + default=None, + metadata=wire( + "gd", + encode=_encode_block_state_delta, + decode=_decode_block_state_delta, + ), + ) + local_deltas: dict[int, BlockStateDelta] | None = field( + default=None, + metadata=wire( + "ld", + encode=_encode_local_deltas, + decode=_decode_local_deltas, + ), + ) + inner_txns: list[SignedTxnWithAD] | None = field( + default=None, + metadata=wire( + "itx", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: SignedTxnWithAD, raw), + ), + ) + shared_accounts: tuple[str, ...] | None = field(default=None, metadata=addr_seq("sa")) + logs: list[bytes] | None = field(default=None, metadata=wire("lg")) + + +@dataclass(slots=True) +class BlockHeader: + """Block header fields.""" + + round: int = field(default=0, metadata=wire("rnd")) + previous_block_hash: bytes = field(default_factory=lambda: bytes(32), metadata=wire("prev")) + previous_block_hash_512: bytes | None = field(default=None, metadata=wire("prev512")) + seed: bytes = field(default=b"", metadata=wire("seed")) + txn_commitments: TxnCommitments = field( + default_factory=TxnCommitments, + metadata=flatten(lambda: TxnCommitments), + ) + timestamp: int = field(default=0, metadata=wire("ts")) + genesis_id: str = field(default="", metadata=wire("gen")) + genesis_hash: bytes = field(default_factory=lambda: bytes(32), metadata=wire("gh")) + proposer: str | None = field(default=None, metadata=addr("prp")) + fees_collected: int | None = field(default=None, metadata=wire("fc")) + bonus: int | None = field(default=None, metadata=wire("bi")) + proposer_payout: int | None = field(default=None, metadata=wire("pp")) + reward_state: RewardState = field( + default_factory=RewardState, + metadata=flatten(lambda: RewardState), + ) + upgrade_state: UpgradeState = field( + default_factory=UpgradeState, + metadata=flatten(lambda: UpgradeState), + ) + upgrade_vote: UpgradeVote | None = field( + default=None, + metadata=flatten(lambda: UpgradeVote), + ) + txn_counter: int | None = field(default=None, metadata=wire("tc")) + state_proof_tracking: BlockStateProofTracking | None = field( + default=None, + metadata=wire( + "spt", + encode=mapping_encoder(lambda: BlockStateProofTrackingData), + decode=mapping_decoder( + lambda: BlockStateProofTrackingData, + key_decoder=_decode_state_proof_tracking_key, + ), + ), + ) + participation_updates: ParticipationUpdates = field( + default_factory=ParticipationUpdates, + metadata=flatten(lambda: ParticipationUpdates), + ) + + +@dataclass(slots=True) +class Block: + """Block header fields and transactions for a ledger round.""" + + header: BlockHeader = field(metadata=flatten(lambda: BlockHeader)) + payset: list[SignedTxnInBlock] | None = field( + default=None, + metadata=wire( + "txns", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: SignedTxnInBlock, raw), + ), + ) + + def __post_init__(self) -> None: + # populates genesis id and hash on transactions if required to ensure + # tx id's are correct + genesis_id = self.header.genesis_id + genesis_hash = self.header.genesis_hash + set_frozen_field = object.__setattr__ + for txn_in_block in self.payset or []: + txn = txn_in_block.signed_transaction.signed_transaction.txn + + if txn_in_block.has_genesis_id and txn.genesis_id is None: + set_frozen_field(txn, "genesis_id", genesis_id) + + # the following assumes that Consensus.RequireGenesisHash is true + # so assigns genesis hash unless explicitly set to False + if txn_in_block.has_genesis_hash is not False and txn.genesis_hash is None: + set_frozen_field(txn, "genesis_hash", genesis_hash) + + +@dataclass(slots=True) +class BlockResponse: + """Response payload for the get block endpoint (with optional certificate).""" + + block: Block = field(metadata=nested("block", lambda: Block)) + cert: dict[str, object] | None = field(default=None, metadata=wire("cert")) diff --git a/src/algokit_algod_client/models/_block_hash_response.py b/src/algokit_algod_client/models/_block_hash_response.py new file mode 100644 index 00000000..e6b7250d --- /dev/null +++ b/src/algokit_algod_client/models/_block_hash_response.py @@ -0,0 +1,14 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class BlockHashResponse: + block_hash: str = field( + default="", + metadata=wire("blockHash"), + ) diff --git a/src/algokit_algod_client/models/_block_txids_response.py b/src/algokit_algod_client/models/_block_txids_response.py new file mode 100644 index 00000000..4596ac8f --- /dev/null +++ b/src/algokit_algod_client/models/_block_txids_response.py @@ -0,0 +1,14 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class BlockTxidsResponse: + block_tx_ids: list[str] = field( + default_factory=list, + metadata=wire("blockTxids"), + ) diff --git a/src/algokit_algod_client/models/_box.py b/src/algokit_algod_client/models/_box.py new file mode 100644 index 00000000..d8a90333 --- /dev/null +++ b/src/algokit_algod_client/models/_box.py @@ -0,0 +1,36 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class Box: + """ + Box name and its content. + """ + + name: bytes = field( + default=b"", + metadata=wire( + "name", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + round_: int = field( + default=0, + metadata=wire("round"), + ) + value: bytes = field( + default=b"", + metadata=wire( + "value", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_algod_client/models/_box_descriptor.py b/src/algokit_algod_client/models/_box_descriptor.py new file mode 100644 index 00000000..15b178d6 --- /dev/null +++ b/src/algokit_algod_client/models/_box_descriptor.py @@ -0,0 +1,24 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class BoxDescriptor: + """ + Box descriptor describes a Box. + """ + + name: bytes = field( + default=b"", + metadata=wire( + "name", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_algod_client/models/_boxes_response.py b/src/algokit_algod_client/models/_boxes_response.py new file mode 100644 index 00000000..b7d7c4de --- /dev/null +++ b/src/algokit_algod_client/models/_boxes_response.py @@ -0,0 +1,21 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._box_descriptor import BoxDescriptor +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class BoxesResponse: + boxes: list[BoxDescriptor] = field( + default_factory=list, + metadata=wire( + "boxes", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: BoxDescriptor, raw), + ), + ) diff --git a/src/algokit_algod_client/models/_build_version_contains_the_current_algod_build_version_information.py b/src/algokit_algod_client/models/_build_version_contains_the_current_algod_build_version_information.py new file mode 100644 index 00000000..9e8a6163 --- /dev/null +++ b/src/algokit_algod_client/models/_build_version_contains_the_current_algod_build_version_information.py @@ -0,0 +1,34 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class BuildVersionContainsTheCurrentAlgodBuildVersionInformation: + branch: str = field( + default="", + metadata=wire("branch"), + ) + build_number: int = field( + default=0, + metadata=wire("build_number"), + ) + channel: str = field( + default="", + metadata=wire("channel"), + ) + commit_hash: str = field( + default="", + metadata=wire("commit_hash"), + ) + major: int = field( + default=0, + metadata=wire("major"), + ) + minor: int = field( + default=0, + metadata=wire("minor"), + ) diff --git a/src/algokit_algod_client/models/_compile_response.py b/src/algokit_algod_client/models/_compile_response.py new file mode 100644 index 00000000..7616d142 --- /dev/null +++ b/src/algokit_algod_client/models/_compile_response.py @@ -0,0 +1,24 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._source_map import SourceMap + + +@dataclass(slots=True) +class CompileResponse: + hash_: str = field( + default="", + metadata=wire("hash"), + ) + result: str = field( + default="", + metadata=wire("result"), + ) + sourcemap: SourceMap | None = field( + default=None, + metadata=nested("sourcemap", lambda: SourceMap), + ) diff --git a/src/algokit_algod_client/models/_disassemble_response.py b/src/algokit_algod_client/models/_disassemble_response.py new file mode 100644 index 00000000..d595fcc9 --- /dev/null +++ b/src/algokit_algod_client/models/_disassemble_response.py @@ -0,0 +1,14 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class DisassembleResponse: + result: str = field( + default="", + metadata=wire("result"), + ) diff --git a/src/algokit_algod_client/models/_error_response.py b/src/algokit_algod_client/models/_error_response.py new file mode 100644 index 00000000..349f0619 --- /dev/null +++ b/src/algokit_algod_client/models/_error_response.py @@ -0,0 +1,22 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class ErrorResponse: + """ + An error response with optional data field. + """ + + message: str = field( + default="", + metadata=wire("message"), + ) + data: dict[str, object] | None = field( + default=None, + metadata=wire("data"), + ) diff --git a/src/algokit_algod_client/models/_eval_delta.py b/src/algokit_algod_client/models/_eval_delta.py new file mode 100644 index 00000000..d76b01d6 --- /dev/null +++ b/src/algokit_algod_client/models/_eval_delta.py @@ -0,0 +1,32 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes_base64, encode_bytes + + +@dataclass(slots=True) +class EvalDelta: + """ + Represents a TEAL value delta. + """ + + action: int = field( + default=0, + metadata=wire("action"), + ) + bytes_: bytes | None = field( + default=None, + metadata=wire( + "bytes", + encode=encode_bytes, + decode=decode_bytes_base64, + ), + ) + uint: int | None = field( + default=None, + metadata=wire("uint"), + ) diff --git a/src/algokit_algod_client/models/_eval_delta_key_value.py b/src/algokit_algod_client/models/_eval_delta_key_value.py new file mode 100644 index 00000000..58f7450c --- /dev/null +++ b/src/algokit_algod_client/models/_eval_delta_key_value.py @@ -0,0 +1,28 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._eval_delta import EvalDelta +from ._serde_helpers import decode_bytes_base64, encode_bytes + + +@dataclass(slots=True) +class EvalDeltaKeyValue: + """ + Key-value pairs for StateDelta. + """ + + value: EvalDelta = field( + metadata=nested("value", lambda: EvalDelta, required=True), + ) + key: bytes = field( + default=b"", + metadata=wire( + "key", + encode=encode_bytes, + decode=decode_bytes_base64, + ), + ) diff --git a/src/algokit_algod_client/models/_genesis_file_in_json.py b/src/algokit_algod_client/models/_genesis_file_in_json.py new file mode 100644 index 00000000..c1ccec0d --- /dev/null +++ b/src/algokit_algod_client/models/_genesis_file_in_json.py @@ -0,0 +1,53 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._allocations_for_genesis_file import AllocationsForGenesisFile +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class GenesisFileInJson: + alloc: list[AllocationsForGenesisFile] = field( + default_factory=list, + metadata=wire( + "alloc", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: AllocationsForGenesisFile, raw), + ), + ) + fees: str = field( + default="", + metadata=wire("fees"), + ) + id_: str = field( + default="", + metadata=wire("id"), + ) + network: str = field( + default="", + metadata=wire("network"), + ) + proto: str = field( + default="", + metadata=wire("proto"), + ) + rwd: str = field( + default="", + metadata=wire("rwd"), + ) + comment: str | None = field( + default=None, + metadata=wire("comment"), + ) + devmode: bool | None = field( + default=None, + metadata=wire("devmode"), + ) + timestamp: int | None = field( + default=None, + metadata=wire("timestamp"), + ) diff --git a/src/algokit_algod_client/models/_get_block_time_stamp_offset_response.py b/src/algokit_algod_client/models/_get_block_time_stamp_offset_response.py new file mode 100644 index 00000000..feb7f27c --- /dev/null +++ b/src/algokit_algod_client/models/_get_block_time_stamp_offset_response.py @@ -0,0 +1,14 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class GetBlockTimeStampOffsetResponse: + offset: int = field( + default=0, + metadata=wire("offset"), + ) diff --git a/src/algokit_algod_client/models/_get_sync_round_response.py b/src/algokit_algod_client/models/_get_sync_round_response.py new file mode 100644 index 00000000..06b9557d --- /dev/null +++ b/src/algokit_algod_client/models/_get_sync_round_response.py @@ -0,0 +1,14 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class GetSyncRoundResponse: + round_: int = field( + default=0, + metadata=wire("round"), + ) diff --git a/src/algokit_algod_client/models/_ledger_state_delta.py b/src/algokit_algod_client/models/_ledger_state_delta.py new file mode 100644 index 00000000..c37edaf2 --- /dev/null +++ b/src/algokit_algod_client/models/_ledger_state_delta.py @@ -0,0 +1,389 @@ +# AUTO-GENERATED: oas_generator +from __future__ import annotations + +from dataclasses import dataclass, field + +from algokit_common.serde import addr, flatten, nested, wire + +from ._block import Block +from ._serde_helpers import ( + decode_bytes_map_key, + decode_model_sequence, + encode_bytes, + encode_model_sequence, + mapping_decoder, + mapping_encoder, +) + +__all__ = [ + "LedgerAccountBaseData", + "LedgerAccountData", + "LedgerAccountDeltas", + "LedgerAccountTotals", + "LedgerAlgoCount", + "LedgerAppLocalState", + "LedgerAppLocalStateDelta", + "LedgerAppParams", + "LedgerAppParamsDelta", + "LedgerAppResourceRecord", + "LedgerAssetHolding", + "LedgerAssetHoldingDelta", + "LedgerAssetParams", + "LedgerAssetParamsDelta", + "LedgerAssetResourceRecord", + "LedgerBalanceRecord", + "LedgerIncludedTransactions", + "LedgerKvValueDelta", + "LedgerModifiedCreatable", + "LedgerStateDelta", + "LedgerStateDeltaForTransactionGroup", + "LedgerStateSchema", + "LedgerTealValue", + "LedgerVotingData", + "TransactionGroupLedgerStateDeltasForRound", +] + + +def _encode_bytes_key(key: object) -> str: + if isinstance(key, bytes): + return encode_bytes(key) + if isinstance(key, memoryview | bytearray): + return encode_bytes(bytes(key)) + raise TypeError("Ledger map keys must be bytes-like") + + +def _encode_numeric_key(key: object) -> str: + if isinstance(key, bool): + return str(int(key)) + if isinstance(key, int): + return str(key) + if isinstance(key, str): + return str(int(key)) + raise TypeError("Ledger map keys must be numeric") + + +def _decode_numeric_key(key: object) -> int: + if isinstance(key, int): + return key + if isinstance(key, str): + return int(key) + raise TypeError("Ledger map keys must be numeric") + + +@dataclass(slots=True) +class LedgerTealValue: + """Type and value for TEAL key-value entries.""" + + type: int = field(metadata=wire("tt", required=True)) + bytes_: bytes | None = field(default=None, metadata=wire("tb")) + uint: int | None = field(default=None, metadata=wire("ui")) + + +@dataclass(slots=True) +class LedgerStateSchema: + """Maximum counts for values stored in state.""" + + num_uints: int | None = field(default=None, metadata=wire("nui")) + num_byte_slices: int | None = field(default=None, metadata=wire("nbs")) + + +@dataclass(slots=True) +class LedgerAppParams: + """Application parameters in ledger deltas.""" + + approval_program: bytes = field(metadata=wire("approv", required=True)) + clear_state_program: bytes = field(metadata=wire("clearp", required=True)) + extra_program_pages: int | None = field(default=None, metadata=wire("epp")) + version: int | None = field(default=None, metadata=wire("v")) + size_sponsor: str | None = field(default=None, metadata=addr("ss")) + local_state_schema: LedgerStateSchema | None = field( + default=None, metadata=nested("lsch", lambda: LedgerStateSchema) + ) + global_state_schema: LedgerStateSchema | None = field( + default=None, metadata=nested("gsch", lambda: LedgerStateSchema) + ) + global_state: dict[bytes, LedgerTealValue] | None = field( + default=None, + metadata=wire( + "gs", + encode=mapping_encoder(lambda: LedgerTealValue, key_encoder=_encode_bytes_key), + decode=mapping_decoder(lambda: LedgerTealValue, key_decoder=decode_bytes_map_key), + ), + ) + + +@dataclass(slots=True) +class LedgerAppLocalState: + """Local state information for an application.""" + + schema: LedgerStateSchema | None = field(default=None, metadata=nested("hsch", lambda: LedgerStateSchema)) + key_value: dict[bytes, LedgerTealValue] | None = field( + default=None, + metadata=wire( + "tkv", + encode=mapping_encoder(lambda: LedgerTealValue, key_encoder=_encode_bytes_key), + decode=mapping_decoder(lambda: LedgerTealValue, key_decoder=decode_bytes_map_key), + ), + ) + + +@dataclass(slots=True) +class LedgerAppLocalStateDelta: + """Tracks changes to an application's local state.""" + + deleted: bool = field(metadata=wire("Deleted", required=True)) + local_state: LedgerAppLocalState | None = field( + default=None, + metadata=nested("LocalState", lambda: LedgerAppLocalState), + ) + + +@dataclass(slots=True) +class LedgerAppParamsDelta: + """Tracks changes to application parameters.""" + + deleted: bool = field(metadata=wire("Deleted", required=True)) + params: LedgerAppParams | None = field(default=None, metadata=nested("Params", lambda: LedgerAppParams)) + + +@dataclass(slots=True) +class LedgerAppResourceRecord: + """App params and local state changes keyed by app and address.""" + + app_id: int = field(metadata=wire("Aidx", required=True)) + address: str = field(metadata=addr("Addr")) + params: LedgerAppParamsDelta = field(metadata=nested("Params", lambda: LedgerAppParamsDelta)) + state: LedgerAppLocalStateDelta = field(metadata=nested("State", lambda: LedgerAppLocalStateDelta)) + + +@dataclass(slots=True) +class LedgerAssetHolding: + """Asset holding details in ledger deltas.""" + + amount: int | None = field(default=None, metadata=wire("a")) + frozen: bool | None = field(default=None, metadata=wire("f")) + + +@dataclass(slots=True) +class LedgerAssetHoldingDelta: + """Tracks a changed asset holding.""" + + deleted: bool = field(metadata=wire("Deleted", required=True)) + holding: LedgerAssetHolding | None = field(default=None, metadata=nested("Holding", lambda: LedgerAssetHolding)) + + +@dataclass(slots=True) +class LedgerAssetParams: + """Asset parameters reflected in ledger deltas.""" + + total: int = field(metadata=wire("t", required=True)) + decimals: int = field(metadata=wire("dc", required=True)) + default_frozen: bool | None = field(default=None, metadata=wire("df")) + unit_name: str | None = field(default=None, metadata=wire("un")) + asset_name: str | None = field(default=None, metadata=wire("an")) + url: str | None = field(default=None, metadata=wire("au")) + metadata_hash: bytes | None = field(default=None, metadata=wire("am")) + manager: str | None = field(default=None, metadata=addr("m")) + reserve: str | None = field(default=None, metadata=addr("r")) + freeze: str | None = field(default=None, metadata=addr("f")) + clawback: str | None = field(default=None, metadata=addr("c")) + + +@dataclass(slots=True) +class LedgerAssetParamsDelta: + """Tracks updates to asset parameters.""" + + deleted: bool = field(metadata=wire("Deleted", required=True)) + params: LedgerAssetParams | None = field(default=None, metadata=nested("Params", lambda: LedgerAssetParams)) + + +@dataclass(slots=True) +class LedgerAssetResourceRecord: + """Asset params and holding changes keyed by asset and address.""" + + asset_id: int = field(metadata=wire("Aidx", required=True)) + address: str = field(metadata=addr("Addr")) + params: LedgerAssetParamsDelta = field(metadata=nested("Params", lambda: LedgerAssetParamsDelta)) + holding: LedgerAssetHoldingDelta = field(metadata=nested("Holding", lambda: LedgerAssetHoldingDelta)) + + +@dataclass(slots=True) +class LedgerVotingData: + """Participation-related voting data.""" + + vote_id: bytes = field(metadata=wire("VoteID", required=True)) + selection_id: bytes = field(metadata=wire("SelectionID", required=True)) + state_proof_id: bytes = field(metadata=wire("StateProofID", required=True)) + vote_first_valid: int = field(metadata=wire("VoteFirstValid", required=True)) + vote_last_valid: int = field(metadata=wire("VoteLastValid", required=True)) + vote_key_dilution: int = field(metadata=wire("VoteKeyDilution", required=True)) + + +@dataclass(slots=True) +class LedgerAccountBaseData: + """Base account data captured in ledger deltas.""" + + status: int = field(metadata=wire("Status", required=True)) + micro_algos: int = field(metadata=wire("MicroAlgos", required=True)) + rewards_base: int = field(metadata=wire("RewardsBase", required=True)) + rewarded_micro_algos: int = field(metadata=wire("RewardedMicroAlgos", required=True)) + auth_address: str = field(metadata=addr("AuthAddr")) + incentive_eligible: bool = field(metadata=wire("IncentiveEligible", required=True)) + total_app_schema: LedgerStateSchema = field(metadata=nested("TotalAppSchema", lambda: LedgerStateSchema)) + total_extra_app_pages: int = field(metadata=wire("TotalExtraAppPages", required=True)) + total_app_params: int = field(metadata=wire("TotalAppParams", required=True)) + total_app_local_states: int = field(metadata=wire("TotalAppLocalStates", required=True)) + total_asset_params: int = field(metadata=wire("TotalAssetParams", required=True)) + total_assets: int = field(metadata=wire("TotalAssets", required=True)) + total_boxes: int = field(metadata=wire("TotalBoxes", required=True)) + total_box_bytes: int = field(metadata=wire("TotalBoxBytes", required=True)) + last_proposed: int = field(metadata=wire("LastProposed", required=True)) + last_heartbeat: int = field(metadata=wire("LastHeartbeat", required=True)) + + +@dataclass(slots=True) +class LedgerAccountData: + """Aggregates base and voting data for an account.""" + + account_base_data: LedgerAccountBaseData = field(metadata=flatten(lambda: LedgerAccountBaseData)) + voting_data: LedgerVotingData = field(metadata=flatten(lambda: LedgerVotingData)) + + +@dataclass(slots=True) +class LedgerBalanceRecord: + """Account data keyed by address.""" + + address: str = field(metadata=addr("Addr")) + account_data: LedgerAccountData = field(metadata=flatten(lambda: LedgerAccountData)) + + +@dataclass(slots=True) +class LedgerAccountDeltas: + """Account/app/asset updates included in a ledger delta.""" + + accounts: list[LedgerBalanceRecord] | None = field( + default=None, + metadata=wire( + "Accts", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: LedgerBalanceRecord, raw), + ), + ) + app_resources: list[LedgerAppResourceRecord] | None = field( + default=None, + metadata=wire( + "AppResources", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: LedgerAppResourceRecord, raw), + ), + ) + asset_resources: list[LedgerAssetResourceRecord] | None = field( + default=None, + metadata=wire( + "AssetResources", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: LedgerAssetResourceRecord, raw), + ), + ) + + +@dataclass(slots=True) +class LedgerKvValueDelta: + """Delta for a single key/value entry in the KV store.""" + + data: bytes | None = field(default=None, metadata=wire("Data")) + old_data: bytes | None = field(default=None, metadata=wire("OldData")) + + +@dataclass(slots=True) +class LedgerIncludedTransactions: + """Transaction placement information.""" + + last_valid: int = field(metadata=wire("LastValid", required=True)) + intra: int = field(metadata=wire("Intra", required=True)) + + +@dataclass(slots=True) +class LedgerModifiedCreatable: + """Changes to a creatable resource.""" + + creatable_type: int = field(metadata=wire("Ctype", required=True)) + created: bool = field(metadata=wire("Created", required=True)) + creator: str = field(metadata=addr("Creator")) + ndeltas: int = field(metadata=wire("Ndeltas", required=True)) + + +@dataclass(slots=True) +class LedgerAlgoCount: + """Totals for groups of accounts.""" + + money: int = field(metadata=wire("mon", required=True)) + reward_units: int = field(metadata=wire("rwd", required=True)) + + +@dataclass(slots=True) +class LedgerAccountTotals: + """Aggregate Algo totals grouped by account status.""" + + online: LedgerAlgoCount = field(metadata=nested("online", lambda: LedgerAlgoCount)) + offline: LedgerAlgoCount = field(metadata=nested("offline", lambda: LedgerAlgoCount)) + not_participating: LedgerAlgoCount = field(metadata=nested("notpart", lambda: LedgerAlgoCount)) + rewards_level: int = field(metadata=wire("rwdlvl", required=True)) + + +@dataclass(slots=True) +class LedgerStateDelta: + """State delta between rounds.""" + + accounts: LedgerAccountDeltas = field(metadata=nested("Accts", lambda: LedgerAccountDeltas)) + block: Block = field(metadata=nested("Hdr", lambda: Block)) + state_proof_next: int = field(metadata=wire("StateProofNext", required=True)) + prev_timestamp: int = field(metadata=wire("PrevTimestamp", required=True)) + totals: LedgerAccountTotals = field(metadata=nested("Totals", lambda: LedgerAccountTotals)) + kv_mods: dict[bytes, LedgerKvValueDelta] | None = field( + default=None, + metadata=wire( + "KvMods", + encode=mapping_encoder(lambda: LedgerKvValueDelta, key_encoder=_encode_bytes_key), + decode=mapping_decoder(lambda: LedgerKvValueDelta, key_decoder=decode_bytes_map_key), + ), + ) + tx_ids: dict[bytes, LedgerIncludedTransactions] | None = field( + default=None, + metadata=wire( + "Txids", + encode=mapping_encoder(lambda: LedgerIncludedTransactions, key_encoder=_encode_bytes_key), + decode=mapping_decoder(lambda: LedgerIncludedTransactions, key_decoder=decode_bytes_map_key), + ), + ) + # NOTE: tx_leases field is intentionally omitted - msgpack maps with object keys are not supported + creatables: dict[int, LedgerModifiedCreatable] | None = field( + default=None, + metadata=wire( + "Creatables", + encode=mapping_encoder(lambda: LedgerModifiedCreatable, key_encoder=_encode_numeric_key), + decode=mapping_decoder(lambda: LedgerModifiedCreatable, key_decoder=_decode_numeric_key), + ), + ) + + +@dataclass(slots=True) +class LedgerStateDeltaForTransactionGroup: + """Ledger delta for a single transaction group.""" + + delta: LedgerStateDelta = field(metadata=nested("Delta", lambda: LedgerStateDelta)) + ids: list[str] = field(metadata=wire("Ids", required=True)) + + +@dataclass(slots=True) +class TransactionGroupLedgerStateDeltasForRound: + """All ledger deltas for transaction groups in a round.""" + + deltas: list[LedgerStateDeltaForTransactionGroup] = field( + metadata=wire( + "Deltas", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: LedgerStateDeltaForTransactionGroup, raw), + required=True, + ) + ) diff --git a/src/algokit_algod_client/models/_light_block_header_proof.py b/src/algokit_algod_client/models/_light_block_header_proof.py new file mode 100644 index 00000000..d70cfa9a --- /dev/null +++ b/src/algokit_algod_client/models/_light_block_header_proof.py @@ -0,0 +1,32 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class LightBlockHeaderProof: + """ + Proof of membership and position of a light block header. + """ + + index: int = field( + default=0, + metadata=wire("index"), + ) + proof: bytes = field( + default=b"", + metadata=wire( + "proof", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + treedepth: int = field( + default=0, + metadata=wire("treedepth"), + ) diff --git a/src/algokit_algod_client/models/_node_status_response.py b/src/algokit_algod_client/models/_node_status_response.py new file mode 100644 index 00000000..4cc358bd --- /dev/null +++ b/src/algokit_algod_client/models/_node_status_response.py @@ -0,0 +1,118 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class NodeStatusResponse: + """ + NodeStatus contains the information about a node status + """ + + catchup_time: int = field( + default=0, + metadata=wire("catchup-time"), + ) + last_round: int = field( + default=0, + metadata=wire("last-round"), + ) + last_version: str = field( + default="", + metadata=wire("last-version"), + ) + next_version: str = field( + default="", + metadata=wire("next-version"), + ) + next_version_round: int = field( + default=0, + metadata=wire("next-version-round"), + ) + next_version_supported: bool = field( + default=False, + metadata=wire("next-version-supported"), + ) + stopped_at_unsupported_round: bool = field( + default=False, + metadata=wire("stopped-at-unsupported-round"), + ) + time_since_last_round: int = field( + default=0, + metadata=wire("time-since-last-round"), + ) + catchpoint: str | None = field( + default=None, + metadata=wire("catchpoint"), + ) + catchpoint_acquired_blocks: int | None = field( + default=None, + metadata=wire("catchpoint-acquired-blocks"), + ) + catchpoint_processed_accounts: int | None = field( + default=None, + metadata=wire("catchpoint-processed-accounts"), + ) + catchpoint_processed_kvs: int | None = field( + default=None, + metadata=wire("catchpoint-processed-kvs"), + ) + catchpoint_total_accounts: int | None = field( + default=None, + metadata=wire("catchpoint-total-accounts"), + ) + catchpoint_total_blocks: int | None = field( + default=None, + metadata=wire("catchpoint-total-blocks"), + ) + catchpoint_total_kvs: int | None = field( + default=None, + metadata=wire("catchpoint-total-kvs"), + ) + catchpoint_verified_accounts: int | None = field( + default=None, + metadata=wire("catchpoint-verified-accounts"), + ) + catchpoint_verified_kvs: int | None = field( + default=None, + metadata=wire("catchpoint-verified-kvs"), + ) + last_catchpoint: str | None = field( + default=None, + metadata=wire("last-catchpoint"), + ) + upgrade_delay: int | None = field( + default=None, + metadata=wire("upgrade-delay"), + ) + upgrade_next_protocol_vote_before: int | None = field( + default=None, + metadata=wire("upgrade-next-protocol-vote-before"), + ) + upgrade_no_votes: int | None = field( + default=None, + metadata=wire("upgrade-no-votes"), + ) + upgrade_node_vote: bool | None = field( + default=None, + metadata=wire("upgrade-node-vote"), + ) + upgrade_vote_rounds: int | None = field( + default=None, + metadata=wire("upgrade-vote-rounds"), + ) + upgrade_votes: int | None = field( + default=None, + metadata=wire("upgrade-votes"), + ) + upgrade_votes_required: int | None = field( + default=None, + metadata=wire("upgrade-votes-required"), + ) + upgrade_yes_votes: int | None = field( + default=None, + metadata=wire("upgrade-yes-votes"), + ) diff --git a/src/algokit_algod_client/models/_pending_transaction_response.py b/src/algokit_algod_client/models/_pending_transaction_response.py new file mode 100644 index 00000000..1ce5b51b --- /dev/null +++ b/src/algokit_algod_client/models/_pending_transaction_response.py @@ -0,0 +1,96 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire +from algokit_transact.models.signed_transaction import SignedTransaction + +from ._account_state_delta import AccountStateDelta +from ._eval_delta_key_value import EvalDeltaKeyValue +from ._serde_helpers import ( + decode_bytes_sequence, + decode_model_sequence, + encode_bytes_sequence, + encode_model_sequence, +) + + +@dataclass(slots=True) +class PendingTransactionResponse: + """ + Details about a pending transaction. If the transaction was recently confirmed, includes + confirmation details like the round and reward details. + """ + + txn: SignedTransaction = field( + metadata=nested("txn", lambda: SignedTransaction, required=True), + ) + pool_error: str = field( + default="", + metadata=wire("pool-error"), + ) + app_id: int | None = field( + default=None, + metadata=wire("application-index"), + ) + asset_closing_amount: int | None = field( + default=None, + metadata=wire("asset-closing-amount"), + ) + asset_id: int | None = field( + default=None, + metadata=wire("asset-index"), + ) + close_rewards: int | None = field( + default=None, + metadata=wire("close-rewards"), + ) + closing_amount: int | None = field( + default=None, + metadata=wire("closing-amount"), + ) + confirmed_round: int | None = field( + default=None, + metadata=wire("confirmed-round"), + ) + global_state_delta: list[EvalDeltaKeyValue] | None = field( + default=None, + metadata=wire( + "global-state-delta", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: EvalDeltaKeyValue, raw), + ), + ) + inner_txns: list["PendingTransactionResponse"] | None = field( + default=None, + metadata=wire( + "inner-txns", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: PendingTransactionResponse, raw), + ), + ) + local_state_delta: list[AccountStateDelta] | None = field( + default=None, + metadata=wire( + "local-state-delta", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: AccountStateDelta, raw), + ), + ) + logs: list[bytes] | None = field( + default=None, + metadata=wire( + "logs", + encode=encode_bytes_sequence, + decode=decode_bytes_sequence, + ), + ) + receiver_rewards: int | None = field( + default=None, + metadata=wire("receiver-rewards"), + ) + sender_rewards: int | None = field( + default=None, + metadata=wire("sender-rewards"), + ) diff --git a/src/algokit_algod_client/models/_pending_transactions_response.py b/src/algokit_algod_client/models/_pending_transactions_response.py new file mode 100644 index 00000000..51f0ea71 --- /dev/null +++ b/src/algokit_algod_client/models/_pending_transactions_response.py @@ -0,0 +1,29 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire +from algokit_transact.models.signed_transaction import SignedTransaction + +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class PendingTransactionsResponse: + """ + PendingTransactions is an array of signed transactions exactly as they were submitted. + """ + + top_transactions: list[SignedTransaction] = field( + default_factory=list, + metadata=wire( + "top-transactions", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: SignedTransaction, raw), + ), + ) + total_transactions: int = field( + default=0, + metadata=wire("total-transactions"), + ) diff --git a/src/algokit_algod_client/models/_post_transactions_response.py b/src/algokit_algod_client/models/_post_transactions_response.py new file mode 100644 index 00000000..2bc27080 --- /dev/null +++ b/src/algokit_algod_client/models/_post_transactions_response.py @@ -0,0 +1,14 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class PostTransactionsResponse: + tx_id: str = field( + default="", + metadata=wire("txId"), + ) diff --git a/src/algokit_algod_client/models/_scratch_change.py b/src/algokit_algod_client/models/_scratch_change.py new file mode 100644 index 00000000..abd1d853 --- /dev/null +++ b/src/algokit_algod_client/models/_scratch_change.py @@ -0,0 +1,23 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._avm_value import AvmValue + + +@dataclass(slots=True) +class ScratchChange: + """ + A write operation into a scratch slot. + """ + + new_value: AvmValue = field( + metadata=nested("new-value", lambda: AvmValue, required=True), + ) + slot: int = field( + default=0, + metadata=wire("slot"), + ) diff --git a/src/algokit_algod_client/models/_serde_helpers.py b/src/algokit_algod_client/models/_serde_helpers.py new file mode 100644 index 00000000..8d99c04f --- /dev/null +++ b/src/algokit_algod_client/models/_serde_helpers.py @@ -0,0 +1,254 @@ +# AUTO-GENERATED: oas_generator +import base64 +from binascii import Error as BinasciiError +from collections.abc import Callable, Iterable, Mapping +from dataclasses import is_dataclass +from enum import Enum +from typing import TypeAlias, TypeVar + +from algokit_common.serde import from_wire, to_wire + +DecodedT = TypeVar("DecodedT") +EnumValueT = TypeVar("EnumValueT", bound=Enum) +MapKeyT = TypeVar("MapKeyT") +BytesLike: TypeAlias = bytes | bytearray | memoryview + + +def _coerce_bytes(value: bytes | bytearray | memoryview) -> bytes: + if isinstance(value, memoryview | bytearray): + return bytes(value) + return value + + +def encode_bytes(value: BytesLike) -> str: + return base64.b64encode(_coerce_bytes(value)).decode("ascii") + + +def decode_bytes(raw: object) -> bytes: + """Decode bytes that may be raw (msgpack) or base64-encoded (JSON).""" + if isinstance(raw, bytes | bytearray | memoryview): + return bytes(raw) + if isinstance(raw, str): + try: + return base64.b64decode(raw.encode("ascii"), validate=True) + except (BinasciiError, UnicodeEncodeError) as exc: + raise ValueError("Invalid base64 payload") from exc + raise TypeError(f"Unsupported value for bytes field: {type(raw)!r}") + + +def decode_bytes_base64(raw: object) -> bytes: + """Decode bytes that are always base64-encoded strings (even in msgpack). + + Used for fields marked with x-algokit-bytes-base64 in the OpenAPI spec. + These fields contain base64-encoded strings in both JSON and msgpack responses. + """ + if isinstance(raw, bytes | bytearray | memoryview | str): + try: + return base64.b64decode(raw, validate=True) + except (BinasciiError, ValueError, UnicodeEncodeError) as exc: + raise ValueError("Invalid base64 payload") from exc + raise TypeError(f"Unsupported value for bytes field: {type(raw)!r}") + + +def encode_fixed_bytes(value: BytesLike, expected_length: int) -> str: + """Encode fixed-length bytes to base64, validating the length.""" + coerced = _coerce_bytes(value) + if len(coerced) != expected_length: + raise ValueError(f"Expected {expected_length} bytes, got {len(coerced)}") + return base64.b64encode(coerced).decode("ascii") + + +def decode_fixed_bytes(raw: object, expected_length: int) -> bytes: + """Decode base64 to fixed-length bytes, validating the length.""" + decoded = decode_bytes(raw) + if len(decoded) != expected_length: + raise ValueError(f"Expected {expected_length} bytes, got {len(decoded)}") + return decoded + + +def decode_bytes_map_key(raw: object) -> bytes: + if isinstance(raw, bytes | bytearray | memoryview): + return bytes(raw) + if isinstance(raw, str): + # note: this is undoing the implicit bytes -> str conversion that + # _coerce_msgpack_key does in client.py + # as long as "strict" was used to encode the str then this should be safe + try: + return raw.encode("utf-8", errors="strict") + except UnicodeEncodeError as fallback_exc: + raise ValueError("Invalid bytes map key") from fallback_exc + raise TypeError(f"Unsupported map key for bytes field: {type(raw)!r}") + + +def encode_bytes_sequence(values: Iterable[BytesLike | None] | None) -> list[str | None] | None: + if values is None: + return None + encoded: list[str | None] = [] + for value in values: + if value is None: + encoded.append(None) + continue + if not isinstance(value, bytes | bytearray | memoryview): + raise TypeError(f"Unsupported value for bytes field sequence: {type(value)!r}") + encoded.append(encode_bytes(value)) + return encoded or None + + +def decode_bytes_sequence(raw: object) -> list[bytes | None] | None: + if not isinstance(raw, list): + return None + decoded: list[bytes | None] = [] + for item in raw: + if item is None: + decoded.append(None) + continue + decoded.append(decode_bytes(item)) + return decoded or None + + +def encode_fixed_bytes_sequence( + values: Iterable[BytesLike | None] | None, expected_length: int +) -> list[str | None] | None: + """Encode a sequence of fixed-length bytes to base64, validating each element's length.""" + if values is None: + return None + encoded: list[str | None] = [] + for value in values: + if value is None: + encoded.append(None) + continue + if not isinstance(value, bytes | bytearray | memoryview): + raise TypeError(f"Unsupported value for bytes field sequence: {type(value)!r}") + encoded.append(encode_fixed_bytes(value, expected_length)) + return encoded or None + + +def decode_fixed_bytes_sequence(raw: object, expected_length: int) -> list[bytes | None] | None: + """Decode a sequence of base64 strings to fixed-length bytes, validating each element's length.""" + if not isinstance(raw, list): + return None + decoded: list[bytes | None] = [] + for item in raw: + if item is None: + decoded.append(None) + continue + decoded.append(decode_fixed_bytes(item, expected_length)) + return decoded or None + + +def encode_model_sequence(values: Iterable[object] | None) -> list[dict[str, object]] | None: + if values is None: + return None + encoded: list[dict[str, object]] = [] + for value in values: + if value is None: + continue + encoded.append(to_wire(value)) + return encoded or None + + +def decode_model_sequence(cls_factory: Callable[[], type[DecodedT]], raw: object) -> list[DecodedT] | None: + if not isinstance(raw, list): + return None + cls = cls_factory() + decoded: list[DecodedT] = [] + for item in raw: + if isinstance(item, Mapping): + decoded.append(from_wire(cls, item)) + return decoded or None + + +def encode_enum_sequence(values: Iterable[object] | None) -> list[object] | None: + if values is None: + return None + encoded: list[object] = [] + for value in values: + if value is None: + continue + encoded.append(value.value if hasattr(value, "value") else value) + return encoded or None + + +def decode_enum_sequence(enum_factory: Callable[[], type[EnumValueT]], raw: object) -> list[EnumValueT] | None: + if not isinstance(raw, list): + return None + enum_cls = enum_factory() + decoded: list[EnumValueT] = [] + for item in raw: + try: + decoded.append(enum_cls(item)) + except Exception: + continue + return decoded or None + + +def encode_model_mapping( + factory: Callable[[], type[DecodedT]], + mapping: Mapping[object, object] | None, + *, + key_encoder: Callable[[object], str] | None = None, +) -> dict[str, object] | None: + if mapping is None: + return None + cls = factory() + encoded: dict[str, object] = {} + for key, value in mapping.items(): + if value is None: + continue + encoded_key: str + if key_encoder is not None: + encoded_key = key_encoder(key) + elif isinstance(key, str): + encoded_key = key + else: + encoded_key = str(key) + if isinstance(value, cls) or is_dataclass(value): + encoded[encoded_key] = to_wire(value) + else: + encoded[encoded_key] = value + return encoded or None + + +def decode_model_mapping( + factory: Callable[[], type[DecodedT]], + raw: object, + *, + key_decoder: Callable[[object], MapKeyT] | None = None, +) -> dict[MapKeyT, DecodedT] | None: + if not isinstance(raw, Mapping): + return None + cls = factory() + decoded: dict[MapKeyT, DecodedT] = {} + for key, value in raw.items(): + if isinstance(value, Mapping): + decoded_key = key_decoder(key) if key_decoder is not None else key + decoded[decoded_key] = from_wire(cls, value) + return decoded or None + + +def decode_optional_bool(raw: object) -> bool | None: + if raw is None: + return None + return bool(raw) + + +def mapping_encoder( + factory: Callable[[], type[DecodedT]], + *, + key_encoder: Callable[[object], str] | None = None, +) -> Callable[[Mapping[object, object] | None], dict[str, object] | None]: + def _encode(mapping: Mapping[object, object] | None) -> dict[str, object] | None: + return encode_model_mapping(factory, mapping, key_encoder=key_encoder) + + return _encode + + +def mapping_decoder( + factory: Callable[[], type[DecodedT]], + *, + key_decoder: Callable[[object], MapKeyT] | None = None, +) -> Callable[[object], dict[MapKeyT, DecodedT] | None]: + def _decode(raw: object) -> dict[MapKeyT, DecodedT] | None: + return decode_model_mapping(factory, raw, key_decoder=key_decoder) + + return _decode diff --git a/src/algokit_algod_client/models/_simulate_initial_states.py b/src/algokit_algod_client/models/_simulate_initial_states.py new file mode 100644 index 00000000..03107c1d --- /dev/null +++ b/src/algokit_algod_client/models/_simulate_initial_states.py @@ -0,0 +1,25 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._application_initial_states import ApplicationInitialStates +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class SimulateInitialStates: + """ + Initial states of resources that were accessed during simulation. + """ + + app_initial_states: list[ApplicationInitialStates] | None = field( + default=None, + metadata=wire( + "app-initial-states", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: ApplicationInitialStates, raw), + ), + ) diff --git a/src/algokit_algod_client/models/_simulate_request.py b/src/algokit_algod_client/models/_simulate_request.py new file mode 100644 index 00000000..87100035 --- /dev/null +++ b/src/algokit_algod_client/models/_simulate_request.py @@ -0,0 +1,54 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._serde_helpers import decode_model_sequence, encode_model_sequence +from ._simulate_request_transaction_group import SimulateRequestTransactionGroup +from ._simulate_trace_config import SimulateTraceConfig + + +@dataclass(slots=True) +class SimulateRequest: + """ + Request type for simulation endpoint. + """ + + txn_groups: list[SimulateRequestTransactionGroup] = field( + default_factory=list, + metadata=wire( + "txn-groups", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: SimulateRequestTransactionGroup, raw), + ), + ) + allow_empty_signatures: bool | None = field( + default=None, + metadata=wire("allow-empty-signatures"), + ) + allow_more_logging: bool | None = field( + default=None, + metadata=wire("allow-more-logging"), + ) + allow_unnamed_resources: bool | None = field( + default=None, + metadata=wire("allow-unnamed-resources"), + ) + exec_trace_config: SimulateTraceConfig | None = field( + default=None, + metadata=nested("exec-trace-config", lambda: SimulateTraceConfig), + ) + extra_opcode_budget: int | None = field( + default=None, + metadata=wire("extra-opcode-budget"), + ) + fix_signers: bool | None = field( + default=None, + metadata=wire("fix-signers"), + ) + round_: int | None = field( + default=None, + metadata=wire("round"), + ) diff --git a/src/algokit_algod_client/models/_simulate_request_transaction_group.py b/src/algokit_algod_client/models/_simulate_request_transaction_group.py new file mode 100644 index 00000000..752a729c --- /dev/null +++ b/src/algokit_algod_client/models/_simulate_request_transaction_group.py @@ -0,0 +1,25 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire +from algokit_transact.models.signed_transaction import SignedTransaction + +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class SimulateRequestTransactionGroup: + """ + A transaction group to simulate. + """ + + txns: list[SignedTransaction] = field( + default_factory=list, + metadata=wire( + "txns", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: SignedTransaction, raw), + ), + ) diff --git a/src/algokit_algod_client/models/_simulate_response.py b/src/algokit_algod_client/models/_simulate_response.py new file mode 100644 index 00000000..61655673 --- /dev/null +++ b/src/algokit_algod_client/models/_simulate_response.py @@ -0,0 +1,44 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._serde_helpers import decode_model_sequence, encode_model_sequence +from ._simulate_initial_states import SimulateInitialStates +from ._simulate_trace_config import SimulateTraceConfig +from ._simulate_transaction_group_result import SimulateTransactionGroupResult +from ._simulation_eval_overrides import SimulationEvalOverrides + + +@dataclass(slots=True) +class SimulateResponse: + last_round: int = field( + default=0, + metadata=wire("last-round"), + ) + txn_groups: list[SimulateTransactionGroupResult] = field( + default_factory=list, + metadata=wire( + "txn-groups", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: SimulateTransactionGroupResult, raw), + ), + ) + version: int = field( + default=0, + metadata=wire("version"), + ) + eval_overrides: SimulationEvalOverrides | None = field( + default=None, + metadata=nested("eval-overrides", lambda: SimulationEvalOverrides), + ) + exec_trace_config: SimulateTraceConfig | None = field( + default=None, + metadata=nested("exec-trace-config", lambda: SimulateTraceConfig), + ) + initial_states: SimulateInitialStates | None = field( + default=None, + metadata=nested("initial-states", lambda: SimulateInitialStates), + ) diff --git a/src/algokit_algod_client/models/_simulate_trace_config.py b/src/algokit_algod_client/models/_simulate_trace_config.py new file mode 100644 index 00000000..3f97c554 --- /dev/null +++ b/src/algokit_algod_client/models/_simulate_trace_config.py @@ -0,0 +1,30 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class SimulateTraceConfig: + """ + An object that configures simulation execution trace. + """ + + enable: bool | None = field( + default=None, + metadata=wire("enable"), + ) + scratch_change: bool | None = field( + default=None, + metadata=wire("scratch-change"), + ) + stack_change: bool | None = field( + default=None, + metadata=wire("stack-change"), + ) + state_change: bool | None = field( + default=None, + metadata=wire("state-change"), + ) diff --git a/src/algokit_algod_client/models/_simulate_transaction_group_result.py b/src/algokit_algod_client/models/_simulate_transaction_group_result.py new file mode 100644 index 00000000..819240ee --- /dev/null +++ b/src/algokit_algod_client/models/_simulate_transaction_group_result.py @@ -0,0 +1,46 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._serde_helpers import decode_model_sequence, encode_model_sequence +from ._simulate_transaction_result import SimulateTransactionResult +from ._simulate_unnamed_resources_accessed import SimulateUnnamedResourcesAccessed + + +@dataclass(slots=True) +class SimulateTransactionGroupResult: + """ + Simulation result for an atomic transaction group + """ + + txn_results: list[SimulateTransactionResult] = field( + default_factory=list, + metadata=wire( + "txn-results", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: SimulateTransactionResult, raw), + ), + ) + app_budget_added: int | None = field( + default=None, + metadata=wire("app-budget-added"), + ) + app_budget_consumed: int | None = field( + default=None, + metadata=wire("app-budget-consumed"), + ) + failed_at: list[int] | None = field( + default=None, + metadata=wire("failed-at"), + ) + failure_message: str | None = field( + default=None, + metadata=wire("failure-message"), + ) + unnamed_resources_accessed: SimulateUnnamedResourcesAccessed | None = field( + default=None, + metadata=nested("unnamed-resources-accessed", lambda: SimulateUnnamedResourcesAccessed), + ) diff --git a/src/algokit_algod_client/models/_simulate_transaction_result.py b/src/algokit_algod_client/models/_simulate_transaction_result.py new file mode 100644 index 00000000..f1c3b6c2 --- /dev/null +++ b/src/algokit_algod_client/models/_simulate_transaction_result.py @@ -0,0 +1,41 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._pending_transaction_response import PendingTransactionResponse +from ._simulate_unnamed_resources_accessed import SimulateUnnamedResourcesAccessed +from ._simulation_transaction_exec_trace import SimulationTransactionExecTrace + + +@dataclass(slots=True) +class SimulateTransactionResult: + """ + Simulation result for an individual transaction + """ + + txn_result: PendingTransactionResponse = field( + metadata=nested("txn-result", lambda: PendingTransactionResponse, required=True), + ) + app_budget_consumed: int | None = field( + default=None, + metadata=wire("app-budget-consumed"), + ) + exec_trace: SimulationTransactionExecTrace | None = field( + default=None, + metadata=nested("exec-trace", lambda: SimulationTransactionExecTrace), + ) + fixed_signer: str | None = field( + default=None, + metadata=wire("fixed-signer"), + ) + logic_sig_budget_consumed: int | None = field( + default=None, + metadata=wire("logic-sig-budget-consumed"), + ) + unnamed_resources_accessed: SimulateUnnamedResourcesAccessed | None = field( + default=None, + metadata=nested("unnamed-resources-accessed", lambda: SimulateUnnamedResourcesAccessed), + ) diff --git a/src/algokit_algod_client/models/_simulate_unnamed_resources_accessed.py b/src/algokit_algod_client/models/_simulate_unnamed_resources_accessed.py new file mode 100644 index 00000000..99fc1f19 --- /dev/null +++ b/src/algokit_algod_client/models/_simulate_unnamed_resources_accessed.py @@ -0,0 +1,64 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire +from algokit_transact.models.app_call import BoxReference, HoldingReference, LocalsReference + +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class SimulateUnnamedResourcesAccessed: + """ + These are resources that were accessed by this group that would normally have caused + failure, but were allowed in simulation. Depending on where this object is in the + response, the unnamed resources it contains may or may not qualify for group resource + sharing. If this is a field in SimulateTransactionGroupResult, the resources do qualify, + but if this is a field in SimulateTransactionResult, they do not qualify. In order to + make this group valid for actual submission, resources that qualify for group sharing + can be made available by any transaction of the group; otherwise, resources must be + placed in the same transaction which accessed them. + """ + + accounts: list[str] | None = field( + default=None, + metadata=wire("accounts"), + ) + app_locals: list[LocalsReference] | None = field( + default=None, + metadata=wire( + "app-locals", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: LocalsReference, raw), + ), + ) + apps: list[int] | None = field( + default=None, + metadata=wire("apps"), + ) + asset_holdings: list[HoldingReference] | None = field( + default=None, + metadata=wire( + "asset-holdings", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: HoldingReference, raw), + ), + ) + assets: list[int] | None = field( + default=None, + metadata=wire("assets"), + ) + boxes: list[BoxReference] | None = field( + default=None, + metadata=wire( + "boxes", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: BoxReference, raw), + ), + ) + extra_box_refs: int | None = field( + default=None, + metadata=wire("extra-box-refs"), + ) diff --git a/src/algokit_algod_client/models/_simulation_eval_overrides.py b/src/algokit_algod_client/models/_simulation_eval_overrides.py new file mode 100644 index 00000000..5f67d528 --- /dev/null +++ b/src/algokit_algod_client/models/_simulation_eval_overrides.py @@ -0,0 +1,40 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class SimulationEvalOverrides: + """ + The set of parameters and limits override during simulation. If this set of parameters + is present, then evaluation parameters may differ from standard evaluation in certain + ways. + """ + + allow_empty_signatures: bool | None = field( + default=None, + metadata=wire("allow-empty-signatures"), + ) + allow_unnamed_resources: bool | None = field( + default=None, + metadata=wire("allow-unnamed-resources"), + ) + extra_opcode_budget: int | None = field( + default=None, + metadata=wire("extra-opcode-budget"), + ) + fix_signers: bool | None = field( + default=None, + metadata=wire("fix-signers"), + ) + max_log_calls: int | None = field( + default=None, + metadata=wire("max-log-calls"), + ) + max_log_size: int | None = field( + default=None, + metadata=wire("max-log-size"), + ) diff --git a/src/algokit_algod_client/models/_simulation_opcode_trace_unit.py b/src/algokit_algod_client/models/_simulation_opcode_trace_unit.py new file mode 100644 index 00000000..e85a0c9e --- /dev/null +++ b/src/algokit_algod_client/models/_simulation_opcode_trace_unit.py @@ -0,0 +1,55 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._application_state_operation import ApplicationStateOperation +from ._avm_value import AvmValue +from ._scratch_change import ScratchChange +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class SimulationOpcodeTraceUnit: + """ + The set of trace information and effect from evaluating a single opcode. + """ + + pc: int = field( + default=0, + metadata=wire("pc"), + ) + scratch_changes: list[ScratchChange] | None = field( + default=None, + metadata=wire( + "scratch-changes", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: ScratchChange, raw), + ), + ) + spawned_inners: list[int] | None = field( + default=None, + metadata=wire("spawned-inners"), + ) + stack_additions: list[AvmValue] | None = field( + default=None, + metadata=wire( + "stack-additions", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: AvmValue, raw), + ), + ) + stack_pop_count: int | None = field( + default=None, + metadata=wire("stack-pop-count"), + ) + state_changes: list[ApplicationStateOperation] | None = field( + default=None, + metadata=wire( + "state-changes", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: ApplicationStateOperation, raw), + ), + ) diff --git a/src/algokit_algod_client/models/_simulation_transaction_exec_trace.py b/src/algokit_algod_client/models/_simulation_transaction_exec_trace.py new file mode 100644 index 00000000..74e30189 --- /dev/null +++ b/src/algokit_algod_client/models/_simulation_transaction_exec_trace.py @@ -0,0 +1,82 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, decode_model_sequence, encode_bytes, encode_model_sequence +from ._simulation_opcode_trace_unit import SimulationOpcodeTraceUnit + + +@dataclass(slots=True) +class SimulationTransactionExecTrace: + """ + The execution trace of calling an app or a logic sig, containing the inner app call + trace in a recursive way. + """ + + approval_program_hash: bytes | None = field( + default=None, + metadata=wire( + "approval-program-hash", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + approval_program_trace: list[SimulationOpcodeTraceUnit] | None = field( + default=None, + metadata=wire( + "approval-program-trace", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: SimulationOpcodeTraceUnit, raw), + ), + ) + clear_state_program_hash: bytes | None = field( + default=None, + metadata=wire( + "clear-state-program-hash", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + clear_state_program_trace: list[SimulationOpcodeTraceUnit] | None = field( + default=None, + metadata=wire( + "clear-state-program-trace", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: SimulationOpcodeTraceUnit, raw), + ), + ) + clear_state_rollback: bool | None = field( + default=None, + metadata=wire("clear-state-rollback"), + ) + clear_state_rollback_error: str | None = field( + default=None, + metadata=wire("clear-state-rollback-error"), + ) + inner_trace: list["SimulationTransactionExecTrace"] | None = field( + default=None, + metadata=wire( + "inner-trace", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: SimulationTransactionExecTrace, raw), + ), + ) + logic_sig_hash: bytes | None = field( + default=None, + metadata=wire( + "logic-sig-hash", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + logic_sig_trace: list[SimulationOpcodeTraceUnit] | None = field( + default=None, + metadata=wire( + "logic-sig-trace", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: SimulationOpcodeTraceUnit, raw), + ), + ) diff --git a/src/algokit_algod_client/models/_source_map.py b/src/algokit_algod_client/models/_source_map.py new file mode 100644 index 00000000..22b14f85 --- /dev/null +++ b/src/algokit_algod_client/models/_source_map.py @@ -0,0 +1,30 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class SourceMap: + """ + Source map for the program + """ + + mappings: str = field( + default="", + metadata=wire("mappings"), + ) + names: list[str] = field( + default_factory=list, + metadata=wire("names"), + ) + sources: list[str] = field( + default_factory=list, + metadata=wire("sources"), + ) + version: int = field( + default=0, + metadata=wire("version"), + ) diff --git a/src/algokit_algod_client/models/_state_delta.py b/src/algokit_algod_client/models/_state_delta.py new file mode 100644 index 00000000..c6c731ce --- /dev/null +++ b/src/algokit_algod_client/models/_state_delta.py @@ -0,0 +1,6 @@ +# AUTO-GENERATED: oas_generator + + +from ._eval_delta_key_value import EvalDeltaKeyValue + +StateDelta = list[EvalDeltaKeyValue] diff --git a/src/algokit_algod_client/models/_state_proof.py b/src/algokit_algod_client/models/_state_proof.py new file mode 100644 index 00000000..4aded6e1 --- /dev/null +++ b/src/algokit_algod_client/models/_state_proof.py @@ -0,0 +1,28 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._serde_helpers import decode_bytes, encode_bytes +from ._state_proof_message import StateProofMessage + + +@dataclass(slots=True) +class StateProof: + """ + Represents a state proof and its corresponding message + """ + + message: StateProofMessage = field( + metadata=nested("Message", lambda: StateProofMessage, required=True), + ) + state_proof: bytes = field( + default=b"", + metadata=wire( + "StateProof", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_algod_client/models/_state_proof_message.py b/src/algokit_algod_client/models/_state_proof_message.py new file mode 100644 index 00000000..28965795 --- /dev/null +++ b/src/algokit_algod_client/models/_state_proof_message.py @@ -0,0 +1,44 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class StateProofMessage: + """ + Represents the message that the state proofs are attesting to. + """ + + block_headers_commitment: bytes = field( + default=b"", + metadata=wire( + "BlockHeadersCommitment", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + first_attested_round: int = field( + default=0, + metadata=wire("FirstAttestedRound"), + ) + last_attested_round: int = field( + default=0, + metadata=wire("LastAttestedRound"), + ) + ln_proven_weight: int = field( + default=0, + metadata=wire("LnProvenWeight"), + ) + voters_commitment: bytes = field( + default=b"", + metadata=wire( + "VotersCommitment", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_algod_client/models/_supply_response.py b/src/algokit_algod_client/models/_supply_response.py new file mode 100644 index 00000000..c8067c56 --- /dev/null +++ b/src/algokit_algod_client/models/_supply_response.py @@ -0,0 +1,26 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class SupplyResponse: + """ + Supply represents the current supply of MicroAlgos in the system + """ + + current_round: int = field( + default=0, + metadata=wire("current_round"), + ) + online_money: int = field( + default=0, + metadata=wire("online-money"), + ) + total_money: int = field( + default=0, + metadata=wire("total-money"), + ) diff --git a/src/algokit_algod_client/models/_teal_key_value.py b/src/algokit_algod_client/models/_teal_key_value.py new file mode 100644 index 00000000..3dd76772 --- /dev/null +++ b/src/algokit_algod_client/models/_teal_key_value.py @@ -0,0 +1,28 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._serde_helpers import decode_bytes, encode_bytes +from ._teal_value import TealValue + + +@dataclass(slots=True) +class TealKeyValue: + """ + Represents a key-value pair in an application store. + """ + + value: TealValue = field( + metadata=nested("value", lambda: TealValue, required=True), + ) + key: bytes = field( + default=b"", + metadata=wire( + "key", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_algod_client/models/_teal_key_value_store.py b/src/algokit_algod_client/models/_teal_key_value_store.py new file mode 100644 index 00000000..253b6bfc --- /dev/null +++ b/src/algokit_algod_client/models/_teal_key_value_store.py @@ -0,0 +1,6 @@ +# AUTO-GENERATED: oas_generator + + +from ._teal_key_value import TealKeyValue + +TealKeyValueStore = list[TealKeyValue] diff --git a/src/algokit_algod_client/models/_teal_value.py b/src/algokit_algod_client/models/_teal_value.py new file mode 100644 index 00000000..70fc323c --- /dev/null +++ b/src/algokit_algod_client/models/_teal_value.py @@ -0,0 +1,32 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class TealValue: + """ + Represents a TEAL value. + """ + + bytes_: bytes = field( + default=b"", + metadata=wire( + "bytes", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + type_: int = field( + default=0, + metadata=wire("type"), + ) + uint: int = field( + default=0, + metadata=wire("uint"), + ) diff --git a/src/algokit_algod_client/models/_transaction_group_ledger_state_deltas_for_round_response.py b/src/algokit_algod_client/models/_transaction_group_ledger_state_deltas_for_round_response.py new file mode 100644 index 00000000..b7e989de --- /dev/null +++ b/src/algokit_algod_client/models/_transaction_group_ledger_state_deltas_for_round_response.py @@ -0,0 +1,21 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._ledger_state_delta import LedgerStateDeltaForTransactionGroup +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class TransactionGroupLedgerStateDeltasForRoundResponse: + deltas: list[LedgerStateDeltaForTransactionGroup] = field( + default_factory=list, + metadata=wire( + "Deltas", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: LedgerStateDeltaForTransactionGroup, raw), + ), + ) diff --git a/src/algokit_algod_client/models/_transaction_parameters_response.py b/src/algokit_algod_client/models/_transaction_parameters_response.py new file mode 100644 index 00000000..045736b8 --- /dev/null +++ b/src/algokit_algod_client/models/_transaction_parameters_response.py @@ -0,0 +1,45 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_fixed_bytes, encode_fixed_bytes + + +@dataclass(slots=True) +class TransactionParametersResponse: + """ + TransactionParams contains the parameters that help a client construct + a new transaction. + """ + + consensus_version: str = field( + default="", + metadata=wire("consensus-version"), + ) + fee: int = field( + default=0, + metadata=wire("fee"), + ) + genesis_hash: bytes = field( + default=b"", + metadata=wire( + "genesis-hash", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) + genesis_id: str = field( + default="", + metadata=wire("genesis-id"), + ) + last_round: int = field( + default=0, + metadata=wire("last-round"), + ) + min_fee: int = field( + default=0, + metadata=wire("min-fee"), + ) diff --git a/src/algokit_algod_client/models/_transaction_proof.py b/src/algokit_algod_client/models/_transaction_proof.py new file mode 100644 index 00000000..a64cb613 --- /dev/null +++ b/src/algokit_algod_client/models/_transaction_proof.py @@ -0,0 +1,44 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class TransactionProof: + """ + Proof of transaction in a block. + """ + + hashtype: str = field( + default="", + metadata=wire("hashtype"), + ) + idx: int = field( + default=0, + metadata=wire("idx"), + ) + proof: bytes = field( + default=b"", + metadata=wire( + "proof", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + stibhash: bytes = field( + default=b"", + metadata=wire( + "stibhash", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + treedepth: int = field( + default=0, + metadata=wire("treedepth"), + ) diff --git a/src/algokit_algod_client/models/_version_contains_the_current_algod_version.py b/src/algokit_algod_client/models/_version_contains_the_current_algod_version.py new file mode 100644 index 00000000..72a19322 --- /dev/null +++ b/src/algokit_algod_client/models/_version_contains_the_current_algod_version.py @@ -0,0 +1,38 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._build_version_contains_the_current_algod_build_version_information import ( + BuildVersionContainsTheCurrentAlgodBuildVersionInformation, +) +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class VersionContainsTheCurrentAlgodVersion: + """ + algod version information. + """ + + build: BuildVersionContainsTheCurrentAlgodBuildVersionInformation = field( + metadata=nested("build", lambda: BuildVersionContainsTheCurrentAlgodBuildVersionInformation, required=True), + ) + genesis_hash_b64: bytes = field( + default=b"", + metadata=wire( + "genesis_hash_b64", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + genesis_id: str = field( + default="", + metadata=wire("genesis_id"), + ) + versions: list[str] = field( + default_factory=list, + metadata=wire("versions"), + ) diff --git a/src/algokit_algod_client/models/suggested_params.py b/src/algokit_algod_client/models/suggested_params.py new file mode 100644 index 00000000..c3e0aa55 --- /dev/null +++ b/src/algokit_algod_client/models/suggested_params.py @@ -0,0 +1,42 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class SuggestedParams: + """Contains parameters relevant to creating a new transaction over a time window.""" + + consensus_version: str = field( + metadata=wire("consensus-version"), + ) + fee: int = field( + metadata=wire("fee"), + ) + genesis_hash: bytes = field( + metadata=wire( + "genesis-hash", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + genesis_id: str = field( + metadata=wire("genesis-id"), + ) + min_fee: int = field( + metadata=wire("min-fee"), + ) + flat_fee: bool = field( + metadata=wire("flat-fee"), + ) + first_valid: int = field( + metadata=wire("first-valid"), + ) + last_valid: int = field( + metadata=wire("last-valid"), + ) diff --git a/src/algokit_algod_client/py.typed b/src/algokit_algod_client/py.typed new file mode 100644 index 00000000..abb15e27 --- /dev/null +++ b/src/algokit_algod_client/py.typed @@ -0,0 +1 @@ +# AUTO-GENERATED: oas_generator diff --git a/src/algokit_algod_client/types.py b/src/algokit_algod_client/types.py new file mode 100644 index 00000000..379362d9 --- /dev/null +++ b/src/algokit_algod_client/types.py @@ -0,0 +1,7 @@ +# AUTO-GENERATED: oas_generator + + +from typing import Any + +JSONMapping = dict[str, Any] +Headers = dict[str, str] diff --git a/src/algokit_common/__init__.py b/src/algokit_common/__init__.py new file mode 100644 index 00000000..ab7086aa --- /dev/null +++ b/src/algokit_common/__init__.py @@ -0,0 +1,50 @@ +from algokit_common.address import address_from_public_key, get_application_address, public_key_from_address +from algokit_common.constants import * # noqa: F403 +from algokit_common.hashing import base32_nopad_decode, base32_nopad_encode, sha512_256 +from algokit_common.serde import ( + DecodeError, + EncodeError, + addr, + addr_seq, + bytes_seq, + enum_value, + flatten, + from_wire, + int_seq, + nested, + to_wire, + to_wire_canonical, + wire, +) +from algokit_common.source_map import ( + PcLineLocation, + ProgramSourceMap, + SourceLocation, + SourceMapVersionError, +) + +__all__ = [ + "DecodeError", + "EncodeError", + "PcLineLocation", + "ProgramSourceMap", + "SourceLocation", + "SourceMapVersionError", + "addr", + "addr_seq", + "address_from_public_key", + "base32_nopad_decode", + "base32_nopad_encode", + "bytes_seq", + "enum_value", + "flatten", + "from_wire", + "get_application_address", + "int_seq", + "nested", + "public_key_from_address", + "sha512_256", + "to_wire", + "to_wire_canonical", + "wire", +] diff --git a/src/algokit_common/address.py b/src/algokit_common/address.py new file mode 100644 index 00000000..22f92fbc --- /dev/null +++ b/src/algokit_common/address.py @@ -0,0 +1,34 @@ +from algokit_common.constants import CHECKSUM_BYTE_LENGTH, PUBLIC_KEY_BYTE_LENGTH +from algokit_common.hashing import base32_nopad_decode, base32_nopad_encode, sha512_256 + +APP_ID_PREFIX = b"appID" + + +def public_key_from_address(address: str) -> bytes: + if not isinstance(address, str): + raise TypeError("address must be str") + raw = base32_nopad_decode(address) + if len(raw) != PUBLIC_KEY_BYTE_LENGTH + CHECKSUM_BYTE_LENGTH: + raise ValueError("invalid address length") + pk = raw[:PUBLIC_KEY_BYTE_LENGTH] + checksum = raw[PUBLIC_KEY_BYTE_LENGTH:] + expected = sha512_256(pk)[-CHECKSUM_BYTE_LENGTH:] + if checksum != expected: + raise ValueError("invalid address checksum") + return pk + + +def address_from_public_key(public_key: bytes) -> str: + if len(public_key) != PUBLIC_KEY_BYTE_LENGTH: + raise ValueError("invalid public key length") + checksum = sha512_256(public_key)[-CHECKSUM_BYTE_LENGTH:] + return base32_nopad_encode(public_key + checksum) + + +def get_application_address(app_id: int) -> str: + """Return the escrow address of an application.""" + if not isinstance(app_id, int): + raise TypeError(f"Expected an int for app_id but received {type(app_id)}") + to_hash = APP_ID_PREFIX + app_id.to_bytes(8, "big") + hash_bytes = sha512_256(to_hash) + return address_from_public_key(hash_bytes) diff --git a/src/algokit_common/constants.py b/src/algokit_common/constants.py new file mode 100644 index 00000000..636933de --- /dev/null +++ b/src/algokit_common/constants.py @@ -0,0 +1,42 @@ +TRANSACTION_DOMAIN_SEPARATOR = b"TX" +TRANSACTION_GROUP_DOMAIN_SEPARATOR = b"TG" +SIGNATURE_ENCODING_INCR = 75 +HASH_BYTES_LENGTH = 32 +PUBLIC_KEY_BYTE_LENGTH = 32 +MAX_TRANSACTION_GROUP_SIZE = 16 +CHECKSUM_BYTE_LENGTH = 4 +ADDRESS_LENGTH = 58 +TRANSACTION_ID_LENGTH = 52 +ZERO_ADDRESS = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ" +LENGTH_ENCODE_BYTE_SIZE = 2 +BOOL_TRUE_BYTE = 0x80 +BOOL_FALSE_BYTE = 0x00 +SIGNATURE_BYTE_LENGTH = 64 +EMPTY_SIGNATURE = bytes(SIGNATURE_BYTE_LENGTH) + +# Transaction fees and amounts +MICROALGOS_TO_ALGOS_RATIO = 1_000_000 +MIN_TXN_FEE = 1000 + +# Application program size constraints +MAX_EXTRA_PROGRAM_PAGES = 3 +PROGRAM_PAGE_SIZE = 2048 # In bytes + +# Application reference limits +MAX_APP_ARGS = 16 +MAX_ARGS_SIZE = 2048 # Maximum size in bytes of all args combined +MAX_OVERALL_REFERENCES = 8 +MAX_ACCOUNT_REFERENCES = 8 +MAX_APP_REFERENCES = 8 +MAX_ASSET_REFERENCES = 8 +MAX_BOX_REFERENCES = 8 + +# Application state schema limits +MAX_GLOBAL_STATE_KEYS = 64 +MAX_LOCAL_STATE_KEYS = 16 + +# Asset configuration limits +MAX_ASSET_NAME_LENGTH = 32 # In bytes +MAX_ASSET_UNIT_NAME_LENGTH = 8 # In bytes +MAX_ASSET_URL_LENGTH = 96 # In bytes +MAX_ASSET_DECIMALS = 19 diff --git a/src/algokit_common/hashing.py b/src/algokit_common/hashing.py new file mode 100644 index 00000000..fb09043e --- /dev/null +++ b/src/algokit_common/hashing.py @@ -0,0 +1,25 @@ +from typing import Final + +from Cryptodome.Hash import SHA512 + + +def sha512_256(data: bytes) -> bytes: + ch = SHA512.new(truncate="256") + ch.update(data) + return ch.digest() + + +BASE32_ALPHABET_NO_PAD: Final[bytes] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567" + + +def base32_nopad_encode(data: bytes) -> str: + import base64 + + return base64.b32encode(data).decode().rstrip("=") + + +def base32_nopad_decode(text: str) -> bytes: + import base64 + + pad_len = (-len(text)) % 8 + return base64.b32decode(text + ("=" * pad_len)) diff --git a/src/algokit_common/py.typed b/src/algokit_common/py.typed new file mode 100644 index 00000000..e69de29b diff --git a/src/algokit_common/serde/__init__.py b/src/algokit_common/serde/__init__.py new file mode 100644 index 00000000..2979d9ef --- /dev/null +++ b/src/algokit_common/serde/__init__.py @@ -0,0 +1,40 @@ +"""Shared serialization helpers for AlgoKit dataclasses. + +The implementation mirrors the serde utilities that previously lived in +``algokit_transact`` so that auto-generated API clients can share the same +wire-format logic. +""" + +from algokit_common.serde._core import ( + DecodeError, + EncodeError, + addr, + addr_seq, + bytes_seq, + enum_value, + flatten, + from_wire, + int_seq, + nested, + sort_msgpack_value, + to_wire, + to_wire_canonical, + wire, +) + +__all__ = [ + "DecodeError", + "EncodeError", + "addr", + "addr_seq", + "bytes_seq", + "enum_value", + "flatten", + "from_wire", + "int_seq", + "nested", + "sort_msgpack_value", + "to_wire", + "to_wire_canonical", + "wire", +] diff --git a/src/algokit_common/serde/_core.py b/src/algokit_common/serde/_core.py new file mode 100644 index 00000000..04d9ca89 --- /dev/null +++ b/src/algokit_common/serde/_core.py @@ -0,0 +1,619 @@ +import builtins +import sys +import types +from collections.abc import Callable, Mapping +from dataclasses import dataclass, fields, is_dataclass +from enum import Enum +from typing import TypeVar, Union, cast, get_args, get_origin, get_type_hints + +from algokit_common import address_from_public_key, public_key_from_address +from algokit_common.serde._primitives import ( + decode_int_like, + encode_bool, + encode_int, + omit_defaults_and_sort, + sort_msgpack_value, +) + +__all__ = [ + "DecodeError", + "EncodeError", + "addr", + "addr_seq", + "bytes_seq", + "enum_value", + "flatten", + "from_wire", + "int_seq", + "nested", + "sort_msgpack_value", + "to_wire", + "to_wire_canonical", + "wire", +] + + +DecodedValueT = TypeVar("DecodedValueT") + + +class EncodeError(ValueError): + pass + + +class DecodeError(ValueError): + pass + + +# Metadata helpers +def wire( + alias: str, + *, + encode: Callable[..., object] | None = None, + decode: Callable[..., object] | type | None = None, + omit_if_none: bool = True, + keep_zero: bool = False, + keep_false: bool = False, + omit_empty_seq: bool = True, + required: bool = False, + pass_obj: bool = False, +) -> dict[str, object]: + return { + "kind": "wire", + "alias": alias, + "encode": encode, + "decode": decode, + "omit_if_none": omit_if_none, + "keep_zero": keep_zero, + "keep_false": keep_false, + "omit_empty_seq": omit_empty_seq, + "required": required, + "pass_obj": pass_obj, + } + + +ChildType = type[object] | Callable[[], type[object]] | None + + +def _expects_text_value(type_hint: object) -> bool: + if isinstance(type_hint, type) and issubclass(type_hint, Enum): + return True + if type_hint is str: + return True + origin = get_origin(type_hint) + if origin is None: + return False + if origin is str: + return True + if origin in (list, tuple, set, frozenset, dict): + return False + args = [arg for arg in get_args(type_hint) if arg is not type(None)] + return any(_expects_text_value(arg) for arg in args) + + +def flatten( + child_cls: ChildType, + *, + present_if: Callable[[Mapping[str, object]], bool] | None = None, +) -> dict[str, object]: + return {"kind": "flatten", "child_cls": child_cls, "present_if": present_if} + + +def nested( + alias: str, + child_cls: ChildType, + *, + present_if: Callable[[Mapping[str, object]], bool] | None = None, + omit_empty_seq: bool = True, + required: bool = False, +) -> dict[str, object]: + return { + "kind": "nested", + "alias": alias, + "child_cls": child_cls, + "present_if": present_if, + "omit_empty_seq": omit_empty_seq, + "required": required, + } + + +@dataclass(slots=True) +class _FieldHandler: + name: str + alias: str | None + encode_fn: Callable[..., object] | None + decode_fn: Callable[[object], object] | type | None + omit_if_none: bool + keep_zero: bool + keep_false: bool + omit_empty_seq: bool + required: bool + kind: str + child_cls: ChildType + nested_alias: str | None + present_if: Callable[[Mapping[str, object]], bool] | None = None + pass_obj: bool = False + expects_text: bool = False + nested_required: bool = False # For nested fields: whether they are required + + +class _SerdePlan: + __slots__ = ("cls", "fields") + + def __init__(self, cls: type[object], handlers: list[_FieldHandler]) -> None: + self.cls = cls + self.fields = handlers + + +_SERDE_CACHE: dict[type[object], _SerdePlan] = {} + + +def _get_dataclass(typ: type) -> type | None: + if get_origin(typ) in {Union, types.UnionType}: + typs = set(get_args(typ)) + else: + typs = {typ} + typs = typs - {types.NoneType} + try: + (maybe_dataclass,) = typs + except ValueError: + return None + if is_dataclass(maybe_dataclass): + return cast(type, maybe_dataclass) + else: + return None + + +def _compile_plan(cls: type[object]) -> _SerdePlan: + if not is_dataclass(cls): + raise TypeError(f"{cls!r} is not a dataclass") + handlers: list[_FieldHandler] = [] + # Use explicit globalns with builtins and empty localns to avoid issues with + # dataclass fields that shadow builtin names (e.g. 'bytes', 'type'). + # When slots=True, the class namespace contains member descriptors that can + # interfere with type hint evaluation. + module = sys.modules.get(cls.__module__, None) + globalns = {**vars(builtins), **(vars(module) if module else {})} + cls_type_hints = get_type_hints(cls, globalns=globalns, localns={}) + for f in fields(cls): + meta = dict(f.metadata or {}) + field_type = cls_type_hints[f.name] + maybe_dataclass = _get_dataclass(field_type) + if maybe_dataclass and not meta: + kind = "nested" + meta = {"child_cls": maybe_dataclass, "alias": f.name, "omit_if_none": True} + else: + kind = cast(str | None, meta.get("kind")) or "wire" + if kind not in ("wire", "flatten", "nested"): + kind = "wire" + + if kind == "wire": + handlers.append( + _FieldHandler( + name=f.name, + alias=cast(str | None, meta.get("alias", f.name)), + encode_fn=cast(Callable[..., object] | None, meta.get("encode")), + decode_fn=cast(Callable[[object], object] | type | None, meta.get("decode")), + omit_if_none=bool(meta.get("omit_if_none", True)), + keep_zero=bool(meta.get("keep_zero", False)), + keep_false=bool(meta.get("keep_false", False)), + omit_empty_seq=bool(meta.get("omit_empty_seq", True)), + required=bool(meta.get("required", False)), + kind=kind, + child_cls=None, + nested_alias=None, + pass_obj=bool(meta.get("pass_obj", False)), + expects_text=_expects_text_value(field_type), + ) + ) + elif kind == "nested": + handlers.append( + _FieldHandler( + name=f.name, + alias=None, + encode_fn=None, + decode_fn=None, + omit_if_none=True, + keep_zero=False, + keep_false=False, + omit_empty_seq=meta.get("omit_empty_seq", True), + required=False, + kind=kind, + child_cls=cast(type[object] | None, meta.get("child_cls")), + nested_alias=cast(str | None, meta.get("alias")), + present_if=cast(Callable[[Mapping[str, object]], bool] | None, meta.get("present_if")), + nested_required=bool(meta.get("required", False)), + ) + ) + else: # flatten + handlers.append( + _FieldHandler( + name=f.name, + alias=None, + encode_fn=None, + decode_fn=None, + omit_if_none=True, + keep_zero=False, + keep_false=False, + omit_empty_seq=True, + required=False, + kind=kind, + child_cls=cast(type[object] | None, meta.get("child_cls")), + nested_alias=None, + present_if=cast(Callable[[Mapping[str, object]], bool] | None, meta.get("present_if")), + ) + ) + + plan = _SerdePlan(cls, handlers) + _SERDE_CACHE[cls] = plan + return plan + + +def _plan_for(cls: type[object]) -> _SerdePlan: + return _SERDE_CACHE.get(cls) or _compile_plan(cls) + + +# Cache for default instances to avoid repeated construction +_DEFAULT_INSTANCE_CACHE: dict[type[object], object] = {} + + +def _construct_default_instance(cls: type[object]) -> object: + """Construct a default instance of a dataclass with all required fields set to defaults. + + This mirrors TypeScript's ObjectModelCodec.defaultValue() behavior: + - Required primitive fields get type-appropriate defaults (0, "", False, b"", etc.) + - Required nested object fields get recursively constructed default instances + - Optional fields are not set (they use their dataclass defaults, typically None) + + The result is cached for performance. + """ + if cls in _DEFAULT_INSTANCE_CACHE: + return _DEFAULT_INSTANCE_CACHE[cls] + + if not is_dataclass(cls): + raise TypeError(f"{cls!r} is not a dataclass") + + plan = _plan_for(cls) + kwargs: dict[str, object] = {} + + for h in plan.fields: + if h.kind == "wire": + # For wire fields, check if it has a default in the dataclass + # If not, we need to provide a default value for required primitives + # The dataclass defaults should already handle this via generator + pass + elif h.kind == "nested" and h.nested_required: + # Required nested fields need default instances + child_cls = _resolve_child_cls(h) + if child_cls is not None: + kwargs[h.name] = _construct_default_instance(child_cls) + # flatten and optional nested fields are not populated + + # Create instance - dataclass defaults will fill in primitive defaults + try: + instance = cls(**kwargs) + except TypeError as exc: + raise DecodeError(f"Failed to construct default instance of {cls.__name__}: {exc}") from exc + + _DEFAULT_INSTANCE_CACHE[cls] = instance + return instance + + +def _encode_scalar(value: object, *, keep_zero: bool, keep_false: bool) -> object | None: + if value is None: + return None + if isinstance(value, bool): + return value if keep_false else encode_bool(value) + if isinstance(value, int): + return encode_int(value, keep_zero=keep_zero) + if isinstance(value, bytes | bytearray | memoryview): + return bytes(value) if isinstance(value, bytearray | memoryview) else value + return value + + +def _resolve_child_cls(h: _FieldHandler) -> type[object] | None: + child = h.child_cls + if child is None: + return None + if isinstance(child, type): + return child + return child() + + +def _encode_nested_field(out: dict[str, object], obj: object, h: _FieldHandler) -> None: + if (value := getattr(obj, h.name)) is None: + return + if not (nested_payload := to_wire(value)) and h.omit_empty_seq: + return + if h.nested_alias is None: + raise EncodeError(f"Missing nested alias for field {h.name!r}") + out[h.nested_alias] = nested_payload + + +def _encode_flatten_field(out: dict[str, object], obj: object, h: _FieldHandler) -> None: + if (value := getattr(obj, h.name)) is None: + return + if child_payload := to_wire(value): + out.update(child_payload) + + +def _encode_wire_field(out: dict[str, object], obj: object, h: _FieldHandler) -> None: + if not h.alias: + return + value = getattr(obj, h.name) + if value is None: + if h.required: + raise EncodeError(f"Field {h.name!r} is required but None") + if h.omit_if_none: + return + _set_path(out, h.alias, None) + return + + if h.encode_fn is not None: + encoded = h.encode_fn(obj, value) if h.pass_obj else h.encode_fn(value) + else: + encoded = _encode_scalar(value, keep_zero=h.keep_zero, keep_false=h.keep_false) + + if h.omit_empty_seq and isinstance(encoded, list | tuple) and not encoded: + return + if encoded is None and h.omit_if_none: + return + _set_path(out, h.alias, encoded) + + +def to_wire(obj: object) -> dict[str, object]: + """Encode a dataclass instance to a wire-ready dict using field metadata.""" + plan = _plan_for(obj.__class__) + out: dict[str, object] = {} + for h in plan.fields: + if h.kind == "nested": + _encode_nested_field(out, obj, h) + elif h.kind == "flatten": + _encode_flatten_field(out, obj, h) + elif h.kind == "wire": + _encode_wire_field(out, obj, h) + return out + + +def to_wire_canonical(obj: object) -> dict[str, object]: + """Return canonical, ready-to-msgpack dict (omit defaults and sort keys).""" + return cast(dict[str, object], omit_defaults_and_sort(dict(to_wire(obj)))) + + +def _decode_with_hint(raw: object, decode_fn: Callable[[object], object] | type | None) -> object: + if decode_fn is None: + if isinstance(raw, bytes | bytearray): + return bytes(raw) + if isinstance(raw, int): + return decode_int_like(raw) + return raw + + if isinstance(decode_fn, type): + try: + return cast("Callable[[object], object]", decode_fn)(raw) + except Exception as exc: + raise DecodeError(f"Failed to construct {decode_fn.__name__} from {raw!r}") from exc + + return decode_fn(raw) + + +def _wire_aliases_for(cls: type[object]) -> frozenset[str]: + plan = _plan_for(cls) + aliases = {h.alias for h in plan.fields if h.kind == "wire" and h.alias} + aliases.update(h.nested_alias for h in plan.fields if h.kind == "nested" and h.nested_alias) + # For flattened fields, recursively collect wire aliases from child classes + for h in plan.fields: + if h.kind == "flatten": + child_cls = _resolve_child_cls(h) + if child_cls is not None: + aliases.update(_wire_aliases_for(child_cls)) + return frozenset(aliases) + + +def _decode_wire_field(kwargs: dict[str, object], h: _FieldHandler, payload: Mapping[str, object]) -> None: + if not (alias := h.alias): + return + if not _has_path(payload, alias): + return + if (raw := _get_path(payload, alias)) is None: + if h.required: + raise DecodeError(f"Missing required field {h.name!r} (alias {alias!r})") + kwargs[h.name] = None + return + value = raw + needs_text = bool( + h.expects_text and (h.decode_fn is None or (isinstance(h.decode_fn, type) and issubclass(h.decode_fn, Enum))) + ) + if needs_text and isinstance(value, bytes | bytearray | memoryview): + raw_bytes = bytes(value) + try: + value = raw_bytes.decode("utf-8") + except UnicodeDecodeError: + # Some Algorand fields legitimately carry printable data inside binary slots. + value = raw_bytes + kwargs[h.name] = _decode_with_hint(value, h.decode_fn) + + +def _decode_nested_field(kwargs: dict[str, object], h: _FieldHandler, payload: Mapping[str, object]) -> None: + child_cls = _resolve_child_cls(h) + if child_cls is None or h.nested_alias is None: + kwargs[h.name] = None + return + if isinstance(raw_nested := payload.get(h.nested_alias), Mapping): + kwargs[h.name] = from_wire(child_cls, raw_nested) + return + # Field is missing or not a Mapping - check if it's required + if h.nested_required: + # Required nested fields get a default instance (mirrors TS ObjectModelCodec.defaultValue()) + kwargs[h.name] = _construct_default_instance(child_cls) + return + if not h.omit_if_none: + kwargs[h.name] = None + + +def _decode_flatten_field(kwargs: dict[str, object], h: _FieldHandler, payload: Mapping[str, object]) -> None: + child_cls = _resolve_child_cls(h) + if child_cls is None: + kwargs[h.name] = None + return + alias_set = _wire_aliases_for(child_cls) + has_any = any(_has_path(payload, k) for k in alias_set) + # If present_if is provided, it takes precedence over the wire alias check. + # This is important for transaction types where the same wire keys (e.g., 'amt', 'rcv') + # could be present but the type field indicates a different transaction type. + if h.present_if is not None: + if not h.present_if(payload): + kwargs[h.name] = None + return + elif not has_any: + kwargs[h.name] = None + return + sub: dict[str, object] = {} + for key in alias_set: + if _has_path(payload, key): + _set_path(sub, key, _get_path(payload, key)) + kwargs[h.name] = from_wire(child_cls, sub) + + +def _set_path(target: dict[str, object], path: str, value: object) -> None: + if "." not in path: + target[path] = value + return + parts = path.split(".") + cur = target + for key in parts[:-1]: + if not isinstance(nxt := cur.get(key), dict): + nxt = {} + cur[key] = nxt + cur = nxt + cur[parts[-1]] = value + + +def _get_path(source: Mapping[str, object], path: str) -> object | None: + if "." not in path: + return source.get(path) + cur: object = source + for key in path.split("."): + if not isinstance(cur, Mapping) or (cur := cur.get(key)) is None: + return None + return cur + + +def _has_path(source: Mapping[str, object], path: str) -> bool: + if "." not in path: + return path in source + cur: object = source + for key in path.split("."): + if not isinstance(cur, Mapping) or key not in cur: + return False + cur = cur[key] + return True + + +def from_wire(cls: type[DecodedValueT], payload: Mapping[str, object]) -> DecodedValueT: + """Decode a wire dict into a dataclass instance using field metadata.""" + plan = _plan_for(cls) + kwargs: dict[str, object] = {} + for h in plan.fields: + if h.kind == "wire": + _decode_wire_field(kwargs, h, payload) + elif h.kind == "nested": + _decode_nested_field(kwargs, h, payload) + elif h.kind == "flatten": + _decode_flatten_field(kwargs, h, payload) + try: + return cast(DecodedValueT, plan.cls(**kwargs)) + except TypeError as exc: + raise DecodeError(f"Failed to construct {plan.cls.__name__}: {exc}") from exc + + +def addr(alias: str, *, omit_if_none: bool = True) -> dict[str, object]: + """Typed helper for address fields (str <-> bytes).""" + from algokit_common.constants import ZERO_ADDRESS + + def _encode(v: object) -> bytes | None: + addr_str = cast(str, v) + # Treat ZERO_ADDRESS as default (omit from output) + if addr_str == ZERO_ADDRESS: + return None + return public_key_from_address(addr_str) + + return wire( + alias, + encode=_encode, + decode=lambda v: address_from_public_key(cast(bytes, v)), + omit_if_none=omit_if_none, + ) + + +E = TypeVar("E", bound=Enum) + + +def enum_value(alias: str, enum_type: type[E], *, fallback: E | None = None) -> dict[str, object]: + """Typed helper for Enum fields that serialize via their .value. + + Args: + alias: The wire format key name + enum_type: The Enum class to encode/decode + fallback: Optional fallback value to use when decoding an unknown value. + If not provided, decoding unknown values will raise DecodeError. + This is useful for forward-compatibility when new enum values may + be added in the future (e.g., new transaction types). + """ + + def _decode(value: object) -> E: + # Normalize bytes to str (msgpack may return string values as bytes) + if isinstance(value, bytes | bytearray | memoryview): + value = bytes(value).decode("utf-8") + try: + return enum_type(value) + except ValueError: + if fallback is not None: + return fallback + raise + + return wire(alias, encode=lambda e: e.value if isinstance(e, enum_type) else e, decode=_decode) + + +def bytes_seq(alias: str, *, omit_if_none: bool = True) -> dict[str, object]: + def _enc(value: object) -> object: + if value is None or not isinstance(value, tuple | list): + return None + out = [bytes(item) for item in value if isinstance(item, bytes | bytearray | memoryview)] + return out or None + + def _dec(value: object) -> object: + if not isinstance(value, list): + return value + return tuple(bytes(item) for item in value if isinstance(item, bytes | bytearray | memoryview)) + + return wire(alias, encode=_enc, decode=_dec, omit_if_none=omit_if_none) + + +def int_seq(alias: str, *, omit_if_none: bool = True) -> dict[str, object]: + def _enc(value: object) -> object: + if value is None or not isinstance(value, tuple | list): + return None + out = [int(item) for item in value if isinstance(item, int)] + return out or None + + def _dec(value: object) -> object: + if not isinstance(value, list): + return value + return tuple(int(item) for item in value if isinstance(item, int)) + + return wire(alias, encode=_enc, decode=_dec, omit_if_none=omit_if_none) + + +def addr_seq(alias: str, *, omit_if_none: bool = True) -> dict[str, object]: + def _enc(value: object) -> object: + if value is None or not isinstance(value, tuple | list): + return None + out = [public_key_from_address(cast(str, item)) for item in value] + return out or None + + def _dec(value: object) -> object: + if not isinstance(value, list): + return value + return tuple(address_from_public_key(bytes(item)) for item in value if isinstance(item, bytes | bytearray)) + + return wire(alias, encode=_enc, decode=_dec, omit_if_none=omit_if_none) diff --git a/src/algokit_common/serde/_primitives.py b/src/algokit_common/serde/_primitives.py new file mode 100644 index 00000000..b553f7d3 --- /dev/null +++ b/src/algokit_common/serde/_primitives.py @@ -0,0 +1,135 @@ +from algokit_common import address_from_public_key, public_key_from_address + + +def encode_address(addr: str | None) -> bytes | None: + if addr is None: + return None + return public_key_from_address(addr) + + +def decode_address(pk: bytes | None) -> str | None: + if pk is None: + return None + return address_from_public_key(pk) + + +def encode_bytes(b: bytes | None) -> bytes | None: + return b if b not in (None, b"") else None + + +def encode_int(n: int | None, *, keep_zero: bool = False) -> int | None: + match n: + case None: + return None + case 0 if not keep_zero: + return None + case _: + return n + + +def encode_bool(v: bool | None) -> bool | None: + return None if v in (None, False) else v + + +def encode_bytes_sequence(seq: tuple[bytes, ...] | None) -> list[bytes] | None: + if not seq: + return None + return [bytes(item) for item in seq] + + +def encode_int_sequence(seq: tuple[int, ...] | None) -> list[int] | None: + if not seq: + return None + return [int(item) for item in seq] + + +def decode_bytes_like(value: object | None) -> bytes | None: + if isinstance(value, bytes | bytearray): + return bytes(value) + return None + + +def decode_int_like(value: object | None) -> int | None: + match value: + case None: + return None + case bool(): + return value + case int(): + return int(value) + case _: + return None + + +_TYPE_PRIORITY = {int: 0, str: 1, bytes: 2} + + +def sort_msgpack_value(value: object) -> object: + """ + Recursively sort msgpack values with canonical key ordering. + + Implements canonical msgpack encoding where map keys are ordered by type: + - Integer keys first (sorted numerically) + - String keys second (sorted lexicographically) + - Binary keys third (sorted by byte value) + + This ensures deterministic, canonical msgpack encoding that matches + the behavior of Algorand's protocol layer (Go's msgp library and Rust's rmpv). + + Args: + value: A Python object (dict, list, or scalar) to sort recursively. + + Returns: + The value with all dictionaries sorted according to msgpack canonical rules. + """ + if isinstance(value, dict): + return { + k: sort_msgpack_value(v) + for k, v in sorted( + value.items(), + key=lambda kv: (_TYPE_PRIORITY.get(type(kv[0]), 3), kv[0]), + ) + } + elif isinstance(value, list | tuple): + return [sort_msgpack_value(v) for v in value] + return value + + +def omit_defaults_and_sort(value: object) -> object: + """ + Recursively omit default-like values and sort with canonical msgpack ordering. + + Combines two operations: + 1. Filters out default-like values (None, 0, "", empty bytes, empty collections) + 2. Sorts dictionaries by key using canonical msgpack ordering (int → str → bytes) + + This is used by to_wire_canonical() for protocol wire format encoding. + """ + if isinstance(value, dict): + filtered = { + k: omit_defaults_and_sort(v) for k, v in value.items() if not is_default_like(omit_defaults_and_sort(v)) + } + # Use sort_msgpack_value for canonical ordering instead of simple lexicographic sort + return sort_msgpack_value(filtered) + if isinstance(value, list | tuple): + return [omit_defaults_and_sort(v) for v in value] + return value + + +def is_default_like(value: object) -> bool: # noqa: PLR0911 + match value: + case None: + return True + case int() as i if i == 0: + return True + case str() as s if s == "": + return True + case (bytes() | bytearray()) as b if len(b) == 0: + return True + case list() as l if len(l) == 0: + return True + case dict() as d: + # omit-empty-object + return all(is_default_like(v) for v in d.values()) + case _: + return False diff --git a/src/algokit_common/source_map.py b/src/algokit_common/source_map.py new file mode 100644 index 00000000..54f109e8 --- /dev/null +++ b/src/algokit_common/source_map.py @@ -0,0 +1,158 @@ +""" +Source map utilities for mapping PC values to TEAL source code lines. + +Provides VLQ-encoded source map decoding per the Source Map Revision 3 spec. +""" + +from dataclasses import dataclass +from typing import Any, Final, cast + +# Source Map Revision 3 - the only supported version +# https://sourcemaps.info/spec.html +SOURCE_MAP_VERSION: Final[int] = 3 + + +class SourceMapVersionError(Exception): + """Raised when an unsupported source map version is encountered.""" + + def __init__(self, version: int) -> None: + super().__init__(f"unsupported source map version: {version}") + + +@dataclass +class SourceLocation: + """Represents a location in source code. + + Attributes: + line: The 0-based line number in the source file. + column: The 0-based column number in the source file (optional). + """ + + line: int + column: int | None = None + + +@dataclass +class PcLineLocation: + """Represents a mapping from PC (program counter) to source location. + + Attributes: + pc: The program counter value. + line: The 0-based line number in the source file. + """ + + pc: int + line: int + + +class ProgramSourceMap: + """ + Decodes a VLQ-encoded source mapping between PC values and TEAL source code lines. + Spec available here: https://sourcemaps.info/spec.html + + Args: + source_map: source map JSON from algod compile endpoint + + Attributes: + version: The source map version (must be 3). + sources: List of source file names. + mappings: The raw VLQ-encoded mappings string. + pc_to_line: Mapping from program counter to source line number. + line_to_pc: Mapping from source line number to list of program counters. + + Raises: + SourceMapVersionError: If the source map version is not 3. + + Example: + >>> from algokit_common import ProgramSourceMap + >>> source_map_data = {"version": 3, "sources": ["main.teal"], "mappings": "..."} + >>> source_map = ProgramSourceMap(source_map_data) + >>> line = source_map.get_line_for_pc(10) + >>> pcs = source_map.get_pcs_for_line(5) + """ + + def __init__(self, source_map: dict[str, Any]) -> None: + self.version: int = source_map["version"] + + if self.version != SOURCE_MAP_VERSION: + raise SourceMapVersionError(self.version) + + self.sources: list[str] = source_map["sources"] + + self.mappings: str = source_map["mappings"] + + pc_list = [_decode_int_value(raw_val) for raw_val in self.mappings.split(";")] + + self.pc_to_line: dict[int, int] = {} + self.line_to_pc: dict[int, list[int]] = {} + + last_line = 0 + for index, line_delta in enumerate(pc_list): + # line_delta is None if the line number has not changed + # or if the line is empty + if line_delta is not None: + last_line = last_line + line_delta + + if last_line not in self.line_to_pc: + self.line_to_pc[last_line] = [] + + self.line_to_pc[last_line].append(index) + self.pc_to_line[index] = last_line + + def get_line_for_pc(self, pc: int) -> int | None: + """Get the source line number for a given program counter. + + Args: + pc: The program counter value. + + Returns: + The source line number, or None if not found. + """ + return self.pc_to_line.get(pc, None) + + def get_pcs_for_line(self, line: int) -> list[int] | None: + """Get the program counter values for a given source line. + + Args: + line: The source line number. + + Returns: + A list of program counter values, or None if not found. + """ + return self.line_to_pc.get(line, None) + + +def _decode_int_value(value: str) -> int | None: + """Decode a VLQ segment to extract the line delta. + + Mappings may have up to 5 segments: + Third segment represents the zero-based starting line in the original source represented. + """ + decoded_value = _base64vlq_decode(value) + return decoded_value[2] if decoded_value else None + + +# Source taken from: https://gist.github.com/mjpieters/86b0d152bb51d5f5979346d11005588b +_b64chars = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" +_b64table: Final[list[int | None]] = [None] * (max(_b64chars) + 1) +for _i, _b in enumerate(_b64chars): + _b64table[_b] = _i + +_shiftsize, _flag, _mask = 5, 1 << 5, (1 << 5) - 1 + + +def _base64vlq_decode(vlqval: str) -> tuple[int, ...]: + """Decode Base64 VLQ value.""" + results = [] + shift = value = 0 + # use byte values and a table to go from base64 characters to integers + for v in map(_b64table.__getitem__, vlqval.encode("ascii")): + v = cast(int, v) # force int type given context + value += (v & _mask) << shift + if v & _flag: + shift += _shiftsize + continue + # determine sign and add to results + results.append((value >> 1) * (-1 if value & 1 else 1)) + shift = value = 0 + return tuple(results) diff --git a/src/algokit_crypto/__init__.py b/src/algokit_crypto/__init__.py new file mode 100644 index 00000000..c3124aa9 --- /dev/null +++ b/src/algokit_crypto/__init__.py @@ -0,0 +1,55 @@ +"""Algokit crypto utilities.""" + +from algokit_crypto.ed25519 import ( + Ed25519Generator, + Ed25519Keypair, + Ed25519SigningKey, + RawEd25519Signer, + RawEd25519Verifier, + WrappedEd25519Seed, + ed25519_generator, + ed25519_verifier, + pynacl_ed25519_generator, + pynacl_ed25519_verifier, +) +from algokit_crypto.hd import ( + HdAccountResult, + HdWalletResult, + WrappedHdExtendedPrivateKey, + WrappedHdMnemonic, + hd_root_key_from_mnemonic, + hd_root_key_from_seed, + hd_seed_from_mnemonic, + peikert_hd_wallet_generator, +) +from algokit_crypto.signing import ( + WrappedEd25519Secret, + WrappedLegacyMnemonic, + ed25519_signing_key_from_wrapped_secret, + pynacl_ed25519_signing_key_from_wrapped_secret, +) + +__all__ = [ + "Ed25519Generator", + "Ed25519Keypair", + "Ed25519SigningKey", + "HdAccountResult", + "HdWalletResult", + "RawEd25519Signer", + "RawEd25519Verifier", + "WrappedEd25519Secret", + "WrappedEd25519Seed", + "WrappedHdExtendedPrivateKey", + "WrappedHdMnemonic", + "WrappedLegacyMnemonic", + "ed25519_generator", + "ed25519_signing_key_from_wrapped_secret", + "ed25519_verifier", + "hd_root_key_from_mnemonic", + "hd_root_key_from_seed", + "hd_seed_from_mnemonic", + "peikert_hd_wallet_generator", + "pynacl_ed25519_generator", + "pynacl_ed25519_signing_key_from_wrapped_secret", + "pynacl_ed25519_verifier", +] diff --git a/src/algokit_crypto/ed25519.py b/src/algokit_crypto/ed25519.py new file mode 100644 index 00000000..7a312d65 --- /dev/null +++ b/src/algokit_crypto/ed25519.py @@ -0,0 +1,136 @@ +"""Ed25519 signature verification and key generation utilities.""" + +from collections.abc import Callable +from typing import Protocol, TypedDict, runtime_checkable + +import nacl.exceptions +import nacl.signing + +ED25519_SEED_SIZE = 32 +"""Size of ed25519 seed in bytes.""" + +RawEd25519Verifier = Callable[[bytes, bytes, bytes], bool] +"""Type for raw ed25519 signature verifier functions. + +Takes (signature: bytes, message: bytes, pubkey: bytes) and returns bool. +""" + +RawEd25519Signer = Callable[[bytes], bytes] +"""Type for raw ed25519 signer functions. + +Takes bytes to sign and returns the signature bytes. +""" + + +class Ed25519Keypair(TypedDict): + """Result of ed25519 key generation.""" + + ed25519_pubkey: bytes + ed25519_secret_key: bytes + raw_ed25519_signer: RawEd25519Signer + + +class Ed25519SigningKey(TypedDict): + """Ed25519 signing key containing a public key and a raw signer function.""" + + ed25519_pubkey: bytes + raw_ed25519_signer: RawEd25519Signer + + +@runtime_checkable +class WrappedEd25519Seed(Protocol): + """Represents a 32-byte Ed25519 seed that can be unwrapped for short-lived use and optionally re-wrapped. + + The ``wrap`` method is optional for implementations where wrapping is handled automatically + (e.g., hardware wallets, keyring services). + """ + + def unwrap_ed25519_seed(self) -> bytearray: ... + def wrap_ed25519_seed(self) -> None: + """Optional method to re-wrap the seed after use. + + Defaults to no-op if not implemented. + """ + ... + + +class Ed25519Generator(Protocol): + """Protocol for ed25519 keypair generator functions. + + Takes optional seed bytes and returns Ed25519Keypair with pubkey, secret key, and signer. + """ + + def __call__(self, seed: bytes | None = None) -> Ed25519Keypair: ... + + +def pynacl_ed25519_verifier(signature: bytes, message: bytes, pubkey: bytes) -> bool: + """Verify an ed25519 signature using PyNaCl (libsodium) implementation. + + Args: + signature: The ed25519 signature bytes (64 bytes). + message: The original message that was signed. + pubkey: The ed25519 public key bytes (32 bytes). + + Returns: + True if the signature is valid, False otherwise. + """ + try: + verify_key = nacl.signing.VerifyKey(pubkey) + verify_key.verify(message, signature) + return True + except nacl.exceptions.BadSignatureError: + return False + + +# Default verifier uses the pynacl implementation +ed25519_verifier: RawEd25519Verifier = pynacl_ed25519_verifier +"""Default ed25519 signature verifier. + +Currently uses the PyNaCl implementation. This may change in the future. +To explicitly use the PyNaCl implementation, use `pynacl_ed25519_verifier`. +""" + + +def pynacl_ed25519_generator(seed: bytes | None = None) -> Ed25519Keypair: + """Generate an ed25519 keypair and raw signer using PyNaCl (libsodium). + + Args: + seed: Optional 32-byte seed for deterministic key generation. + If not provided, a random keypair will be generated. + + Returns: + An Ed25519Keypair containing the public key (32 bytes), secret key (32 bytes), + and a raw signer function. + """ + if seed is not None: + # Use provided seed (must be 32 bytes for ed25519) + if len(seed) != ED25519_SEED_SIZE: + raise ValueError(f"Seed must be {ED25519_SEED_SIZE} bytes for ed25519 key generation") + signing_key = nacl.signing.SigningKey(seed) + else: + # Generate random keypair + signing_key = nacl.signing.SigningKey.generate() + + # Get the public key + verify_key = signing_key.verify_key + ed25519_pubkey = bytes(verify_key) + + def raw_ed25519_signer(bytes_to_sign: bytes) -> bytes: + """Sign bytes using the ed25519 secret key.""" + signed = signing_key.sign(bytes_to_sign) + return signed.signature + + return { + "ed25519_pubkey": ed25519_pubkey, + "ed25519_secret_key": signing_key.encode(), + "raw_ed25519_signer": raw_ed25519_signer, + } + + +# Default generator uses the pynacl implementation +ed25519_generator: Ed25519Generator = pynacl_ed25519_generator +"""Default ed25519 keypair generator. + +Currently uses the PyNaCl implementation. This may change in the future. +To explicitly use the PyNaCl implementation, use `pynacl_ed25519_generator`. +""" diff --git a/src/algokit_crypto/hd.py b/src/algokit_crypto/hd.py new file mode 100644 index 00000000..6ec47814 --- /dev/null +++ b/src/algokit_crypto/hd.py @@ -0,0 +1,233 @@ +"""Hierarchical Deterministic (HD) wallet generation using xhd-wallet-api.""" + +from collections.abc import Callable +from typing import Protocol, TypedDict, runtime_checkable + +from xhd_wallet_api_py import ( + DerivationScheme, + KeyContext, + derive_path, + from_seed, + key_gen, + public_key, + raw_sign, + seed_from_mnemonic, +) + +from algokit_crypto.ed25519 import RawEd25519Signer + +# Seed size for HD wallet generation +HD_WALLET_SEED_SIZE = 64 + +# BIP44 path constants for Algorand +BIP44_PURPOSE = 44 +BIP44_COIN_TYPE = 283 +BIP44_CHANGE = 0 + +# Hardening bit for BIP44 derivation +HARDENED_BIT = 0x80000000 + + +def _harden(index: int) -> int: + """Convert a normal index to a hardened index.""" + return index | HARDENED_BIT + + +# Type for BIP44 path tuple: (purpose', coin_type', account', change, index) +BIP44Path = tuple[int, int, int, int, int] + + +class HdAccountResult(TypedDict): + """Result of HD account generation.""" + + ed25519_pubkey: bytes + """The ed25519 public key corresponding to the generated account and index (32 bytes).""" + extended_private_key: bytearray + """The extended ed25519 private key (96 bytes for scalar + prefix + chain code).""" + bip44_path: BIP44Path + """The BIP44 path used to derive the key for the generated account and index.""" + raw_ed25519_signer: RawEd25519Signer + """A signer function that can sign bytes using the ed25519 secret key.""" + + +HdAccountGenerator = Callable[[int, int], HdAccountResult] +"""Type for HD account generator functions. + +Takes (account: int, index: int) and returns HdAccountResult. +""" + + +class HdWalletResult(TypedDict): + """Result of HD wallet generation.""" + + hd_root_key: bytearray + """The HD root key (96 bytes extended private key).""" + account_generator: HdAccountGenerator + """Function to generate accounts from the HD wallet.""" + + +HdWalletGenerator = Callable[[bytearray | None], HdWalletResult] +"""Type for HD wallet generator functions. + +Takes optional seed bytes and returns HdWalletResult with root key and account generator. +""" + + +@runtime_checkable +class WrappedHdExtendedPrivateKey(Protocol): + """Represents a 96-byte ``scalar || prefix || chain_code`` secret that can be unwrapped + for short-lived use and optionally re-wrapped. + + The ``chain_code`` is NOT used for signing. It can, however, be used for key derivation. + If your secret is only used for signing, it is recommended to only store the first 64 bytes + in the secret store and then pad the secret to 96 bytes in the unwrap function. + + The ``wrap`` method is optional for implementations where wrapping is handled automatically + (e.g., hardware wallets, keyring services). + """ + + def unwrap_hd_extended_private_key(self) -> bytearray: ... + def wrap_hd_extended_private_key(self) -> None: + """Optional method to re-wrap the extended private key after use. + + Defaults to no-op if not implemented. + """ + ... + + +@runtime_checkable +class WrappedHdMnemonic(Protocol): + """Represents a BIP39 mnemonic phrase for HD wallet derivation. + + The mnemonic is converted to a seed internally using the xhd-wallet-api's + seed_from_mnemonic function, then used to derive the HD wallet. + + The ``wrap`` method is optional for implementations where wrapping is handled automatically + (e.g., hardware wallets, keyring services). + """ + + def unwrap_hd_mnemonic(self) -> str: ... + def wrap_hd_mnemonic(self) -> None: + """Optional method to re-wrap the mnemonic after use. + + Defaults to no-op if not implemented. + """ + ... + + +def hd_seed_from_mnemonic(mnemonic: str) -> bytearray: + """Convert a BIP39 mnemonic phrase to a 64-byte seed. + + Args: + mnemonic: A BIP39 mnemonic phrase (typically 12, 15, 18, 21, or 24 words). + + Returns: + A 64-byte seed derived from the mnemonic using the xhd-wallet-api's + seed_from_mnemonic function. + """ + seed = seed_from_mnemonic(mnemonic) + return bytearray(seed) + + +def hd_root_key_from_seed(seed: bytearray) -> bytearray: + """Convert a 64-byte seed to a 96-byte HD extended private key root. + + Args: + seed: A 64-byte seed. + + Returns: + A 96-byte extended private key (root key). + + Raises: + ValueError: If the seed is not 64 bytes. + """ + if len(seed) != HD_WALLET_SEED_SIZE: + raise ValueError(f"Seed must be {HD_WALLET_SEED_SIZE} bytes, got {len(seed)}") + return from_seed(seed) + + +def hd_root_key_from_mnemonic(mnemonic: str) -> bytearray: + """Convert a BIP39 mnemonic phrase directly to a 96-byte HD extended private key root. + + This is a convenience function that combines hd_seed_from_mnemonic and + hd_root_key_from_seed. + + Args: + mnemonic: A BIP39 mnemonic phrase. + + Returns: + A 96-byte extended private key (root key). + """ + seed = hd_seed_from_mnemonic(mnemonic) + return hd_root_key_from_seed(seed) + + +def peikert_hd_wallet_generator(seed: bytearray | None = None) -> HdWalletResult: + """Generate an HD wallet using the Peikert derivation scheme. + + Args: + seed: Optional 64-byte seed for deterministic wallet generation. + If not provided, a random seed will be generated. + + Returns: + An HdWalletResult containing the HD root key and an account generator function. + """ + import os + + if seed is None: + seed = bytearray(os.urandom(HD_WALLET_SEED_SIZE)) + elif len(seed) != HD_WALLET_SEED_SIZE: + raise ValueError(f"Seed must be {HD_WALLET_SEED_SIZE} bytes") + + root_key = from_seed(seed) + + def _account_generator(account: int, index: int) -> HdAccountResult: + # Generate key using key_gen with Peikert derivation + # Note: In TypeScript, account is passed directly and key_gen handles the context + xprv_key = key_gen( + root_key, + KeyContext.Address, + account, + index, + DerivationScheme.Peikert, + ) + + # Extract public key from the generated xprv + ed25519_pubkey = public_key(xprv_key) + + # Construct BIP44 path (matching TypeScript implementation) + bip44_path: BIP44Path = ( + _harden(BIP44_PURPOSE), + _harden(BIP44_COIN_TYPE), + _harden(account), + BIP44_CHANGE, + index, + ) + + # Derive the extended private key at the BIP44 path + extended_private_key = derive_path( + root_key, + list(bip44_path), + DerivationScheme.Peikert, + ) + + def raw_ed25519_signer(bytes_to_sign: bytes) -> bytes: + """Sign bytes using the ed25519 secret key.""" + return raw_sign( + root_key, + list(bip44_path), + bytes_to_sign, + DerivationScheme.Peikert, + ) + + return { + "ed25519_pubkey": ed25519_pubkey, + "extended_private_key": extended_private_key, + "bip44_path": bip44_path, + "raw_ed25519_signer": raw_ed25519_signer, + } + + return { + "hd_root_key": root_key, + "account_generator": _account_generator, + } diff --git a/src/algokit_crypto/py.typed b/src/algokit_crypto/py.typed new file mode 100644 index 00000000..e69de29b diff --git a/src/algokit_crypto/signing.py b/src/algokit_crypto/signing.py new file mode 100644 index 00000000..8fd0c201 --- /dev/null +++ b/src/algokit_crypto/signing.py @@ -0,0 +1,330 @@ +"""Wrapped-secret Ed25519 signing utilities. + +Provides functions to derive Ed25519 signing keys from wrapped secrets, +with memory zeroing for security. Supports Ed25519 seeds, HD extended +private keys, HD mnemonics, and legacy Algorand mnemonics. +""" + +from __future__ import annotations + +import hashlib +from collections.abc import Callable +from typing import Protocol, runtime_checkable + +import nacl.bindings +import nacl.signing +from exceptiongroup import ExceptionGroup +from xhd_wallet_api_py import public_key + +from algokit_algo25 import seed_from_mnemonic +from algokit_crypto.ed25519 import ED25519_SEED_SIZE, Ed25519SigningKey, WrappedEd25519Seed +from algokit_crypto.hd import ( + BIP44_CHANGE, + BIP44_COIN_TYPE, + BIP44_PURPOSE, + WrappedHdExtendedPrivateKey, + WrappedHdMnemonic, + hd_root_key_from_mnemonic, +) + +ED25519_EXTENDED_PRIVATE_KEY_LENGTH = 96 + +_ED25519_ORDER = 0x1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED + +# Hardening bit for BIP44 derivation +_HARDENED_BIT = 0x80000000 + + +@runtime_checkable +class WrappedLegacyMnemonic(Protocol): + """Represents a legacy 25-word Algorand mnemonic phrase. + + The ``wrap`` method is optional for implementations where wrapping is handled automatically + (e.g., hardware wallets, keyring services). + """ + + def unwrap_legacy_mnemonic(self) -> str: ... + def wrap_legacy_mnemonic(self) -> None: + """Optional method to re-wrap the mnemonic after use. + + Defaults to no-op if not implemented. + """ + ... + + +WrappedEd25519Secret = WrappedEd25519Seed | WrappedHdExtendedPrivateKey | WrappedHdMnemonic | WrappedLegacyMnemonic + + +def _harden(index: int) -> int: + """Convert a normal index to a hardened index.""" + return index | _HARDENED_BIT + + +def _assert_ed25519_secret_length(secret: bytearray | bytes, secret_type: str) -> None: + if secret_type == "ed25519 seed": + expected_length = ED25519_SEED_SIZE + elif secret_type == "HD extended key": + expected_length = ED25519_EXTENDED_PRIVATE_KEY_LENGTH + else: + raise ValueError(f"Unknown secret type: {secret_type}") + + if len(secret) != expected_length: + raise ValueError(f"Expected unwrapped {secret_type} to be {expected_length} bytes, got {len(secret)}.") + + +def _raw_sign(extended_secret_key: bytearray, data: bytes) -> bytes: + """Sign data using an HD extended secret key (first 64 bytes: scalar || prefix). + + Implements Ed25519 signing with a pre-derived scalar (no SHA-512 hashing of the + secret key), matching the Peikert HD wallet derivation scheme. + """ + scalar = int.from_bytes(extended_secret_key[:32], "little") + k_r = bytes(extended_secret_key[32:64]) + + # (1): pubKey = scalar * G + pubkey = public_key(extended_secret_key) + + # (2): r = SHA512(kR || data) mod order + r_hash = hashlib.sha512(k_r + data).digest() + r = int.from_bytes(r_hash, "little") % _ED25519_ORDER + + # (3): R = r * G + r_bytes = r.to_bytes(32, "little") + r_point = nacl.bindings.crypto_scalarmult_ed25519_base_noclamp(r_bytes) + + # (4): h = SHA512(R || pubkey || data) mod order + h_hash = hashlib.sha512(r_point + pubkey + data).digest() + h = int.from_bytes(h_hash, "little") % _ED25519_ORDER + + # (5): S = (r + h * scalar) mod order + s = (r + h * scalar) % _ED25519_ORDER + s_bytes = s.to_bytes(32, "little") + + return r_point + s_bytes + + +def _zero_secret(secret: bytearray | None) -> None: + """Zero out a bytearray secret in memory.""" + if secret is not None: + secret[:] = b"\x00" * len(secret) + + +def _get_wrap_function(wrapped: WrappedEd25519Secret) -> Callable[[], None]: + """Get the appropriate wrap function for a wrapped secret. + + Returns a no-op function if the wrap method is not implemented. + """ + # Use hasattr to check for unwrap methods to determine the type + # This allows implementations without wrap methods to work + if hasattr(wrapped, "unwrap_ed25519_seed"): + return getattr(wrapped, "wrap_ed25519_seed", lambda: None) + elif hasattr(wrapped, "unwrap_hd_extended_private_key"): + return getattr(wrapped, "wrap_hd_extended_private_key", lambda: None) + elif hasattr(wrapped, "unwrap_hd_mnemonic"): + return getattr(wrapped, "wrap_hd_mnemonic", lambda: None) + elif hasattr(wrapped, "unwrap_legacy_mnemonic"): + return getattr(wrapped, "wrap_legacy_mnemonic", lambda: None) + else: + raise ValueError("Invalid WrappedEd25519Secret: unknown type") + + +def _unwrap_and_derive_pubkey(wrapped: WrappedEd25519Secret) -> tuple[bytes, bytearray | None]: + """Unwrap the secret and derive the public key. + + Returns: + A tuple of (public_key, secret_bytes) where secret_bytes may be None for mnemonic types. + """ + # Use hasattr to check for unwrap methods to determine the type + if hasattr(wrapped, "unwrap_ed25519_seed"): + secret = wrapped.unwrap_ed25519_seed() + _assert_ed25519_secret_length(secret, "ed25519 seed") + signing_key = nacl.signing.SigningKey(bytes(secret)) + pubkey = bytes(signing_key.verify_key) + return pubkey, secret + + elif hasattr(wrapped, "unwrap_hd_extended_private_key"): + secret = wrapped.unwrap_hd_extended_private_key() + _assert_ed25519_secret_length(secret, "HD extended key") + pubkey = public_key(secret) + return pubkey, secret + + elif hasattr(wrapped, "unwrap_hd_mnemonic"): + mnemonic = wrapped.unwrap_hd_mnemonic() + # Convert mnemonic to root key and derive account 0, index 0 + root_key = hd_root_key_from_mnemonic(mnemonic) + # Derive the extended private key at the BIP44 path + from xhd_wallet_api_py import DerivationScheme, derive_path + + bip44_path = [ + _harden(BIP44_PURPOSE), + _harden(BIP44_COIN_TYPE), + _harden(0), # account 0 + BIP44_CHANGE, + 0, # index 0 + ] + extended_private_key = derive_path(root_key, bip44_path, DerivationScheme.Peikert) + pubkey = public_key(extended_private_key) + return pubkey, extended_private_key + + elif hasattr(wrapped, "unwrap_legacy_mnemonic"): + mnemonic = wrapped.unwrap_legacy_mnemonic() + seed = seed_from_mnemonic(mnemonic) + signing_key = nacl.signing.SigningKey(seed) + pubkey = bytes(signing_key.verify_key) + # Return the seed as the secret to be zeroed + return pubkey, bytearray(seed) + + else: + raise ValueError("Invalid WrappedEd25519Secret: missing unwrap function") + + +def _unwrap_and_sign(wrapped: WrappedEd25519Secret, data: bytes) -> tuple[bytes, bytearray | None]: + """Unwrap the secret and sign the data. + + Returns: + A tuple of (signature, secret_bytes) where secret_bytes may be None for mnemonic types. + """ + # Use hasattr to check for unwrap methods to determine the type + if hasattr(wrapped, "unwrap_ed25519_seed"): + secret = wrapped.unwrap_ed25519_seed() + _assert_ed25519_secret_length(secret, "ed25519 seed") + sk = nacl.signing.SigningKey(bytes(secret)) + signed = sk.sign(data) + return signed.signature, secret + + elif hasattr(wrapped, "unwrap_hd_extended_private_key"): + secret = wrapped.unwrap_hd_extended_private_key() + _assert_ed25519_secret_length(secret, "HD extended key") + signature = _raw_sign(secret, data) + return signature, secret + + elif hasattr(wrapped, "unwrap_hd_mnemonic"): + mnemonic = wrapped.unwrap_hd_mnemonic() + # Convert mnemonic to root key and derive account 0, index 0 + root_key = hd_root_key_from_mnemonic(mnemonic) + # Sign using the derived path + from xhd_wallet_api_py import DerivationScheme, raw_sign + + bip44_path = [ + _harden(BIP44_PURPOSE), + _harden(BIP44_COIN_TYPE), + _harden(0), # account 0 + BIP44_CHANGE, + 0, # index 0 + ] + signature = raw_sign(root_key, bip44_path, data, DerivationScheme.Peikert) + # Return None for secret since we don't have direct access to it + return signature, None + + elif hasattr(wrapped, "unwrap_legacy_mnemonic"): + mnemonic = wrapped.unwrap_legacy_mnemonic() + seed = seed_from_mnemonic(mnemonic) + sk = nacl.signing.SigningKey(seed) + signed = sk.sign(data) + # Return the seed as the secret to be zeroed + return signed.signature, bytearray(seed) + + else: + raise ValueError("Invalid WrappedEd25519Secret: missing unwrap function") + + +def pynacl_ed25519_signing_key_from_wrapped_secret(wrapped: WrappedEd25519Secret) -> Ed25519SigningKey: + """Create an Ed25519 signing key from a wrapped secret using PyNaCl. + + Supports Ed25519 seeds, HD extended private keys, HD mnemonics (BIP39), + and legacy Algorand mnemonics (25-word). + + The unwrapped secret is zeroed out after use in ``finally`` blocks. + + Args: + wrapped: A wrapped secret implementing one of the WrappedEd25519Secret protocols. + + Returns: + An Ed25519SigningKey with the derived public key and a signer closure. + + Raises: + ValueError: If the unwrapped secret has an invalid length. + ExceptionGroup: If both the crypto operation and re-wrap fail. + """ + # Determine wrap function + wrap_function = _get_wrap_function(wrapped) + + # Derive public key + pubkey: bytes | None = None + pubkey_error: Exception | None = None + wrap_error: Exception | None = None + secret: bytearray | None = None + try: + pubkey, secret = _unwrap_and_derive_pubkey(wrapped) + except Exception as e: + pubkey_error = e + finally: + try: + wrap_function() + except Exception as e: + wrap_error = e + finally: + _zero_secret(secret) + + if pubkey_error is not None and wrap_error is not None: + raise ExceptionGroup( + "Deriving Ed25519 public key failed and failed to re-wrap Ed25519 secret. Check both errors for details.", + [pubkey_error, wrap_error], + ) + + if pubkey_error is not None: + raise pubkey_error + + if wrap_error is not None: + raise wrap_error + + if pubkey is None: + raise RuntimeError("Deriving Ed25519 public key failed unexpectedly without an error.") + + # Build signer closure + def signer(bytes_to_sign: bytes) -> bytes: + signature: bytes | None = None + signing_error: Exception | None = None + sign_wrap_error: Exception | None = None + sign_secret: bytearray | None = None + try: + signature, sign_secret = _unwrap_and_sign(wrapped, bytes_to_sign) + except Exception as e: + signing_error = e + finally: + try: + wrap_function() + except Exception as e: + sign_wrap_error = e + finally: + _zero_secret(sign_secret) + + if signing_error is not None and sign_wrap_error is not None: + raise ExceptionGroup( + "Signing failed and failed to re-wrap Ed25519 secret. Check both errors for details.", + [signing_error, sign_wrap_error], + ) + + if signing_error is not None: + raise signing_error + + if sign_wrap_error is not None: + raise sign_wrap_error + + if signature is None: + raise RuntimeError("Signing failed unexpectedly without an error.") + + return signature + + return Ed25519SigningKey( + ed25519_pubkey=pubkey, + raw_ed25519_signer=signer, + ) + + +ed25519_signing_key_from_wrapped_secret = pynacl_ed25519_signing_key_from_wrapped_secret +"""Default function to create an Ed25519 signing key from a wrapped secret. + +Currently uses the PyNaCl implementation. This may change in the future. +To explicitly use the PyNaCl implementation, use ``pynacl_ed25519_signing_key_from_wrapped_secret``. +""" diff --git a/src/algokit_indexer_client/__init__.py b/src/algokit_indexer_client/__init__.py new file mode 100644 index 00000000..2c58bc4e --- /dev/null +++ b/src/algokit_indexer_client/__init__.py @@ -0,0 +1,10 @@ +# AUTO-GENERATED: oas_generator + + +from .client import IndexerClient +from .config import ClientConfig + +__all__ = [ + "ClientConfig", + "IndexerClient", +] diff --git a/src/algokit_indexer_client/client.py b/src/algokit_indexer_client/client.py new file mode 100644 index 00000000..edee4898 --- /dev/null +++ b/src/algokit_indexer_client/client.py @@ -0,0 +1,1456 @@ +# AUTO-GENERATED: oas_generator +import random +import time +from dataclasses import is_dataclass +from datetime import datetime +from typing import Any, Literal, TypeVar, overload + +import httpx +import msgpack + +from algokit_common.serde import from_wire, to_wire + +from . import models +from .config import ClientConfig +from .exceptions import UnexpectedStatusError +from .types import Headers + +# HTTP status codes that warrant a retry (aligned with algokit-utils-ts) +_RETRY_STATUS_CODES: frozenset[int] = frozenset({408, 413, 429, 500, 502, 503, 504}) +# Network error codes that warrant a retry (aligned with algokit-utils-ts) +_RETRY_ERROR_CODES: frozenset[str] = frozenset( + { + "ETIMEDOUT", + "ECONNRESET", + "EADDRINUSE", + "ECONNREFUSED", + "EPIPE", + "ENOTFOUND", + "ENETUNREACH", + "EAI_AGAIN", + "EPROTO", + } +) +_MAX_BACKOFF_MS: float = 10_000.0 +_DEFAULT_MAX_TRIES: int = 5 + +ModelT = TypeVar("ModelT") +ListModelT = TypeVar("ListModelT") +PrimitiveT = TypeVar("PrimitiveT") + +# Prefixed markers used when converting unhashable msgpack map keys into hashable tuples +_UNHASHABLE_PREFIXES: dict[str, str] = { + "dict": "__dict_key__", + "list": "__list_key__", + "set": "__set_key__", + "generic": "__unhashable__", +} + + +class IndexerClient: + def __init__(self, config: ClientConfig | None = None, *, http_client: httpx.Client | None = None) -> None: + self._config = config or ClientConfig() + # Track whether a custom HTTP client was provided to avoid retry conflicts + self._uses_custom_client = http_client is not None + self._client = http_client or httpx.Client( + base_url=self._config.base_url, + timeout=self._config.timeout, + verify=self._config.verify, + ) + + def close(self) -> None: + self._client.close() + + def _calculate_max_tries(self) -> int: + """Calculate maximum number of tries from config.max_retries.""" + max_retries = self._config.max_retries + if not isinstance(max_retries, int) or max_retries < 0: + return _DEFAULT_MAX_TRIES + return max_retries + 1 + + def _should_retry(self, error: Exception | None, status_code: int | None, attempt: int, max_tries: int) -> bool: + """Determine if a request should be retried based on error/status and attempt count.""" + if attempt >= max_tries: + return False + + # Check HTTP status code + if status_code is not None and status_code in _RETRY_STATUS_CODES: + return True + + # Check network error codes (aligned with algokit-utils-ts) + if error is not None: + error_code = self._extract_error_code(error) + if error_code and error_code in _RETRY_ERROR_CODES: + return True + + return False + + def _extract_error_code(self, error: BaseException) -> str | None: + """Extract error code from exception, checking common attributes.""" + # Check for 'code' attribute (common in OS/network errors) + if hasattr(error, "code") and isinstance(error.code, str): + return error.code + # Check for errno attribute + if hasattr(error, "errno") and error.errno is not None: + import errno as errno_module + + try: + return errno_module.errorcode.get(error.errno) + except (TypeError, AttributeError): + pass + # Check __cause__ for wrapped errors + if error.__cause__ is not None: + return self._extract_error_code(error.__cause__) + return None + + def _request_with_retry(self, request_kwargs: dict[str, Any]) -> httpx.Response: + """Execute request with exponential backoff retry for transient failures. + + When a custom HTTP client is provided, retries are disabled to avoid + conflicts with any retry mechanism the custom client may implement. + """ + # Disable retries when using a custom HTTP client to avoid conflicts + # with the client's own retry mechanism + if self._uses_custom_client: + return self._client.request(**request_kwargs) + + max_tries = self._calculate_max_tries() + attempt = 1 + last_error: Exception | None = None + + while attempt <= max_tries: + status_code: int | None = None + try: + response = self._client.request(**request_kwargs) + status_code = response.status_code + if not self._should_retry(None, status_code, attempt, max_tries): + return response + except httpx.TransportError as exc: + last_error = exc + if not self._should_retry(exc, None, attempt, max_tries): + raise + + if attempt == 1: + backoff_ms = 0.0 + else: + base_backoff = min(1000.0 * (2 ** (attempt - 1)), _MAX_BACKOFF_MS) + jitter = 0.5 + random.random() # Random value between 0.5 and 1.5 + backoff_ms = base_backoff * jitter + if backoff_ms > 0: + time.sleep(backoff_ms / 1000.0) + attempt += 1 + + # Should not reach here, but satisfy type checker + if last_error: + raise last_error + raise RuntimeError(f"Request failed after {max_tries} attempt(s)") + + # common + + def health_check( + self, + ) -> models.HealthCheck: + """ + Returns 200 if healthy. + """ + + path = "/health" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.HealthCheck) + + raise UnexpectedStatusError(response.status_code, response.text) + + # lookup + + def lookup_account_app_local_states( + self, + account_id: str, + *, + application_id: int | None = None, + include_all: bool | None = None, + limit: int | None = None, + next_: str | None = None, + ) -> models.ApplicationLocalStatesResponse: + """ + Lookup an account's asset holdings, optionally for a specific ID. + """ + + path = "/v2/accounts/{account-id}/apps-local-state" + path = path.replace("{account-id}", str(account_id)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if application_id is not None: + params["application-id"] = application_id + + if include_all is not None: + params["include-all"] = include_all + + if limit is not None: + params["limit"] = limit + + if next_ is not None: + params["next"] = next_ + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.ApplicationLocalStatesResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def lookup_account_assets( + self, + account_id: str, + *, + asset_id: int | None = None, + include_all: bool | None = None, + limit: int | None = None, + next_: str | None = None, + ) -> models.AssetHoldingsResponse: + """ + Lookup an account's asset holdings, optionally for a specific ID. + """ + + path = "/v2/accounts/{account-id}/assets" + path = path.replace("{account-id}", str(account_id)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if asset_id is not None: + params["asset-id"] = asset_id + + if include_all is not None: + params["include-all"] = include_all + + if limit is not None: + params["limit"] = limit + + if next_ is not None: + params["next"] = next_ + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.AssetHoldingsResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def lookup_account_by_id( + self, + account_id: str, + *, + round_: int | None = None, + include_all: bool | None = None, + exclude: list[str] | None = None, + ) -> models.AccountResponse: + """ + Lookup account information. + """ + + path = "/v2/accounts/{account-id}" + path = path.replace("{account-id}", str(account_id)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if round_ is not None: + params["round"] = round_ + + if include_all is not None: + params["include-all"] = include_all + + if exclude is not None: + params["exclude"] = exclude + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.AccountResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def lookup_account_created_applications( + self, + account_id: str, + *, + application_id: int | None = None, + include_all: bool | None = None, + limit: int | None = None, + next_: str | None = None, + ) -> models.ApplicationsResponse: + """ + Lookup an account's created application parameters, optionally for a specific ID. + """ + + path = "/v2/accounts/{account-id}/created-applications" + path = path.replace("{account-id}", str(account_id)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if application_id is not None: + params["application-id"] = application_id + + if include_all is not None: + params["include-all"] = include_all + + if limit is not None: + params["limit"] = limit + + if next_ is not None: + params["next"] = next_ + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.ApplicationsResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def lookup_account_created_assets( + self, + account_id: str, + *, + asset_id: int | None = None, + include_all: bool | None = None, + limit: int | None = None, + next_: str | None = None, + ) -> models.AssetsResponse: + """ + Lookup an account's created asset parameters, optionally for a specific ID. + """ + + path = "/v2/accounts/{account-id}/created-assets" + path = path.replace("{account-id}", str(account_id)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if asset_id is not None: + params["asset-id"] = asset_id + + if include_all is not None: + params["include-all"] = include_all + + if limit is not None: + params["limit"] = limit + + if next_ is not None: + params["next"] = next_ + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.AssetsResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def lookup_account_transactions( # noqa: C901, PLR0912, PLR0913 + self, + account_id: str, + *, + limit: int | None = None, + next_: str | None = None, + note_prefix: str | None = None, + tx_type: str | None = None, + sig_type: str | None = None, + txid: str | None = None, + round_: int | None = None, + min_round: int | None = None, + max_round: int | None = None, + asset_id: int | None = None, + before_time: datetime | None = None, + after_time: datetime | None = None, + currency_greater_than: int | None = None, + currency_less_than: int | None = None, + rekey_to: bool | None = None, + ) -> models.TransactionsResponse: + """ + Lookup account transactions. Transactions are returned newest to oldest. + """ + + path = "/v2/accounts/{account-id}/transactions" + path = path.replace("{account-id}", str(account_id)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if limit is not None: + params["limit"] = limit + + if next_ is not None: + params["next"] = next_ + + if note_prefix is not None: + params["note-prefix"] = note_prefix + + if tx_type is not None: + params["tx-type"] = tx_type + + if sig_type is not None: + params["sig-type"] = sig_type + + if txid is not None: + params["txid"] = txid + + if round_ is not None: + params["round"] = round_ + + if min_round is not None: + params["min-round"] = min_round + + if max_round is not None: + params["max-round"] = max_round + + if asset_id is not None: + params["asset-id"] = asset_id + + if before_time is not None: + params["before-time"] = before_time + + if after_time is not None: + params["after-time"] = after_time + + if currency_greater_than is not None: + params["currency-greater-than"] = currency_greater_than + + if currency_less_than is not None: + params["currency-less-than"] = currency_less_than + + if rekey_to is not None: + params["rekey-to"] = rekey_to + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.TransactionsResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def lookup_application_box_by_id_and_name( + self, + application_id: int, + name: str, + ) -> models.Box: + """ + Get box information for a given application. + """ + + path = "/v2/applications/{application-id}/box" + path = path.replace("{application-id}", str(application_id)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if name is not None: + params["name"] = name + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.Box) + + raise UnexpectedStatusError(response.status_code, response.text) + + def lookup_application_by_id( + self, + application_id: int, + *, + include_all: bool | None = None, + ) -> models.ApplicationResponse: + """ + Lookup application. + """ + + path = "/v2/applications/{application-id}" + path = path.replace("{application-id}", str(application_id)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if include_all is not None: + params["include-all"] = include_all + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.ApplicationResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def lookup_application_logs_by_id( + self, + application_id: int, + *, + limit: int | None = None, + next_: str | None = None, + txid: str | None = None, + min_round: int | None = None, + max_round: int | None = None, + sender_address: str | None = None, + ) -> models.ApplicationLogsResponse: + """ + Lookup application logs. + """ + + path = "/v2/applications/{application-id}/logs" + path = path.replace("{application-id}", str(application_id)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if limit is not None: + params["limit"] = limit + + if next_ is not None: + params["next"] = next_ + + if txid is not None: + params["txid"] = txid + + if min_round is not None: + params["min-round"] = min_round + + if max_round is not None: + params["max-round"] = max_round + + if sender_address is not None: + params["sender-address"] = sender_address + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.ApplicationLogsResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def lookup_asset_balances( + self, + asset_id: int, + *, + include_all: bool | None = None, + limit: int | None = None, + next_: str | None = None, + currency_greater_than: int | None = None, + currency_less_than: int | None = None, + ) -> models.AssetBalancesResponse: + """ + Lookup the list of accounts who hold this asset + """ + + path = "/v2/assets/{asset-id}/balances" + path = path.replace("{asset-id}", str(asset_id)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if include_all is not None: + params["include-all"] = include_all + + if limit is not None: + params["limit"] = limit + + if next_ is not None: + params["next"] = next_ + + if currency_greater_than is not None: + params["currency-greater-than"] = currency_greater_than + + if currency_less_than is not None: + params["currency-less-than"] = currency_less_than + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.AssetBalancesResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def lookup_asset_by_id( + self, + asset_id: int, + *, + include_all: bool | None = None, + ) -> models.AssetResponse: + """ + Lookup asset information. + """ + + path = "/v2/assets/{asset-id}" + path = path.replace("{asset-id}", str(asset_id)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if include_all is not None: + params["include-all"] = include_all + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.AssetResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def lookup_asset_transactions( # noqa: C901, PLR0912, PLR0913 + self, + asset_id: int, + *, + limit: int | None = None, + next_: str | None = None, + note_prefix: str | None = None, + tx_type: str | None = None, + sig_type: str | None = None, + txid: str | None = None, + round_: int | None = None, + min_round: int | None = None, + max_round: int | None = None, + before_time: datetime | None = None, + after_time: datetime | None = None, + currency_greater_than: int | None = None, + currency_less_than: int | None = None, + address: str | None = None, + address_role: str | None = None, + exclude_close_to: bool | None = None, + rekey_to: bool | None = None, + ) -> models.TransactionsResponse: + """ + Lookup transactions for an asset. Transactions are returned oldest to newest. + """ + + path = "/v2/assets/{asset-id}/transactions" + path = path.replace("{asset-id}", str(asset_id)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if limit is not None: + params["limit"] = limit + + if next_ is not None: + params["next"] = next_ + + if note_prefix is not None: + params["note-prefix"] = note_prefix + + if tx_type is not None: + params["tx-type"] = tx_type + + if sig_type is not None: + params["sig-type"] = sig_type + + if txid is not None: + params["txid"] = txid + + if round_ is not None: + params["round"] = round_ + + if min_round is not None: + params["min-round"] = min_round + + if max_round is not None: + params["max-round"] = max_round + + if before_time is not None: + params["before-time"] = before_time + + if after_time is not None: + params["after-time"] = after_time + + if currency_greater_than is not None: + params["currency-greater-than"] = currency_greater_than + + if currency_less_than is not None: + params["currency-less-than"] = currency_less_than + + if address is not None: + params["address"] = address + + if address_role is not None: + params["address-role"] = address_role + + if exclude_close_to is not None: + params["exclude-close-to"] = exclude_close_to + + if rekey_to is not None: + params["rekey-to"] = rekey_to + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.TransactionsResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def lookup_block( + self, + round_number: int, + *, + header_only: bool | None = None, + ) -> models.Block: + """ + Lookup block. + """ + + path = "/v2/blocks/{round-number}" + path = path.replace("{round-number}", str(round_number)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if header_only is not None: + params["header-only"] = header_only + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.Block) + + raise UnexpectedStatusError(response.status_code, response.text) + + def lookup_transaction_by_id( + self, + txid: str, + ) -> models.TransactionResponse: + """ + Lookup a single transaction. + """ + + path = "/v2/transactions/{txid}" + path = path.replace("{txid}", str(txid)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.TransactionResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + # search + + def search_for_accounts( # noqa: C901, PLR0913 + self, + *, + asset_id: int | None = None, + limit: int | None = None, + next_: str | None = None, + currency_greater_than: int | None = None, + include_all: bool | None = None, + exclude: list[str] | None = None, + currency_less_than: int | None = None, + auth_addr: str | None = None, + round_: int | None = None, + application_id: int | None = None, + online_only: bool | None = None, + ) -> models.AccountsResponse: + """ + Search for accounts. + """ + + path = "/v2/accounts" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if asset_id is not None: + params["asset-id"] = asset_id + + if limit is not None: + params["limit"] = limit + + if next_ is not None: + params["next"] = next_ + + if currency_greater_than is not None: + params["currency-greater-than"] = currency_greater_than + + if include_all is not None: + params["include-all"] = include_all + + if exclude is not None: + params["exclude"] = exclude + + if currency_less_than is not None: + params["currency-less-than"] = currency_less_than + + if auth_addr is not None: + params["auth-addr"] = auth_addr + + if round_ is not None: + params["round"] = round_ + + if application_id is not None: + params["application-id"] = application_id + + if online_only is not None: + params["online-only"] = online_only + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.AccountsResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def search_for_application_boxes( + self, + application_id: int, + *, + limit: int | None = None, + next_: str | None = None, + ) -> models.BoxesResponse: + """ + Get box names for a given application. + """ + + path = "/v2/applications/{application-id}/boxes" + path = path.replace("{application-id}", str(application_id)) + + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if limit is not None: + params["limit"] = limit + + if next_ is not None: + params["next"] = next_ + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.BoxesResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def search_for_applications( + self, + *, + application_id: int | None = None, + creator: str | None = None, + include_all: bool | None = None, + limit: int | None = None, + next_: str | None = None, + ) -> models.ApplicationsResponse: + """ + Search for applications + """ + + path = "/v2/applications" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if application_id is not None: + params["application-id"] = application_id + + if creator is not None: + params["creator"] = creator + + if include_all is not None: + params["include-all"] = include_all + + if limit is not None: + params["limit"] = limit + + if next_ is not None: + params["next"] = next_ + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.ApplicationsResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def search_for_assets( + self, + *, + include_all: bool | None = None, + limit: int | None = None, + next_: str | None = None, + creator: str | None = None, + name: str | None = None, + unit: str | None = None, + asset_id: int | None = None, + ) -> models.AssetsResponse: + """ + Search for assets. + """ + + path = "/v2/assets" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if include_all is not None: + params["include-all"] = include_all + + if limit is not None: + params["limit"] = limit + + if next_ is not None: + params["next"] = next_ + + if creator is not None: + params["creator"] = creator + + if name is not None: + params["name"] = name + + if unit is not None: + params["unit"] = unit + + if asset_id is not None: + params["asset-id"] = asset_id + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.AssetsResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def search_for_block_headers( # noqa: C901 + self, + *, + limit: int | None = None, + next_: str | None = None, + min_round: int | None = None, + max_round: int | None = None, + before_time: datetime | None = None, + after_time: datetime | None = None, + proposers: list[str] | None = None, + expired: list[str] | None = None, + absent: list[str] | None = None, + ) -> models.BlockHeadersResponse: + """ + Search for block headers. Block headers are returned in ascending round order. + Transactions are not included in the output. + """ + + path = "/v2/block-headers" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if limit is not None: + params["limit"] = limit + + if next_ is not None: + params["next"] = next_ + + if min_round is not None: + params["min-round"] = min_round + + if max_round is not None: + params["max-round"] = max_round + + if before_time is not None: + params["before-time"] = before_time + + if after_time is not None: + params["after-time"] = after_time + + if proposers is not None: + params["proposers"] = proposers + + if expired is not None: + params["expired"] = expired + + if absent is not None: + params["absent"] = absent + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.BlockHeadersResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def search_for_transactions( # noqa: C901, PLR0912, PLR0913 + self, + *, + limit: int | None = None, + next_: str | None = None, + note_prefix: str | None = None, + tx_type: str | None = None, + sig_type: str | None = None, + group_id: str | None = None, + txid: str | None = None, + round_: int | None = None, + min_round: int | None = None, + max_round: int | None = None, + asset_id: int | None = None, + before_time: datetime | None = None, + after_time: datetime | None = None, + currency_greater_than: int | None = None, + currency_less_than: int | None = None, + address: str | None = None, + address_role: str | None = None, + exclude_close_to: bool | None = None, + rekey_to: bool | None = None, + application_id: int | None = None, + ) -> models.TransactionsResponse: + """ + Search for transactions. Transactions are returned oldest to newest unless the address + parameter is used, in which case results are returned newest to oldest. + """ + + path = "/v2/transactions" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + if limit is not None: + params["limit"] = limit + + if next_ is not None: + params["next"] = next_ + + if note_prefix is not None: + params["note-prefix"] = note_prefix + + if tx_type is not None: + params["tx-type"] = tx_type + + if sig_type is not None: + params["sig-type"] = sig_type + + if group_id is not None: + params["group-id"] = group_id + + if txid is not None: + params["txid"] = txid + + if round_ is not None: + params["round"] = round_ + + if min_round is not None: + params["min-round"] = min_round + + if max_round is not None: + params["max-round"] = max_round + + if asset_id is not None: + params["asset-id"] = asset_id + + if before_time is not None: + params["before-time"] = before_time + + if after_time is not None: + params["after-time"] = after_time + + if currency_greater_than is not None: + params["currency-greater-than"] = currency_greater_than + + if currency_less_than is not None: + params["currency-less-than"] = currency_less_than + + if address is not None: + params["address"] = address + + if address_role is not None: + params["address-role"] = address_role + + if exclude_close_to is not None: + params["exclude-close-to"] = exclude_close_to + + if rekey_to is not None: + params["rekey-to"] = rekey_to + + if application_id is not None: + params["application-id"] = application_id + + accept_value: str | None = None + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.TransactionsResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def _assign_body( + self, + request_kwargs: dict[str, Any], + payload: object, + descriptor: dict[str, object], + media_types: list[str], + ) -> None: + encoded = self._encode_payload(payload, descriptor) + binary_types = {"application/x-binary", "application/octet-stream"} + if bool(descriptor.get("is_binary")) or any(mt in binary_types for mt in media_types): + if encoded is None: + return + request_kwargs["content"] = encoded + if media_types: + request_kwargs.setdefault("headers", {})["content-type"] = media_types[0] + else: + request_kwargs.setdefault("headers", {})["content-type"] = "application/octet-stream" + elif "application/json" in media_types: + request_kwargs["json"] = encoded + elif "application/msgpack" in media_types: + request_kwargs["content"] = msgpack.packb(encoded, use_bin_type=True) + request_kwargs.setdefault("headers", {})["content-type"] = "application/msgpack" + else: + request_kwargs["json"] = encoded + + def _encode_payload(self, payload: object, descriptor: dict[str, object]) -> object: + if payload is None: + return None + if is_dataclass(payload): + return to_wire(payload) + list_model = descriptor.get("list_model") + if list_model and isinstance(payload, list): + return [to_wire(item) if is_dataclass(item) else item for item in payload] + return payload + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + model: type[ModelT], + is_binary: bool = False, + raw_msgpack: bool = False, + ) -> ModelT: ... + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + list_model: type[ListModelT], + is_binary: bool = False, + raw_msgpack: bool = False, + ) -> list[ListModelT]: ... + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + type_: type[PrimitiveT], + is_binary: bool = False, + raw_msgpack: bool = False, + ) -> PrimitiveT: ... + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + is_binary: Literal[True], + raw_msgpack: bool = False, + ) -> bytes: ... + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + raw_msgpack: Literal[True], + ) -> bytes: ... + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + type_: None = None, + is_binary: bool = False, + raw_msgpack: bool = False, + ) -> object: ... + + def _decode_response( + self, + response: httpx.Response, + *, + model: type[Any] | None = None, + list_model: type[Any] | None = None, + type_: type[Any] | None = None, + is_binary: bool = False, + raw_msgpack: bool = False, + ) -> object: + if is_binary or raw_msgpack: + return response.content + content_type = response.headers.get("content-type", "application/json") + if "msgpack" in content_type: + # Handle msgpack unpacking with support for unhashable keys + # Use Unpacker for more control over the unpacking process + unpacker = msgpack.Unpacker( + raw=True, + strict_map_key=False, + object_pairs_hook=self._msgpack_pairs_hook, + ) + unpacker.feed(response.content) + try: + data = unpacker.unpack() + except TypeError: + # If unpacking fails due to unhashable keys, try without the hook + # and handle in normalization + unpacker = msgpack.Unpacker(raw=True, strict_map_key=False) + unpacker.feed(response.content) + data = unpacker.unpack() + data = self._normalize_msgpack(data) + elif content_type.startswith("application/json"): + data = response.json() + else: + data = response.text + if model is not None: + return from_wire(model, data) + if list_model is not None: + return [from_wire(list_model, item) for item in data] + if type_ is not None: + return data + return data + + def _normalize_msgpack(self, value: object) -> object: + # Handle pairs returned from msgpack_pairs_hook when keys are unhashable + _pair_length = 2 + if isinstance(value, list) and value and isinstance(value[0], tuple | list) and len(value[0]) == _pair_length: + # Convert to dict with normalized keys + pairs_dict: dict[object, object] = {} + for pair in value: + if isinstance(pair, tuple | list) and len(pair) == _pair_length: + k, v = pair + # For unhashable keys (like dict keys), use a tuple representation + try: + normalized_key = self._coerce_msgpack_key(k) + pairs_dict[normalized_key] = self._normalize_msgpack(v) + except TypeError: + # Key is unhashable - use tuple representation + normalized_key = ("__unhashable__", id(k), str(k)) + pairs_dict[normalized_key] = self._normalize_msgpack(v) + return pairs_dict + if isinstance(value, dict): + # Safely normalize maps: coerce string/bytes keys, but tolerate complex/unhashable keys + try: + normalized_dict: dict[object, object] = {} + for key, item in value.items(): + normalized_dict[self._coerce_msgpack_key(key)] = self._normalize_msgpack(item) + return normalized_dict + except TypeError: + # Some maps can decode to object/dict keys; keep original keys and + # only normalize values to avoid "unhashable type: 'dict'" errors. + for k, item in list(value.items()): + value[k] = self._normalize_msgpack(item) + return value + if isinstance(value, list): + return [self._normalize_msgpack(item) for item in value] + return value + + def _coerce_msgpack_key(self, key: object) -> object: + if isinstance(key, bytes): + try: + return key.decode("utf-8", errors="strict") + except UnicodeDecodeError: + return key + return key + + def _msgpack_pairs_hook(self, pairs: list[tuple[object, object]] | list[list[object]]) -> dict[object, object]: + # Convert pairs to dict, handling unhashable keys by converting them to hashable tuples + out: dict[object, object] = {} + _hashable_type_tuple = (str, int, float, bool, type(None), bytes) + + for k, v in pairs: + if isinstance(k, dict | list | set): + # Convert unhashable key to hashable tuple + hashable_key: tuple[str, object] + if isinstance(k, dict): + try: + hashable_key = (_UNHASHABLE_PREFIXES["dict"], tuple(sorted(k.items()))) + except TypeError: + hashable_key = (_UNHASHABLE_PREFIXES["dict"], str(k)) + elif isinstance(k, list): + prefix = _UNHASHABLE_PREFIXES["list"] + hashable_key = (prefix, tuple(k) if all(isinstance(x, _hashable_type_tuple) for x in k) else str(k)) + else: # set + prefix = _UNHASHABLE_PREFIXES["set"] + if all(isinstance(x, _hashable_type_tuple) for x in k): + hashable_key = (prefix, tuple(sorted(k))) + else: + hashable_key = (prefix, str(k)) + out[hashable_key] = v + else: + # Key should be hashable, use as-is + try: + out[k] = v + except TypeError: + # Unexpected unhashable type, convert to tuple + out[(_UNHASHABLE_PREFIXES["generic"], str(type(k).__name__), str(k))] = v + return out diff --git a/src/algokit_indexer_client/config.py b/src/algokit_indexer_client/config.py new file mode 100644 index 00000000..111fc2c2 --- /dev/null +++ b/src/algokit_indexer_client/config.py @@ -0,0 +1,36 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + + +@dataclass(slots=True) +class ClientConfig: + """Runtime configuration for IndexerClient. + + Attributes: + base_url: Base URL for the API endpoint. + token: Optional authentication token. + token_header: Header name for the authentication token. + timeout: Request timeout in seconds. Set to None for no timeout. + verify: SSL certificate verification. Can be a boolean or path to CA bundle. + extra_headers: Additional headers to include in all requests. + max_retries: Maximum number of retry attempts for transient failures. + Set to 0 to disable retries. Default is 4 (5 total attempts). + Note: Retries are automatically disabled when a custom http_client + is provided to avoid conflicts with the client's own retry mechanism. + """ + + base_url: str = "http://localhost:8980" + token: str | None = None + token_header: str = "X-Indexer-API-Token" + timeout: float | None = 30.0 + verify: bool | str = True + extra_headers: dict[str, str] = field(default_factory=dict) + max_retries: int = 4 + + def resolve_headers(self) -> dict[str, str]: + headers = dict(self.extra_headers) + if self.token: + headers[self.token_header] = self.token + return headers diff --git a/src/algokit_indexer_client/exceptions.py b/src/algokit_indexer_client/exceptions.py new file mode 100644 index 00000000..06e4b129 --- /dev/null +++ b/src/algokit_indexer_client/exceptions.py @@ -0,0 +1,59 @@ +# AUTO-GENERATED: oas_generator + +from http import HTTPStatus +from json import JSONDecodeError, loads + + +class ApiError(RuntimeError): + """Base exception for errors raised by generated clients.""" + + +def _format_payload(payload: object) -> str | None: # noqa: C901, PLR0912 + """Extract a human-friendly message from a payload.""" + if payload is None: + return None + + text: str | None = None + if isinstance(payload, (bytes | bytearray | memoryview)): + try: + text = bytes(payload).decode("utf-8", errors="ignore") + except Exception: + text = None + if text is None: + text = str(payload) + + result = text.strip() + if not result: + return None + + try: + decoded = loads(result) + except (JSONDecodeError, TypeError): + return result + + if isinstance(decoded, dict): + for key in ("message", "msg", "error", "detail", "description", "data"): + value = decoded.get(key) + if isinstance(value, str): + candidate = value.strip() + if candidate: + result = candidate + break + + if isinstance(decoded, list) and decoded: + first = decoded[0] + if isinstance(first, str): + candidate = first.strip() + if candidate: + result = candidate + + return result + + +class UnexpectedStatusError(ApiError): + def __init__(self, status_code: int, payload: object) -> None: + message = _format_payload(payload) + description = f" {message}" if message else "" + super().__init__(f"Unexpected status code {status_code}{description}") + self.status_code = HTTPStatus(status_code) + self.payload = payload diff --git a/src/algokit_indexer_client/models/__init__.py b/src/algokit_indexer_client/models/__init__.py new file mode 100644 index 00000000..490b12de --- /dev/null +++ b/src/algokit_indexer_client/models/__init__.py @@ -0,0 +1,148 @@ +# AUTO-GENERATED: oas_generator + + +from ._account import Account +from ._account_participation import AccountParticipation +from ._account_response import AccountResponse +from ._account_state_delta import AccountStateDelta +from ._accounts_response import AccountsResponse +from ._application import Application +from ._application_local_state import ApplicationLocalState +from ._application_local_states_response import ApplicationLocalStatesResponse +from ._application_log_data import ApplicationLogData +from ._application_logs_response import ApplicationLogsResponse +from ._application_params import ApplicationParams +from ._application_response import ApplicationResponse +from ._application_state_schema import ApplicationStateSchema +from ._applications_response import ApplicationsResponse +from ._asset import Asset +from ._asset_balances_response import AssetBalancesResponse +from ._asset_holding import AssetHolding +from ._asset_holdings_response import AssetHoldingsResponse +from ._asset_params import AssetParams +from ._asset_response import AssetResponse +from ._assets_response import AssetsResponse +from ._block import Block +from ._block_headers_response import BlockHeadersResponse +from ._block_rewards import BlockRewards +from ._block_upgrade_state import BlockUpgradeState +from ._block_upgrade_vote import BlockUpgradeVote +from ._box import Box +from ._box_descriptor import BoxDescriptor +from ._box_reference import BoxReference +from ._boxes_response import BoxesResponse +from ._error_response import ErrorResponse +from ._eval_delta import EvalDelta +from ._eval_delta_key_value import EvalDeltaKeyValue +from ._hash_factory import HashFactory +from ._hb_proof_fields import HbProofFields +from ._health_check import HealthCheck +from ._holding_ref import HoldingRef +from ._indexer_state_proof_message import IndexerStateProofMessage +from ._locals_ref import LocalsRef +from ._merkle_array_proof import MerkleArrayProof +from ._mini_asset_holding import MiniAssetHolding +from ._on_completion import OnCompletion +from ._participation_updates import ParticipationUpdates +from ._resource_ref import ResourceRef +from ._state_delta import StateDelta +from ._state_proof_fields import StateProofFields +from ._state_proof_participant import StateProofParticipant +from ._state_proof_reveal import StateProofReveal +from ._state_proof_sig_slot import StateProofSigSlot +from ._state_proof_signature import StateProofSignature +from ._state_proof_tracking import StateProofTracking +from ._state_proof_verifier import StateProofVerifier +from ._state_schema import StateSchema +from ._teal_key_value import TealKeyValue +from ._teal_key_value_store import TealKeyValueStore +from ._teal_value import TealValue +from ._transaction import Transaction +from ._transaction_application import TransactionApplication +from ._transaction_asset_config import TransactionAssetConfig +from ._transaction_asset_freeze import TransactionAssetFreeze +from ._transaction_asset_transfer import TransactionAssetTransfer +from ._transaction_heartbeat import TransactionHeartbeat +from ._transaction_keyreg import TransactionKeyreg +from ._transaction_payment import TransactionPayment +from ._transaction_response import TransactionResponse +from ._transaction_signature import TransactionSignature +from ._transaction_signature_logicsig import TransactionSignatureLogicsig +from ._transaction_signature_multisig import TransactionSignatureMultisig +from ._transaction_signature_multisig_subsignature import TransactionSignatureMultisigSubsignature +from ._transaction_state_proof import TransactionStateProof +from ._transactions_response import TransactionsResponse + +__all__ = [ + "Account", + "AccountParticipation", + "AccountResponse", + "AccountStateDelta", + "AccountsResponse", + "Application", + "ApplicationLocalState", + "ApplicationLocalStatesResponse", + "ApplicationLogData", + "ApplicationLogsResponse", + "ApplicationParams", + "ApplicationResponse", + "ApplicationStateSchema", + "ApplicationsResponse", + "Asset", + "AssetBalancesResponse", + "AssetHolding", + "AssetHoldingsResponse", + "AssetParams", + "AssetResponse", + "AssetsResponse", + "Block", + "BlockHeadersResponse", + "BlockRewards", + "BlockUpgradeState", + "BlockUpgradeVote", + "Box", + "BoxDescriptor", + "BoxReference", + "BoxesResponse", + "ErrorResponse", + "EvalDelta", + "EvalDeltaKeyValue", + "HashFactory", + "HbProofFields", + "HealthCheck", + "HoldingRef", + "IndexerStateProofMessage", + "LocalsRef", + "MerkleArrayProof", + "MiniAssetHolding", + "OnCompletion", + "ParticipationUpdates", + "ResourceRef", + "StateDelta", + "StateProofFields", + "StateProofParticipant", + "StateProofReveal", + "StateProofSigSlot", + "StateProofSignature", + "StateProofTracking", + "StateProofVerifier", + "StateSchema", + "TealKeyValue", + "TealKeyValueStore", + "TealValue", + "Transaction", + "TransactionApplication", + "TransactionAssetConfig", + "TransactionAssetFreeze", + "TransactionAssetTransfer", + "TransactionHeartbeat", + "TransactionKeyreg", + "TransactionPayment", + "TransactionResponse", + "TransactionSignature", + "TransactionSignatureLogicsig", + "TransactionSignatureMultisig", + "TransactionSignatureMultisigSubsignature", + "TransactionStateProof", + "TransactionsResponse", +] diff --git a/src/algokit_indexer_client/models/_account.py b/src/algokit_indexer_client/models/_account.py new file mode 100644 index 00000000..3634ea3b --- /dev/null +++ b/src/algokit_indexer_client/models/_account.py @@ -0,0 +1,161 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._account_participation import AccountParticipation +from ._application import Application +from ._application_local_state import ApplicationLocalState +from ._application_state_schema import ApplicationStateSchema +from ._asset import Asset +from ._asset_holding import AssetHolding +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class Account: + """ + Account information at a given round. + + Definition: + data/basics/userBalance.go : AccountData + """ + + address: str = field( + default="", + metadata=wire("address"), + ) + amount: int = field( + default=0, + metadata=wire("amount"), + ) + amount_without_pending_rewards: int = field( + default=0, + metadata=wire("amount-without-pending-rewards"), + ) + min_balance: int = field( + default=0, + metadata=wire("min-balance"), + ) + pending_rewards: int = field( + default=0, + metadata=wire("pending-rewards"), + ) + rewards: int = field( + default=0, + metadata=wire("rewards"), + ) + round_: int = field( + default=0, + metadata=wire("round"), + ) + status: str = field( + default="", + metadata=wire("status"), + ) + total_apps_opted_in: int = field( + default=0, + metadata=wire("total-apps-opted-in"), + ) + total_assets_opted_in: int = field( + default=0, + metadata=wire("total-assets-opted-in"), + ) + total_box_bytes: int = field( + default=0, + metadata=wire("total-box-bytes"), + ) + total_boxes: int = field( + default=0, + metadata=wire("total-boxes"), + ) + total_created_apps: int = field( + default=0, + metadata=wire("total-created-apps"), + ) + total_created_assets: int = field( + default=0, + metadata=wire("total-created-assets"), + ) + apps_local_state: list[ApplicationLocalState] | None = field( + default=None, + metadata=wire( + "apps-local-state", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: ApplicationLocalState, raw), + ), + ) + apps_total_extra_pages: int | None = field( + default=None, + metadata=wire("apps-total-extra-pages"), + ) + apps_total_schema: ApplicationStateSchema | None = field( + default=None, + metadata=nested("apps-total-schema", lambda: ApplicationStateSchema), + ) + assets: list[AssetHolding] | None = field( + default=None, + metadata=wire( + "assets", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: AssetHolding, raw), + ), + ) + auth_addr: str | None = field( + default=None, + metadata=wire("auth-addr"), + ) + closed_at_round: int | None = field( + default=None, + metadata=wire("closed-at-round"), + ) + created_apps: list[Application] | None = field( + default=None, + metadata=wire( + "created-apps", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: Application, raw), + ), + ) + created_assets: list[Asset] | None = field( + default=None, + metadata=wire( + "created-assets", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: Asset, raw), + ), + ) + created_at_round: int | None = field( + default=None, + metadata=wire("created-at-round"), + ) + deleted: bool | None = field( + default=None, + metadata=wire("deleted"), + ) + incentive_eligible: bool | None = field( + default=None, + metadata=wire("incentive-eligible"), + ) + last_heartbeat: int | None = field( + default=None, + metadata=wire("last-heartbeat"), + ) + last_proposed: int | None = field( + default=None, + metadata=wire("last-proposed"), + ) + participation: AccountParticipation | None = field( + default=None, + metadata=nested("participation", lambda: AccountParticipation), + ) + reward_base: int | None = field( + default=None, + metadata=wire("reward-base"), + ) + sig_type: str | None = field( + default=None, + metadata=wire("sig-type"), + ) diff --git a/src/algokit_indexer_client/models/_account_participation.py b/src/algokit_indexer_client/models/_account_participation.py new file mode 100644 index 00000000..33353c94 --- /dev/null +++ b/src/algokit_indexer_client/models/_account_participation.py @@ -0,0 +1,53 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_fixed_bytes, encode_fixed_bytes + + +@dataclass(slots=True) +class AccountParticipation: + """ + AccountParticipation describes the parameters used by this account in consensus + protocol. + """ + + selection_participation_key: bytes = field( + default=b"", + metadata=wire( + "selection-participation-key", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) + vote_first_valid: int = field( + default=0, + metadata=wire("vote-first-valid"), + ) + vote_key_dilution: int = field( + default=0, + metadata=wire("vote-key-dilution"), + ) + vote_last_valid: int = field( + default=0, + metadata=wire("vote-last-valid"), + ) + vote_participation_key: bytes = field( + default=b"", + metadata=wire( + "vote-participation-key", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) + state_proof_key: bytes | None = field( + default=None, + metadata=wire( + "state-proof-key", + encode=lambda v: encode_fixed_bytes(v, 64), + decode=lambda raw: decode_fixed_bytes(raw, 64), + ), + ) diff --git a/src/algokit_indexer_client/models/_account_response.py b/src/algokit_indexer_client/models/_account_response.py new file mode 100644 index 00000000..2f367ccb --- /dev/null +++ b/src/algokit_indexer_client/models/_account_response.py @@ -0,0 +1,19 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._account import Account + + +@dataclass(slots=True) +class AccountResponse: + account: Account = field( + metadata=nested("account", lambda: Account, required=True), + ) + current_round: int = field( + default=0, + metadata=wire("current-round"), + ) diff --git a/src/algokit_indexer_client/models/_account_state_delta.py b/src/algokit_indexer_client/models/_account_state_delta.py new file mode 100644 index 00000000..41fbcfd5 --- /dev/null +++ b/src/algokit_indexer_client/models/_account_state_delta.py @@ -0,0 +1,29 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._eval_delta_key_value import EvalDeltaKeyValue +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class AccountStateDelta: + """ + Application state delta. + """ + + address: str = field( + default="", + metadata=wire("address"), + ) + delta: list[EvalDeltaKeyValue] = field( + default_factory=list, + metadata=wire( + "delta", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: EvalDeltaKeyValue, raw), + ), + ) diff --git a/src/algokit_indexer_client/models/_accounts_response.py b/src/algokit_indexer_client/models/_accounts_response.py new file mode 100644 index 00000000..e794aa3a --- /dev/null +++ b/src/algokit_indexer_client/models/_accounts_response.py @@ -0,0 +1,29 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._account import Account +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class AccountsResponse: + accounts: list[Account] = field( + default_factory=list, + metadata=wire( + "accounts", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: Account, raw), + ), + ) + current_round: int = field( + default=0, + metadata=wire("current-round"), + ) + next_token: str | None = field( + default=None, + metadata=wire("next-token"), + ) diff --git a/src/algokit_indexer_client/models/_application.py b/src/algokit_indexer_client/models/_application.py new file mode 100644 index 00000000..8e7e9873 --- /dev/null +++ b/src/algokit_indexer_client/models/_application.py @@ -0,0 +1,35 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._application_params import ApplicationParams + + +@dataclass(slots=True) +class Application: + """ + Application index and its parameters + """ + + params: ApplicationParams = field( + metadata=nested("params", lambda: ApplicationParams, required=True), + ) + id_: int = field( + default=0, + metadata=wire("id"), + ) + created_at_round: int | None = field( + default=None, + metadata=wire("created-at-round"), + ) + deleted: bool | None = field( + default=None, + metadata=wire("deleted"), + ) + deleted_at_round: int | None = field( + default=None, + metadata=wire("deleted-at-round"), + ) diff --git a/src/algokit_indexer_client/models/_application_local_state.py b/src/algokit_indexer_client/models/_application_local_state.py new file mode 100644 index 00000000..2ab76aa5 --- /dev/null +++ b/src/algokit_indexer_client/models/_application_local_state.py @@ -0,0 +1,45 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._application_state_schema import ApplicationStateSchema +from ._serde_helpers import decode_model_sequence, encode_model_sequence +from ._teal_key_value import TealKeyValue + + +@dataclass(slots=True) +class ApplicationLocalState: + """ + Stores local state associated with an application. + """ + + schema: ApplicationStateSchema = field( + metadata=nested("schema", lambda: ApplicationStateSchema, required=True), + ) + id_: int = field( + default=0, + metadata=wire("id"), + ) + closed_out_at_round: int | None = field( + default=None, + metadata=wire("closed-out-at-round"), + ) + deleted: bool | None = field( + default=None, + metadata=wire("deleted"), + ) + key_value: list[TealKeyValue] | None = field( + default=None, + metadata=wire( + "key-value", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: TealKeyValue, raw), + ), + ) + opted_in_at_round: int | None = field( + default=None, + metadata=wire("opted-in-at-round"), + ) diff --git a/src/algokit_indexer_client/models/_application_local_states_response.py b/src/algokit_indexer_client/models/_application_local_states_response.py new file mode 100644 index 00000000..fb20034d --- /dev/null +++ b/src/algokit_indexer_client/models/_application_local_states_response.py @@ -0,0 +1,29 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._application_local_state import ApplicationLocalState +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class ApplicationLocalStatesResponse: + apps_local_states: list[ApplicationLocalState] = field( + default_factory=list, + metadata=wire( + "apps-local-states", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: ApplicationLocalState, raw), + ), + ) + current_round: int = field( + default=0, + metadata=wire("current-round"), + ) + next_token: str | None = field( + default=None, + metadata=wire("next-token"), + ) diff --git a/src/algokit_indexer_client/models/_application_log_data.py b/src/algokit_indexer_client/models/_application_log_data.py new file mode 100644 index 00000000..288f1a41 --- /dev/null +++ b/src/algokit_indexer_client/models/_application_log_data.py @@ -0,0 +1,28 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes_sequence, encode_bytes_sequence + + +@dataclass(slots=True) +class ApplicationLogData: + """ + Stores the global information associated with an application. + """ + + logs: list[bytes] = field( + default_factory=list, + metadata=wire( + "logs", + encode=encode_bytes_sequence, + decode=decode_bytes_sequence, + ), + ) + tx_id: str = field( + default="", + metadata=wire("txid"), + ) diff --git a/src/algokit_indexer_client/models/_application_logs_response.py b/src/algokit_indexer_client/models/_application_logs_response.py new file mode 100644 index 00000000..e86f202a --- /dev/null +++ b/src/algokit_indexer_client/models/_application_logs_response.py @@ -0,0 +1,33 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._application_log_data import ApplicationLogData +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class ApplicationLogsResponse: + application_id: int = field( + default=0, + metadata=wire("application-id"), + ) + current_round: int = field( + default=0, + metadata=wire("current-round"), + ) + log_data: list[ApplicationLogData] | None = field( + default=None, + metadata=wire( + "log-data", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: ApplicationLogData, raw), + ), + ) + next_token: str | None = field( + default=None, + metadata=wire("next-token"), + ) diff --git a/src/algokit_indexer_client/models/_application_params.py b/src/algokit_indexer_client/models/_application_params.py new file mode 100644 index 00000000..39395c18 --- /dev/null +++ b/src/algokit_indexer_client/models/_application_params.py @@ -0,0 +1,62 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._application_state_schema import ApplicationStateSchema +from ._serde_helpers import decode_bytes, decode_model_sequence, encode_bytes, encode_model_sequence +from ._teal_key_value import TealKeyValue + + +@dataclass(slots=True) +class ApplicationParams: + """ + Stores the global information associated with an application. + """ + + approval_program: bytes | None = field( + default=None, + metadata=wire( + "approval-program", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + clear_state_program: bytes | None = field( + default=None, + metadata=wire( + "clear-state-program", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + creator: str | None = field( + default=None, + metadata=wire("creator"), + ) + extra_program_pages: int | None = field( + default=None, + metadata=wire("extra-program-pages"), + ) + global_state: list[TealKeyValue] | None = field( + default=None, + metadata=wire( + "global-state", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: TealKeyValue, raw), + ), + ) + global_state_schema: ApplicationStateSchema | None = field( + default=None, + metadata=nested("global-state-schema", lambda: ApplicationStateSchema), + ) + local_state_schema: ApplicationStateSchema | None = field( + default=None, + metadata=nested("local-state-schema", lambda: ApplicationStateSchema), + ) + version: int | None = field( + default=None, + metadata=wire("version"), + ) diff --git a/src/algokit_indexer_client/models/_application_response.py b/src/algokit_indexer_client/models/_application_response.py new file mode 100644 index 00000000..8b92e55b --- /dev/null +++ b/src/algokit_indexer_client/models/_application_response.py @@ -0,0 +1,20 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._application import Application + + +@dataclass(slots=True) +class ApplicationResponse: + current_round: int = field( + default=0, + metadata=wire("current-round"), + ) + application: Application | None = field( + default=None, + metadata=nested("application", lambda: Application), + ) diff --git a/src/algokit_indexer_client/models/_application_state_schema.py b/src/algokit_indexer_client/models/_application_state_schema.py new file mode 100644 index 00000000..293f7b50 --- /dev/null +++ b/src/algokit_indexer_client/models/_application_state_schema.py @@ -0,0 +1,22 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class ApplicationStateSchema: + """ + Specifies maximums on the number of each type that may be stored. + """ + + num_byte_slices: int = field( + default=0, + metadata=wire("num-byte-slice"), + ) + num_uints: int = field( + default=0, + metadata=wire("num-uint"), + ) diff --git a/src/algokit_indexer_client/models/_applications_response.py b/src/algokit_indexer_client/models/_applications_response.py new file mode 100644 index 00000000..3fe49d05 --- /dev/null +++ b/src/algokit_indexer_client/models/_applications_response.py @@ -0,0 +1,29 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._application import Application +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class ApplicationsResponse: + applications: list[Application] = field( + default_factory=list, + metadata=wire( + "applications", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: Application, raw), + ), + ) + current_round: int = field( + default=0, + metadata=wire("current-round"), + ) + next_token: str | None = field( + default=None, + metadata=wire("next-token"), + ) diff --git a/src/algokit_indexer_client/models/_asset.py b/src/algokit_indexer_client/models/_asset.py new file mode 100644 index 00000000..86cbf782 --- /dev/null +++ b/src/algokit_indexer_client/models/_asset.py @@ -0,0 +1,35 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._asset_params import AssetParams + + +@dataclass(slots=True) +class Asset: + """ + Specifies both the unique identifier and the parameters for an asset + """ + + params: AssetParams = field( + metadata=nested("params", lambda: AssetParams, required=True), + ) + id_: int = field( + default=0, + metadata=wire("index"), + ) + created_at_round: int | None = field( + default=None, + metadata=wire("created-at-round"), + ) + deleted: bool | None = field( + default=None, + metadata=wire("deleted"), + ) + destroyed_at_round: int | None = field( + default=None, + metadata=wire("destroyed-at-round"), + ) diff --git a/src/algokit_indexer_client/models/_asset_balances_response.py b/src/algokit_indexer_client/models/_asset_balances_response.py new file mode 100644 index 00000000..2b739251 --- /dev/null +++ b/src/algokit_indexer_client/models/_asset_balances_response.py @@ -0,0 +1,29 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._mini_asset_holding import MiniAssetHolding +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class AssetBalancesResponse: + balances: list[MiniAssetHolding] = field( + default_factory=list, + metadata=wire( + "balances", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: MiniAssetHolding, raw), + ), + ) + current_round: int = field( + default=0, + metadata=wire("current-round"), + ) + next_token: str | None = field( + default=None, + metadata=wire("next-token"), + ) diff --git a/src/algokit_indexer_client/models/_asset_holding.py b/src/algokit_indexer_client/models/_asset_holding.py new file mode 100644 index 00000000..5d0ce700 --- /dev/null +++ b/src/algokit_indexer_client/models/_asset_holding.py @@ -0,0 +1,41 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class AssetHolding: + """ + Describes an asset held by an account. + + Definition: + data/basics/userBalance.go : AssetHolding + """ + + amount: int = field( + default=0, + metadata=wire("amount"), + ) + asset_id: int = field( + default=0, + metadata=wire("asset-id"), + ) + is_frozen: bool = field( + default=False, + metadata=wire("is-frozen"), + ) + deleted: bool | None = field( + default=None, + metadata=wire("deleted"), + ) + opted_in_at_round: int | None = field( + default=None, + metadata=wire("opted-in-at-round"), + ) + opted_out_at_round: int | None = field( + default=None, + metadata=wire("opted-out-at-round"), + ) diff --git a/src/algokit_indexer_client/models/_asset_holdings_response.py b/src/algokit_indexer_client/models/_asset_holdings_response.py new file mode 100644 index 00000000..3441c1f1 --- /dev/null +++ b/src/algokit_indexer_client/models/_asset_holdings_response.py @@ -0,0 +1,29 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._asset_holding import AssetHolding +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class AssetHoldingsResponse: + assets: list[AssetHolding] = field( + default_factory=list, + metadata=wire( + "assets", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: AssetHolding, raw), + ), + ) + current_round: int = field( + default=0, + metadata=wire("current-round"), + ) + next_token: str | None = field( + default=None, + metadata=wire("next-token"), + ) diff --git a/src/algokit_indexer_client/models/_asset_params.py b/src/algokit_indexer_client/models/_asset_params.py new file mode 100644 index 00000000..adb7944b --- /dev/null +++ b/src/algokit_indexer_client/models/_asset_params.py @@ -0,0 +1,97 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, decode_fixed_bytes, encode_bytes, encode_fixed_bytes + + +@dataclass(slots=True) +class AssetParams: + r""" + AssetParams specifies the parameters for an asset. + + \[apar\] when part of an AssetConfig transaction. + + Definition: + data/transactions/asset.go : AssetParams + """ + + creator: str = field( + default="", + metadata=wire("creator"), + ) + decimals: int = field( + default=0, + metadata=wire("decimals"), + ) + total: int = field( + default=0, + metadata=wire("total"), + ) + clawback: str | None = field( + default=None, + metadata=wire("clawback"), + ) + default_frozen: bool | None = field( + default=None, + metadata=wire("default-frozen"), + ) + freeze: str | None = field( + default=None, + metadata=wire("freeze"), + ) + manager: str | None = field( + default=None, + metadata=wire("manager"), + ) + metadata_hash: bytes | None = field( + default=None, + metadata=wire( + "metadata-hash", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) + name: str | None = field( + default=None, + metadata=wire("name"), + ) + name_b64: bytes | None = field( + default=None, + metadata=wire( + "name-b64", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + reserve: str | None = field( + default=None, + metadata=wire("reserve"), + ) + unit_name: str | None = field( + default=None, + metadata=wire("unit-name"), + ) + unit_name_b64: bytes | None = field( + default=None, + metadata=wire( + "unit-name-b64", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + url: str | None = field( + default=None, + metadata=wire("url"), + ) + url_b64: bytes | None = field( + default=None, + metadata=wire( + "url-b64", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_indexer_client/models/_asset_response.py b/src/algokit_indexer_client/models/_asset_response.py new file mode 100644 index 00000000..955e8f4a --- /dev/null +++ b/src/algokit_indexer_client/models/_asset_response.py @@ -0,0 +1,19 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._asset import Asset + + +@dataclass(slots=True) +class AssetResponse: + asset: Asset = field( + metadata=nested("asset", lambda: Asset, required=True), + ) + current_round: int = field( + default=0, + metadata=wire("current-round"), + ) diff --git a/src/algokit_indexer_client/models/_assets_response.py b/src/algokit_indexer_client/models/_assets_response.py new file mode 100644 index 00000000..22e4f7f6 --- /dev/null +++ b/src/algokit_indexer_client/models/_assets_response.py @@ -0,0 +1,29 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._asset import Asset +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class AssetsResponse: + assets: list[Asset] = field( + default_factory=list, + metadata=wire( + "assets", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: Asset, raw), + ), + ) + current_round: int = field( + default=0, + metadata=wire("current-round"), + ) + next_token: str | None = field( + default=None, + metadata=wire("next-token"), + ) diff --git a/src/algokit_indexer_client/models/_block.py b/src/algokit_indexer_client/models/_block.py new file mode 100644 index 00000000..042f4b28 --- /dev/null +++ b/src/algokit_indexer_client/models/_block.py @@ -0,0 +1,142 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._block_rewards import BlockRewards +from ._block_upgrade_state import BlockUpgradeState +from ._block_upgrade_vote import BlockUpgradeVote +from ._participation_updates import ParticipationUpdates +from ._serde_helpers import decode_fixed_bytes, decode_model_sequence, encode_fixed_bytes, encode_model_sequence +from ._state_proof_tracking import StateProofTracking +from ._transaction import Transaction + + +@dataclass(slots=True) +class Block: + """ + Block information. + + Definition: + data/bookkeeping/block.go : Block + """ + + participation_updates: ParticipationUpdates = field( + metadata=nested("participation-updates", lambda: ParticipationUpdates, required=True), + ) + rewards: BlockRewards = field( + metadata=nested("rewards", lambda: BlockRewards, required=True), + ) + upgrade_state: BlockUpgradeState = field( + metadata=nested("upgrade-state", lambda: BlockUpgradeState, required=True), + ) + genesis_hash: bytes = field( + default=b"", + metadata=wire( + "genesis-hash", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) + genesis_id: str = field( + default="", + metadata=wire("genesis-id"), + ) + previous_block_hash: bytes = field( + default=b"", + metadata=wire( + "previous-block-hash", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) + round_: int = field( + default=0, + metadata=wire("round"), + ) + seed: bytes = field( + default=b"", + metadata=wire( + "seed", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) + timestamp: int = field( + default=0, + metadata=wire("timestamp"), + ) + transactions: list[Transaction] = field( + default_factory=list, + metadata=wire( + "transactions", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: Transaction, raw), + ), + ) + transactions_root: bytes = field( + default=b"", + metadata=wire( + "transactions-root", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) + bonus: int | None = field( + default=None, + metadata=wire("bonus"), + ) + fees_collected: int | None = field( + default=None, + metadata=wire("fees-collected"), + ) + previous_block_hash_512: bytes | None = field( + default=None, + metadata=wire( + "previous-block-hash-512", + encode=lambda v: encode_fixed_bytes(v, 64), + decode=lambda raw: decode_fixed_bytes(raw, 64), + ), + ) + proposer: str | None = field( + default=None, + metadata=wire("proposer"), + ) + proposer_payout: int | None = field( + default=None, + metadata=wire("proposer-payout"), + ) + state_proof_tracking: list[StateProofTracking] | None = field( + default=None, + metadata=wire( + "state-proof-tracking", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: StateProofTracking, raw), + ), + ) + transactions_root_sha256: bytes | None = field( + default=None, + metadata=wire( + "transactions-root-sha256", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) + transactions_root_sha512: bytes | None = field( + default=None, + metadata=wire( + "transactions-root-sha512", + encode=lambda v: encode_fixed_bytes(v, 64), + decode=lambda raw: decode_fixed_bytes(raw, 64), + ), + ) + txn_counter: int | None = field( + default=None, + metadata=wire("txn-counter"), + ) + upgrade_vote: BlockUpgradeVote | None = field( + default=None, + metadata=nested("upgrade-vote", lambda: BlockUpgradeVote), + ) diff --git a/src/algokit_indexer_client/models/_block_headers_response.py b/src/algokit_indexer_client/models/_block_headers_response.py new file mode 100644 index 00000000..e87d1c79 --- /dev/null +++ b/src/algokit_indexer_client/models/_block_headers_response.py @@ -0,0 +1,29 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._block import Block +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class BlockHeadersResponse: + blocks: list[Block] = field( + default_factory=list, + metadata=wire( + "blocks", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: Block, raw), + ), + ) + current_round: int = field( + default=0, + metadata=wire("current-round"), + ) + next_token: str | None = field( + default=None, + metadata=wire("next-token"), + ) diff --git a/src/algokit_indexer_client/models/_block_rewards.py b/src/algokit_indexer_client/models/_block_rewards.py new file mode 100644 index 00000000..bb7d07a2 --- /dev/null +++ b/src/algokit_indexer_client/models/_block_rewards.py @@ -0,0 +1,38 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class BlockRewards: + """ + Fields relating to rewards, + """ + + fee_sink: str = field( + default="", + metadata=wire("fee-sink"), + ) + rewards_calculation_round: int = field( + default=0, + metadata=wire("rewards-calculation-round"), + ) + rewards_level: int = field( + default=0, + metadata=wire("rewards-level"), + ) + rewards_pool: str = field( + default="", + metadata=wire("rewards-pool"), + ) + rewards_rate: int = field( + default=0, + metadata=wire("rewards-rate"), + ) + rewards_residue: int = field( + default=0, + metadata=wire("rewards-residue"), + ) diff --git a/src/algokit_indexer_client/models/_block_upgrade_state.py b/src/algokit_indexer_client/models/_block_upgrade_state.py new file mode 100644 index 00000000..785a7788 --- /dev/null +++ b/src/algokit_indexer_client/models/_block_upgrade_state.py @@ -0,0 +1,34 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class BlockUpgradeState: + """ + Fields relating to a protocol upgrade. + """ + + current_protocol: str = field( + default="", + metadata=wire("current-protocol"), + ) + next_protocol: str | None = field( + default=None, + metadata=wire("next-protocol"), + ) + next_protocol_approvals: int | None = field( + default=None, + metadata=wire("next-protocol-approvals"), + ) + next_protocol_switch_on: int | None = field( + default=None, + metadata=wire("next-protocol-switch-on"), + ) + next_protocol_vote_before: int | None = field( + default=None, + metadata=wire("next-protocol-vote-before"), + ) diff --git a/src/algokit_indexer_client/models/_block_upgrade_vote.py b/src/algokit_indexer_client/models/_block_upgrade_vote.py new file mode 100644 index 00000000..8c640854 --- /dev/null +++ b/src/algokit_indexer_client/models/_block_upgrade_vote.py @@ -0,0 +1,26 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class BlockUpgradeVote: + """ + Fields relating to voting for a protocol upgrade. + """ + + upgrade_approve: bool | None = field( + default=None, + metadata=wire("upgrade-approve"), + ) + upgrade_delay: int | None = field( + default=None, + metadata=wire("upgrade-delay"), + ) + upgrade_propose: str | None = field( + default=None, + metadata=wire("upgrade-propose"), + ) diff --git a/src/algokit_indexer_client/models/_box.py b/src/algokit_indexer_client/models/_box.py new file mode 100644 index 00000000..d8a90333 --- /dev/null +++ b/src/algokit_indexer_client/models/_box.py @@ -0,0 +1,36 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class Box: + """ + Box name and its content. + """ + + name: bytes = field( + default=b"", + metadata=wire( + "name", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + round_: int = field( + default=0, + metadata=wire("round"), + ) + value: bytes = field( + default=b"", + metadata=wire( + "value", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_indexer_client/models/_box_descriptor.py b/src/algokit_indexer_client/models/_box_descriptor.py new file mode 100644 index 00000000..7b679ce5 --- /dev/null +++ b/src/algokit_indexer_client/models/_box_descriptor.py @@ -0,0 +1,24 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class BoxDescriptor: + """ + Box descriptor describes an app box without a value. + """ + + name: bytes = field( + default=b"", + metadata=wire( + "name", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_indexer_client/models/_box_reference.py b/src/algokit_indexer_client/models/_box_reference.py new file mode 100644 index 00000000..8bb04656 --- /dev/null +++ b/src/algokit_indexer_client/models/_box_reference.py @@ -0,0 +1,28 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class BoxReference: + """ + BoxReference names a box by its name and the application ID it belongs to. + """ + + app: int = field( + default=0, + metadata=wire("app"), + ) + name: bytes = field( + default=b"", + metadata=wire( + "name", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_indexer_client/models/_boxes_response.py b/src/algokit_indexer_client/models/_boxes_response.py new file mode 100644 index 00000000..b7fa4fca --- /dev/null +++ b/src/algokit_indexer_client/models/_boxes_response.py @@ -0,0 +1,29 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._box_descriptor import BoxDescriptor +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class BoxesResponse: + application_id: int = field( + default=0, + metadata=wire("application-id"), + ) + boxes: list[BoxDescriptor] = field( + default_factory=list, + metadata=wire( + "boxes", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: BoxDescriptor, raw), + ), + ) + next_token: str | None = field( + default=None, + metadata=wire("next-token"), + ) diff --git a/src/algokit_indexer_client/models/_error_response.py b/src/algokit_indexer_client/models/_error_response.py new file mode 100644 index 00000000..be9300af --- /dev/null +++ b/src/algokit_indexer_client/models/_error_response.py @@ -0,0 +1,18 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class ErrorResponse: + message: str = field( + default="", + metadata=wire("message"), + ) + data: dict[str, object] | None = field( + default=None, + metadata=wire("data"), + ) diff --git a/src/algokit_indexer_client/models/_eval_delta.py b/src/algokit_indexer_client/models/_eval_delta.py new file mode 100644 index 00000000..5e599f7e --- /dev/null +++ b/src/algokit_indexer_client/models/_eval_delta.py @@ -0,0 +1,32 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class EvalDelta: + """ + Represents a TEAL value delta. + """ + + action: int = field( + default=0, + metadata=wire("action"), + ) + bytes_: bytes | None = field( + default=None, + metadata=wire( + "bytes", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + uint: int | None = field( + default=None, + metadata=wire("uint"), + ) diff --git a/src/algokit_indexer_client/models/_eval_delta_key_value.py b/src/algokit_indexer_client/models/_eval_delta_key_value.py new file mode 100644 index 00000000..f56d1d49 --- /dev/null +++ b/src/algokit_indexer_client/models/_eval_delta_key_value.py @@ -0,0 +1,28 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._eval_delta import EvalDelta +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class EvalDeltaKeyValue: + """ + Key-value pairs for StateDelta. + """ + + value: EvalDelta = field( + metadata=nested("value", lambda: EvalDelta, required=True), + ) + key: bytes = field( + default=b"", + metadata=wire( + "key", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_indexer_client/models/_hash_factory.py b/src/algokit_indexer_client/models/_hash_factory.py new file mode 100644 index 00000000..25c1e491 --- /dev/null +++ b/src/algokit_indexer_client/models/_hash_factory.py @@ -0,0 +1,14 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class HashFactory: + hash_type: int | None = field( + default=None, + metadata=wire("hash-type"), + ) diff --git a/src/algokit_indexer_client/models/_hb_proof_fields.py b/src/algokit_indexer_client/models/_hb_proof_fields.py new file mode 100644 index 00000000..f12610e5 --- /dev/null +++ b/src/algokit_indexer_client/models/_hb_proof_fields.py @@ -0,0 +1,57 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_fixed_bytes, encode_fixed_bytes + + +@dataclass(slots=True) +class HbProofFields: + r""" + \[hbprf\] HbProof is a signature using HeartbeatAddress's partkey, thereby showing it is + online. + """ + + hb_pk: bytes | None = field( + default=None, + metadata=wire( + "hb-pk", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) + hb_pk1sig: bytes | None = field( + default=None, + metadata=wire( + "hb-pk1sig", + encode=lambda v: encode_fixed_bytes(v, 64), + decode=lambda raw: decode_fixed_bytes(raw, 64), + ), + ) + hb_pk2: bytes | None = field( + default=None, + metadata=wire( + "hb-pk2", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) + hb_pk2sig: bytes | None = field( + default=None, + metadata=wire( + "hb-pk2sig", + encode=lambda v: encode_fixed_bytes(v, 64), + decode=lambda raw: decode_fixed_bytes(raw, 64), + ), + ) + hb_sig: bytes | None = field( + default=None, + metadata=wire( + "hb-sig", + encode=lambda v: encode_fixed_bytes(v, 64), + decode=lambda raw: decode_fixed_bytes(raw, 64), + ), + ) diff --git a/src/algokit_indexer_client/models/_health_check.py b/src/algokit_indexer_client/models/_health_check.py new file mode 100644 index 00000000..d60c0e48 --- /dev/null +++ b/src/algokit_indexer_client/models/_health_check.py @@ -0,0 +1,42 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class HealthCheck: + """ + A health check response. + """ + + db_available: bool = field( + default=False, + metadata=wire("db-available"), + ) + is_migrating: bool = field( + default=False, + metadata=wire("is-migrating"), + ) + message: str = field( + default="", + metadata=wire("message"), + ) + round_: int = field( + default=0, + metadata=wire("round"), + ) + version: str = field( + default="", + metadata=wire("version"), + ) + data: dict[str, object] | None = field( + default=None, + metadata=wire("data"), + ) + errors: list[str] | None = field( + default=None, + metadata=wire("errors"), + ) diff --git a/src/algokit_indexer_client/models/_holding_ref.py b/src/algokit_indexer_client/models/_holding_ref.py new file mode 100644 index 00000000..1eabcf87 --- /dev/null +++ b/src/algokit_indexer_client/models/_holding_ref.py @@ -0,0 +1,23 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.constants import ZERO_ADDRESS +from algokit_common.serde import wire + + +@dataclass(slots=True) +class HoldingRef: + """ + HoldingRef names a holding by referring to an Address and Asset it belongs to. + """ + + address: str = field( + default=ZERO_ADDRESS, + metadata=wire("address"), + ) + asset: int = field( + default=0, + metadata=wire("asset"), + ) diff --git a/src/algokit_indexer_client/models/_indexer_state_proof_message.py b/src/algokit_indexer_client/models/_indexer_state_proof_message.py new file mode 100644 index 00000000..77c884d8 --- /dev/null +++ b/src/algokit_indexer_client/models/_indexer_state_proof_message.py @@ -0,0 +1,40 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class IndexerStateProofMessage: + block_headers_commitment: bytes | None = field( + default=None, + metadata=wire( + "block-headers-commitment", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + first_attested_round: int | None = field( + default=None, + metadata=wire("first-attested-round"), + ) + latest_attested_round: int | None = field( + default=None, + metadata=wire("latest-attested-round"), + ) + ln_proven_weight: int | None = field( + default=None, + metadata=wire("ln-proven-weight"), + ) + voters_commitment: bytes | None = field( + default=None, + metadata=wire( + "voters-commitment", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_indexer_client/models/_locals_ref.py b/src/algokit_indexer_client/models/_locals_ref.py new file mode 100644 index 00000000..af3e8023 --- /dev/null +++ b/src/algokit_indexer_client/models/_locals_ref.py @@ -0,0 +1,23 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.constants import ZERO_ADDRESS +from algokit_common.serde import wire + + +@dataclass(slots=True) +class LocalsRef: + """ + LocalsRef names a local state by referring to an Address and App it belongs to. + """ + + address: str = field( + default=ZERO_ADDRESS, + metadata=wire("address"), + ) + app: int = field( + default=0, + metadata=wire("app"), + ) diff --git a/src/algokit_indexer_client/models/_merkle_array_proof.py b/src/algokit_indexer_client/models/_merkle_array_proof.py new file mode 100644 index 00000000..e75c6783 --- /dev/null +++ b/src/algokit_indexer_client/models/_merkle_array_proof.py @@ -0,0 +1,29 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._hash_factory import HashFactory +from ._serde_helpers import decode_bytes_sequence, encode_bytes_sequence + + +@dataclass(slots=True) +class MerkleArrayProof: + hash_factory: HashFactory | None = field( + default=None, + metadata=nested("hash-factory", lambda: HashFactory), + ) + path: list[bytes] | None = field( + default=None, + metadata=wire( + "path", + encode=encode_bytes_sequence, + decode=decode_bytes_sequence, + ), + ) + tree_depth: int | None = field( + default=None, + metadata=wire("tree-depth"), + ) diff --git a/src/algokit_indexer_client/models/_mini_asset_holding.py b/src/algokit_indexer_client/models/_mini_asset_holding.py new file mode 100644 index 00000000..4fbb4ab9 --- /dev/null +++ b/src/algokit_indexer_client/models/_mini_asset_holding.py @@ -0,0 +1,38 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class MiniAssetHolding: + """ + A simplified version of AssetHolding + """ + + address: str = field( + default="", + metadata=wire("address"), + ) + amount: int = field( + default=0, + metadata=wire("amount"), + ) + is_frozen: bool = field( + default=False, + metadata=wire("is-frozen"), + ) + deleted: bool | None = field( + default=None, + metadata=wire("deleted"), + ) + opted_in_at_round: int | None = field( + default=None, + metadata=wire("opted-in-at-round"), + ) + opted_out_at_round: int | None = field( + default=None, + metadata=wire("opted-out-at-round"), + ) diff --git a/src/algokit_indexer_client/models/_on_completion.py b/src/algokit_indexer_client/models/_on_completion.py new file mode 100644 index 00000000..2f0f7f0c --- /dev/null +++ b/src/algokit_indexer_client/models/_on_completion.py @@ -0,0 +1,25 @@ +# AUTO-GENERATED: oas_generator + + +from enum import Enum + + +class OnCompletion(Enum): + r""" + \[apan\] defines the what additional actions occur with the transaction. + + Valid types: + * noop + * optin + * closeout + * clear + * update + * delete + """ + + NOOP = "noop" + OPTIN = "optin" + CLOSEOUT = "closeout" + CLEAR = "clear" + UPDATE = "update" + DELETE = "delete" diff --git a/src/algokit_indexer_client/models/_participation_updates.py b/src/algokit_indexer_client/models/_participation_updates.py new file mode 100644 index 00000000..aaa340d1 --- /dev/null +++ b/src/algokit_indexer_client/models/_participation_updates.py @@ -0,0 +1,22 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class ParticipationUpdates: + """ + Participation account data that needs to be checked/acted on by the network. + """ + + absent_participation_accounts: list[str] = field( + default_factory=list, + metadata=wire("absent-participation-accounts"), + ) + expired_participation_accounts: list[str] = field( + default_factory=list, + metadata=wire("expired-participation-accounts"), + ) diff --git a/src/algokit_indexer_client/models/_resource_ref.py b/src/algokit_indexer_client/models/_resource_ref.py new file mode 100644 index 00000000..bf824fb1 --- /dev/null +++ b/src/algokit_indexer_client/models/_resource_ref.py @@ -0,0 +1,42 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._box_reference import BoxReference +from ._holding_ref import HoldingRef +from ._locals_ref import LocalsRef + + +@dataclass(slots=True) +class ResourceRef: + """ + ResourceRef names a single resource. Only one of the fields should be set. + """ + + address: str | None = field( + default=None, + metadata=wire("address"), + ) + application_id: int | None = field( + default=None, + metadata=wire("application-id"), + ) + asset_id: int | None = field( + default=None, + metadata=wire("asset-id"), + ) + box: BoxReference | None = field( + default=None, + metadata=nested("box", lambda: BoxReference), + ) + holding: HoldingRef | None = field( + default=None, + metadata=nested("holding", lambda: HoldingRef), + ) + local: LocalsRef | None = field( + default=None, + metadata=nested("local", lambda: LocalsRef), + ) diff --git a/src/algokit_indexer_client/models/_serde_helpers.py b/src/algokit_indexer_client/models/_serde_helpers.py new file mode 100644 index 00000000..8d99c04f --- /dev/null +++ b/src/algokit_indexer_client/models/_serde_helpers.py @@ -0,0 +1,254 @@ +# AUTO-GENERATED: oas_generator +import base64 +from binascii import Error as BinasciiError +from collections.abc import Callable, Iterable, Mapping +from dataclasses import is_dataclass +from enum import Enum +from typing import TypeAlias, TypeVar + +from algokit_common.serde import from_wire, to_wire + +DecodedT = TypeVar("DecodedT") +EnumValueT = TypeVar("EnumValueT", bound=Enum) +MapKeyT = TypeVar("MapKeyT") +BytesLike: TypeAlias = bytes | bytearray | memoryview + + +def _coerce_bytes(value: bytes | bytearray | memoryview) -> bytes: + if isinstance(value, memoryview | bytearray): + return bytes(value) + return value + + +def encode_bytes(value: BytesLike) -> str: + return base64.b64encode(_coerce_bytes(value)).decode("ascii") + + +def decode_bytes(raw: object) -> bytes: + """Decode bytes that may be raw (msgpack) or base64-encoded (JSON).""" + if isinstance(raw, bytes | bytearray | memoryview): + return bytes(raw) + if isinstance(raw, str): + try: + return base64.b64decode(raw.encode("ascii"), validate=True) + except (BinasciiError, UnicodeEncodeError) as exc: + raise ValueError("Invalid base64 payload") from exc + raise TypeError(f"Unsupported value for bytes field: {type(raw)!r}") + + +def decode_bytes_base64(raw: object) -> bytes: + """Decode bytes that are always base64-encoded strings (even in msgpack). + + Used for fields marked with x-algokit-bytes-base64 in the OpenAPI spec. + These fields contain base64-encoded strings in both JSON and msgpack responses. + """ + if isinstance(raw, bytes | bytearray | memoryview | str): + try: + return base64.b64decode(raw, validate=True) + except (BinasciiError, ValueError, UnicodeEncodeError) as exc: + raise ValueError("Invalid base64 payload") from exc + raise TypeError(f"Unsupported value for bytes field: {type(raw)!r}") + + +def encode_fixed_bytes(value: BytesLike, expected_length: int) -> str: + """Encode fixed-length bytes to base64, validating the length.""" + coerced = _coerce_bytes(value) + if len(coerced) != expected_length: + raise ValueError(f"Expected {expected_length} bytes, got {len(coerced)}") + return base64.b64encode(coerced).decode("ascii") + + +def decode_fixed_bytes(raw: object, expected_length: int) -> bytes: + """Decode base64 to fixed-length bytes, validating the length.""" + decoded = decode_bytes(raw) + if len(decoded) != expected_length: + raise ValueError(f"Expected {expected_length} bytes, got {len(decoded)}") + return decoded + + +def decode_bytes_map_key(raw: object) -> bytes: + if isinstance(raw, bytes | bytearray | memoryview): + return bytes(raw) + if isinstance(raw, str): + # note: this is undoing the implicit bytes -> str conversion that + # _coerce_msgpack_key does in client.py + # as long as "strict" was used to encode the str then this should be safe + try: + return raw.encode("utf-8", errors="strict") + except UnicodeEncodeError as fallback_exc: + raise ValueError("Invalid bytes map key") from fallback_exc + raise TypeError(f"Unsupported map key for bytes field: {type(raw)!r}") + + +def encode_bytes_sequence(values: Iterable[BytesLike | None] | None) -> list[str | None] | None: + if values is None: + return None + encoded: list[str | None] = [] + for value in values: + if value is None: + encoded.append(None) + continue + if not isinstance(value, bytes | bytearray | memoryview): + raise TypeError(f"Unsupported value for bytes field sequence: {type(value)!r}") + encoded.append(encode_bytes(value)) + return encoded or None + + +def decode_bytes_sequence(raw: object) -> list[bytes | None] | None: + if not isinstance(raw, list): + return None + decoded: list[bytes | None] = [] + for item in raw: + if item is None: + decoded.append(None) + continue + decoded.append(decode_bytes(item)) + return decoded or None + + +def encode_fixed_bytes_sequence( + values: Iterable[BytesLike | None] | None, expected_length: int +) -> list[str | None] | None: + """Encode a sequence of fixed-length bytes to base64, validating each element's length.""" + if values is None: + return None + encoded: list[str | None] = [] + for value in values: + if value is None: + encoded.append(None) + continue + if not isinstance(value, bytes | bytearray | memoryview): + raise TypeError(f"Unsupported value for bytes field sequence: {type(value)!r}") + encoded.append(encode_fixed_bytes(value, expected_length)) + return encoded or None + + +def decode_fixed_bytes_sequence(raw: object, expected_length: int) -> list[bytes | None] | None: + """Decode a sequence of base64 strings to fixed-length bytes, validating each element's length.""" + if not isinstance(raw, list): + return None + decoded: list[bytes | None] = [] + for item in raw: + if item is None: + decoded.append(None) + continue + decoded.append(decode_fixed_bytes(item, expected_length)) + return decoded or None + + +def encode_model_sequence(values: Iterable[object] | None) -> list[dict[str, object]] | None: + if values is None: + return None + encoded: list[dict[str, object]] = [] + for value in values: + if value is None: + continue + encoded.append(to_wire(value)) + return encoded or None + + +def decode_model_sequence(cls_factory: Callable[[], type[DecodedT]], raw: object) -> list[DecodedT] | None: + if not isinstance(raw, list): + return None + cls = cls_factory() + decoded: list[DecodedT] = [] + for item in raw: + if isinstance(item, Mapping): + decoded.append(from_wire(cls, item)) + return decoded or None + + +def encode_enum_sequence(values: Iterable[object] | None) -> list[object] | None: + if values is None: + return None + encoded: list[object] = [] + for value in values: + if value is None: + continue + encoded.append(value.value if hasattr(value, "value") else value) + return encoded or None + + +def decode_enum_sequence(enum_factory: Callable[[], type[EnumValueT]], raw: object) -> list[EnumValueT] | None: + if not isinstance(raw, list): + return None + enum_cls = enum_factory() + decoded: list[EnumValueT] = [] + for item in raw: + try: + decoded.append(enum_cls(item)) + except Exception: + continue + return decoded or None + + +def encode_model_mapping( + factory: Callable[[], type[DecodedT]], + mapping: Mapping[object, object] | None, + *, + key_encoder: Callable[[object], str] | None = None, +) -> dict[str, object] | None: + if mapping is None: + return None + cls = factory() + encoded: dict[str, object] = {} + for key, value in mapping.items(): + if value is None: + continue + encoded_key: str + if key_encoder is not None: + encoded_key = key_encoder(key) + elif isinstance(key, str): + encoded_key = key + else: + encoded_key = str(key) + if isinstance(value, cls) or is_dataclass(value): + encoded[encoded_key] = to_wire(value) + else: + encoded[encoded_key] = value + return encoded or None + + +def decode_model_mapping( + factory: Callable[[], type[DecodedT]], + raw: object, + *, + key_decoder: Callable[[object], MapKeyT] | None = None, +) -> dict[MapKeyT, DecodedT] | None: + if not isinstance(raw, Mapping): + return None + cls = factory() + decoded: dict[MapKeyT, DecodedT] = {} + for key, value in raw.items(): + if isinstance(value, Mapping): + decoded_key = key_decoder(key) if key_decoder is not None else key + decoded[decoded_key] = from_wire(cls, value) + return decoded or None + + +def decode_optional_bool(raw: object) -> bool | None: + if raw is None: + return None + return bool(raw) + + +def mapping_encoder( + factory: Callable[[], type[DecodedT]], + *, + key_encoder: Callable[[object], str] | None = None, +) -> Callable[[Mapping[object, object] | None], dict[str, object] | None]: + def _encode(mapping: Mapping[object, object] | None) -> dict[str, object] | None: + return encode_model_mapping(factory, mapping, key_encoder=key_encoder) + + return _encode + + +def mapping_decoder( + factory: Callable[[], type[DecodedT]], + *, + key_decoder: Callable[[object], MapKeyT] | None = None, +) -> Callable[[object], dict[MapKeyT, DecodedT] | None]: + def _decode(raw: object) -> dict[MapKeyT, DecodedT] | None: + return decode_model_mapping(factory, raw, key_decoder=key_decoder) + + return _decode diff --git a/src/algokit_indexer_client/models/_state_delta.py b/src/algokit_indexer_client/models/_state_delta.py new file mode 100644 index 00000000..c6c731ce --- /dev/null +++ b/src/algokit_indexer_client/models/_state_delta.py @@ -0,0 +1,6 @@ +# AUTO-GENERATED: oas_generator + + +from ._eval_delta_key_value import EvalDeltaKeyValue + +StateDelta = list[EvalDeltaKeyValue] diff --git a/src/algokit_indexer_client/models/_state_proof_fields.py b/src/algokit_indexer_client/models/_state_proof_fields.py new file mode 100644 index 00000000..ca36d766 --- /dev/null +++ b/src/algokit_indexer_client/models/_state_proof_fields.py @@ -0,0 +1,57 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._merkle_array_proof import MerkleArrayProof +from ._serde_helpers import decode_bytes, decode_model_sequence, encode_bytes, encode_model_sequence +from ._state_proof_reveal import StateProofReveal + + +@dataclass(slots=True) +class StateProofFields: + r""" + \[sp\] represents a state proof. + + Definition: + crypto/stateproof/structs.go : StateProof + """ + + part_proofs: MerkleArrayProof | None = field( + default=None, + metadata=nested("part-proofs", lambda: MerkleArrayProof), + ) + positions_to_reveal: list[int] | None = field( + default=None, + metadata=wire("positions-to-reveal"), + ) + reveals: list[StateProofReveal] | None = field( + default=None, + metadata=wire( + "reveals", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: StateProofReveal, raw), + ), + ) + salt_version: int | None = field( + default=None, + metadata=wire("salt-version"), + ) + sig_commit: bytes | None = field( + default=None, + metadata=wire( + "sig-commit", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + sig_proofs: MerkleArrayProof | None = field( + default=None, + metadata=nested("sig-proofs", lambda: MerkleArrayProof), + ) + signed_weight: int | None = field( + default=None, + metadata=wire("signed-weight"), + ) diff --git a/src/algokit_indexer_client/models/_state_proof_participant.py b/src/algokit_indexer_client/models/_state_proof_participant.py new file mode 100644 index 00000000..18583f38 --- /dev/null +++ b/src/algokit_indexer_client/models/_state_proof_participant.py @@ -0,0 +1,20 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._state_proof_verifier import StateProofVerifier + + +@dataclass(slots=True) +class StateProofParticipant: + verifier: StateProofVerifier | None = field( + default=None, + metadata=nested("verifier", lambda: StateProofVerifier), + ) + weight: int | None = field( + default=None, + metadata=wire("weight"), + ) diff --git a/src/algokit_indexer_client/models/_state_proof_reveal.py b/src/algokit_indexer_client/models/_state_proof_reveal.py new file mode 100644 index 00000000..b5a7522e --- /dev/null +++ b/src/algokit_indexer_client/models/_state_proof_reveal.py @@ -0,0 +1,25 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._state_proof_participant import StateProofParticipant +from ._state_proof_sig_slot import StateProofSigSlot + + +@dataclass(slots=True) +class StateProofReveal: + participant: StateProofParticipant | None = field( + default=None, + metadata=nested("participant", lambda: StateProofParticipant), + ) + position: int | None = field( + default=None, + metadata=wire("position"), + ) + sig_slot: StateProofSigSlot | None = field( + default=None, + metadata=nested("sig-slot", lambda: StateProofSigSlot), + ) diff --git a/src/algokit_indexer_client/models/_state_proof_sig_slot.py b/src/algokit_indexer_client/models/_state_proof_sig_slot.py new file mode 100644 index 00000000..ef5fd3bb --- /dev/null +++ b/src/algokit_indexer_client/models/_state_proof_sig_slot.py @@ -0,0 +1,20 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._state_proof_signature import StateProofSignature + + +@dataclass(slots=True) +class StateProofSigSlot: + lower_sig_weight: int | None = field( + default=None, + metadata=wire("lower-sig-weight"), + ) + signature: StateProofSignature | None = field( + default=None, + metadata=nested("signature", lambda: StateProofSignature), + ) diff --git a/src/algokit_indexer_client/models/_state_proof_signature.py b/src/algokit_indexer_client/models/_state_proof_signature.py new file mode 100644 index 00000000..9d6bc88c --- /dev/null +++ b/src/algokit_indexer_client/models/_state_proof_signature.py @@ -0,0 +1,37 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._merkle_array_proof import MerkleArrayProof +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class StateProofSignature: + falcon_signature: bytes | None = field( + default=None, + metadata=wire( + "falcon-signature", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + merkle_array_index: int | None = field( + default=None, + metadata=wire("merkle-array-index"), + ) + proof: MerkleArrayProof | None = field( + default=None, + metadata=nested("proof", lambda: MerkleArrayProof), + ) + verifying_key: bytes | None = field( + default=None, + metadata=wire( + "verifying-key", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_indexer_client/models/_state_proof_tracking.py b/src/algokit_indexer_client/models/_state_proof_tracking.py new file mode 100644 index 00000000..bebbe0ba --- /dev/null +++ b/src/algokit_indexer_client/models/_state_proof_tracking.py @@ -0,0 +1,32 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class StateProofTracking: + next_round: int | None = field( + default=None, + metadata=wire("next-round"), + ) + online_total_weight: int | None = field( + default=None, + metadata=wire("online-total-weight"), + ) + type_: int | None = field( + default=None, + metadata=wire("type"), + ) + voters_commitment: bytes | None = field( + default=None, + metadata=wire( + "voters-commitment", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_indexer_client/models/_state_proof_verifier.py b/src/algokit_indexer_client/models/_state_proof_verifier.py new file mode 100644 index 00000000..d7dc7f71 --- /dev/null +++ b/src/algokit_indexer_client/models/_state_proof_verifier.py @@ -0,0 +1,24 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_fixed_bytes, encode_fixed_bytes + + +@dataclass(slots=True) +class StateProofVerifier: + commitment: bytes | None = field( + default=None, + metadata=wire( + "commitment", + encode=lambda v: encode_fixed_bytes(v, 64), + decode=lambda raw: decode_fixed_bytes(raw, 64), + ), + ) + key_lifetime: int | None = field( + default=None, + metadata=wire("key-lifetime"), + ) diff --git a/src/algokit_indexer_client/models/_state_schema.py b/src/algokit_indexer_client/models/_state_schema.py new file mode 100644 index 00000000..129a7b01 --- /dev/null +++ b/src/algokit_indexer_client/models/_state_schema.py @@ -0,0 +1,25 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class StateSchema: + r""" + Represents a \[apls\] local-state or \[apgs\] global-state schema. These schemas + determine how much storage may be used in a local-state or global-state for an + application. The more space used, the larger minimum balance must be maintained in the + account holding the data. + """ + + num_byte_slices: int = field( + default=0, + metadata=wire("num-byte-slice"), + ) + num_uints: int = field( + default=0, + metadata=wire("num-uint"), + ) diff --git a/src/algokit_indexer_client/models/_teal_key_value.py b/src/algokit_indexer_client/models/_teal_key_value.py new file mode 100644 index 00000000..3dd76772 --- /dev/null +++ b/src/algokit_indexer_client/models/_teal_key_value.py @@ -0,0 +1,28 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._serde_helpers import decode_bytes, encode_bytes +from ._teal_value import TealValue + + +@dataclass(slots=True) +class TealKeyValue: + """ + Represents a key-value pair in an application store. + """ + + value: TealValue = field( + metadata=nested("value", lambda: TealValue, required=True), + ) + key: bytes = field( + default=b"", + metadata=wire( + "key", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_indexer_client/models/_teal_key_value_store.py b/src/algokit_indexer_client/models/_teal_key_value_store.py new file mode 100644 index 00000000..253b6bfc --- /dev/null +++ b/src/algokit_indexer_client/models/_teal_key_value_store.py @@ -0,0 +1,6 @@ +# AUTO-GENERATED: oas_generator + + +from ._teal_key_value import TealKeyValue + +TealKeyValueStore = list[TealKeyValue] diff --git a/src/algokit_indexer_client/models/_teal_value.py b/src/algokit_indexer_client/models/_teal_value.py new file mode 100644 index 00000000..70fc323c --- /dev/null +++ b/src/algokit_indexer_client/models/_teal_value.py @@ -0,0 +1,32 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class TealValue: + """ + Represents a TEAL value. + """ + + bytes_: bytes = field( + default=b"", + metadata=wire( + "bytes", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + type_: int = field( + default=0, + metadata=wire("type"), + ) + uint: int = field( + default=0, + metadata=wire("uint"), + ) diff --git a/src/algokit_indexer_client/models/_transaction.py b/src/algokit_indexer_client/models/_transaction.py new file mode 100644 index 00000000..73ed0212 --- /dev/null +++ b/src/algokit_indexer_client/models/_transaction.py @@ -0,0 +1,213 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._account_state_delta import AccountStateDelta +from ._eval_delta_key_value import EvalDeltaKeyValue +from ._serde_helpers import ( + decode_bytes, + decode_bytes_sequence, + decode_fixed_bytes, + decode_model_sequence, + encode_bytes, + encode_bytes_sequence, + encode_fixed_bytes, + encode_model_sequence, +) +from ._transaction_application import TransactionApplication +from ._transaction_asset_config import TransactionAssetConfig +from ._transaction_asset_freeze import TransactionAssetFreeze +from ._transaction_asset_transfer import TransactionAssetTransfer +from ._transaction_heartbeat import TransactionHeartbeat +from ._transaction_keyreg import TransactionKeyreg +from ._transaction_payment import TransactionPayment +from ._transaction_signature import TransactionSignature +from ._transaction_state_proof import TransactionStateProof + + +@dataclass(slots=True) +class Transaction: + """ + Contains all fields common to all transactions and serves as an envelope to all + transactions type. Represents both regular and inner transactions. + + Definition: + data/transactions/signedtxn.go : SignedTxn + data/transactions/transaction.go : Transaction + """ + + fee: int = field( + default=0, + metadata=wire("fee"), + ) + first_valid: int = field( + default=0, + metadata=wire("first-valid"), + ) + last_valid: int = field( + default=0, + metadata=wire("last-valid"), + ) + sender: str = field( + default="", + metadata=wire("sender"), + ) + tx_type: str = field( + default="", + metadata=wire("tx-type"), + ) + application_transaction: TransactionApplication | None = field( + default=None, + metadata=nested("application-transaction", lambda: TransactionApplication), + ) + asset_config_transaction: TransactionAssetConfig | None = field( + default=None, + metadata=nested("asset-config-transaction", lambda: TransactionAssetConfig), + ) + asset_freeze_transaction: TransactionAssetFreeze | None = field( + default=None, + metadata=nested("asset-freeze-transaction", lambda: TransactionAssetFreeze), + ) + asset_transfer_transaction: TransactionAssetTransfer | None = field( + default=None, + metadata=nested("asset-transfer-transaction", lambda: TransactionAssetTransfer), + ) + auth_addr: str | None = field( + default=None, + metadata=wire("auth-addr"), + ) + close_rewards: int | None = field( + default=None, + metadata=wire("close-rewards"), + ) + closing_amount: int | None = field( + default=None, + metadata=wire("closing-amount"), + ) + confirmed_round: int | None = field( + default=None, + metadata=wire("confirmed-round"), + ) + created_app_id: int | None = field( + default=None, + metadata=wire("created-application-index"), + ) + created_asset_id: int | None = field( + default=None, + metadata=wire("created-asset-index"), + ) + genesis_hash: bytes | None = field( + default=None, + metadata=wire( + "genesis-hash", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) + genesis_id: str | None = field( + default=None, + metadata=wire("genesis-id"), + ) + global_state_delta: list[EvalDeltaKeyValue] | None = field( + default=None, + metadata=wire( + "global-state-delta", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: EvalDeltaKeyValue, raw), + ), + ) + group: bytes | None = field( + default=None, + metadata=wire( + "group", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) + heartbeat_transaction: TransactionHeartbeat | None = field( + default=None, + metadata=nested("heartbeat-transaction", lambda: TransactionHeartbeat), + ) + id_: str | None = field( + default=None, + metadata=wire("id"), + ) + inner_txns: list["Transaction"] | None = field( + default=None, + metadata=wire( + "inner-txns", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: Transaction, raw), + ), + ) + intra_round_offset: int | None = field( + default=None, + metadata=wire("intra-round-offset"), + ) + keyreg_transaction: TransactionKeyreg | None = field( + default=None, + metadata=nested("keyreg-transaction", lambda: TransactionKeyreg), + ) + lease: bytes | None = field( + default=None, + metadata=wire( + "lease", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) + local_state_delta: list[AccountStateDelta] | None = field( + default=None, + metadata=wire( + "local-state-delta", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: AccountStateDelta, raw), + ), + ) + logs: list[bytes] | None = field( + default=None, + metadata=wire( + "logs", + encode=encode_bytes_sequence, + decode=decode_bytes_sequence, + ), + ) + note: bytes | None = field( + default=None, + metadata=wire( + "note", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + payment_transaction: TransactionPayment | None = field( + default=None, + metadata=nested("payment-transaction", lambda: TransactionPayment), + ) + receiver_rewards: int | None = field( + default=None, + metadata=wire("receiver-rewards"), + ) + rekey_to: str | None = field( + default=None, + metadata=wire("rekey-to"), + ) + round_time: int | None = field( + default=None, + metadata=wire("round-time"), + ) + sender_rewards: int | None = field( + default=None, + metadata=wire("sender-rewards"), + ) + signature: TransactionSignature | None = field( + default=None, + metadata=nested("signature", lambda: TransactionSignature), + ) + state_proof_transaction: TransactionStateProof | None = field( + default=None, + metadata=nested("state-proof-transaction", lambda: TransactionStateProof), + ) diff --git a/src/algokit_indexer_client/models/_transaction_application.py b/src/algokit_indexer_client/models/_transaction_application.py new file mode 100644 index 00000000..5d7ad16a --- /dev/null +++ b/src/algokit_indexer_client/models/_transaction_application.py @@ -0,0 +1,105 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import enum_value, nested, wire + +from ._box_reference import BoxReference +from ._on_completion import OnCompletion +from ._resource_ref import ResourceRef +from ._serde_helpers import ( + decode_bytes, + decode_bytes_sequence, + decode_model_sequence, + encode_bytes, + encode_bytes_sequence, + encode_model_sequence, +) +from ._state_schema import StateSchema + + +@dataclass(slots=True) +class TransactionApplication: + """ + Fields for application transactions. + + Definition: + data/transactions/application.go : ApplicationCallTxnFields + """ + + on_completion: OnCompletion = field( + metadata=enum_value("on-completion", OnCompletion), + ) + application_id: int = field( + default=0, + metadata=wire("application-id"), + ) + access: list[ResourceRef] | None = field( + default=None, + metadata=wire( + "access", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: ResourceRef, raw), + ), + ) + accounts: list[str] | None = field( + default=None, + metadata=wire("accounts"), + ) + application_args: list[bytes] | None = field( + default=None, + metadata=wire( + "application-args", + encode=encode_bytes_sequence, + decode=decode_bytes_sequence, + ), + ) + approval_program: bytes | None = field( + default=None, + metadata=wire( + "approval-program", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + box_references: list[BoxReference] | None = field( + default=None, + metadata=wire( + "box-references", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: BoxReference, raw), + ), + ) + clear_state_program: bytes | None = field( + default=None, + metadata=wire( + "clear-state-program", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + extra_program_pages: int | None = field( + default=None, + metadata=wire("extra-program-pages"), + ) + foreign_apps: list[int] | None = field( + default=None, + metadata=wire("foreign-apps"), + ) + foreign_assets: list[int] | None = field( + default=None, + metadata=wire("foreign-assets"), + ) + global_state_schema: StateSchema | None = field( + default=None, + metadata=nested("global-state-schema", lambda: StateSchema), + ) + local_state_schema: StateSchema | None = field( + default=None, + metadata=nested("local-state-schema", lambda: StateSchema), + ) + reject_version: int | None = field( + default=None, + metadata=wire("reject-version"), + ) diff --git a/src/algokit_indexer_client/models/_transaction_asset_config.py b/src/algokit_indexer_client/models/_transaction_asset_config.py new file mode 100644 index 00000000..c96ae388 --- /dev/null +++ b/src/algokit_indexer_client/models/_transaction_asset_config.py @@ -0,0 +1,31 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._asset_params import AssetParams + + +@dataclass(slots=True) +class TransactionAssetConfig: + """ + Fields for asset allocation, re-configuration, and destruction. + + + A zero value for asset-id indicates asset creation. + A zero value for the params indicates asset destruction. + + Definition: + data/transactions/asset.go : AssetConfigTxnFields + """ + + asset_id: int | None = field( + default=None, + metadata=wire("asset-id"), + ) + params: AssetParams | None = field( + default=None, + metadata=nested("params", lambda: AssetParams), + ) diff --git a/src/algokit_indexer_client/models/_transaction_asset_freeze.py b/src/algokit_indexer_client/models/_transaction_asset_freeze.py new file mode 100644 index 00000000..7c692639 --- /dev/null +++ b/src/algokit_indexer_client/models/_transaction_asset_freeze.py @@ -0,0 +1,29 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class TransactionAssetFreeze: + """ + Fields for an asset freeze transaction. + + Definition: + data/transactions/asset.go : AssetFreezeTxnFields + """ + + address: str = field( + default="", + metadata=wire("address"), + ) + asset_id: int = field( + default=0, + metadata=wire("asset-id"), + ) + new_freeze_status: bool = field( + default=False, + metadata=wire("new-freeze-status"), + ) diff --git a/src/algokit_indexer_client/models/_transaction_asset_transfer.py b/src/algokit_indexer_client/models/_transaction_asset_transfer.py new file mode 100644 index 00000000..c1ac45aa --- /dev/null +++ b/src/algokit_indexer_client/models/_transaction_asset_transfer.py @@ -0,0 +1,41 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class TransactionAssetTransfer: + """ + Fields for an asset transfer transaction. + + Definition: + data/transactions/asset.go : AssetTransferTxnFields + """ + + amount: int = field( + default=0, + metadata=wire("amount"), + ) + asset_id: int = field( + default=0, + metadata=wire("asset-id"), + ) + receiver: str = field( + default="", + metadata=wire("receiver"), + ) + close_amount: int | None = field( + default=None, + metadata=wire("close-amount"), + ) + close_to: str | None = field( + default=None, + metadata=wire("close-to"), + ) + sender: str | None = field( + default=None, + metadata=wire("sender"), + ) diff --git a/src/algokit_indexer_client/models/_transaction_heartbeat.py b/src/algokit_indexer_client/models/_transaction_heartbeat.py new file mode 100644 index 00000000..3cc27599 --- /dev/null +++ b/src/algokit_indexer_client/models/_transaction_heartbeat.py @@ -0,0 +1,47 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._hb_proof_fields import HbProofFields +from ._serde_helpers import decode_bytes, decode_fixed_bytes, encode_bytes, encode_fixed_bytes + + +@dataclass(slots=True) +class TransactionHeartbeat: + """ + Fields for a heartbeat transaction. + + Definition: + data/transactions/heartbeat.go : HeartbeatTxnFields + """ + + hb_proof: HbProofFields = field( + metadata=nested("hb-proof", lambda: HbProofFields, required=True), + ) + hb_address: str = field( + default="", + metadata=wire("hb-address"), + ) + hb_key_dilution: int = field( + default=0, + metadata=wire("hb-key-dilution"), + ) + hb_seed: bytes = field( + default=b"", + metadata=wire( + "hb-seed", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + hb_vote_id: bytes = field( + default=b"", + metadata=wire( + "hb-vote-id", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) diff --git a/src/algokit_indexer_client/models/_transaction_keyreg.py b/src/algokit_indexer_client/models/_transaction_keyreg.py new file mode 100644 index 00000000..1b1e3272 --- /dev/null +++ b/src/algokit_indexer_client/models/_transaction_keyreg.py @@ -0,0 +1,59 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_fixed_bytes, encode_fixed_bytes + + +@dataclass(slots=True) +class TransactionKeyreg: + """ + Fields for a keyreg transaction. + + Definition: + data/transactions/keyreg.go : KeyregTxnFields + """ + + non_participation: bool | None = field( + default=None, + metadata=wire("non-participation"), + ) + selection_participation_key: bytes | None = field( + default=None, + metadata=wire( + "selection-participation-key", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) + state_proof_key: bytes | None = field( + default=None, + metadata=wire( + "state-proof-key", + encode=lambda v: encode_fixed_bytes(v, 64), + decode=lambda raw: decode_fixed_bytes(raw, 64), + ), + ) + vote_first_valid: int | None = field( + default=None, + metadata=wire("vote-first-valid"), + ) + vote_key_dilution: int | None = field( + default=None, + metadata=wire("vote-key-dilution"), + ) + vote_last_valid: int | None = field( + default=None, + metadata=wire("vote-last-valid"), + ) + vote_participation_key: bytes | None = field( + default=None, + metadata=wire( + "vote-participation-key", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) diff --git a/src/algokit_indexer_client/models/_transaction_payment.py b/src/algokit_indexer_client/models/_transaction_payment.py new file mode 100644 index 00000000..25a6a1ef --- /dev/null +++ b/src/algokit_indexer_client/models/_transaction_payment.py @@ -0,0 +1,33 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class TransactionPayment: + """ + Fields for a payment transaction. + + Definition: + data/transactions/payment.go : PaymentTxnFields + """ + + amount: int = field( + default=0, + metadata=wire("amount"), + ) + receiver: str = field( + default="", + metadata=wire("receiver"), + ) + close_amount: int | None = field( + default=None, + metadata=wire("close-amount"), + ) + close_remainder_to: str | None = field( + default=None, + metadata=wire("close-remainder-to"), + ) diff --git a/src/algokit_indexer_client/models/_transaction_response.py b/src/algokit_indexer_client/models/_transaction_response.py new file mode 100644 index 00000000..3f6a3edd --- /dev/null +++ b/src/algokit_indexer_client/models/_transaction_response.py @@ -0,0 +1,19 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._transaction import Transaction + + +@dataclass(slots=True) +class TransactionResponse: + transaction: Transaction = field( + metadata=nested("transaction", lambda: Transaction, required=True), + ) + current_round: int = field( + default=0, + metadata=wire("current-round"), + ) diff --git a/src/algokit_indexer_client/models/_transaction_signature.py b/src/algokit_indexer_client/models/_transaction_signature.py new file mode 100644 index 00000000..98b03d2a --- /dev/null +++ b/src/algokit_indexer_client/models/_transaction_signature.py @@ -0,0 +1,35 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._serde_helpers import decode_bytes, encode_bytes +from ._transaction_signature_logicsig import TransactionSignatureLogicsig +from ._transaction_signature_multisig import TransactionSignatureMultisig + + +@dataclass(slots=True) +class TransactionSignature: + """ + Validation signature associated with some data. Only one of the signatures should be + provided. + """ + + logicsig: TransactionSignatureLogicsig | None = field( + default=None, + metadata=nested("logicsig", lambda: TransactionSignatureLogicsig), + ) + multisig: TransactionSignatureMultisig | None = field( + default=None, + metadata=nested("multisig", lambda: TransactionSignatureMultisig), + ) + sig: bytes | None = field( + default=None, + metadata=wire( + "sig", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_indexer_client/models/_transaction_signature_logicsig.py b/src/algokit_indexer_client/models/_transaction_signature_logicsig.py new file mode 100644 index 00000000..d2335bb3 --- /dev/null +++ b/src/algokit_indexer_client/models/_transaction_signature_logicsig.py @@ -0,0 +1,59 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._serde_helpers import ( + decode_bytes, + decode_bytes_sequence, + decode_fixed_bytes, + encode_bytes, + encode_bytes_sequence, + encode_fixed_bytes, +) +from ._transaction_signature_multisig import TransactionSignatureMultisig + + +@dataclass(slots=True) +class TransactionSignatureLogicsig: + r""" + \[lsig\] Programatic transaction signature. + + Definition: + data/transactions/logicsig.go + """ + + logic: bytes = field( + default=b"", + metadata=wire( + "logic", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + args: list[bytes] | None = field( + default=None, + metadata=wire( + "args", + encode=encode_bytes_sequence, + decode=decode_bytes_sequence, + ), + ) + logic_multisig_signature: TransactionSignatureMultisig | None = field( + default=None, + metadata=nested("logic-multisig-signature", lambda: TransactionSignatureMultisig), + ) + multisig_signature: TransactionSignatureMultisig | None = field( + default=None, + metadata=nested("multisig-signature", lambda: TransactionSignatureMultisig), + ) + signature: bytes | None = field( + default=None, + metadata=wire( + "signature", + encode=lambda v: encode_fixed_bytes(v, 64), + decode=lambda raw: decode_fixed_bytes(raw, 64), + ), + ) diff --git a/src/algokit_indexer_client/models/_transaction_signature_multisig.py b/src/algokit_indexer_client/models/_transaction_signature_multisig.py new file mode 100644 index 00000000..5c538412 --- /dev/null +++ b/src/algokit_indexer_client/models/_transaction_signature_multisig.py @@ -0,0 +1,36 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_model_sequence, encode_model_sequence +from ._transaction_signature_multisig_subsignature import TransactionSignatureMultisigSubsignature + + +@dataclass(slots=True) +class TransactionSignatureMultisig: + """ + structure holding multiple subsignatures. + + Definition: + crypto/multisig.go : MultisigSig + """ + + subsignature: list[TransactionSignatureMultisigSubsignature] | None = field( + default=None, + metadata=wire( + "subsignature", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: TransactionSignatureMultisigSubsignature, raw), + ), + ) + threshold: int | None = field( + default=None, + metadata=wire("threshold"), + ) + version: int | None = field( + default=None, + metadata=wire("version"), + ) diff --git a/src/algokit_indexer_client/models/_transaction_signature_multisig_subsignature.py b/src/algokit_indexer_client/models/_transaction_signature_multisig_subsignature.py new file mode 100644 index 00000000..4dc048ca --- /dev/null +++ b/src/algokit_indexer_client/models/_transaction_signature_multisig_subsignature.py @@ -0,0 +1,28 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_fixed_bytes, encode_fixed_bytes + + +@dataclass(slots=True) +class TransactionSignatureMultisigSubsignature: + public_key: bytes | None = field( + default=None, + metadata=wire( + "public-key", + encode=lambda v: encode_fixed_bytes(v, 32), + decode=lambda raw: decode_fixed_bytes(raw, 32), + ), + ) + signature: bytes | None = field( + default=None, + metadata=wire( + "signature", + encode=lambda v: encode_fixed_bytes(v, 64), + decode=lambda raw: decode_fixed_bytes(raw, 64), + ), + ) diff --git a/src/algokit_indexer_client/models/_transaction_state_proof.py b/src/algokit_indexer_client/models/_transaction_state_proof.py new file mode 100644 index 00000000..688e21a1 --- /dev/null +++ b/src/algokit_indexer_client/models/_transaction_state_proof.py @@ -0,0 +1,32 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._indexer_state_proof_message import IndexerStateProofMessage +from ._state_proof_fields import StateProofFields + + +@dataclass(slots=True) +class TransactionStateProof: + """ + Fields for a state proof transaction. + + Definition: + data/transactions/stateproof.go : StateProofTxnFields + """ + + message: IndexerStateProofMessage | None = field( + default=None, + metadata=nested("message", lambda: IndexerStateProofMessage), + ) + state_proof: StateProofFields | None = field( + default=None, + metadata=nested("state-proof", lambda: StateProofFields), + ) + state_proof_type: int | None = field( + default=None, + metadata=wire("state-proof-type"), + ) diff --git a/src/algokit_indexer_client/models/_transactions_response.py b/src/algokit_indexer_client/models/_transactions_response.py new file mode 100644 index 00000000..a9b0a086 --- /dev/null +++ b/src/algokit_indexer_client/models/_transactions_response.py @@ -0,0 +1,29 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_model_sequence, encode_model_sequence +from ._transaction import Transaction + + +@dataclass(slots=True) +class TransactionsResponse: + current_round: int = field( + default=0, + metadata=wire("current-round"), + ) + transactions: list[Transaction] = field( + default_factory=list, + metadata=wire( + "transactions", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: Transaction, raw), + ), + ) + next_token: str | None = field( + default=None, + metadata=wire("next-token"), + ) diff --git a/src/algokit_indexer_client/py.typed b/src/algokit_indexer_client/py.typed new file mode 100644 index 00000000..abb15e27 --- /dev/null +++ b/src/algokit_indexer_client/py.typed @@ -0,0 +1 @@ +# AUTO-GENERATED: oas_generator diff --git a/src/algokit_indexer_client/types.py b/src/algokit_indexer_client/types.py new file mode 100644 index 00000000..379362d9 --- /dev/null +++ b/src/algokit_indexer_client/types.py @@ -0,0 +1,7 @@ +# AUTO-GENERATED: oas_generator + + +from typing import Any + +JSONMapping = dict[str, Any] +Headers = dict[str, str] diff --git a/src/algokit_kmd_client/__init__.py b/src/algokit_kmd_client/__init__.py new file mode 100644 index 00000000..44d5d279 --- /dev/null +++ b/src/algokit_kmd_client/__init__.py @@ -0,0 +1,10 @@ +# AUTO-GENERATED: oas_generator + + +from .client import KmdClient +from .config import ClientConfig + +__all__ = [ + "ClientConfig", + "KmdClient", +] diff --git a/src/algokit_kmd_client/client.py b/src/algokit_kmd_client/client.py new file mode 100644 index 00000000..b2feec1d --- /dev/null +++ b/src/algokit_kmd_client/client.py @@ -0,0 +1,1240 @@ +# AUTO-GENERATED: oas_generator +import random +import time +from dataclasses import is_dataclass +from typing import Any, Literal, TypeVar, overload + +import httpx +import msgpack + +from algokit_common.serde import from_wire, to_wire + +from . import models +from .config import ClientConfig +from .exceptions import UnexpectedStatusError +from .types import Headers + +# HTTP status codes that warrant a retry (aligned with algokit-utils-ts) +_RETRY_STATUS_CODES: frozenset[int] = frozenset({408, 413, 429, 500, 502, 503, 504}) +# Network error codes that warrant a retry (aligned with algokit-utils-ts) +_RETRY_ERROR_CODES: frozenset[str] = frozenset( + { + "ETIMEDOUT", + "ECONNRESET", + "EADDRINUSE", + "ECONNREFUSED", + "EPIPE", + "ENOTFOUND", + "ENETUNREACH", + "EAI_AGAIN", + "EPROTO", + } +) +_MAX_BACKOFF_MS: float = 10_000.0 +_DEFAULT_MAX_TRIES: int = 5 + +ModelT = TypeVar("ModelT") +ListModelT = TypeVar("ListModelT") +PrimitiveT = TypeVar("PrimitiveT") + +# Prefixed markers used when converting unhashable msgpack map keys into hashable tuples +_UNHASHABLE_PREFIXES: dict[str, str] = { + "dict": "__dict_key__", + "list": "__list_key__", + "set": "__set_key__", + "generic": "__unhashable__", +} + + +class KmdClient: + def __init__(self, config: ClientConfig | None = None, *, http_client: httpx.Client | None = None) -> None: + self._config = config or ClientConfig() + # Track whether a custom HTTP client was provided to avoid retry conflicts + self._uses_custom_client = http_client is not None + self._client = http_client or httpx.Client( + base_url=self._config.base_url, + timeout=self._config.timeout, + verify=self._config.verify, + ) + + def close(self) -> None: + self._client.close() + + def _calculate_max_tries(self) -> int: + """Calculate maximum number of tries from config.max_retries.""" + max_retries = self._config.max_retries + if not isinstance(max_retries, int) or max_retries < 0: + return _DEFAULT_MAX_TRIES + return max_retries + 1 + + def _should_retry(self, error: Exception | None, status_code: int | None, attempt: int, max_tries: int) -> bool: + """Determine if a request should be retried based on error/status and attempt count.""" + if attempt >= max_tries: + return False + + # Check HTTP status code + if status_code is not None and status_code in _RETRY_STATUS_CODES: + return True + + # Check network error codes (aligned with algokit-utils-ts) + if error is not None: + error_code = self._extract_error_code(error) + if error_code and error_code in _RETRY_ERROR_CODES: + return True + + return False + + def _extract_error_code(self, error: BaseException) -> str | None: + """Extract error code from exception, checking common attributes.""" + # Check for 'code' attribute (common in OS/network errors) + if hasattr(error, "code") and isinstance(error.code, str): + return error.code + # Check for errno attribute + if hasattr(error, "errno") and error.errno is not None: + import errno as errno_module + + try: + return errno_module.errorcode.get(error.errno) + except (TypeError, AttributeError): + pass + # Check __cause__ for wrapped errors + if error.__cause__ is not None: + return self._extract_error_code(error.__cause__) + return None + + def _request_with_retry(self, request_kwargs: dict[str, Any]) -> httpx.Response: + """Execute request with exponential backoff retry for transient failures. + + When a custom HTTP client is provided, retries are disabled to avoid + conflicts with any retry mechanism the custom client may implement. + """ + # Disable retries when using a custom HTTP client to avoid conflicts + # with the client's own retry mechanism + if self._uses_custom_client: + return self._client.request(**request_kwargs) + + max_tries = self._calculate_max_tries() + attempt = 1 + last_error: Exception | None = None + + while attempt <= max_tries: + status_code: int | None = None + try: + response = self._client.request(**request_kwargs) + status_code = response.status_code + if not self._should_retry(None, status_code, attempt, max_tries): + return response + except httpx.TransportError as exc: + last_error = exc + if not self._should_retry(exc, None, attempt, max_tries): + raise + + if attempt == 1: + backoff_ms = 0.0 + else: + base_backoff = min(1000.0 * (2 ** (attempt - 1)), _MAX_BACKOFF_MS) + jitter = 0.5 + random.random() # Random value between 0.5 and 1.5 + backoff_ms = base_backoff * jitter + if backoff_ms > 0: + time.sleep(backoff_ms / 1000.0) + attempt += 1 + + # Should not reach here, but satisfy type checker + if last_error: + raise last_error + raise RuntimeError(f"Request failed after {max_tries} attempt(s)") + + # default + + def create_wallet( + self, + body: models.CreateWalletRequest, + ) -> models.CreateWalletResponse: + """ + Create a wallet + """ + + path = "/v1/wallet" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "CreateWalletRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.CreateWalletResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def delete_key( + self, + body: models.DeleteKeyRequest, + ) -> None: + """ + Delete a key + """ + + path = "/v1/key" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "DELETE", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "DeleteKeyRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return + + raise UnexpectedStatusError(response.status_code, response.text) + + def delete_multisig( + self, + body: models.DeleteMultisigRequest, + ) -> None: + """ + Delete a multisig + """ + + path = "/v1/multisig" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "DELETE", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "DeleteMultisigRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return + + raise UnexpectedStatusError(response.status_code, response.text) + + def export_key( + self, + body: models.ExportKeyRequest, + ) -> models.ExportKeyResponse: + """ + Export a key + """ + + path = "/v1/key/export" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "ExportKeyRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.ExportKeyResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def export_master_key( + self, + body: models.ExportMasterKeyRequest, + ) -> models.ExportMasterKeyResponse: + """ + Export the master derivation key from a wallet + """ + + path = "/v1/master-key/export" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "ExportMasterKeyRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.ExportMasterKeyResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def export_multisig( + self, + body: models.ExportMultisigRequest, + ) -> models.ExportMultisigResponse: + """ + Export multisig address metadata + """ + + path = "/v1/multisig/export" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "ExportMultisigRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.ExportMultisigResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def generate_key( + self, + body: models.GenerateKeyRequest, + ) -> models.GenerateKeyResponse: + """ + Generate a key + """ + + path = "/v1/key" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "GenerateKeyRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.GenerateKeyResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def import_key( + self, + body: models.ImportKeyRequest, + ) -> models.ImportKeyResponse: + """ + Import a key + """ + + path = "/v1/key/import" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "ImportKeyRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.ImportKeyResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def import_multisig( + self, + body: models.ImportMultisigRequest, + ) -> models.ImportMultisigResponse: + """ + Import a multisig account + """ + + path = "/v1/multisig/import" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "ImportMultisigRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.ImportMultisigResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def init_wallet_handle( + self, + body: models.InitWalletHandleTokenRequest, + ) -> models.InitWalletHandleTokenResponse: + """ + Initialize a wallet handle token + """ + + path = "/v1/wallet/init" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "InitWalletHandleTokenRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.InitWalletHandleTokenResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def list_keys_in_wallet( + self, + body: models.ListKeysRequest, + ) -> models.ListKeysResponse: + """ + List keys in wallet + """ + + path = "/v1/key/list" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "ListKeysRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.ListKeysResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def list_multisig( + self, + body: models.ListMultisigRequest, + ) -> models.ListMultisigResponse: + """ + List multisig accounts + """ + + path = "/v1/multisig/list" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "ListMultisigRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.ListMultisigResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def list_wallets( + self, + *, + body: models.ListWalletsRequest | None = None, + ) -> models.ListWalletsResponse: + """ + List wallets + """ + + path = "/v1/wallets" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "ListWalletsRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.ListWalletsResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def release_wallet_handle_token( + self, + body: models.ReleaseWalletHandleTokenRequest, + ) -> None: + """ + Release a wallet handle token + """ + + path = "/v1/wallet/release" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "ReleaseWalletHandleTokenRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return + + raise UnexpectedStatusError(response.status_code, response.text) + + def rename_wallet( + self, + body: models.RenameWalletRequest, + ) -> models.RenameWalletResponse: + """ + Rename a wallet + """ + + path = "/v1/wallet/rename" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "RenameWalletRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.RenameWalletResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def renew_wallet_handle_token( + self, + body: models.RenewWalletHandleTokenRequest, + ) -> models.RenewWalletHandleTokenResponse: + """ + Renew a wallet handle token + """ + + path = "/v1/wallet/renew" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "RenewWalletHandleTokenRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.RenewWalletHandleTokenResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def sign_multisig_program( + self, + body: models.SignProgramMultisigRequest, + ) -> models.SignProgramMultisigResponse: + """ + Sign a program for a multisig account + """ + + path = "/v1/multisig/signprogram" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "SignProgramMultisigRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.SignProgramMultisigResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def sign_multisig_transaction( + self, + body: models.SignMultisigTxnRequest, + ) -> models.SignMultisigResponse: + """ + Sign a multisig transaction + """ + + path = "/v1/multisig/sign" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "SignMultisigTxnRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.SignMultisigResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def sign_program( + self, + body: models.SignProgramRequest, + ) -> models.SignProgramResponse: + """ + Sign program + """ + + path = "/v1/program/sign" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "SignProgramRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.SignProgramResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def sign_transaction( + self, + body: models.SignTxnRequest, + ) -> models.SignTransactionResponse: + """ + Sign a transaction + """ + + path = "/v1/transaction/sign" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "SignTxnRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.SignTransactionResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def version( + self, + *, + body: models.VersionsRequest | None = None, + ) -> models.VersionsResponse: + """ + Retrieves the current version + """ + + path = "/versions" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "GET", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "VersionsRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.VersionsResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def wallet_info( + self, + body: models.WalletInfoRequest, + ) -> models.WalletInfoResponse: + """ + Get wallet info + """ + + path = "/v1/wallet/info" + params: dict[str, Any] = {} + headers: Headers = self._config.resolve_headers() + + accept_value: str | None = None + + body_media_types = ["application/json"] + + headers.setdefault("accept", accept_value or "application/json") + request_kwargs: dict[str, Any] = { + "method": "POST", + "url": path, + "params": params, + "headers": headers, + } + + if body is not None: + self._assign_body( + request_kwargs, + body, + { + "model": "WalletInfoRequest", + }, + body_media_types, + ) + + response = self._request_with_retry(request_kwargs) + if response.is_success: + return self._decode_response(response, model=models.WalletInfoResponse) + + raise UnexpectedStatusError(response.status_code, response.text) + + def _assign_body( + self, + request_kwargs: dict[str, Any], + payload: object, + descriptor: dict[str, object], + media_types: list[str], + ) -> None: + encoded = self._encode_payload(payload, descriptor) + binary_types = {"application/x-binary", "application/octet-stream"} + if bool(descriptor.get("is_binary")) or any(mt in binary_types for mt in media_types): + if encoded is None: + return + request_kwargs["content"] = encoded + if media_types: + request_kwargs.setdefault("headers", {})["content-type"] = media_types[0] + else: + request_kwargs.setdefault("headers", {})["content-type"] = "application/octet-stream" + elif "application/json" in media_types: + request_kwargs["json"] = encoded + elif "application/msgpack" in media_types: + request_kwargs["content"] = msgpack.packb(encoded, use_bin_type=True) + request_kwargs.setdefault("headers", {})["content-type"] = "application/msgpack" + else: + request_kwargs["json"] = encoded + + def _encode_payload(self, payload: object, descriptor: dict[str, object]) -> object: + if payload is None: + return None + if is_dataclass(payload): + return to_wire(payload) + list_model = descriptor.get("list_model") + if list_model and isinstance(payload, list): + return [to_wire(item) if is_dataclass(item) else item for item in payload] + return payload + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + model: type[ModelT], + is_binary: bool = False, + raw_msgpack: bool = False, + ) -> ModelT: ... + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + list_model: type[ListModelT], + is_binary: bool = False, + raw_msgpack: bool = False, + ) -> list[ListModelT]: ... + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + type_: type[PrimitiveT], + is_binary: bool = False, + raw_msgpack: bool = False, + ) -> PrimitiveT: ... + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + is_binary: Literal[True], + raw_msgpack: bool = False, + ) -> bytes: ... + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + raw_msgpack: Literal[True], + ) -> bytes: ... + + @overload + def _decode_response( + self, + response: httpx.Response, + *, + type_: None = None, + is_binary: bool = False, + raw_msgpack: bool = False, + ) -> object: ... + + def _decode_response( + self, + response: httpx.Response, + *, + model: type[Any] | None = None, + list_model: type[Any] | None = None, + type_: type[Any] | None = None, + is_binary: bool = False, + raw_msgpack: bool = False, + ) -> object: + if is_binary or raw_msgpack: + return response.content + content_type = response.headers.get("content-type", "application/json") + if "msgpack" in content_type: + # Handle msgpack unpacking with support for unhashable keys + # Use Unpacker for more control over the unpacking process + unpacker = msgpack.Unpacker( + raw=True, + strict_map_key=False, + object_pairs_hook=self._msgpack_pairs_hook, + ) + unpacker.feed(response.content) + try: + data = unpacker.unpack() + except TypeError: + # If unpacking fails due to unhashable keys, try without the hook + # and handle in normalization + unpacker = msgpack.Unpacker(raw=True, strict_map_key=False) + unpacker.feed(response.content) + data = unpacker.unpack() + data = self._normalize_msgpack(data) + elif content_type.startswith("application/json"): + data = response.json() + else: + data = response.text + if model is not None: + return from_wire(model, data) + if list_model is not None: + return [from_wire(list_model, item) for item in data] + if type_ is not None: + return data + return data + + def _normalize_msgpack(self, value: object) -> object: + # Handle pairs returned from msgpack_pairs_hook when keys are unhashable + _pair_length = 2 + if isinstance(value, list) and value and isinstance(value[0], tuple | list) and len(value[0]) == _pair_length: + # Convert to dict with normalized keys + pairs_dict: dict[object, object] = {} + for pair in value: + if isinstance(pair, tuple | list) and len(pair) == _pair_length: + k, v = pair + # For unhashable keys (like dict keys), use a tuple representation + try: + normalized_key = self._coerce_msgpack_key(k) + pairs_dict[normalized_key] = self._normalize_msgpack(v) + except TypeError: + # Key is unhashable - use tuple representation + normalized_key = ("__unhashable__", id(k), str(k)) + pairs_dict[normalized_key] = self._normalize_msgpack(v) + return pairs_dict + if isinstance(value, dict): + # Safely normalize maps: coerce string/bytes keys, but tolerate complex/unhashable keys + try: + normalized_dict: dict[object, object] = {} + for key, item in value.items(): + normalized_dict[self._coerce_msgpack_key(key)] = self._normalize_msgpack(item) + return normalized_dict + except TypeError: + # Some maps can decode to object/dict keys; keep original keys and + # only normalize values to avoid "unhashable type: 'dict'" errors. + for k, item in list(value.items()): + value[k] = self._normalize_msgpack(item) + return value + if isinstance(value, list): + return [self._normalize_msgpack(item) for item in value] + return value + + def _coerce_msgpack_key(self, key: object) -> object: + if isinstance(key, bytes): + try: + return key.decode("utf-8", errors="strict") + except UnicodeDecodeError: + return key + return key + + def _msgpack_pairs_hook(self, pairs: list[tuple[object, object]] | list[list[object]]) -> dict[object, object]: + # Convert pairs to dict, handling unhashable keys by converting them to hashable tuples + out: dict[object, object] = {} + _hashable_type_tuple = (str, int, float, bool, type(None), bytes) + + for k, v in pairs: + if isinstance(k, dict | list | set): + # Convert unhashable key to hashable tuple + hashable_key: tuple[str, object] + if isinstance(k, dict): + try: + hashable_key = (_UNHASHABLE_PREFIXES["dict"], tuple(sorted(k.items()))) + except TypeError: + hashable_key = (_UNHASHABLE_PREFIXES["dict"], str(k)) + elif isinstance(k, list): + prefix = _UNHASHABLE_PREFIXES["list"] + hashable_key = (prefix, tuple(k) if all(isinstance(x, _hashable_type_tuple) for x in k) else str(k)) + else: # set + prefix = _UNHASHABLE_PREFIXES["set"] + if all(isinstance(x, _hashable_type_tuple) for x in k): + hashable_key = (prefix, tuple(sorted(k))) + else: + hashable_key = (prefix, str(k)) + out[hashable_key] = v + else: + # Key should be hashable, use as-is + try: + out[k] = v + except TypeError: + # Unexpected unhashable type, convert to tuple + out[(_UNHASHABLE_PREFIXES["generic"], str(type(k).__name__), str(k))] = v + return out diff --git a/src/algokit_kmd_client/config.py b/src/algokit_kmd_client/config.py new file mode 100644 index 00000000..4c9c4f05 --- /dev/null +++ b/src/algokit_kmd_client/config.py @@ -0,0 +1,36 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + + +@dataclass(slots=True) +class ClientConfig: + """Runtime configuration for KmdClient. + + Attributes: + base_url: Base URL for the API endpoint. + token: Optional authentication token. + token_header: Header name for the authentication token. + timeout: Request timeout in seconds. Set to None for no timeout. + verify: SSL certificate verification. Can be a boolean or path to CA bundle. + extra_headers: Additional headers to include in all requests. + max_retries: Maximum number of retry attempts for transient failures. + Set to 0 to disable retries. Default is 4 (5 total attempts). + Note: Retries are automatically disabled when a custom http_client + is provided to avoid conflicts with the client's own retry mechanism. + """ + + base_url: str = "http://localhost:7833" + token: str | None = None + token_header: str = "X-KMD-API-Token" + timeout: float | None = 30.0 + verify: bool | str = True + extra_headers: dict[str, str] = field(default_factory=dict) + max_retries: int = 4 + + def resolve_headers(self) -> dict[str, str]: + headers = dict(self.extra_headers) + if self.token: + headers[self.token_header] = self.token + return headers diff --git a/src/algokit_kmd_client/exceptions.py b/src/algokit_kmd_client/exceptions.py new file mode 100644 index 00000000..06e4b129 --- /dev/null +++ b/src/algokit_kmd_client/exceptions.py @@ -0,0 +1,59 @@ +# AUTO-GENERATED: oas_generator + +from http import HTTPStatus +from json import JSONDecodeError, loads + + +class ApiError(RuntimeError): + """Base exception for errors raised by generated clients.""" + + +def _format_payload(payload: object) -> str | None: # noqa: C901, PLR0912 + """Extract a human-friendly message from a payload.""" + if payload is None: + return None + + text: str | None = None + if isinstance(payload, (bytes | bytearray | memoryview)): + try: + text = bytes(payload).decode("utf-8", errors="ignore") + except Exception: + text = None + if text is None: + text = str(payload) + + result = text.strip() + if not result: + return None + + try: + decoded = loads(result) + except (JSONDecodeError, TypeError): + return result + + if isinstance(decoded, dict): + for key in ("message", "msg", "error", "detail", "description", "data"): + value = decoded.get(key) + if isinstance(value, str): + candidate = value.strip() + if candidate: + result = candidate + break + + if isinstance(decoded, list) and decoded: + first = decoded[0] + if isinstance(first, str): + candidate = first.strip() + if candidate: + result = candidate + + return result + + +class UnexpectedStatusError(ApiError): + def __init__(self, status_code: int, payload: object) -> None: + message = _format_payload(payload) + description = f" {message}" if message else "" + super().__init__(f"Unexpected status code {status_code}{description}") + self.status_code = HTTPStatus(status_code) + self.payload = payload diff --git a/src/algokit_kmd_client/models/__init__.py b/src/algokit_kmd_client/models/__init__.py new file mode 100644 index 00000000..12752dad --- /dev/null +++ b/src/algokit_kmd_client/models/__init__.py @@ -0,0 +1,112 @@ +# AUTO-GENERATED: oas_generator + + +from ._classical_signatures import ClassicalSignatures +from ._create_wallet_request import CreateWalletRequest +from ._create_wallet_response import CreateWalletResponse +from ._delete_key_request import DeleteKeyRequest +from ._delete_multisig_request import DeleteMultisigRequest +from ._digest_represents_a32_byte_value_holding_the256_bit_hash_digest import ( + DigestRepresentsA32ByteValueHoldingThe256BitHashDigest, +) +from ._ed25519_public_key import Ed25519PublicKey +from ._export_key_request import ExportKeyRequest +from ._export_key_response import ExportKeyResponse +from ._export_master_key_request import ExportMasterKeyRequest +from ._export_master_key_response import ExportMasterKeyResponse +from ._export_multisig_request import ExportMultisigRequest +from ._export_multisig_response import ExportMultisigResponse +from ._generate_key_request import GenerateKeyRequest +from ._generate_key_response import GenerateKeyResponse +from ._import_key_request import ImportKeyRequest +from ._import_key_response import ImportKeyResponse +from ._import_multisig_request import ImportMultisigRequest +from ._import_multisig_response import ImportMultisigResponse +from ._init_wallet_handle_token_request import InitWalletHandleTokenRequest +from ._init_wallet_handle_token_response import InitWalletHandleTokenResponse +from ._list_keys_request import ListKeysRequest +from ._list_keys_response import ListKeysResponse +from ._list_multisig_request import ListMultisigRequest +from ._list_multisig_response import ListMultisigResponse +from ._list_wallets_request import ListWalletsRequest +from ._list_wallets_response import ListWalletsResponse +from ._master_derivation_key import MasterDerivationKey +from ._multisig_sig import MultisigSig +from ._multisig_subsig import MultisigSubsig +from ._public_key import PublicKey +from ._release_wallet_handle_token_request import ReleaseWalletHandleTokenRequest +from ._rename_wallet_request import RenameWalletRequest +from ._rename_wallet_response import RenameWalletResponse +from ._renew_wallet_handle_token_request import RenewWalletHandleTokenRequest +from ._renew_wallet_handle_token_response import RenewWalletHandleTokenResponse +from ._sign_multisig_response import SignMultisigResponse +from ._sign_multisig_txn_request import SignMultisigTxnRequest +from ._sign_program_multisig_request import SignProgramMultisigRequest +from ._sign_program_multisig_response import SignProgramMultisigResponse +from ._sign_program_request import SignProgramRequest +from ._sign_program_response import SignProgramResponse +from ._sign_transaction_response import SignTransactionResponse +from ._sign_txn_request import SignTxnRequest +from ._signature import Signature +from ._tx_type import TxType +from ._versions_request import VersionsRequest +from ._versions_response import VersionsResponse +from ._wallet import Wallet +from ._wallet_handle import WalletHandle +from ._wallet_info_request import WalletInfoRequest +from ._wallet_info_response import WalletInfoResponse + +__all__ = [ + "ClassicalSignatures", + "CreateWalletRequest", + "CreateWalletResponse", + "DeleteKeyRequest", + "DeleteMultisigRequest", + "DigestRepresentsA32ByteValueHoldingThe256BitHashDigest", + "Ed25519PublicKey", + "ExportKeyRequest", + "ExportKeyResponse", + "ExportMasterKeyRequest", + "ExportMasterKeyResponse", + "ExportMultisigRequest", + "ExportMultisigResponse", + "GenerateKeyRequest", + "GenerateKeyResponse", + "ImportKeyRequest", + "ImportKeyResponse", + "ImportMultisigRequest", + "ImportMultisigResponse", + "InitWalletHandleTokenRequest", + "InitWalletHandleTokenResponse", + "ListKeysRequest", + "ListKeysResponse", + "ListMultisigRequest", + "ListMultisigResponse", + "ListWalletsRequest", + "ListWalletsResponse", + "MasterDerivationKey", + "MultisigSig", + "MultisigSubsig", + "PublicKey", + "ReleaseWalletHandleTokenRequest", + "RenameWalletRequest", + "RenameWalletResponse", + "RenewWalletHandleTokenRequest", + "RenewWalletHandleTokenResponse", + "SignMultisigResponse", + "SignMultisigTxnRequest", + "SignProgramMultisigRequest", + "SignProgramMultisigResponse", + "SignProgramRequest", + "SignProgramResponse", + "SignTransactionResponse", + "SignTxnRequest", + "Signature", + "TxType", + "VersionsRequest", + "VersionsResponse", + "Wallet", + "WalletHandle", + "WalletInfoRequest", + "WalletInfoResponse", +] diff --git a/src/algokit_kmd_client/models/_classical_signatures.py b/src/algokit_kmd_client/models/_classical_signatures.py new file mode 100644 index 00000000..7c77e10a --- /dev/null +++ b/src/algokit_kmd_client/models/_classical_signatures.py @@ -0,0 +1,4 @@ +# AUTO-GENERATED: oas_generator + + +ClassicalSignatures = bytes diff --git a/src/algokit_kmd_client/models/_create_wallet_request.py b/src/algokit_kmd_client/models/_create_wallet_request.py new file mode 100644 index 00000000..ade83359 --- /dev/null +++ b/src/algokit_kmd_client/models/_create_wallet_request.py @@ -0,0 +1,36 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class CreateWalletRequest: + """ + The request for `POST /v1/wallet` + """ + + wallet_name: str = field( + default="", + metadata=wire("wallet_name"), + ) + wallet_password: str = field( + default="", + metadata=wire("wallet_password"), + ) + master_derivation_key: bytes | None = field( + default=None, + metadata=wire( + "master_derivation_key", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + wallet_driver_name: str | None = field( + default="sqlite", + metadata=wire("wallet_driver_name"), + ) diff --git a/src/algokit_kmd_client/models/_create_wallet_response.py b/src/algokit_kmd_client/models/_create_wallet_response.py new file mode 100644 index 00000000..81518435 --- /dev/null +++ b/src/algokit_kmd_client/models/_create_wallet_response.py @@ -0,0 +1,19 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested + +from ._wallet import Wallet + + +@dataclass(slots=True) +class CreateWalletResponse: + """ + CreateWalletResponse is the response to `POST /v1/wallet` + """ + + wallet: Wallet = field( + metadata=nested("wallet", lambda: Wallet, required=True), + ) diff --git a/src/algokit_kmd_client/models/_delete_key_request.py b/src/algokit_kmd_client/models/_delete_key_request.py new file mode 100644 index 00000000..49ad7447 --- /dev/null +++ b/src/algokit_kmd_client/models/_delete_key_request.py @@ -0,0 +1,27 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.constants import ZERO_ADDRESS +from algokit_common.serde import wire + + +@dataclass(slots=True) +class DeleteKeyRequest: + """ + The request for `DELETE /v1/key` + """ + + address: str = field( + default=ZERO_ADDRESS, + metadata=wire("address"), + ) + wallet_handle_token: str = field( + default="", + metadata=wire("wallet_handle_token"), + ) + wallet_password: str | None = field( + default=None, + metadata=wire("wallet_password"), + ) diff --git a/src/algokit_kmd_client/models/_delete_multisig_request.py b/src/algokit_kmd_client/models/_delete_multisig_request.py new file mode 100644 index 00000000..51b18410 --- /dev/null +++ b/src/algokit_kmd_client/models/_delete_multisig_request.py @@ -0,0 +1,27 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.constants import ZERO_ADDRESS +from algokit_common.serde import wire + + +@dataclass(slots=True) +class DeleteMultisigRequest: + """ + The request for `DELETE /v1/multisig` + """ + + address: str = field( + default=ZERO_ADDRESS, + metadata=wire("address"), + ) + wallet_handle_token: str = field( + default="", + metadata=wire("wallet_handle_token"), + ) + wallet_password: str | None = field( + default=None, + metadata=wire("wallet_password"), + ) diff --git a/src/algokit_kmd_client/models/_digest_represents_a32_byte_value_holding_the256_bit_hash_digest.py b/src/algokit_kmd_client/models/_digest_represents_a32_byte_value_holding_the256_bit_hash_digest.py new file mode 100644 index 00000000..b802162b --- /dev/null +++ b/src/algokit_kmd_client/models/_digest_represents_a32_byte_value_holding_the256_bit_hash_digest.py @@ -0,0 +1,4 @@ +# AUTO-GENERATED: oas_generator + + +DigestRepresentsA32ByteValueHoldingThe256BitHashDigest = bytes diff --git a/src/algokit_kmd_client/models/_ed25519_public_key.py b/src/algokit_kmd_client/models/_ed25519_public_key.py new file mode 100644 index 00000000..d34f05f9 --- /dev/null +++ b/src/algokit_kmd_client/models/_ed25519_public_key.py @@ -0,0 +1,4 @@ +# AUTO-GENERATED: oas_generator + + +Ed25519PublicKey = bytes diff --git a/src/algokit_kmd_client/models/_export_key_request.py b/src/algokit_kmd_client/models/_export_key_request.py new file mode 100644 index 00000000..d70065a8 --- /dev/null +++ b/src/algokit_kmd_client/models/_export_key_request.py @@ -0,0 +1,27 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.constants import ZERO_ADDRESS +from algokit_common.serde import wire + + +@dataclass(slots=True) +class ExportKeyRequest: + """ + The request for `POST /v1/key/export` + """ + + address: str = field( + default=ZERO_ADDRESS, + metadata=wire("address"), + ) + wallet_handle_token: str = field( + default="", + metadata=wire("wallet_handle_token"), + ) + wallet_password: str | None = field( + default=None, + metadata=wire("wallet_password"), + ) diff --git a/src/algokit_kmd_client/models/_export_key_response.py b/src/algokit_kmd_client/models/_export_key_response.py new file mode 100644 index 00000000..6c6544eb --- /dev/null +++ b/src/algokit_kmd_client/models/_export_key_response.py @@ -0,0 +1,24 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class ExportKeyResponse: + """ + ExportKeyResponse is the response to `POST /v1/key/export` + """ + + private_key: bytes = field( + default=b"", + metadata=wire( + "private_key", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_kmd_client/models/_export_master_key_request.py b/src/algokit_kmd_client/models/_export_master_key_request.py new file mode 100644 index 00000000..9abfa528 --- /dev/null +++ b/src/algokit_kmd_client/models/_export_master_key_request.py @@ -0,0 +1,22 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class ExportMasterKeyRequest: + """ + The request for `POST /v1/master-key/export` + """ + + wallet_handle_token: str = field( + default="", + metadata=wire("wallet_handle_token"), + ) + wallet_password: str | None = field( + default=None, + metadata=wire("wallet_password"), + ) diff --git a/src/algokit_kmd_client/models/_export_master_key_response.py b/src/algokit_kmd_client/models/_export_master_key_response.py new file mode 100644 index 00000000..a74f3e81 --- /dev/null +++ b/src/algokit_kmd_client/models/_export_master_key_response.py @@ -0,0 +1,24 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class ExportMasterKeyResponse: + """ + ExportMasterKeyResponse is the response to `POST /v1/master-key/export` + """ + + master_derivation_key: bytes = field( + default=b"", + metadata=wire( + "master_derivation_key", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_kmd_client/models/_export_multisig_request.py b/src/algokit_kmd_client/models/_export_multisig_request.py new file mode 100644 index 00000000..f57e70e7 --- /dev/null +++ b/src/algokit_kmd_client/models/_export_multisig_request.py @@ -0,0 +1,23 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.constants import ZERO_ADDRESS +from algokit_common.serde import wire + + +@dataclass(slots=True) +class ExportMultisigRequest: + """ + The request for `POST /v1/multisig/export` + """ + + address: str = field( + default=ZERO_ADDRESS, + metadata=wire("address"), + ) + wallet_handle_token: str = field( + default="", + metadata=wire("wallet_handle_token"), + ) diff --git a/src/algokit_kmd_client/models/_export_multisig_response.py b/src/algokit_kmd_client/models/_export_multisig_response.py new file mode 100644 index 00000000..561b91d0 --- /dev/null +++ b/src/algokit_kmd_client/models/_export_multisig_response.py @@ -0,0 +1,32 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes_sequence, encode_bytes_sequence + + +@dataclass(slots=True) +class ExportMultisigResponse: + """ + ExportMultisigResponse is the response to `POST /v1/multisig/export` + """ + + multisig_version: int = field( + default=0, + metadata=wire("multisig_version"), + ) + public_keys: list[bytes] = field( + default_factory=list, + metadata=wire( + "pks", + encode=encode_bytes_sequence, + decode=decode_bytes_sequence, + ), + ) + threshold: int = field( + default=0, + metadata=wire("threshold"), + ) diff --git a/src/algokit_kmd_client/models/_generate_key_request.py b/src/algokit_kmd_client/models/_generate_key_request.py new file mode 100644 index 00000000..d62a36f0 --- /dev/null +++ b/src/algokit_kmd_client/models/_generate_key_request.py @@ -0,0 +1,18 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class GenerateKeyRequest: + """ + The request for `POST /v1/key` + """ + + wallet_handle_token: str = field( + default="", + metadata=wire("wallet_handle_token"), + ) diff --git a/src/algokit_kmd_client/models/_generate_key_response.py b/src/algokit_kmd_client/models/_generate_key_response.py new file mode 100644 index 00000000..033f1526 --- /dev/null +++ b/src/algokit_kmd_client/models/_generate_key_response.py @@ -0,0 +1,19 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.constants import ZERO_ADDRESS +from algokit_common.serde import wire + + +@dataclass(slots=True) +class GenerateKeyResponse: + """ + GenerateKeyResponse is the response to `POST /v1/key` + """ + + address: str = field( + default=ZERO_ADDRESS, + metadata=wire("address"), + ) diff --git a/src/algokit_kmd_client/models/_import_key_request.py b/src/algokit_kmd_client/models/_import_key_request.py new file mode 100644 index 00000000..0179b14a --- /dev/null +++ b/src/algokit_kmd_client/models/_import_key_request.py @@ -0,0 +1,28 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class ImportKeyRequest: + """ + The request for `POST /v1/key/import` + """ + + private_key: bytes = field( + default=b"", + metadata=wire( + "private_key", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + wallet_handle_token: str = field( + default="", + metadata=wire("wallet_handle_token"), + ) diff --git a/src/algokit_kmd_client/models/_import_key_response.py b/src/algokit_kmd_client/models/_import_key_response.py new file mode 100644 index 00000000..2b1a47a1 --- /dev/null +++ b/src/algokit_kmd_client/models/_import_key_response.py @@ -0,0 +1,19 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.constants import ZERO_ADDRESS +from algokit_common.serde import wire + + +@dataclass(slots=True) +class ImportKeyResponse: + """ + ImportKeyResponse is the response to `POST /v1/key/import` + """ + + address: str = field( + default=ZERO_ADDRESS, + metadata=wire("address"), + ) diff --git a/src/algokit_kmd_client/models/_import_multisig_request.py b/src/algokit_kmd_client/models/_import_multisig_request.py new file mode 100644 index 00000000..8775146b --- /dev/null +++ b/src/algokit_kmd_client/models/_import_multisig_request.py @@ -0,0 +1,36 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes_sequence, encode_bytes_sequence + + +@dataclass(slots=True) +class ImportMultisigRequest: + """ + The request for `POST /v1/multisig/import` + """ + + multisig_version: int = field( + default=0, + metadata=wire("multisig_version"), + ) + public_keys: list[bytes] = field( + default_factory=list, + metadata=wire( + "pks", + encode=encode_bytes_sequence, + decode=decode_bytes_sequence, + ), + ) + threshold: int = field( + default=0, + metadata=wire("threshold"), + ) + wallet_handle_token: str = field( + default="", + metadata=wire("wallet_handle_token"), + ) diff --git a/src/algokit_kmd_client/models/_import_multisig_response.py b/src/algokit_kmd_client/models/_import_multisig_response.py new file mode 100644 index 00000000..48551736 --- /dev/null +++ b/src/algokit_kmd_client/models/_import_multisig_response.py @@ -0,0 +1,19 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.constants import ZERO_ADDRESS +from algokit_common.serde import wire + + +@dataclass(slots=True) +class ImportMultisigResponse: + """ + ImportMultisigResponse is the response to `POST /v1/multisig/import` + """ + + address: str = field( + default=ZERO_ADDRESS, + metadata=wire("address"), + ) diff --git a/src/algokit_kmd_client/models/_init_wallet_handle_token_request.py b/src/algokit_kmd_client/models/_init_wallet_handle_token_request.py new file mode 100644 index 00000000..046854ea --- /dev/null +++ b/src/algokit_kmd_client/models/_init_wallet_handle_token_request.py @@ -0,0 +1,22 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class InitWalletHandleTokenRequest: + """ + The request for `POST /v1/wallet/init` + """ + + wallet_id: str = field( + default="", + metadata=wire("wallet_id"), + ) + wallet_password: str = field( + default="", + metadata=wire("wallet_password"), + ) diff --git a/src/algokit_kmd_client/models/_init_wallet_handle_token_response.py b/src/algokit_kmd_client/models/_init_wallet_handle_token_response.py new file mode 100644 index 00000000..ea63b874 --- /dev/null +++ b/src/algokit_kmd_client/models/_init_wallet_handle_token_response.py @@ -0,0 +1,18 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class InitWalletHandleTokenResponse: + """ + InitWalletHandleTokenResponse is the response to `POST /v1/wallet/init` + """ + + wallet_handle_token: str = field( + default="", + metadata=wire("wallet_handle_token"), + ) diff --git a/src/algokit_kmd_client/models/_list_keys_request.py b/src/algokit_kmd_client/models/_list_keys_request.py new file mode 100644 index 00000000..17415e62 --- /dev/null +++ b/src/algokit_kmd_client/models/_list_keys_request.py @@ -0,0 +1,18 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class ListKeysRequest: + """ + The request for `POST /v1/key/list` + """ + + wallet_handle_token: str = field( + default="", + metadata=wire("wallet_handle_token"), + ) diff --git a/src/algokit_kmd_client/models/_list_keys_response.py b/src/algokit_kmd_client/models/_list_keys_response.py new file mode 100644 index 00000000..a3d5d989 --- /dev/null +++ b/src/algokit_kmd_client/models/_list_keys_response.py @@ -0,0 +1,18 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class ListKeysResponse: + """ + ListKeysResponse is the response to `POST /v1/key/list` + """ + + addresses: list[str] = field( + default_factory=list, + metadata=wire("addresses"), + ) diff --git a/src/algokit_kmd_client/models/_list_multisig_request.py b/src/algokit_kmd_client/models/_list_multisig_request.py new file mode 100644 index 00000000..e32b7cf6 --- /dev/null +++ b/src/algokit_kmd_client/models/_list_multisig_request.py @@ -0,0 +1,18 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class ListMultisigRequest: + """ + The request for `POST /v1/multisig/list` + """ + + wallet_handle_token: str = field( + default="", + metadata=wire("wallet_handle_token"), + ) diff --git a/src/algokit_kmd_client/models/_list_multisig_response.py b/src/algokit_kmd_client/models/_list_multisig_response.py new file mode 100644 index 00000000..9676327c --- /dev/null +++ b/src/algokit_kmd_client/models/_list_multisig_response.py @@ -0,0 +1,18 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class ListMultisigResponse: + """ + ListMultisigResponse is the response to `POST /v1/multisig/list` + """ + + addresses: list[str] = field( + default_factory=list, + metadata=wire("addresses"), + ) diff --git a/src/algokit_kmd_client/models/_list_wallets_request.py b/src/algokit_kmd_client/models/_list_wallets_request.py new file mode 100644 index 00000000..0a837954 --- /dev/null +++ b/src/algokit_kmd_client/models/_list_wallets_request.py @@ -0,0 +1,11 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass + + +@dataclass(slots=True) +class ListWalletsRequest: + """ + APIV1GETWalletsRequest is the request for `GET /v1/wallets` + """ diff --git a/src/algokit_kmd_client/models/_list_wallets_response.py b/src/algokit_kmd_client/models/_list_wallets_response.py new file mode 100644 index 00000000..d3c4e923 --- /dev/null +++ b/src/algokit_kmd_client/models/_list_wallets_response.py @@ -0,0 +1,25 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_model_sequence, encode_model_sequence +from ._wallet import Wallet + + +@dataclass(slots=True) +class ListWalletsResponse: + """ + ListWalletsResponse is the response to `GET /v1/wallets` + """ + + wallets: list[Wallet] = field( + default_factory=list, + metadata=wire( + "wallets", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: Wallet, raw), + ), + ) diff --git a/src/algokit_kmd_client/models/_master_derivation_key.py b/src/algokit_kmd_client/models/_master_derivation_key.py new file mode 100644 index 00000000..15e741aa --- /dev/null +++ b/src/algokit_kmd_client/models/_master_derivation_key.py @@ -0,0 +1,4 @@ +# AUTO-GENERATED: oas_generator + + +MasterDerivationKey = bytes diff --git a/src/algokit_kmd_client/models/_multisig_sig.py b/src/algokit_kmd_client/models/_multisig_sig.py new file mode 100644 index 00000000..7ecc9c06 --- /dev/null +++ b/src/algokit_kmd_client/models/_multisig_sig.py @@ -0,0 +1,33 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._multisig_subsig import MultisigSubsig +from ._serde_helpers import decode_model_sequence, encode_model_sequence + + +@dataclass(slots=True) +class MultisigSig: + """ + MultisigSig is the structure that holds multiple Subsigs + """ + + subsignatures: list[MultisigSubsig] = field( + default_factory=list, + metadata=wire( + "subsig", + encode=encode_model_sequence, + decode=lambda raw: decode_model_sequence(lambda: MultisigSubsig, raw), + ), + ) + threshold: int = field( + default=0, + metadata=wire("thr"), + ) + version: int = field( + default=0, + metadata=wire("v"), + ) diff --git a/src/algokit_kmd_client/models/_multisig_subsig.py b/src/algokit_kmd_client/models/_multisig_subsig.py new file mode 100644 index 00000000..af2ef774 --- /dev/null +++ b/src/algokit_kmd_client/models/_multisig_subsig.py @@ -0,0 +1,33 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class MultisigSubsig: + """ + MultisigSubsig is a struct that holds a pair of public key and signatures + signatures may be empty + """ + + public_key: bytes = field( + default=b"", + metadata=wire( + "pk", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + signature: bytes | None = field( + default=None, + metadata=wire( + "s", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_kmd_client/models/_public_key.py b/src/algokit_kmd_client/models/_public_key.py new file mode 100644 index 00000000..ba050da8 --- /dev/null +++ b/src/algokit_kmd_client/models/_public_key.py @@ -0,0 +1,4 @@ +# AUTO-GENERATED: oas_generator + + +PublicKey = bytes diff --git a/src/algokit_kmd_client/models/_release_wallet_handle_token_request.py b/src/algokit_kmd_client/models/_release_wallet_handle_token_request.py new file mode 100644 index 00000000..c2810dd4 --- /dev/null +++ b/src/algokit_kmd_client/models/_release_wallet_handle_token_request.py @@ -0,0 +1,18 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class ReleaseWalletHandleTokenRequest: + """ + The request for `POST /v1/wallet/release` + """ + + wallet_handle_token: str = field( + default="", + metadata=wire("wallet_handle_token"), + ) diff --git a/src/algokit_kmd_client/models/_rename_wallet_request.py b/src/algokit_kmd_client/models/_rename_wallet_request.py new file mode 100644 index 00000000..cc1a52dc --- /dev/null +++ b/src/algokit_kmd_client/models/_rename_wallet_request.py @@ -0,0 +1,26 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class RenameWalletRequest: + """ + The request for `POST /v1/wallet/rename` + """ + + wallet_id: str = field( + default="", + metadata=wire("wallet_id"), + ) + wallet_name: str = field( + default="", + metadata=wire("wallet_name"), + ) + wallet_password: str = field( + default="", + metadata=wire("wallet_password"), + ) diff --git a/src/algokit_kmd_client/models/_rename_wallet_response.py b/src/algokit_kmd_client/models/_rename_wallet_response.py new file mode 100644 index 00000000..9c2f2ec9 --- /dev/null +++ b/src/algokit_kmd_client/models/_rename_wallet_response.py @@ -0,0 +1,19 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested + +from ._wallet import Wallet + + +@dataclass(slots=True) +class RenameWalletResponse: + """ + RenameWalletResponse is the response to `POST /v1/wallet/rename` + """ + + wallet: Wallet = field( + metadata=nested("wallet", lambda: Wallet, required=True), + ) diff --git a/src/algokit_kmd_client/models/_renew_wallet_handle_token_request.py b/src/algokit_kmd_client/models/_renew_wallet_handle_token_request.py new file mode 100644 index 00000000..16e2048a --- /dev/null +++ b/src/algokit_kmd_client/models/_renew_wallet_handle_token_request.py @@ -0,0 +1,18 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class RenewWalletHandleTokenRequest: + """ + The request for `POST /v1/wallet/renew` + """ + + wallet_handle_token: str = field( + default="", + metadata=wire("wallet_handle_token"), + ) diff --git a/src/algokit_kmd_client/models/_renew_wallet_handle_token_response.py b/src/algokit_kmd_client/models/_renew_wallet_handle_token_response.py new file mode 100644 index 00000000..0d16c584 --- /dev/null +++ b/src/algokit_kmd_client/models/_renew_wallet_handle_token_response.py @@ -0,0 +1,19 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested + +from ._wallet_handle import WalletHandle + + +@dataclass(slots=True) +class RenewWalletHandleTokenResponse: + """ + RenewWalletHandleTokenResponse is the response to `POST /v1/wallet/renew` + """ + + wallet_handle: WalletHandle = field( + metadata=nested("wallet_handle", lambda: WalletHandle, required=True), + ) diff --git a/src/algokit_kmd_client/models/_serde_helpers.py b/src/algokit_kmd_client/models/_serde_helpers.py new file mode 100644 index 00000000..8d99c04f --- /dev/null +++ b/src/algokit_kmd_client/models/_serde_helpers.py @@ -0,0 +1,254 @@ +# AUTO-GENERATED: oas_generator +import base64 +from binascii import Error as BinasciiError +from collections.abc import Callable, Iterable, Mapping +from dataclasses import is_dataclass +from enum import Enum +from typing import TypeAlias, TypeVar + +from algokit_common.serde import from_wire, to_wire + +DecodedT = TypeVar("DecodedT") +EnumValueT = TypeVar("EnumValueT", bound=Enum) +MapKeyT = TypeVar("MapKeyT") +BytesLike: TypeAlias = bytes | bytearray | memoryview + + +def _coerce_bytes(value: bytes | bytearray | memoryview) -> bytes: + if isinstance(value, memoryview | bytearray): + return bytes(value) + return value + + +def encode_bytes(value: BytesLike) -> str: + return base64.b64encode(_coerce_bytes(value)).decode("ascii") + + +def decode_bytes(raw: object) -> bytes: + """Decode bytes that may be raw (msgpack) or base64-encoded (JSON).""" + if isinstance(raw, bytes | bytearray | memoryview): + return bytes(raw) + if isinstance(raw, str): + try: + return base64.b64decode(raw.encode("ascii"), validate=True) + except (BinasciiError, UnicodeEncodeError) as exc: + raise ValueError("Invalid base64 payload") from exc + raise TypeError(f"Unsupported value for bytes field: {type(raw)!r}") + + +def decode_bytes_base64(raw: object) -> bytes: + """Decode bytes that are always base64-encoded strings (even in msgpack). + + Used for fields marked with x-algokit-bytes-base64 in the OpenAPI spec. + These fields contain base64-encoded strings in both JSON and msgpack responses. + """ + if isinstance(raw, bytes | bytearray | memoryview | str): + try: + return base64.b64decode(raw, validate=True) + except (BinasciiError, ValueError, UnicodeEncodeError) as exc: + raise ValueError("Invalid base64 payload") from exc + raise TypeError(f"Unsupported value for bytes field: {type(raw)!r}") + + +def encode_fixed_bytes(value: BytesLike, expected_length: int) -> str: + """Encode fixed-length bytes to base64, validating the length.""" + coerced = _coerce_bytes(value) + if len(coerced) != expected_length: + raise ValueError(f"Expected {expected_length} bytes, got {len(coerced)}") + return base64.b64encode(coerced).decode("ascii") + + +def decode_fixed_bytes(raw: object, expected_length: int) -> bytes: + """Decode base64 to fixed-length bytes, validating the length.""" + decoded = decode_bytes(raw) + if len(decoded) != expected_length: + raise ValueError(f"Expected {expected_length} bytes, got {len(decoded)}") + return decoded + + +def decode_bytes_map_key(raw: object) -> bytes: + if isinstance(raw, bytes | bytearray | memoryview): + return bytes(raw) + if isinstance(raw, str): + # note: this is undoing the implicit bytes -> str conversion that + # _coerce_msgpack_key does in client.py + # as long as "strict" was used to encode the str then this should be safe + try: + return raw.encode("utf-8", errors="strict") + except UnicodeEncodeError as fallback_exc: + raise ValueError("Invalid bytes map key") from fallback_exc + raise TypeError(f"Unsupported map key for bytes field: {type(raw)!r}") + + +def encode_bytes_sequence(values: Iterable[BytesLike | None] | None) -> list[str | None] | None: + if values is None: + return None + encoded: list[str | None] = [] + for value in values: + if value is None: + encoded.append(None) + continue + if not isinstance(value, bytes | bytearray | memoryview): + raise TypeError(f"Unsupported value for bytes field sequence: {type(value)!r}") + encoded.append(encode_bytes(value)) + return encoded or None + + +def decode_bytes_sequence(raw: object) -> list[bytes | None] | None: + if not isinstance(raw, list): + return None + decoded: list[bytes | None] = [] + for item in raw: + if item is None: + decoded.append(None) + continue + decoded.append(decode_bytes(item)) + return decoded or None + + +def encode_fixed_bytes_sequence( + values: Iterable[BytesLike | None] | None, expected_length: int +) -> list[str | None] | None: + """Encode a sequence of fixed-length bytes to base64, validating each element's length.""" + if values is None: + return None + encoded: list[str | None] = [] + for value in values: + if value is None: + encoded.append(None) + continue + if not isinstance(value, bytes | bytearray | memoryview): + raise TypeError(f"Unsupported value for bytes field sequence: {type(value)!r}") + encoded.append(encode_fixed_bytes(value, expected_length)) + return encoded or None + + +def decode_fixed_bytes_sequence(raw: object, expected_length: int) -> list[bytes | None] | None: + """Decode a sequence of base64 strings to fixed-length bytes, validating each element's length.""" + if not isinstance(raw, list): + return None + decoded: list[bytes | None] = [] + for item in raw: + if item is None: + decoded.append(None) + continue + decoded.append(decode_fixed_bytes(item, expected_length)) + return decoded or None + + +def encode_model_sequence(values: Iterable[object] | None) -> list[dict[str, object]] | None: + if values is None: + return None + encoded: list[dict[str, object]] = [] + for value in values: + if value is None: + continue + encoded.append(to_wire(value)) + return encoded or None + + +def decode_model_sequence(cls_factory: Callable[[], type[DecodedT]], raw: object) -> list[DecodedT] | None: + if not isinstance(raw, list): + return None + cls = cls_factory() + decoded: list[DecodedT] = [] + for item in raw: + if isinstance(item, Mapping): + decoded.append(from_wire(cls, item)) + return decoded or None + + +def encode_enum_sequence(values: Iterable[object] | None) -> list[object] | None: + if values is None: + return None + encoded: list[object] = [] + for value in values: + if value is None: + continue + encoded.append(value.value if hasattr(value, "value") else value) + return encoded or None + + +def decode_enum_sequence(enum_factory: Callable[[], type[EnumValueT]], raw: object) -> list[EnumValueT] | None: + if not isinstance(raw, list): + return None + enum_cls = enum_factory() + decoded: list[EnumValueT] = [] + for item in raw: + try: + decoded.append(enum_cls(item)) + except Exception: + continue + return decoded or None + + +def encode_model_mapping( + factory: Callable[[], type[DecodedT]], + mapping: Mapping[object, object] | None, + *, + key_encoder: Callable[[object], str] | None = None, +) -> dict[str, object] | None: + if mapping is None: + return None + cls = factory() + encoded: dict[str, object] = {} + for key, value in mapping.items(): + if value is None: + continue + encoded_key: str + if key_encoder is not None: + encoded_key = key_encoder(key) + elif isinstance(key, str): + encoded_key = key + else: + encoded_key = str(key) + if isinstance(value, cls) or is_dataclass(value): + encoded[encoded_key] = to_wire(value) + else: + encoded[encoded_key] = value + return encoded or None + + +def decode_model_mapping( + factory: Callable[[], type[DecodedT]], + raw: object, + *, + key_decoder: Callable[[object], MapKeyT] | None = None, +) -> dict[MapKeyT, DecodedT] | None: + if not isinstance(raw, Mapping): + return None + cls = factory() + decoded: dict[MapKeyT, DecodedT] = {} + for key, value in raw.items(): + if isinstance(value, Mapping): + decoded_key = key_decoder(key) if key_decoder is not None else key + decoded[decoded_key] = from_wire(cls, value) + return decoded or None + + +def decode_optional_bool(raw: object) -> bool | None: + if raw is None: + return None + return bool(raw) + + +def mapping_encoder( + factory: Callable[[], type[DecodedT]], + *, + key_encoder: Callable[[object], str] | None = None, +) -> Callable[[Mapping[object, object] | None], dict[str, object] | None]: + def _encode(mapping: Mapping[object, object] | None) -> dict[str, object] | None: + return encode_model_mapping(factory, mapping, key_encoder=key_encoder) + + return _encode + + +def mapping_decoder( + factory: Callable[[], type[DecodedT]], + *, + key_decoder: Callable[[object], MapKeyT] | None = None, +) -> Callable[[object], dict[MapKeyT, DecodedT] | None]: + def _decode(raw: object) -> dict[MapKeyT, DecodedT] | None: + return decode_model_mapping(factory, raw, key_decoder=key_decoder) + + return _decode diff --git a/src/algokit_kmd_client/models/_sign_multisig_response.py b/src/algokit_kmd_client/models/_sign_multisig_response.py new file mode 100644 index 00000000..7374d6b9 --- /dev/null +++ b/src/algokit_kmd_client/models/_sign_multisig_response.py @@ -0,0 +1,24 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class SignMultisigResponse: + """ + SignMultisigResponse is the response to `POST /v1/multisig/sign` + """ + + multisig: bytes = field( + default=b"", + metadata=wire( + "multisig", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_kmd_client/models/_sign_multisig_txn_request.py b/src/algokit_kmd_client/models/_sign_multisig_txn_request.py new file mode 100644 index 00000000..76569ed4 --- /dev/null +++ b/src/algokit_kmd_client/models/_sign_multisig_txn_request.py @@ -0,0 +1,53 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._multisig_sig import MultisigSig +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class SignMultisigTxnRequest: + """ + The request for `POST /v1/multisig/sign` + """ + + public_key: bytes = field( + default=b"", + metadata=wire( + "public_key", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + transaction: bytes = field( + default=b"", + metadata=wire( + "transaction", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + wallet_handle_token: str = field( + default="", + metadata=wire("wallet_handle_token"), + ) + partial_multisig: MultisigSig | None = field( + default=None, + metadata=nested("partial_multisig", lambda: MultisigSig), + ) + signer: bytes | None = field( + default=None, + metadata=wire( + "signer", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + wallet_password: str | None = field( + default=None, + metadata=wire("wallet_password"), + ) diff --git a/src/algokit_kmd_client/models/_sign_program_multisig_request.py b/src/algokit_kmd_client/models/_sign_program_multisig_request.py new file mode 100644 index 00000000..c86a6125 --- /dev/null +++ b/src/algokit_kmd_client/models/_sign_program_multisig_request.py @@ -0,0 +1,54 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.constants import ZERO_ADDRESS +from algokit_common.serde import nested, wire + +from ._multisig_sig import MultisigSig +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class SignProgramMultisigRequest: + """ + The request for `POST /v1/multisig/signprogram` + """ + + address: str = field( + default=ZERO_ADDRESS, + metadata=wire("address"), + ) + program: bytes = field( + default=b"", + metadata=wire( + "data", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + public_key: bytes = field( + default=b"", + metadata=wire( + "public_key", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + wallet_handle_token: str = field( + default="", + metadata=wire("wallet_handle_token"), + ) + partial_multisig: MultisigSig | None = field( + default=None, + metadata=nested("partial_multisig", lambda: MultisigSig), + ) + use_legacy_msig: bool | None = field( + default=None, + metadata=wire("use_legacy_msig"), + ) + wallet_password: str | None = field( + default=None, + metadata=wire("wallet_password"), + ) diff --git a/src/algokit_kmd_client/models/_sign_program_multisig_response.py b/src/algokit_kmd_client/models/_sign_program_multisig_response.py new file mode 100644 index 00000000..8669a629 --- /dev/null +++ b/src/algokit_kmd_client/models/_sign_program_multisig_response.py @@ -0,0 +1,24 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class SignProgramMultisigResponse: + """ + SignProgramMultisigResponse is the response to `POST /v1/multisig/signdata` + """ + + multisig: bytes = field( + default=b"", + metadata=wire( + "multisig", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_kmd_client/models/_sign_program_request.py b/src/algokit_kmd_client/models/_sign_program_request.py new file mode 100644 index 00000000..6f03d77c --- /dev/null +++ b/src/algokit_kmd_client/models/_sign_program_request.py @@ -0,0 +1,37 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.constants import ZERO_ADDRESS +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class SignProgramRequest: + """ + The request for `POST /v1/program/sign` + """ + + address: str = field( + default=ZERO_ADDRESS, + metadata=wire("address"), + ) + program: bytes = field( + default=b"", + metadata=wire( + "data", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + wallet_handle_token: str = field( + default="", + metadata=wire("wallet_handle_token"), + ) + wallet_password: str | None = field( + default=None, + metadata=wire("wallet_password"), + ) diff --git a/src/algokit_kmd_client/models/_sign_program_response.py b/src/algokit_kmd_client/models/_sign_program_response.py new file mode 100644 index 00000000..0577c6b0 --- /dev/null +++ b/src/algokit_kmd_client/models/_sign_program_response.py @@ -0,0 +1,24 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class SignProgramResponse: + """ + SignProgramResponse is the response to `POST /v1/data/sign` + """ + + sig: bytes = field( + default=b"", + metadata=wire( + "sig", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_kmd_client/models/_sign_transaction_response.py b/src/algokit_kmd_client/models/_sign_transaction_response.py new file mode 100644 index 00000000..c5b495fc --- /dev/null +++ b/src/algokit_kmd_client/models/_sign_transaction_response.py @@ -0,0 +1,24 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class SignTransactionResponse: + """ + SignTransactionResponse is the response to `POST /v1/transaction/sign` + """ + + signed_transaction: bytes = field( + default=b"", + metadata=wire( + "signed_transaction", + encode=encode_bytes, + decode=decode_bytes, + ), + ) diff --git a/src/algokit_kmd_client/models/_sign_txn_request.py b/src/algokit_kmd_client/models/_sign_txn_request.py new file mode 100644 index 00000000..3292ea4c --- /dev/null +++ b/src/algokit_kmd_client/models/_sign_txn_request.py @@ -0,0 +1,40 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + +from ._serde_helpers import decode_bytes, encode_bytes + + +@dataclass(slots=True) +class SignTxnRequest: + """ + The request for `POST /v1/transaction/sign` + """ + + transaction: bytes = field( + default=b"", + metadata=wire( + "transaction", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + wallet_handle_token: str = field( + default="", + metadata=wire("wallet_handle_token"), + ) + public_key: bytes | None = field( + default=None, + metadata=wire( + "public_key", + encode=encode_bytes, + decode=decode_bytes, + ), + ) + wallet_password: str | None = field( + default=None, + metadata=wire("wallet_password"), + ) diff --git a/src/algokit_kmd_client/models/_signature.py b/src/algokit_kmd_client/models/_signature.py new file mode 100644 index 00000000..416d9c16 --- /dev/null +++ b/src/algokit_kmd_client/models/_signature.py @@ -0,0 +1,4 @@ +# AUTO-GENERATED: oas_generator + + +Signature = bytes diff --git a/src/algokit_kmd_client/models/_tx_type.py b/src/algokit_kmd_client/models/_tx_type.py new file mode 100644 index 00000000..d6bdc742 --- /dev/null +++ b/src/algokit_kmd_client/models/_tx_type.py @@ -0,0 +1,4 @@ +# AUTO-GENERATED: oas_generator + + +TxType = str diff --git a/src/algokit_kmd_client/models/_versions_request.py b/src/algokit_kmd_client/models/_versions_request.py new file mode 100644 index 00000000..75320dad --- /dev/null +++ b/src/algokit_kmd_client/models/_versions_request.py @@ -0,0 +1,11 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass + + +@dataclass(slots=True) +class VersionsRequest: + """ + VersionsRequest is the request for `GET /versions` + """ diff --git a/src/algokit_kmd_client/models/_versions_response.py b/src/algokit_kmd_client/models/_versions_response.py new file mode 100644 index 00000000..ea25075b --- /dev/null +++ b/src/algokit_kmd_client/models/_versions_response.py @@ -0,0 +1,19 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class VersionsResponse: + """ + VersionsResponse is the response to `GET /versions` + friendly:VersionsResponse + """ + + versions: list[str] = field( + default_factory=list, + metadata=wire("versions"), + ) diff --git a/src/algokit_kmd_client/models/_wallet.py b/src/algokit_kmd_client/models/_wallet.py new file mode 100644 index 00000000..a3947ec1 --- /dev/null +++ b/src/algokit_kmd_client/models/_wallet.py @@ -0,0 +1,38 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class Wallet: + """ + Wallet is the API's representation of a wallet + """ + + driver_name: str = field( + default="", + metadata=wire("driver_name"), + ) + driver_version: int = field( + default=0, + metadata=wire("driver_version"), + ) + id_: str = field( + default="", + metadata=wire("id"), + ) + mnemonic_ux: bool = field( + default=False, + metadata=wire("mnemonic_ux"), + ) + name: str = field( + default="", + metadata=wire("name"), + ) + supported_txs: list[str] = field( + default_factory=list, + metadata=wire("supported_txs"), + ) diff --git a/src/algokit_kmd_client/models/_wallet_handle.py b/src/algokit_kmd_client/models/_wallet_handle.py new file mode 100644 index 00000000..8275c172 --- /dev/null +++ b/src/algokit_kmd_client/models/_wallet_handle.py @@ -0,0 +1,24 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested, wire + +from ._wallet import Wallet + + +@dataclass(slots=True) +class WalletHandle: + """ + WalletHandle includes the wallet the handle corresponds to + and the number of number of seconds to expiration + """ + + wallet: Wallet = field( + metadata=nested("wallet", lambda: Wallet, required=True), + ) + expires_seconds: int = field( + default=0, + metadata=wire("expires_seconds"), + ) diff --git a/src/algokit_kmd_client/models/_wallet_info_request.py b/src/algokit_kmd_client/models/_wallet_info_request.py new file mode 100644 index 00000000..f6d9a694 --- /dev/null +++ b/src/algokit_kmd_client/models/_wallet_info_request.py @@ -0,0 +1,18 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import wire + + +@dataclass(slots=True) +class WalletInfoRequest: + """ + The request for `POST /v1/wallet/info` + """ + + wallet_handle_token: str = field( + default="", + metadata=wire("wallet_handle_token"), + ) diff --git a/src/algokit_kmd_client/models/_wallet_info_response.py b/src/algokit_kmd_client/models/_wallet_info_response.py new file mode 100644 index 00000000..4f5ebf34 --- /dev/null +++ b/src/algokit_kmd_client/models/_wallet_info_response.py @@ -0,0 +1,19 @@ +# AUTO-GENERATED: oas_generator + + +from dataclasses import dataclass, field + +from algokit_common.serde import nested + +from ._wallet_handle import WalletHandle + + +@dataclass(slots=True) +class WalletInfoResponse: + """ + WalletInfoResponse is the response to `POST /v1/wallet/info` + """ + + wallet_handle: WalletHandle = field( + metadata=nested("wallet_handle", lambda: WalletHandle, required=True), + ) diff --git a/src/algokit_kmd_client/py.typed b/src/algokit_kmd_client/py.typed new file mode 100644 index 00000000..abb15e27 --- /dev/null +++ b/src/algokit_kmd_client/py.typed @@ -0,0 +1 @@ +# AUTO-GENERATED: oas_generator diff --git a/src/algokit_kmd_client/types.py b/src/algokit_kmd_client/types.py new file mode 100644 index 00000000..379362d9 --- /dev/null +++ b/src/algokit_kmd_client/types.py @@ -0,0 +1,7 @@ +# AUTO-GENERATED: oas_generator + + +from typing import Any + +JSONMapping = dict[str, Any] +Headers = dict[str, str] diff --git a/src/algokit_transact/__init__.py b/src/algokit_transact/__init__.py new file mode 100644 index 00000000..59e58f75 --- /dev/null +++ b/src/algokit_transact/__init__.py @@ -0,0 +1,190 @@ +from algokit_transact.codec.signed import ( + decode_logic_signature, + decode_signed_transaction, + decode_signed_transactions, + encode_signed_transaction, + encode_signed_transactions, +) +from algokit_transact.codec.transaction import ( + decode_transaction, + decode_transactions, + encode_transaction, + encode_transaction_raw, + encode_transactions, + from_transaction_dto, + get_encoded_transaction_type, + to_transaction_dto, +) +from algokit_transact.exceptions import ( + AlgokitTransactError, + TransactionValidationError, +) +from algokit_transact.logicsig import ( + DelegatedLsigResult, + LogicSigAccount, +) +from algokit_transact.models.app_call import ( + AppCallTransactionFields, + BoxReference, + HoldingReference, + LocalsReference, + ResourceReference, +) +from algokit_transact.models.asset_config import AssetConfigTransactionFields +from algokit_transact.models.asset_freeze import AssetFreezeTransactionFields +from algokit_transact.models.asset_transfer import AssetTransferTransactionFields +from algokit_transact.models.common import OnApplicationComplete, StateSchema +from algokit_transact.models.heartbeat import HeartbeatProof, HeartbeatTransactionFields +from algokit_transact.models.key_registration import KeyRegistrationTransactionFields +from algokit_transact.models.payment import PaymentTransactionFields +from algokit_transact.models.signed_transaction import SignedTransaction +from algokit_transact.models.state_proof import ( + FalconSignatureStruct, + FalconVerifier, + HashFactory, + MerkleArrayProof, + MerkleSignatureVerifier, + Participant, + Reveal, + SigslotCommit, + StateProof, + StateProofMessage, + StateProofTransactionFields, +) +from algokit_transact.models.transaction import Transaction, TransactionType +from algokit_transact.multisig import MultisigAccount, MultisigMetadata +from algokit_transact.ops.fees import ( + assign_fee, + calculate_fee, + estimate_transaction_size, +) +from algokit_transact.ops.group import ( + group_transactions, +) +from algokit_transact.ops.ids import ( + get_transaction_id, + get_transaction_id_raw, +) +from algokit_transact.ops.validate import ( + ValidationIssue, + ValidationIssueCode, + validate_app_call_fields, + validate_asset_config_fields, + validate_asset_freeze_fields, + validate_asset_transfer_fields, + validate_key_registration_fields, + validate_transaction, +) +from algokit_transact.signer import ( + Addressable, + AddressWithDelegatedLsigSigner, + AddressWithMxBytesSigner, + AddressWithProgramDataSigner, + AddressWithSigners, + AddressWithTransactionSigner, + BytesSigner, + DelegatedLsigSigner, + MxBytesSigner, + ProgramDataSigner, + TransactionSigner, + generate_address_with_signers, + make_basic_account_transaction_signer, + make_empty_transaction_signer, +) +from algokit_transact.signing.logic_signature import LogicSigSignature +from algokit_transact.signing.multisig import ( + address_from_multisig_signature, + apply_multisig_subsignature, + merge_multisignatures, + new_multisig_signature, + participants_from_multisig_signature, +) +from algokit_transact.signing.types import MultisigSignature, MultisigSubsignature +from algokit_transact.signing.validation import sanity_check_program + +__all__ = [ + "AddressWithDelegatedLsigSigner", + "AddressWithMxBytesSigner", + "AddressWithProgramDataSigner", + "AddressWithSigners", + "AddressWithTransactionSigner", + "Addressable", + "AlgokitTransactError", + "AppCallTransactionFields", + "AssetConfigTransactionFields", + "AssetFreezeTransactionFields", + "AssetTransferTransactionFields", + "BoxReference", + "BytesSigner", + "DelegatedLsigResult", + "DelegatedLsigSigner", + "FalconSignatureStruct", + "FalconVerifier", + "HashFactory", + "HeartbeatProof", + "HeartbeatTransactionFields", + "HoldingReference", + "KeyRegistrationTransactionFields", + "LocalsReference", + "LogicSigAccount", + "LogicSigSignature", + "MerkleArrayProof", + "MerkleSignatureVerifier", + "MultisigAccount", + "MultisigMetadata", + "MultisigSignature", + "MultisigSubsignature", + "MxBytesSigner", + "OnApplicationComplete", + "Participant", + "PaymentTransactionFields", + "ProgramDataSigner", + "ResourceReference", + "Reveal", + "SignedTransaction", + "SigslotCommit", + "StateProof", + "StateProofMessage", + "StateProofTransactionFields", + "StateSchema", + "Transaction", + "TransactionSigner", + "TransactionType", + "TransactionValidationError", + "ValidationIssue", + "ValidationIssueCode", + "address_from_multisig_signature", + "apply_multisig_subsignature", + "assign_fee", + "calculate_fee", + "decode_logic_signature", + "decode_signed_transaction", + "decode_signed_transactions", + "decode_transaction", + "decode_transactions", + "encode_signed_transaction", + "encode_signed_transactions", + "encode_transaction", + "encode_transaction_raw", + "encode_transactions", + "estimate_transaction_size", + "from_transaction_dto", + "generate_address_with_signers", + "get_encoded_transaction_type", + "get_transaction_id", + "get_transaction_id_raw", + "group_transactions", + "make_basic_account_transaction_signer", + "make_empty_transaction_signer", + "merge_multisignatures", + "new_multisig_signature", + "participants_from_multisig_signature", + "sanity_check_program", + "to_transaction_dto", + "validate_app_call_fields", + "validate_asset_config_fields", + "validate_asset_freeze_fields", + "validate_asset_transfer_fields", + "validate_key_registration_fields", + "validate_transaction", +] diff --git a/src/algokit_transact/codec/__init__.py b/src/algokit_transact/codec/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/algokit_transact/codec/msgpack.py b/src/algokit_transact/codec/msgpack.py new file mode 100644 index 00000000..899aa053 --- /dev/null +++ b/src/algokit_transact/codec/msgpack.py @@ -0,0 +1,11 @@ +from msgpack import packb, unpackb + + +def encode_msgpack(value: object) -> bytes: + """Encode a Python value into canonical msgpack bytes.""" + return packb(value, use_bin_type=True, strict_types=True) + + +def decode_msgpack(data: bytes) -> object: + """Decode msgpack bytes into a Python structure.""" + return unpackb(data, raw=False, strict_map_key=False) diff --git a/src/algokit_transact/codec/serde.py b/src/algokit_transact/codec/serde.py new file mode 100644 index 00000000..f1493ba4 --- /dev/null +++ b/src/algokit_transact/codec/serde.py @@ -0,0 +1,7 @@ +"""Compatibility shim for serde helpers. + +The implementation now lives in ``algokit_common.serde`` so that external +packages (including generated API clients) can share the same primitives. +""" + +from algokit_common.serde import * # noqa: F403 diff --git a/src/algokit_transact/codec/signed.py b/src/algokit_transact/codec/signed.py new file mode 100644 index 00000000..2628ce0e --- /dev/null +++ b/src/algokit_transact/codec/signed.py @@ -0,0 +1,40 @@ +from collections.abc import Iterable +from typing import cast + +from algokit_transact.codec.msgpack import decode_msgpack, encode_msgpack +from algokit_transact.codec.serde import from_wire, to_wire_canonical +from algokit_transact.models.signed_transaction import SignedTransaction +from algokit_transact.models.transaction import Transaction +from algokit_transact.signing.logic_signature import LogicSigSignature + + +def encode_signed_transaction(stx: SignedTransaction) -> bytes: + payload = to_wire_canonical(stx) + return encode_msgpack(payload) + + +def encode_signed_transactions(signed_transactions: Iterable[SignedTransaction]) -> list[bytes]: + return [encode_signed_transaction(stx) for stx in signed_transactions] + + +def decode_signed_transaction(encoded: bytes) -> SignedTransaction: + raw: object = decode_msgpack(encoded) + if not isinstance(raw, dict): + raise ValueError("decoded signed transaction is not a dict") + dto = cast(dict[str, object], raw) + stx = from_wire(SignedTransaction, dto) + if not isinstance(stx.txn, Transaction): + raise ValueError("signed transaction missing 'txn'") + return stx + + +def decode_signed_transactions(encoded_signed_transactions: Iterable[bytes]) -> list[SignedTransaction]: + return [decode_signed_transaction(item) for item in encoded_signed_transactions] + + +def decode_logic_signature(encoded: bytes) -> LogicSigSignature: + raw: object = decode_msgpack(encoded) + if not isinstance(raw, dict): + raise ValueError("decoded logic signature is not a dict") + dto = raw + return from_wire(LogicSigSignature, dto) diff --git a/src/algokit_transact/codec/transaction.py b/src/algokit_transact/codec/transaction.py new file mode 100644 index 00000000..0d363428 --- /dev/null +++ b/src/algokit_transact/codec/transaction.py @@ -0,0 +1,59 @@ +from collections.abc import Iterable, Mapping + +from algokit_common.constants import TRANSACTION_DOMAIN_SEPARATOR +from algokit_transact.codec.msgpack import decode_msgpack, encode_msgpack +from algokit_transact.codec.serde import from_wire, to_wire, to_wire_canonical +from algokit_transact.models.transaction import Transaction, TransactionType + + +def _from_type_str(s: str) -> TransactionType: + return TransactionType(s) + + +def to_transaction_dto(tx: Transaction) -> dict[str, object]: + return to_wire(tx) + + +def encode_transaction_raw(tx: Transaction) -> bytes: + canonical = to_wire_canonical(tx) + return encode_msgpack(canonical) + + +def encode_transaction(tx: Transaction) -> bytes: + raw = encode_transaction_raw(tx) + return TRANSACTION_DOMAIN_SEPARATOR + raw + + +def encode_transactions(transactions: Iterable[Transaction]) -> list[bytes]: + return [encode_transaction(tx) for tx in transactions] + + +def from_transaction_dto(dto: Mapping[str, object]) -> Transaction: + return from_wire(Transaction, dto) + + +def decode_transaction(encoded: bytes) -> Transaction: + if not encoded: + raise ValueError("attempted to decode 0 bytes") + + payload = encoded.removeprefix(TRANSACTION_DOMAIN_SEPARATOR) + + raw = decode_msgpack(payload) + if not isinstance(raw, dict): + raise ValueError("decoded msgpack is not a dict") + + return from_transaction_dto(raw) + + +def decode_transactions(encoded_transactions: Iterable[bytes]) -> list[Transaction]: + return [decode_transaction(item) for item in encoded_transactions] + + +def get_encoded_transaction_type(encoded_transaction: bytes) -> TransactionType: + payload = encoded_transaction.removeprefix(TRANSACTION_DOMAIN_SEPARATOR) + + raw = decode_msgpack(payload) + if isinstance(raw, dict) and isinstance(tx_type := raw.get("type"), str): + return _from_type_str(tx_type) + + return decode_transaction(encoded_transaction).transaction_type diff --git a/src/algokit_transact/exceptions.py b/src/algokit_transact/exceptions.py new file mode 100644 index 00000000..a9542053 --- /dev/null +++ b/src/algokit_transact/exceptions.py @@ -0,0 +1,17 @@ +from collections.abc import Sequence +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from algokit_transact.ops.validate import ValidationIssue + + +class AlgokitTransactError(Exception): + """Base error for algokit-transact.""" + + +class TransactionValidationError(AlgokitTransactError): + """Raised when a transaction fails validation.""" + + def __init__(self, message: str, *, issues: "Sequence[ValidationIssue] | None" = None) -> None: + super().__init__(message) + self.issues: list[ValidationIssue] = list(issues or []) diff --git a/src/algokit_transact/logicsig.py b/src/algokit_transact/logicsig.py new file mode 100644 index 00000000..3694932d --- /dev/null +++ b/src/algokit_transact/logicsig.py @@ -0,0 +1,179 @@ +import dataclasses +from collections.abc import Sequence +from functools import cached_property +from typing import TYPE_CHECKING + +from algokit_common import address_from_public_key, public_key_from_address, sha512_256 +from algokit_transact import decode_logic_signature +from algokit_transact.codec.signed import encode_signed_transaction +from algokit_transact.models.signed_transaction import SignedTransaction +from algokit_transact.models.transaction import Transaction +from algokit_transact.ops.validate import validate_signed_transaction +from algokit_transact.signing.logic_signature import LogicSigSignature +from algokit_transact.signing.types import MultisigSignature +from algokit_transact.signing.validation import sanity_check_program + +if TYPE_CHECKING: + from algokit_transact.signer import ( + AddressWithDelegatedLsigSigner, + ProgramDataSigner, + TransactionSigner, + ) + +_MULTISIG_DOMAIN_SEPARATOR = b"MultisigAddr" +_PROG_DATA_TAG = b"ProgData" +_PROGRAM_TAG = b"Program" +_MX_TAG = b"MX" +_MSIG_PROGRAM_TAG = b"MsigProgram" + + +@dataclasses.dataclass(frozen=True) +class DelegatedLsigResult: + addr: str + sig: bytes | None = None + lmsig: MultisigSignature | None = None + + def __post_init__(self) -> None: + # invalid to have neither or both defined + if bool(self.sig) == bool(self.lmsig): + raise ValueError("Must provide either a signature or a multi signature") + + +@dataclasses.dataclass(kw_only=True) +class LogicSig: + logic: bytes + """The LogicSig program bytes.""" + args: Sequence[bytes] = dataclasses.field(default=()) + """The arguments to pass to the LogicSig program.""" + _address: str | None = None + + def __post_init__(self) -> None: + sanity_check_program(self.logic) + + @staticmethod + def from_signature(signature: LogicSigSignature) -> "LogicSig": + return LogicSig(logic=signature.logic, args=signature.args or ()) + + @staticmethod + def from_bytes(encoded_lsig: bytes) -> "LogicSig": + signature = decode_logic_signature(encoded_lsig) + return LogicSig.from_signature(signature) + + @cached_property + def address(self) -> str: + """The LogicSig account address (delegated address or escrow address).""" + return self._address or address_from_public_key(sha512_256(_PROGRAM_TAG + self.logic)) + + @property + def addr(self) -> str: + """Alias for address property (matching TypeScript's get addr()).""" + return self.address + + def bytes_to_sign_for_delegation(self, msig_address: str | None = None) -> bytes: + if msig_address: + return _MSIG_PROGRAM_TAG + public_key_from_address(msig_address) + self.logic + else: + return _PROGRAM_TAG + self.logic + + def sign_program_data(self, data: bytes, signer: "ProgramDataSigner") -> bytes: + return signer(self, data) + + def program_data_to_sign(self, data: bytes) -> bytes: + return _PROG_DATA_TAG + public_key_from_address(self.address) + data + + def account(self) -> "LogicSigAccount": + return LogicSigAccount(logic=self.logic, args=self.args) + + def delegated_account(self, delegator: str) -> "LogicSigAccount": + return LogicSigAccount(logic=self.logic, args=self.args, _address=delegator) + + +@dataclasses.dataclass(kw_only=True) +class LogicSigAccount(LogicSig): + """Account wrapper for LogicSig signing. Supports delegation including secretless signing.""" + + sig: bytes | None = None + msig: MultisigSignature | None = None + lmsig: MultisigSignature | None = None + + @staticmethod + def from_signature(signature: LogicSigSignature, delgator: str | None = None) -> "LogicSigAccount": + from algokit_transact.multisig import MultisigAccount + + if msig := (signature.lmsig or signature.msig): + msig_addr = MultisigAccount.from_signature(msig).addr + if delgator and delgator != msig_addr: + raise ValueError("Provided delegator address does not match multisig address") + + return LogicSigAccount( + logic=signature.logic, + args=signature.args or (), + _address=msig_addr, + lmsig=signature.lmsig, + msig=signature.msig, + ) + + if (signature.sig or delgator) is None: + raise ValueError("Delegated address must be provided when logic sig has a signature") + + return LogicSigAccount(logic=signature.logic, args=signature.args or (), _address=delgator, sig=signature.sig) + + @staticmethod + def from_bytes(encoded_lsig: bytes, delegator: str | None = None) -> "LogicSigAccount": + decoded = decode_logic_signature(encoded_lsig) + return LogicSigAccount.from_signature(decoded, delegator) + + @property + def is_delegated(self) -> bool: + """Whether this LogicSig is delegated to an account.""" + return self.sig is not None or self.lmsig is not None + + @property + def signer(self) -> "TransactionSigner": + """Transaction signer callable.""" + program = self.logic + args = list(self.args) or None + signature = self.sig + multisig_sig = self.lmsig + lsig_address = self.address + + def signer(txn_group: Sequence[Transaction], indexes_to_sign: Sequence[int]) -> list[bytes]: + blobs: list[bytes] = [] + for index in indexes_to_sign: + txn = txn_group[index] + logic_sig = LogicSigSignature( + logic=program, + args=args, + sig=signature, + lmsig=multisig_sig, + ) + auth_addr = lsig_address if txn.sender != lsig_address else None + + signed = SignedTransaction( + txn=txn, + sig=None, + msig=None, + lsig=logic_sig, + auth_address=auth_addr, + ) + validate_signed_transaction(signed) + blobs.append(encode_signed_transaction(signed)) + return blobs + + return signer + + def sign_for_delegation(self, signer: "AddressWithDelegatedLsigSigner") -> None: + result = signer.delegated_lsig_signer(self, None) + + if result.addr != self.address: + raise ValueError( + f"Delegator address from signer does not match expected delegator address." + f" Expected: {self.addr}, got: {result.addr}", + ) + + if result.sig: + self.sig = result.sig + elif result.lmsig: + self.lmsig = result.lmsig + else: + raise ValueError("Delegated lsig signer must return either a sig or lmsig") diff --git a/src/algokit_transact/models/__init__.py b/src/algokit_transact/models/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/algokit_transact/models/app_call.py b/src/algokit_transact/models/app_call.py new file mode 100644 index 00000000..12282e39 --- /dev/null +++ b/src/algokit_transact/models/app_call.py @@ -0,0 +1,447 @@ +from collections.abc import Iterable, Mapping, Sequence +from dataclasses import dataclass, field +from typing import Literal, cast + +from algokit_common.address import address_from_public_key +from algokit_common.constants import ZERO_ADDRESS +from algokit_transact.codec.serde import ( + DecodeError, + EncodeError, + addr, + addr_seq, + bytes_seq, + enum_value, + int_seq, + nested, + to_wire, + wire, +) +from algokit_transact.models.common import OnApplicationComplete, StateSchema + + +def _decode_address_field(value: object) -> str: + """Decode address from wire format (can be bytes or string)""" + if isinstance(value, str): + return value + if isinstance(value, bytes): + # The API returns address as UTF-8 encoded string, not public key bytes + return value.decode("utf-8") + raise DecodeError(f"Invalid address format: {type(value)}") + + +@dataclass(slots=True, frozen=True) +class BoxReference: + app_id: int = field(default=0, metadata=wire("app")) + name: bytes = field(default=b"", metadata=wire("name")) + + +@dataclass(slots=True, frozen=True) +class HoldingReference: + asset_id: int = field(metadata=wire("asset")) + address: str = field(metadata=wire("account", decode=_decode_address_field)) + + +@dataclass(slots=True, frozen=True) +class LocalsReference: + app_id: int = field(metadata=wire("app")) + address: str = field(metadata=wire("account", decode=_decode_address_field)) + + +@dataclass(slots=True, frozen=True) +class ResourceReference: + address: str | None = None + app_id: int | None = None + asset_id: int | None = None + holding: HoldingReference | None = None + locals: LocalsReference | None = None + box: BoxReference | None = None + + +@dataclass(slots=True, frozen=True) +class _WireBoxReference: + index: int + name: bytes + + +@dataclass(slots=True, frozen=True) +class _AddressAccessEntry: + address: str = field(metadata=addr("d", omit_if_none=False)) + + +ByteLike = bytes | bytearray | memoryview + + +def _coerce_bytes(payload: object) -> bytes | None: + if isinstance(payload, ByteLike): + return bytes(payload) + if isinstance(payload, Sequence) and not isinstance(payload, str | bytes | bytearray | memoryview): + ints: list[int] = [] + for part in payload: + if isinstance(part, bool): + ints.append(int(part)) + continue + if isinstance(part, int): + ints.append(part) + continue + return None + try: + return bytes(ints) + except ValueError: + return None + return None + + +def _require_bytes(payload: object | None, context: str) -> bytes: + data = _coerce_bytes(payload) if payload is not None else None + if data is None: + raise EncodeError(f"{context} must be bytes-like") + return data + + +def _encode_box_references( + app_call: "AppCallTransactionFields", + value: object, +) -> list[dict[str, object]] | None: + if value is None: + return None + if not isinstance(value, Iterable): + raise EncodeError("Box references must be iterable") + raw_refs = _coerce_box_sequence(cast(Iterable[BoxReference | _WireBoxReference], value)) + if not raw_refs: + return None + + app_refs = app_call.app_references or [] + encoded: list[dict[str, object]] = [] + for raw in raw_refs: + ref = _normalize_box_reference(app_call, raw) + index = _map_box_app_id_to_index(ref.app_id, app_call, app_refs) + encoded.append({"i": index, "n": ref.name}) + return encoded + + +def _decode_box_references(value: object) -> list[_WireBoxReference] | None: + if value is None: + return None + if isinstance(value, list): + entries: list[_WireBoxReference] = [] + for item in value: + if not isinstance(item, Mapping): + continue + index = int(item.get("i", 0)) + name_payload = item.get("n", b"") + name = _coerce_bytes(name_payload) or b"" + entries.append(_WireBoxReference(index=index, name=name)) + return list(entries) if entries else None + return None + + +def _encode_access_references( + app_call: "AppCallTransactionFields", + value: object, +) -> list[dict[str, object]] | None: + if value is None: + return None + if not isinstance(value, Iterable): + raise EncodeError("Access references must be iterable") + raw_refs = _coerce_resource_sequence(cast(Iterable[ResourceReference], value)) + if not raw_refs: + return None + + builder = _AccessListBuilder(app_call) + for ref in (_normalize_resource_reference(item) for item in raw_refs): + builder.add(ref) + + return builder.entries or None + + +def _decode_access_references(value: object) -> list[ResourceReference] | None: # noqa: C901, PLR0912, PLR0915 + if value is None: + return None + if not isinstance(value, list): + return None + + result: list[ResourceReference] = [] + for item in value: + if not isinstance(item, Mapping): + continue + if "d" in item: + address_raw = item.get("d") + address_bytes = _coerce_bytes(address_raw) + if address_bytes is None: + continue + result.append(ResourceReference(address=address_from_public_key(address_bytes))) + continue + if "s" in item: + asset_raw = item.get("s") + if not isinstance(asset_raw, int): + continue + result.append(ResourceReference(asset_id=asset_raw)) + continue + if "p" in item: + app_raw = item.get("p") + if not isinstance(app_raw, int): + continue + result.append(ResourceReference(app_id=app_raw)) + continue + if "h" in item: + holding_payload = item.get("h") + if not isinstance(holding_payload, Mapping): + continue + asset_index_raw = holding_payload.get("s") + if not isinstance(asset_index_raw, int): + raise DecodeError("Holding missing asset index") + asset_index = asset_index_raw + if asset_index <= 0 or asset_index > len(result): + raise DecodeError("Holding asset index out of bounds") + asset_entry = result[asset_index - 1] + if asset_entry.asset_id is None: + raise DecodeError("Holding asset index does not reference an asset") + address_index_raw = holding_payload.get("d") + address_index = int(address_index_raw) if isinstance(address_index_raw, int) else 0 + if address_index == 0: + address = ZERO_ADDRESS + else: + if address_index > len(result): + raise DecodeError("Holding address index out of bounds") + address_entry = result[address_index - 1] + if address_entry.address is None: + raise DecodeError("Holding address index does not reference an address") + address = address_entry.address + result.append(ResourceReference(holding=HoldingReference(asset_id=asset_entry.asset_id, address=address))) + continue + if "l" in item: + locals_payload = item.get("l") + if not isinstance(locals_payload, Mapping): + continue + address_index_raw = locals_payload.get("d") + address_index = int(address_index_raw) if isinstance(address_index_raw, int) else 0 + if address_index == 0: + address = ZERO_ADDRESS + else: + if address_index > len(result): + raise DecodeError("Locals address index out of bounds") + address_entry = result[address_index - 1] + if address_entry.address is None: + raise DecodeError("Locals address index does not reference an address") + address = address_entry.address + app_index_raw = locals_payload.get("p") + app_index = int(app_index_raw) if isinstance(app_index_raw, int) else 0 + if app_index == 0: + app_id = 0 + else: + if app_index > len(result): + raise DecodeError("Locals app index out of bounds") + app_entry = result[app_index - 1] + if app_entry.app_id is None: + raise DecodeError("Locals app index does not reference an app") + app_id = app_entry.app_id + result.append(ResourceReference(locals=LocalsReference(app_id=app_id, address=address))) + continue + if "b" in item: + box_payload = item.get("b") + if not isinstance(box_payload, Mapping): + continue + name_raw = box_payload.get("n") + name = _coerce_bytes(name_raw) + if name is None: + raise DecodeError("Box missing name") + app_index_raw = box_payload.get("i") + app_index = int(app_index_raw) if isinstance(app_index_raw, int) else 0 + if app_index == 0: + app_id = 0 + else: + if app_index > len(result): + raise DecodeError("Box app index out of bounds") + app_entry = result[app_index - 1] + if app_entry.app_id is None: + raise DecodeError("Box app index does not reference an app") + app_id = app_entry.app_id + result.append(ResourceReference(box=BoxReference(app_id=app_id, name=name))) + + return list(result) if result else None + + +@dataclass(slots=True, frozen=True) +class AppCallTransactionFields: + app_id: int = field(default=0, metadata=wire("apid")) + on_complete: OnApplicationComplete = field( + default=OnApplicationComplete.NoOp, metadata=enum_value("apan", OnApplicationComplete) + ) + approval_program: bytes | None = field(default=None, metadata=wire("apap")) + clear_state_program: bytes | None = field(default=None, metadata=wire("apsu")) + global_state_schema: StateSchema | None = field(default=None, metadata=nested("apgs", StateSchema)) + local_state_schema: StateSchema | None = field(default=None, metadata=nested("apls", StateSchema)) + args: list[bytes] | None = field(default=None, metadata=bytes_seq("apaa")) + account_references: list[str] | None = field(default=None, metadata=addr_seq("apat")) + app_references: list[int] | None = field(default=None, metadata=int_seq("apfa")) + asset_references: list[int] | None = field(default=None, metadata=int_seq("apas")) + extra_program_pages: int | None = field(default=None, metadata=wire("apep")) + reject_version: int | None = field(default=None, metadata=wire("aprv")) + box_references: list[BoxReference] | None = field( + default=None, + metadata=wire( + "apbx", + encode=_encode_box_references, + decode=_decode_box_references, + pass_obj=True, + ), + ) + access_references: list[ResourceReference] | None = field( + default=None, + metadata=wire( + "al", + encode=_encode_access_references, + decode=_decode_access_references, + pass_obj=True, + ), + ) + + def __post_init__(self) -> None: + if self.box_references: + normalized_boxes = [ + _normalize_box_reference(self, item) for item in _coerce_box_sequence(self.box_references) + ] + object.__setattr__(self, "box_references", normalized_boxes or None) + if self.access_references: + normalized_access = [ + _normalize_resource_reference(item) for item in _coerce_resource_sequence(self.access_references) + ] + object.__setattr__(self, "access_references", normalized_access or None) + + +def _coerce_box_sequence( + boxes: Iterable[BoxReference | _WireBoxReference], +) -> list[BoxReference | _WireBoxReference]: + if isinstance(boxes, list): + return boxes + return list(boxes) + + +def _coerce_resource_sequence( + resources: Iterable[ResourceReference], +) -> list[ResourceReference]: + if isinstance(resources, list): + return resources + return list(resources) + + +def _normalize_box_reference( + app_call: AppCallTransactionFields, + ref: BoxReference | _WireBoxReference, +) -> BoxReference: + if isinstance(ref, BoxReference): + return ref + if isinstance(ref, _WireBoxReference): + app_id = _map_box_index_to_app_id(ref.index, app_call) + return BoxReference(app_id=app_id, name=ref.name) + raise TypeError("Unsupported box reference payload") + + +def _normalize_resource_reference(ref: ResourceReference) -> ResourceReference: + if isinstance(ref, ResourceReference): + return ref + raise TypeError("Unsupported resource reference payload") + + +def _map_box_index_to_app_id(index: int, app_call: AppCallTransactionFields) -> int: + if index == 0: + return app_call.app_id + app_refs = app_call.app_references or [] + pos = index - 1 + if pos < 0 or pos >= len(app_refs): + raise DecodeError("Box reference index is out of bounds for application references") + return app_refs[pos] + + +def _map_box_app_id_to_index( + app_id: int, + app_call: AppCallTransactionFields, + app_refs: list[int], +) -> int: + if app_id in (0, app_call.app_id): + return 0 + try: + pos = app_refs.index(app_id) + except ValueError as exc: + raise EncodeError("Box reference app id must exist in application references") from exc + return pos + 1 + + +class _AccessListBuilder: + def __init__(self, app_call: "AppCallTransactionFields") -> None: + self._app_call = app_call + self._entries: list[dict[str, object]] = [] + + @property + def entries(self) -> list[dict[str, object]]: + return self._entries + + def add(self, ref: ResourceReference) -> None: + if self._register_direct(ref): + return + if self._register_holding(ref): + return + if self._register_locals(ref): + return + self._register_box(ref) + + def ensure(self, target: ResourceReference) -> int: + if target.address: + address_entry = to_wire(_AddressAccessEntry(address=target.address)) + encoded_address = _require_bytes(address_entry.get("d"), "Address access entry") + return self._ensure_entry("d", encoded_address) + + if target.asset_id is not None: + return self._ensure_entry("s", int(target.asset_id)) + + if target.app_id is not None: + return self._ensure_entry("p", int(target.app_id)) + + return len(self._entries) + + def _ensure_entry(self, key: Literal["d", "s", "p"], value: bytes | int) -> int: + for idx, entry in enumerate(self._entries): + if entry.get(key) == value: + return idx + 1 + self._entries.append({key: value}) + return len(self._entries) + + def _register_direct(self, ref: ResourceReference) -> bool: + if not (ref.address or ref.asset_id is not None or ref.app_id is not None): + return False + self.ensure(ref) + return True + + def _register_holding(self, ref: ResourceReference) -> bool: + holding = ref.holding + if holding is None: + return False + address_index = 0 + if holding.address and holding.address != ZERO_ADDRESS: + address_index = self.ensure(ResourceReference(address=holding.address)) + asset_index = self.ensure(ResourceReference(asset_id=holding.asset_id)) + self._entries.append({"h": {"d": address_index, "s": asset_index}}) + return True + + def _register_locals(self, ref: ResourceReference) -> bool: + locals_ref = ref.locals + if locals_ref is None: + return False + address_index = 0 + if locals_ref.address and locals_ref.address != ZERO_ADDRESS: + address_index = self.ensure(ResourceReference(address=locals_ref.address)) + app_index = 0 + if locals_ref.app_id and locals_ref.app_id != self._app_call.app_id: + app_index = self.ensure(ResourceReference(app_id=locals_ref.app_id)) + self._entries.append({"l": {"d": address_index, "p": app_index}}) + return True + + def _register_box(self, ref: ResourceReference) -> bool: + box_ref = ref.box + if box_ref is None: + return False + app_index = 0 + if box_ref.app_id not in (0, self._app_call.app_id): + app_index = self.ensure(ResourceReference(app_id=box_ref.app_id)) + self._entries.append({"b": {"i": app_index, "n": box_ref.name}}) + return True diff --git a/src/algokit_transact/models/asset_config.py b/src/algokit_transact/models/asset_config.py new file mode 100644 index 00000000..d99fe62a --- /dev/null +++ b/src/algokit_transact/models/asset_config.py @@ -0,0 +1,19 @@ +from dataclasses import dataclass, field + +from algokit_transact.codec.serde import addr, wire + + +@dataclass(slots=True, frozen=True) +class AssetConfigTransactionFields: + asset_id: int = field(default=0, metadata=wire("caid")) + total: int | None = field(default=None, metadata=wire("apar.t")) + decimals: int | None = field(default=None, metadata=wire("apar.dc")) + default_frozen: bool | None = field(default=None, metadata=wire("apar.df")) + unit_name: str | None = field(default=None, metadata=wire("apar.un")) + asset_name: str | None = field(default=None, metadata=wire("apar.an")) + url: str | None = field(default=None, metadata=wire("apar.au")) + metadata_hash: bytes | None = field(default=None, metadata=wire("apar.am")) + manager: str | None = field(default=None, metadata=addr("apar.m", omit_if_none=True)) + reserve: str | None = field(default=None, metadata=addr("apar.r", omit_if_none=True)) + freeze: str | None = field(default=None, metadata=addr("apar.f", omit_if_none=True)) + clawback: str | None = field(default=None, metadata=addr("apar.c", omit_if_none=True)) diff --git a/src/algokit_transact/models/asset_freeze.py b/src/algokit_transact/models/asset_freeze.py new file mode 100644 index 00000000..69bc9f1d --- /dev/null +++ b/src/algokit_transact/models/asset_freeze.py @@ -0,0 +1,11 @@ +from dataclasses import dataclass, field + +from algokit_common.constants import ZERO_ADDRESS +from algokit_transact.codec.serde import addr, wire + + +@dataclass(slots=True, frozen=True) +class AssetFreezeTransactionFields: + asset_id: int = field(default=0, metadata=wire("faid")) + freeze_target: str = field(default=ZERO_ADDRESS, metadata=addr("fadd")) + frozen: bool = field(default=False, metadata=wire("afrz")) diff --git a/src/algokit_transact/models/asset_transfer.py b/src/algokit_transact/models/asset_transfer.py new file mode 100644 index 00000000..74294101 --- /dev/null +++ b/src/algokit_transact/models/asset_transfer.py @@ -0,0 +1,13 @@ +from dataclasses import dataclass, field + +from algokit_common.constants import ZERO_ADDRESS +from algokit_transact.codec.serde import addr, wire + + +@dataclass(slots=True, frozen=True) +class AssetTransferTransactionFields: + asset_id: int = field(default=0, metadata=wire("xaid")) + receiver: str = field(default=ZERO_ADDRESS, metadata=addr("arcv")) + amount: int = field(default=0, metadata=wire("aamt")) + close_remainder_to: str | None = field(default=None, metadata=addr("aclose", omit_if_none=True)) + asset_sender: str | None = field(default=None, metadata=addr("asnd", omit_if_none=True)) diff --git a/src/algokit_transact/models/common.py b/src/algokit_transact/models/common.py new file mode 100644 index 00000000..4d760a76 --- /dev/null +++ b/src/algokit_transact/models/common.py @@ -0,0 +1,17 @@ +from dataclasses import dataclass, field +from enum import Enum + + +class OnApplicationComplete(Enum): + NoOp = 0 + OptIn = 1 + CloseOut = 2 + ClearState = 3 + UpdateApplication = 4 + DeleteApplication = 5 + + +@dataclass(slots=True, frozen=True) +class StateSchema: + num_uints: int = field(default=0, metadata={"kind": "wire", "alias": "nui"}) + num_byte_slices: int = field(default=0, metadata={"kind": "wire", "alias": "nbs"}) diff --git a/src/algokit_transact/models/heartbeat.py b/src/algokit_transact/models/heartbeat.py new file mode 100644 index 00000000..1512255f --- /dev/null +++ b/src/algokit_transact/models/heartbeat.py @@ -0,0 +1,21 @@ +from dataclasses import dataclass, field + +from algokit_transact.codec.serde import addr, nested, wire + + +@dataclass(slots=True, frozen=True) +class HeartbeatProof: + signature: bytes | None = field(default=None, metadata=wire("s")) + public_key: bytes | None = field(default=None, metadata=wire("p")) + public_key_2: bytes | None = field(default=None, metadata=wire("p2")) + public_key_1_signature: bytes | None = field(default=None, metadata=wire("p1s")) + public_key_2_signature: bytes | None = field(default=None, metadata=wire("p2s")) + + +@dataclass(slots=True, frozen=True) +class HeartbeatTransactionFields: + address: str | None = field(default=None, metadata=addr("a", omit_if_none=True)) + proof: HeartbeatProof | None = field(default=None, metadata=nested("prf", HeartbeatProof)) + seed: bytes | None = field(default=None, metadata=wire("sd")) + vote_id: bytes | None = field(default=None, metadata=wire("vid")) + key_dilution: int | None = field(default=None, metadata=wire("kd", keep_zero=True)) diff --git a/src/algokit_transact/models/key_registration.py b/src/algokit_transact/models/key_registration.py new file mode 100644 index 00000000..ead18290 --- /dev/null +++ b/src/algokit_transact/models/key_registration.py @@ -0,0 +1,14 @@ +from dataclasses import dataclass, field + +from algokit_transact.codec.serde import wire + + +@dataclass(slots=True, frozen=True) +class KeyRegistrationTransactionFields: + vote_key: bytes | None = field(default=None, metadata=wire("votekey")) + selection_key: bytes | None = field(default=None, metadata=wire("selkey")) + vote_first: int | None = field(default=None, metadata=wire("votefst")) + vote_last: int | None = field(default=None, metadata=wire("votelst")) + vote_key_dilution: int | None = field(default=None, metadata=wire("votekd")) + state_proof_key: bytes | None = field(default=None, metadata=wire("sprfkey")) + non_participation: bool | None = field(default=None, metadata=wire("nonpart")) diff --git a/src/algokit_transact/models/payment.py b/src/algokit_transact/models/payment.py new file mode 100644 index 00000000..16cbb13e --- /dev/null +++ b/src/algokit_transact/models/payment.py @@ -0,0 +1,14 @@ +from dataclasses import dataclass, field + +from algokit_common.constants import ZERO_ADDRESS +from algokit_transact.codec.serde import addr, wire + + +@dataclass(slots=True, frozen=True) +class PaymentTransactionFields: + amount: int = field(default=0, metadata=wire("amt")) + receiver: str = field(default=ZERO_ADDRESS, metadata=addr("rcv")) + close_remainder_to: str | None = field( + default=None, + metadata=addr("close", omit_if_none=True), + ) diff --git a/src/algokit_transact/models/signed_transaction.py b/src/algokit_transact/models/signed_transaction.py new file mode 100644 index 00000000..5c1fe365 --- /dev/null +++ b/src/algokit_transact/models/signed_transaction.py @@ -0,0 +1,21 @@ +from dataclasses import dataclass, field + +from algokit_transact.codec.serde import addr, nested, wire +from algokit_transact.models.transaction import Transaction +from algokit_transact.signing.logic_signature import LogicSigSignature +from algokit_transact.signing.types import MultisigSignature + + +@dataclass(slots=True, frozen=True) +class SignedTransaction: + txn: Transaction = field(metadata=nested("txn", Transaction)) + sig: bytes | None = field(default=None, metadata=wire("sig")) + msig: MultisigSignature | None = field( + default=None, + metadata=nested("msig", MultisigSignature), + ) + lsig: LogicSigSignature | None = field( + default=None, + metadata=nested("lsig", LogicSigSignature), + ) + auth_address: str | None = field(default=None, metadata=addr("sgnr")) diff --git a/src/algokit_transact/models/state_proof.py b/src/algokit_transact/models/state_proof.py new file mode 100644 index 00000000..64aa1826 --- /dev/null +++ b/src/algokit_transact/models/state_proof.py @@ -0,0 +1,150 @@ +from collections.abc import Iterable, Mapping +from dataclasses import dataclass, field +from typing import cast + +from algokit_transact.codec.serde import bytes_seq, from_wire, int_seq, nested, to_wire, wire + + +@dataclass(slots=True, frozen=True) +class HashFactory: + hash_type: int | None = field(default=None, metadata=wire("t")) + + +@dataclass(slots=True, frozen=True) +class MerkleArrayProof: + path: list[bytes] | None = field(default=None, metadata=bytes_seq("pth")) + hash_factory: HashFactory | None = field(default=None, metadata=nested("hsh", HashFactory)) + tree_depth: int | None = field(default=None, metadata=wire("td")) + + +@dataclass(slots=True, frozen=True) +class MerkleSignatureVerifier: + commitment: bytes | None = field(default=None, metadata=wire("cmt")) + key_lifetime: int | None = field(default=None, metadata=wire("lf")) + + +@dataclass(slots=True, frozen=True) +class Participant: + verifier: MerkleSignatureVerifier | None = field(default=None, metadata=nested("p", MerkleSignatureVerifier)) + weight: int | None = field(default=None, metadata=wire("w")) + + +@dataclass(slots=True, frozen=True) +class FalconVerifier: + public_key: bytes | None = field(default=None, metadata=wire("k")) + + +@dataclass(slots=True, frozen=True) +class FalconSignatureStruct: + signature: bytes | None = field(default=None, metadata=wire("sig")) + vector_commitment_index: int | None = field(default=None, metadata=wire("idx")) + proof: MerkleArrayProof | None = field(default=None, metadata=nested("prf", MerkleArrayProof)) + verifying_key: FalconVerifier | None = field(default=None, metadata=nested("vkey", FalconVerifier)) + + +@dataclass(slots=True, frozen=True) +class SigslotCommit: + sig: FalconSignatureStruct | None = field(default=None, metadata=nested("s", FalconSignatureStruct)) + lower_sig_weight: int | None = field(default=None, metadata=wire("l")) + + +@dataclass(slots=True, frozen=True) +class Reveal: + participant: Participant | None = field(default=None, metadata=nested("p", Participant)) + sigslot: SigslotCommit | None = field(default=None, metadata=nested("s", SigslotCommit)) + + +@dataclass(slots=True, frozen=True) +class StateProof: + sig_commit: bytes | None = field(default=None, metadata=wire("c")) + signed_weight: int | None = field(default=None, metadata=wire("w", keep_zero=True)) + sig_proofs: MerkleArrayProof | None = field(default=None, metadata=nested("S", MerkleArrayProof)) + part_proofs: MerkleArrayProof | None = field(default=None, metadata=nested("P", MerkleArrayProof)) + merkle_signature_salt_version: int | None = field(default=None, metadata=wire("v")) + reveals: dict[int, Reveal] | None = field( + default=None, + metadata=wire( + "r", + encode=lambda obj: _encode_reveals(cast(dict[int, Reveal] | None, obj)), + decode=lambda obj: _decode_reveals(obj), + ), + ) + positions_to_reveal: list[int] | None = field(default=None, metadata=int_seq("pr")) + + +@dataclass(slots=True, frozen=True) +class StateProofMessage: + block_headers_commitment: bytes | None = field(default=None, metadata=wire("b")) + voters_commitment: bytes | None = field(default=None, metadata=wire("v")) + ln_proven_weight: int | None = field(default=None, metadata=wire("P")) + first_attested_round: int | None = field(default=None, metadata=wire("f")) + last_attested_round: int | None = field(default=None, metadata=wire("l")) + + +@dataclass(slots=True, frozen=True) +class StateProofTransactionFields: + state_proof_type: int = field(default=0, metadata=wire("sptype")) + # Flatten state proof and message at the transaction level (aliases under root: sp and spmsg) + state_proof: StateProof | None = field(default=None, metadata=nested("sp", StateProof)) + message: StateProofMessage | None = field(default=None, metadata=nested("spmsg", StateProofMessage)) + + +def _encode_reveals(mapping: Mapping[int, Reveal] | Iterable[Reveal] | None) -> dict[int, dict[str, object]] | None: + if mapping is None: + return None + entries: Iterable[tuple[int, Reveal]] + if isinstance(mapping, Mapping): + entries = ( + (key if isinstance(key, int) else _coerce_reveal_position(key, idx), reveal) + for idx, (key, reveal) in enumerate(mapping.items()) + ) + else: + entries = ((_coerce_reveal_position(None, idx), reveal) for idx, reveal in enumerate(mapping)) + encoded: dict[int, dict[str, object]] = {} + for position, reveal in entries: + data = to_wire(reveal) + payload = {key: value for key in ("p", "s") if (value := data.get(key)) is not None} + if payload: + encoded[int(position)] = payload + return encoded or None + + +def _decode_reveals(obj: object | None) -> dict[int, Reveal] | None: + if obj is None: + return None + + if isinstance(obj, Mapping): + decoded: dict[int, Reveal] = {} + for key, value in obj.items(): + if not isinstance(value, Mapping): + continue + position = _coerce_reveal_position(key, len(decoded)) + payload = {k: v for k, v in value.items() if k in {"p", "s"}} + if payload: + decoded[position] = from_wire(Reveal, payload) + return decoded or None + + if isinstance(obj, list): + decoded_list: dict[int, Reveal] = {} + for idx, value in enumerate(obj): + if not isinstance(value, Mapping): + continue + position = _coerce_reveal_position(value.get("pos"), idx) + payload = {k: v for k, v in value.items() if k in {"p", "s"}} + if payload: + decoded_list[position] = from_wire(Reveal, payload) + return decoded_list or None + + return None + + +def _coerce_reveal_position(raw: object, fallback: int) -> int: + if isinstance(raw, int): + return raw + if isinstance(raw, str): + try: + return int(raw) + except ValueError: + return fallback + # Fallback silently to preserve legacy behavior when nodes omit this field. + return fallback diff --git a/src/algokit_transact/models/transaction.py b/src/algokit_transact/models/transaction.py new file mode 100644 index 00000000..6cc63750 --- /dev/null +++ b/src/algokit_transact/models/transaction.py @@ -0,0 +1,88 @@ +from collections.abc import Mapping +from dataclasses import dataclass, field +from enum import Enum + +from algokit_common.constants import ZERO_ADDRESS +from algokit_transact.codec.serde import addr, enum_value, flatten, nested, wire +from algokit_transact.models.app_call import AppCallTransactionFields +from algokit_transact.models.asset_config import AssetConfigTransactionFields +from algokit_transact.models.asset_freeze import AssetFreezeTransactionFields +from algokit_transact.models.asset_transfer import AssetTransferTransactionFields +from algokit_transact.models.heartbeat import HeartbeatTransactionFields +from algokit_transact.models.key_registration import KeyRegistrationTransactionFields +from algokit_transact.models.payment import PaymentTransactionFields +from algokit_transact.models.state_proof import StateProofTransactionFields + + +class TransactionType(Enum): + Payment = "pay" + AssetTransfer = "axfer" + AssetFreeze = "afrz" + AssetConfig = "acfg" + KeyRegistration = "keyreg" + AppCall = "appl" + StateProof = "stpf" + Heartbeat = "hb" + # Unknown transaction type - used when decoding transactions with unrecognized type values. + # This should not be used when creating new transactions. + Unknown = "unknown" + + +def _get_tx_type(payload: Mapping[str, object]) -> str | None: + """Helper to extract transaction type from payload, normalizing bytes to str.""" + type_val = payload.get("type") + if type_val is None: + return None + if isinstance(type_val, bytes | bytearray | memoryview): + return bytes(type_val).decode("utf-8") + return str(type_val) + + +@dataclass(slots=True, frozen=True) +class Transaction: + transaction_type: TransactionType = field( + metadata=enum_value("type", TransactionType, fallback=TransactionType.Unknown) + ) + sender: str = field(default=ZERO_ADDRESS, metadata=addr("snd")) + first_valid: int = field(default=0, metadata=wire("fv")) + last_valid: int = field(default=0, metadata=wire("lv")) + + fee: int | None = field(default=None, metadata=wire("fee")) + genesis_hash: bytes | None = field(default=None, metadata=wire("gh")) + genesis_id: str | None = field(default=None, metadata=wire("gen")) + note: bytes | None = field(default=None, metadata=wire("note")) + rekey_to: str | None = field(default=None, metadata=addr("rekey")) + lease: bytes | None = field(default=None, metadata=wire("lx")) + group: bytes | None = field(default=None, metadata=wire("grp")) + + payment: PaymentTransactionFields | None = field( + default=None, metadata=flatten(PaymentTransactionFields, present_if=lambda p: _get_tx_type(p) == "pay") + ) + asset_transfer: AssetTransferTransactionFields | None = field( + default=None, metadata=flatten(AssetTransferTransactionFields, present_if=lambda p: _get_tx_type(p) == "axfer") + ) + asset_config: AssetConfigTransactionFields | None = field( + default=None, metadata=flatten(AssetConfigTransactionFields, present_if=lambda p: _get_tx_type(p) == "acfg") + ) + application_call: AppCallTransactionFields | None = field( + default=None, metadata=flatten(AppCallTransactionFields, present_if=lambda p: _get_tx_type(p) == "appl") + ) + key_registration: KeyRegistrationTransactionFields | None = field( + default=None, + metadata=flatten(KeyRegistrationTransactionFields, present_if=lambda p: _get_tx_type(p) == "keyreg"), + ) + asset_freeze: AssetFreezeTransactionFields | None = field( + default=None, metadata=flatten(AssetFreezeTransactionFields, present_if=lambda p: _get_tx_type(p) == "afrz") + ) + heartbeat: HeartbeatTransactionFields | None = field( + default=None, metadata=nested("hb", HeartbeatTransactionFields) + ) + state_proof: StateProofTransactionFields | None = field( + default=None, metadata=flatten(StateProofTransactionFields, present_if=lambda p: _get_tx_type(p) == "stpf") + ) + + def tx_id(self) -> str: + """Return the transaction ID.""" + from algokit_transact.ops.ids import get_transaction_id + + return get_transaction_id(self) diff --git a/src/algokit_transact/multisig.py b/src/algokit_transact/multisig.py new file mode 100644 index 00000000..3b8d03a7 --- /dev/null +++ b/src/algokit_transact/multisig.py @@ -0,0 +1,220 @@ +import dataclasses +from collections.abc import Sequence +from functools import cached_property +from typing import TYPE_CHECKING + +from algokit_common import address_from_public_key +from algokit_transact.codec.signed import encode_signed_transaction +from algokit_transact.codec.transaction import encode_transaction +from algokit_transact.models.signed_transaction import SignedTransaction +from algokit_transact.models.transaction import Transaction as AlgokitTransaction +from algokit_transact.ops.validate import validate_signed_transaction +from algokit_transact.signer import AddressWithSigners +from algokit_transact.signing.multisig import ( + address_from_multisig_signature, + apply_multisig_subsignature, + new_multisig_signature, +) +from algokit_transact.signing.types import MultisigSignature + +if TYPE_CHECKING: + from algokit_transact.signer import ( + DelegatedLsigSigner, + TransactionSigner, + ) +__all__ = [ + "MultisigAccount", + "MultisigMetadata", +] + + +@dataclasses.dataclass(kw_only=True) +class MultisigMetadata: + """Metadata for a multisig account.""" + + version: int + threshold: int + addrs: list[str] + + +@dataclasses.dataclass(frozen=True) +class MultisigAccount: + """Account wrapper for multisig signing. Supports secretless signing.""" + + params: MultisigMetadata + """The multisig account parameters.""" + sub_signers: Sequence[AddressWithSigners] + """The list of signing accounts.""" + + @staticmethod + def from_signature(msig: MultisigSignature) -> "MultisigAccount": + """ + Create a MultisigAccount from a MultisigSignature. + + This is primarily used to extract the multisig address from a signature, + such as when dealing with delegated logic signatures. + + Args: + msig: The multisig signature to create the account from + + Returns: + A MultisigAccount with no sub-signers + """ + params = MultisigMetadata( + version=msig.version, + threshold=msig.threshold, + addrs=[address_from_public_key(subsig.public_key) for subsig in msig.subsigs], + ) + return MultisigAccount(params=params, sub_signers=[]) + + @cached_property + def _multisig_signature(self) -> MultisigSignature: + return new_multisig_signature( + self.params.version, + self.params.threshold, + self.params.addrs, + ) + + @cached_property + def signer(self) -> "TransactionSigner": + address_to_signer = {account.addr: account.bytes_signer for account in self.sub_signers} + msig_address = self.address + base_multisig = self._multisig_signature + + def signer(txn_group: Sequence[AlgokitTransaction], indexes_to_sign: Sequence[int]) -> list[bytes]: + blobs: list[bytes] = [] + for index in indexes_to_sign: + txn = txn_group[index] + payload = encode_transaction(txn) + + multisig_sig = base_multisig + for subsig in base_multisig.subsigs: + subsig_addr = address_from_public_key(subsig.public_key) + if subsig_addr in address_to_signer: + signature = address_to_signer[subsig_addr](payload) + multisig_sig = apply_multisig_subsignature(multisig_sig, subsig_addr, signature) + + signed = SignedTransaction( + txn=txn, + sig=None, + msig=multisig_sig, + lsig=None, + auth_address=msig_address if txn.sender != msig_address else None, + ) + validate_signed_transaction(signed) + blobs.append(encode_signed_transaction(signed)) + return blobs + + return signer + + @cached_property + def address(self) -> str: + """The multisig account address.""" + return address_from_multisig_signature(self._multisig_signature) + + @property + def addr(self) -> str: + """Alias for address property (matching TypeScript's get addr()).""" + return self.address + + @cached_property + def delegated_lsig_signer(self) -> "DelegatedLsigSigner": + from algokit_transact.logicsig import DelegatedLsigResult, LogicSigAccount + + def delegated_signer(lsig: LogicSigAccount, _: MultisigAccount | None) -> DelegatedLsigResult: + lmsig = lsig.lmsig or self._multisig_signature + + for addr_with_signer in self.sub_signers: + addr = addr_with_signer.addr + result = addr_with_signer.delegated_lsig_signer(lsig, self) + if result.sig is None: + raise ValueError( + f"Signer for address {addr} did not produce a valid signature when signing logic sig" + f" for multisig account {self.addr}", + ) + + lmsig = self.apply_signature(lmsig, addr, result.sig) + + return DelegatedLsigResult(addr=self.addr, lmsig=lmsig) + + return delegated_signer + + def apply_signature(self, msig: MultisigSignature, address: str, sig: bytes) -> MultisigSignature: + expected = self.params + if msig.version != expected.version or msig.threshold != expected.threshold: + given = MultisigMetadata( + version=msig.version, + threshold=msig.threshold, + addrs=[address_from_public_key(s.public_key) for s in msig.subsigs], + ) + + raise ValueError( + f"Multisig signature parameters do not match expected multisig parameters. {expected=!r}, {given=!r}" + ) + return apply_multisig_subsignature(msig, address, sig) + + def create_multisig_transaction(self, txn: AlgokitTransaction) -> SignedTransaction: + """ + Create a multisig transaction without any signatures. + + Args: + txn: The transaction to create a multisig transaction for + + Returns: + A SignedTransaction with empty multisig structure + """ + msig = self.create_multisig_signature() + + auth_address = self.address if txn.sender != self.address else None + + return SignedTransaction( + txn=txn, + sig=None, + msig=msig, + lsig=None, + auth_address=auth_address, + ) + + def create_multisig_signature(self) -> MultisigSignature: + """ + Create an empty multisig signature structure. + + Returns: + A MultisigSignature with empty signatures + """ + return new_multisig_signature( + self.params.version, + self.params.threshold, + self.params.addrs, + ) + + def apply_signature_to_txn(self, txn: SignedTransaction, pubkey: bytes, signature: bytes) -> SignedTransaction: + """ + Apply a signature to a signed transaction, returning a new SignedTransaction. + + Note: Unlike TypeScript which mutates in place, this returns a new SignedTransaction + since Python's SignedTransaction is a frozen dataclass. + + Args: + txn: The signed transaction to apply the signature to + pubkey: The public key of the signer + signature: The signature to apply + + Returns: + A new SignedTransaction with the signature applied + """ + from dataclasses import replace + + msig = txn.msig + if not msig: + created_txn = self.create_multisig_transaction(txn.txn) + msig = created_txn.msig + + if not msig: + raise ValueError("Failed to create multisig signature") + + # Convert to address for validation via apply_signature + address = address_from_public_key(pubkey) + updated_msig = self.apply_signature(msig, address, signature) + + return replace(txn, msig=updated_msig) diff --git a/src/algokit_transact/ops/__init__.py b/src/algokit_transact/ops/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/algokit_transact/ops/fees.py b/src/algokit_transact/ops/fees.py new file mode 100644 index 00000000..caa62489 --- /dev/null +++ b/src/algokit_transact/ops/fees.py @@ -0,0 +1,47 @@ +from dataclasses import replace + +from algokit_common.constants import SIGNATURE_ENCODING_INCR +from algokit_transact.codec.transaction import encode_transaction_raw +from algokit_transact.models.transaction import Transaction + + +def estimate_transaction_size(tx: Transaction) -> int: + raw = encode_transaction_raw(tx) + return len(raw) + SIGNATURE_ENCODING_INCR + + +def calculate_fee( + tx: Transaction, + *, + fee_per_byte: int, + min_fee: int, + extra_fee: int | None = None, + max_fee: int | None = None, +) -> int: + fee = 0 + if fee_per_byte > 0: + fee = fee_per_byte * estimate_transaction_size(tx) + fee = max(fee, min_fee) + if extra_fee is not None: + fee += extra_fee + if max_fee is not None and fee > max_fee: + raise ValueError(f"Transaction fee {fee} µALGO is greater than max fee {max_fee} µALGO") + return fee + + +def assign_fee( + tx: Transaction, + *, + fee_per_byte: int, + min_fee: int, + extra_fee: int | None = None, + max_fee: int | None = None, +) -> Transaction: + fee = calculate_fee( + tx, + fee_per_byte=fee_per_byte, + min_fee=min_fee, + extra_fee=extra_fee, + max_fee=max_fee, + ) + return replace(tx, fee=fee) diff --git a/src/algokit_transact/ops/group.py b/src/algokit_transact/ops/group.py new file mode 100644 index 00000000..2b57d11d --- /dev/null +++ b/src/algokit_transact/ops/group.py @@ -0,0 +1,28 @@ +from collections.abc import Iterable +from dataclasses import replace + +from algokit_common import sha512_256 +from algokit_common.constants import MAX_TRANSACTION_GROUP_SIZE, TRANSACTION_GROUP_DOMAIN_SEPARATOR +from algokit_transact.codec.msgpack import encode_msgpack +from algokit_transact.models.transaction import Transaction +from algokit_transact.ops.ids import get_transaction_id_raw + + +def group_transactions(transactions: Iterable[Transaction]) -> list[Transaction]: + txs = list(transactions) + + if not txs: + raise ValueError("Transaction group cannot be empty") + if len(txs) > MAX_TRANSACTION_GROUP_SIZE: + raise ValueError(f"Transaction group size exceeds the max limit of {MAX_TRANSACTION_GROUP_SIZE}") + + tx_hashes = [] + for tx in txs: + if tx.group is not None: + raise ValueError("Transactions must not already be grouped") + tx_hashes.append(get_transaction_id_raw(tx)) + + encoded = encode_msgpack({"txlist": tx_hashes}) + group = sha512_256(TRANSACTION_GROUP_DOMAIN_SEPARATOR + encoded) + + return [replace(tx, group=group) for tx in txs] diff --git a/src/algokit_transact/ops/ids.py b/src/algokit_transact/ops/ids.py new file mode 100644 index 00000000..6174da0e --- /dev/null +++ b/src/algokit_transact/ops/ids.py @@ -0,0 +1,16 @@ +from algokit_common import base32_nopad_encode, sha512_256 +from algokit_common.constants import TRANSACTION_ID_LENGTH +from algokit_transact.codec.transaction import encode_transaction +from algokit_transact.models.transaction import Transaction + + +def get_transaction_id_raw(transaction: Transaction) -> bytes: + if transaction.genesis_hash is None: + raise ValueError("Cannot compute transaction id without genesis hash") + encoded = encode_transaction(transaction) + return sha512_256(encoded) + + +def get_transaction_id(transaction: Transaction) -> str: + raw = get_transaction_id_raw(transaction) + return base32_nopad_encode(raw)[:TRANSACTION_ID_LENGTH] diff --git a/src/algokit_transact/ops/validate.py b/src/algokit_transact/ops/validate.py new file mode 100644 index 00000000..0e366f9d --- /dev/null +++ b/src/algokit_transact/ops/validate.py @@ -0,0 +1,517 @@ +from collections.abc import Mapping +from dataclasses import dataclass +from enum import Enum + +from algokit_common.constants import ( + MAX_ACCOUNT_REFERENCES, + MAX_APP_ARGS, + MAX_APP_REFERENCES, + MAX_ARGS_SIZE, + MAX_ASSET_DECIMALS, + MAX_ASSET_NAME_LENGTH, + MAX_ASSET_REFERENCES, + MAX_ASSET_UNIT_NAME_LENGTH, + MAX_ASSET_URL_LENGTH, + MAX_BOX_REFERENCES, + MAX_EXTRA_PROGRAM_PAGES, + MAX_GLOBAL_STATE_KEYS, + MAX_LOCAL_STATE_KEYS, + MAX_OVERALL_REFERENCES, + PROGRAM_PAGE_SIZE, + SIGNATURE_BYTE_LENGTH, +) +from algokit_transact.exceptions import TransactionValidationError +from algokit_transact.models.app_call import AppCallTransactionFields +from algokit_transact.models.asset_config import AssetConfigTransactionFields +from algokit_transact.models.asset_freeze import AssetFreezeTransactionFields +from algokit_transact.models.asset_transfer import AssetTransferTransactionFields +from algokit_transact.models.common import OnApplicationComplete +from algokit_transact.models.key_registration import KeyRegistrationTransactionFields +from algokit_transact.models.signed_transaction import SignedTransaction +from algokit_transact.models.transaction import Transaction + + +class ValidationIssueCode(Enum): + REQUIRED_FIELD = "required_field" + FIELD_TOO_LONG = "field_too_long" + IMMUTABLE_FIELD = "immutable_field" + ZERO_VALUE_FIELD = "zero_value_field" + ARBITRARY_CONSTRAINT = "arbitrary_constraint" + + +@dataclass(slots=True, frozen=True) +class ValidationIssue: + code: ValidationIssueCode + message: str + field: str | None = None + context: Mapping[str, object] | None = None + + +def _issue( + code: ValidationIssueCode, + message: str, + *, + field: str | None = None, + context: Mapping[str, object] | None = None, +) -> ValidationIssue: + return ValidationIssue(code=code, message=message, field=field, context=context) + + +def validate_signed_transaction(stx: SignedTransaction) -> None: + validate_transaction(stx.txn) + + signatures = [s for s in (stx.sig, stx.msig, stx.lsig) if s is not None] + + if len(signatures) > 1: + raise ValueError("Only one signature type can be set") + + if stx.sig is not None and len(stx.sig) != SIGNATURE_BYTE_LENGTH: + raise ValueError("Signature must be 64 bytes") + + +def validate_transaction(transaction: Transaction) -> None: + if not transaction.sender: + raise TransactionValidationError("Transaction sender is required") + + type_fields = [ + transaction.payment, + transaction.asset_transfer, + transaction.asset_config, + transaction.application_call, + transaction.key_registration, + transaction.asset_freeze, + transaction.heartbeat, + transaction.state_proof, + ] + match sum(1 for f in type_fields if f is not None): + case 0: + raise TransactionValidationError("No transaction type specific field is set") + case n if n > 1: + raise TransactionValidationError("Multiple transaction type specific fields set") + + issues: list[ValidationIssue] = [] + type_label: str | None = None + + match transaction: + case Transaction(application_call=app_call) if app_call is not None: + issues.extend(validate_app_call_fields(app_call)) + type_label = "App call" + case Transaction(asset_config=asset_config) if asset_config is not None: + issues.extend(validate_asset_config_fields(asset_config)) + type_label = "Asset config" + case Transaction(asset_transfer=asset_transfer) if asset_transfer is not None: + issues.extend(validate_asset_transfer_fields(asset_transfer)) + type_label = "Asset transfer" + case Transaction(asset_freeze=asset_freeze) if asset_freeze is not None: + issues.extend(validate_asset_freeze_fields(asset_freeze)) + type_label = "Asset freeze" + case Transaction(key_registration=key_registration) if key_registration is not None: + issues.extend(validate_key_registration_fields(key_registration)) + type_label = "Key registration" + + if issues and type_label: + messages = "\n".join(issue.message for issue in issues) + raise TransactionValidationError(f"{type_label} validation failed: {messages}", issues=issues) + + +def validate_app_call_fields(app_call: AppCallTransactionFields) -> list[ValidationIssue]: + issues: list[ValidationIssue] = [] + + if app_call.app_id == 0: + issues.extend(_validate_app_creation(app_call)) + else: + issues.extend(_validate_app_operation(app_call)) + + issues.extend(_validate_app_common_fields(app_call)) + return issues + + +def _validate_app_creation(app_call: AppCallTransactionFields) -> list[ValidationIssue]: + issues: list[ValidationIssue] = [] + issues.extend(_require_creation_programs(app_call)) + issues.extend(_validate_program_sizes(app_call)) + issues.extend(_validate_state_schema_limits(app_call)) + return issues + + +def _require_creation_programs(app_call: AppCallTransactionFields) -> list[ValidationIssue]: + issues: list[ValidationIssue] = [] + match (app_call.approval_program, app_call.clear_state_program): + case (None | b"", _): + issues.append( + _issue(ValidationIssueCode.REQUIRED_FIELD, "Approval program is required", field="Approval program") + ) + case (_, None | b""): + issues.append( + _issue( + ValidationIssueCode.REQUIRED_FIELD, "Clear state program is required", field="Clear state program" + ) + ) + return issues + + +def _validate_program_sizes(app_call: AppCallTransactionFields) -> list[ValidationIssue]: + issues: list[ValidationIssue] = [] + extra_pages = app_call.extra_program_pages or 0 + max_program_size = PROGRAM_PAGE_SIZE * (1 + extra_pages) + approval_size = len(app_call.approval_program or b"") + clear_state_size = len(app_call.clear_state_program or b"") + combined_size = approval_size + clear_state_size + + match extra_pages: + case n if n > MAX_EXTRA_PROGRAM_PAGES: + issues.append( + _issue( + ValidationIssueCode.FIELD_TOO_LONG, + f"Extra program pages cannot exceed {MAX_EXTRA_PROGRAM_PAGES} pages, got {n}", + field="Extra program pages", + context={"max": MAX_EXTRA_PROGRAM_PAGES, "actual": n, "unit": "pages"}, + ) + ) + + match approval_size: + case size if size > max_program_size: + issues.append( + _issue( + ValidationIssueCode.FIELD_TOO_LONG, + f"Approval program cannot exceed {max_program_size} bytes", + field="Approval program", + context={"max": max_program_size, "actual": size, "unit": "bytes"}, + ) + ) + + match clear_state_size: + case size if size > max_program_size: + issues.append( + _issue( + ValidationIssueCode.FIELD_TOO_LONG, + f"Clear state program cannot exceed {max_program_size} bytes", + field="Clear state program", + context={"max": max_program_size, "actual": size, "unit": "bytes"}, + ) + ) + + match combined_size: + case size if size > max_program_size: + issues.append( + _issue( + ValidationIssueCode.FIELD_TOO_LONG, + f"Combined approval and clear state programs cannot exceed {max_program_size} bytes", + field="Combined program size", + context={"max": max_program_size, "actual": size, "unit": "bytes"}, + ) + ) + + return issues + + +def _validate_state_schema_limits(app_call: AppCallTransactionFields) -> list[ValidationIssue]: + issues: list[ValidationIssue] = [] + if app_call.global_state_schema is not None: + total = app_call.global_state_schema.num_uints + app_call.global_state_schema.num_byte_slices + if total > MAX_GLOBAL_STATE_KEYS: + issues.append( + _issue( + ValidationIssueCode.FIELD_TOO_LONG, + f"Global state schema cannot exceed {MAX_GLOBAL_STATE_KEYS} keys", + field="Global state schema", + context={"max": MAX_GLOBAL_STATE_KEYS, "actual": total, "unit": "keys"}, + ) + ) + + if app_call.local_state_schema is not None: + total = app_call.local_state_schema.num_uints + app_call.local_state_schema.num_byte_slices + if total > MAX_LOCAL_STATE_KEYS: + issues.append( + _issue( + ValidationIssueCode.FIELD_TOO_LONG, + f"Local state schema cannot exceed {MAX_LOCAL_STATE_KEYS} keys", + field="Local state schema", + context={"max": MAX_LOCAL_STATE_KEYS, "actual": total, "unit": "keys"}, + ) + ) + + return issues + + +def _validate_app_operation(app_call: AppCallTransactionFields) -> list[ValidationIssue]: + issues: list[ValidationIssue] = [] + + def immutable(field: str) -> None: + issues.append( + _issue(ValidationIssueCode.IMMUTABLE_FIELD, f"{field} is immutable and cannot be changed", field=field) + ) + + match app_call.on_complete: + case OnApplicationComplete.UpdateApplication: + if not app_call.approval_program: + issues.append( + _issue(ValidationIssueCode.REQUIRED_FIELD, "Approval program is required", field="Approval program") + ) + if not app_call.clear_state_program: + issues.append( + _issue( + ValidationIssueCode.REQUIRED_FIELD, + "Clear state program is required", + field="Clear state program", + ) + ) + + if app_call.global_state_schema is not None: + immutable("Global state schema") + if app_call.local_state_schema is not None: + immutable("Local state schema") + if app_call.extra_program_pages is not None: + immutable("Extra program pages") + + return issues + + +def _validate_app_common_fields(app_call: AppCallTransactionFields) -> list[ValidationIssue]: + return [ + *_validate_app_args_limits(app_call), + *_validate_reference_limits(app_call), + *_validate_box_reference_constraints(app_call), + *_validate_total_reference_limit(app_call), + ] + + +def _validate_app_args_limits(app_call: AppCallTransactionFields) -> list[ValidationIssue]: + issues: list[ValidationIssue] = [] + if app_call.args is None: + return issues + if len(app_call.args) > MAX_APP_ARGS: + issues.append( + _issue( + ValidationIssueCode.FIELD_TOO_LONG, + f"Args cannot exceed {MAX_APP_ARGS} arguments", + field="Args", + context={"max": MAX_APP_ARGS, "actual": len(app_call.args), "unit": "arguments"}, + ) + ) + total_size = sum(len(arg) for arg in app_call.args) + if total_size > MAX_ARGS_SIZE: + issues.append( + _issue( + ValidationIssueCode.FIELD_TOO_LONG, + f"Args total size cannot exceed {MAX_ARGS_SIZE} bytes", + field="Args total size", + context={"max": MAX_ARGS_SIZE, "actual": total_size, "unit": "bytes"}, + ) + ) + return issues + + +def _validate_reference_limits(app_call: AppCallTransactionFields) -> list[ValidationIssue]: + issues: list[ValidationIssue] = [] + reference_limits = ( + ("Account references", app_call.account_references, MAX_ACCOUNT_REFERENCES), + ("App references", app_call.app_references, MAX_APP_REFERENCES), + ("Asset references", app_call.asset_references, MAX_ASSET_REFERENCES), + ) + for label, refs, limit in reference_limits: + if refs is not None and len(refs) > limit: + issues.append( + _issue( + ValidationIssueCode.FIELD_TOO_LONG, + f"{label} cannot exceed {limit} refs", + field=label, + context={"max": limit, "actual": len(refs), "unit": "refs"}, + ) + ) + + return issues + + +def _validate_box_reference_constraints(app_call: AppCallTransactionFields) -> list[ValidationIssue]: + issues: list[ValidationIssue] = [] + box_refs = app_call.box_references or () + if not box_refs: + return issues + if len(box_refs) > MAX_BOX_REFERENCES: + issues.append( + _issue( + ValidationIssueCode.FIELD_TOO_LONG, + f"Box references cannot exceed {MAX_BOX_REFERENCES} refs", + field="Box references", + context={"max": MAX_BOX_REFERENCES, "actual": len(box_refs), "unit": "refs"}, + ) + ) + allowed_app_ids: set[int] = {app_call.app_id, 0} + allowed_app_ids.update(app_call.app_references or ()) + for ref in box_refs: + if ref.app_id not in allowed_app_ids: + issues.append( + _issue( + ValidationIssueCode.ARBITRARY_CONSTRAINT, + f"Box reference for app ID {ref.app_id} must reference the current app or an app reference", + field="Box references", + ) + ) + return issues + + +def _validate_total_reference_limit(app_call: AppCallTransactionFields) -> list[ValidationIssue]: + total_refs = ( + len(app_call.account_references or ()) + + len(app_call.app_references or ()) + + len(app_call.asset_references or ()) + + len(app_call.box_references or ()) + ) + if total_refs <= MAX_OVERALL_REFERENCES: + return [] + return [ + _issue( + ValidationIssueCode.FIELD_TOO_LONG, + f"Total references cannot exceed {MAX_OVERALL_REFERENCES} refs", + field="Total references", + context={"max": MAX_OVERALL_REFERENCES, "actual": total_refs, "unit": "refs"}, + ) + ] + + +def validate_asset_config_fields(asset_config: AssetConfigTransactionFields) -> list[ValidationIssue]: + if asset_config.asset_id == 0: + return _validate_asset_creation(asset_config) + return _validate_asset_configuration(asset_config) + + +def _validate_asset_creation(asset_config: AssetConfigTransactionFields) -> list[ValidationIssue]: + issues: list[ValidationIssue] = [] + + def check_len(name: str, value: str | None, limit: int) -> None: + match value: + case str(s) if len(s) > limit: + issues.append( + _issue( + ValidationIssueCode.FIELD_TOO_LONG, + f"{name} cannot exceed {limit} bytes, got {len(s)}", + field=name, + context={"max": limit, "actual": len(s), "unit": "bytes"}, + ) + ) + + match asset_config.total: + case None: + issues.append(_issue(ValidationIssueCode.REQUIRED_FIELD, "Total is required", field="Total")) + + match asset_config.decimals: + case int(d) if d > MAX_ASSET_DECIMALS: + issues.append( + _issue( + ValidationIssueCode.FIELD_TOO_LONG, + f"Decimals cannot exceed {MAX_ASSET_DECIMALS} decimal places, got {d}", + field="Decimals", + context={"max": MAX_ASSET_DECIMALS, "actual": d, "unit": "decimal places"}, + ) + ) + + check_len("Unit name", asset_config.unit_name, MAX_ASSET_UNIT_NAME_LENGTH) + check_len("Asset name", asset_config.asset_name, MAX_ASSET_NAME_LENGTH) + check_len("Url", asset_config.url, MAX_ASSET_URL_LENGTH) + + return issues + + +def _validate_asset_configuration(asset_config: AssetConfigTransactionFields) -> list[ValidationIssue]: + immutable_fields = [ + ("total", "Total"), + ("decimals", "Decimals"), + ("default_frozen", "Default frozen"), + ("asset_name", "Asset name"), + ("unit_name", "Unit name"), + ("url", "Url"), + ("metadata_hash", "Metadata hash"), + ] + + return [ + _issue( + ValidationIssueCode.IMMUTABLE_FIELD, + f"{label} is immutable and cannot be changed", + field=label, + ) + for attr, label in immutable_fields + if getattr(asset_config, attr) is not None + ] + + +def validate_asset_transfer_fields(asset_transfer: AssetTransferTransactionFields) -> list[ValidationIssue]: + issues: list[ValidationIssue] = [] + + if asset_transfer.asset_id == 0: + issues.append( + _issue( + ValidationIssueCode.ZERO_VALUE_FIELD, + "Asset ID must not be 0", + field="Asset ID", + ) + ) + + return issues + + +def validate_asset_freeze_fields(asset_freeze: AssetFreezeTransactionFields) -> list[ValidationIssue]: + issues: list[ValidationIssue] = [] + + if asset_freeze.asset_id == 0: + issues.append( + _issue( + ValidationIssueCode.ZERO_VALUE_FIELD, + "Asset ID must not be 0", + field="Asset ID", + ) + ) + + return issues + + +def validate_key_registration_fields(key_reg: KeyRegistrationTransactionFields) -> list[ValidationIssue]: + issues: list[ValidationIssue] = [] + + has_participation_fields = any( + field is not None + for field in ( + key_reg.vote_key, + key_reg.selection_key, + key_reg.state_proof_key, + key_reg.vote_first, + key_reg.vote_last, + key_reg.vote_key_dilution, + ) + ) + + if not has_participation_fields: + return issues + + required_fields = [ + (key_reg.vote_key, "Vote key"), + (key_reg.selection_key, "Selection key"), + (key_reg.state_proof_key, "State proof key"), + (key_reg.vote_first, "Vote first"), + (key_reg.vote_last, "Vote last"), + (key_reg.vote_key_dilution, "Vote key dilution"), + ] + + for value, field_name in required_fields: + if value is None: + issues.append(_issue(ValidationIssueCode.REQUIRED_FIELD, f"{field_name} is required", field=field_name)) + + if key_reg.vote_first is not None and key_reg.vote_last is not None and key_reg.vote_first >= key_reg.vote_last: + issues.append( + _issue( + ValidationIssueCode.ARBITRARY_CONSTRAINT, + "Vote first must be less than vote last", + field="Vote first", + ) + ) + + if key_reg.non_participation: + issues.append( + _issue( + ValidationIssueCode.ARBITRARY_CONSTRAINT, + "Online key registration cannot have non participation flag set", + field="Non participation", + ) + ) + + return issues diff --git a/src/algokit_transact/py.typed b/src/algokit_transact/py.typed new file mode 100644 index 00000000..e69de29b diff --git a/src/algokit_transact/signer.py b/src/algokit_transact/signer.py new file mode 100644 index 00000000..4847c2a3 --- /dev/null +++ b/src/algokit_transact/signer.py @@ -0,0 +1,187 @@ +"""Transaction and data signing types and utilities.""" + +import base64 +from collections.abc import Callable, Sequence +from dataclasses import dataclass +from typing import TYPE_CHECKING, Protocol, runtime_checkable + +import nacl.signing + +from algokit_common import address_from_public_key +from algokit_common.constants import EMPTY_SIGNATURE +from algokit_transact.codec.signed import encode_signed_transaction +from algokit_transact.codec.transaction import encode_transaction +from algokit_transact.models.signed_transaction import SignedTransaction +from algokit_transact.models.transaction import Transaction +from algokit_transact.ops.validate import validate_signed_transaction + +if TYPE_CHECKING: + from algokit_transact.logicsig import ( + DelegatedLsigResult, + LogicSig, + LogicSigAccount, + ) + from algokit_transact.multisig import MultisigAccount +_MX_BYTES_DOMAIN_SEPARATOR = b"MX" + +DelegatedLsigSigner = Callable[["LogicSigAccount", "MultisigAccount | None"], "DelegatedLsigResult"] +ProgramDataSigner = Callable[["LogicSig", bytes], bytes] +TransactionSigner = Callable[["Sequence[Transaction]", Sequence[int]], list[bytes]] +BytesSigner = Callable[[bytes], bytes] +MxBytesSigner = Callable[[bytes], bytes] + + +@runtime_checkable +class Addressable(Protocol): + """Protocol for objects with an address.""" + + @property + def addr(self) -> str: ... + + +@runtime_checkable +class AddressWithTransactionSigner(Addressable, Protocol): + """Protocol for objects with transaction signing capability.""" + + @property + def signer(self) -> TransactionSigner: ... + + +@runtime_checkable +class AddressWithDelegatedLsigSigner(Addressable, Protocol): + """Protocol for objects with logic signature delegation signing.""" + + @property + def delegated_lsig_signer(self) -> DelegatedLsigSigner: ... + + +@runtime_checkable +class AddressWithProgramDataSigner(Addressable, Protocol): + """Protocol for objects with program data signing capability.""" + + @property + def program_data_signer(self) -> ProgramDataSigner: ... + + +@runtime_checkable +class AddressWithMxBytesSigner(Addressable, Protocol): + """Protocol for objects with MX-prefixed bytes signing capability.""" + + @property + def mx_bytes_signer(self) -> MxBytesSigner: ... + + +@dataclass(frozen=True, slots=True) +class AddressWithSigners: + """Container for an address with all signing capabilities.""" + + addr: str + signer: TransactionSigner + delegated_lsig_signer: DelegatedLsigSigner + program_data_signer: ProgramDataSigner + bytes_signer: BytesSigner + mx_bytes_signer: MxBytesSigner + + +def generate_address_with_signers( + ed25519_pubkey: bytes, + raw_ed25519_signer: BytesSigner, + *, + sending_address: str | None = None, +) -> AddressWithSigners: + """Generate domain-separated signers from an ed25519 pubkey and raw signer. + + Args: + ed25519_pubkey: The ed25519 public key bytes. + raw_ed25519_signer: A function that signs raw bytes with the ed25519 private key. + sending_address: Optional address to use as the sending address. If provided, + this will be the `addr` in the returned object, and the address derived + from `ed25519_pubkey` will be used as the auth_address when signing + transactions where the sender differs from the sending_address. + + Returns: + An AddressWithSigners containing the address and all signing functions. + """ + auth_addr = address_from_public_key(ed25519_pubkey) + addr = sending_address if sending_address is not None else auth_addr + + def transaction_signer(txn_group: Sequence[Transaction], indexes_to_sign: Sequence[int]) -> list[bytes]: + result: list[bytes] = [] + for index in indexes_to_sign: + txn = txn_group[index] + bytes_to_sign = encode_transaction(txn) + signature = raw_ed25519_signer(bytes_to_sign) + stxn = SignedTransaction( + txn=txn, + sig=signature, + auth_address=auth_addr if txn.sender != auth_addr else None, + ) + validate_signed_transaction(stxn) + result.append(encode_signed_transaction(stxn)) + return result + + def delegated_lsig_signer(lsig: "LogicSigAccount", msig: "MultisigAccount | None" = None) -> "DelegatedLsigResult": + from algokit_transact import DelegatedLsigResult + + payload = lsig.bytes_to_sign_for_delegation(msig.address if msig else None) + sig = raw_ed25519_signer(payload) + return DelegatedLsigResult(addr=addr, sig=sig) + + def program_data_signer(lsig: "LogicSig", data: bytes) -> bytes: + payload = lsig.program_data_to_sign(data) + return raw_ed25519_signer(payload) + + def mx_bytes_signer(data: bytes) -> bytes: + payload = _MX_BYTES_DOMAIN_SEPARATOR + data + return raw_ed25519_signer(payload) + + return AddressWithSigners( + addr=addr, + signer=transaction_signer, + delegated_lsig_signer=delegated_lsig_signer, + program_data_signer=program_data_signer, + bytes_signer=raw_ed25519_signer, + mx_bytes_signer=mx_bytes_signer, + ) + + +def make_empty_transaction_signer() -> TransactionSigner: + """Create a signer that returns empty signatures (for simulation only).""" + + def empty_signer(txn_group: Sequence[Transaction], indexes_to_sign: Sequence[int]) -> list[bytes]: + result: list[bytes] = [] + for index in indexes_to_sign: + stxn = SignedTransaction( + txn=txn_group[index], + sig=EMPTY_SIGNATURE, + ) + validate_signed_transaction(stxn) + result.append(encode_signed_transaction(stxn)) + return result + + return empty_signer + + +def make_basic_account_transaction_signer(private_key: str) -> TransactionSigner: + """Create a transaction signer from a base64-encoded private key. + + Args: + private_key: Base64-encoded 64-byte private key (first 32 bytes are seed, + last 32 bytes are public key). + + Returns: + A TransactionSigner function that can sign transactions. + """ + # Decode the base64 private key (64 bytes: 32-byte seed + 32-byte public key) + key_bytes = base64.b64decode(private_key) + seed = key_bytes[:32] + public_key = key_bytes[32:] + + # Create signing key from seed + signing_key = nacl.signing.SigningKey(seed) + + def raw_signer(bytes_to_sign: bytes) -> bytes: + signed = signing_key.sign(bytes_to_sign) + return signed.signature + + return generate_address_with_signers(public_key, raw_signer).signer diff --git a/src/algokit_transact/signing/__init__.py b/src/algokit_transact/signing/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/algokit_transact/signing/logic_signature.py b/src/algokit_transact/signing/logic_signature.py new file mode 100644 index 00000000..ace55997 --- /dev/null +++ b/src/algokit_transact/signing/logic_signature.py @@ -0,0 +1,19 @@ +from dataclasses import dataclass, field + +from algokit_transact.codec.serde import bytes_seq, nested, wire +from algokit_transact.signing.types import MultisigSignature + + +@dataclass(slots=True, frozen=True) +class LogicSigSignature: + logic: bytes = field(metadata=wire("l")) + args: list[bytes] | None = field(default=None, metadata=bytes_seq("arg")) + sig: bytes | None = field(default=None, metadata=wire("sig")) + msig: MultisigSignature | None = field( + default=None, + metadata=nested("msig", MultisigSignature), + ) + lmsig: MultisigSignature | None = field( + default=None, + metadata=nested("lmsig", MultisigSignature), + ) diff --git a/src/algokit_transact/signing/multisig.py b/src/algokit_transact/signing/multisig.py new file mode 100644 index 00000000..c85eafdb --- /dev/null +++ b/src/algokit_transact/signing/multisig.py @@ -0,0 +1,84 @@ +from collections.abc import Iterable +from dataclasses import replace + +from algokit_common import ( + PUBLIC_KEY_BYTE_LENGTH, + address_from_public_key, + public_key_from_address, + sha512_256, +) +from algokit_transact.signing.types import MultisigSignature, MultisigSubsignature + +_MULTISIG_DOMAIN_SEPARATOR = b"MultisigAddr" + + +def new_multisig_signature(version: int, threshold: int, participants: Iterable[str]) -> MultisigSignature: + participants = list(participants) + if version == 0: + raise ValueError("Version cannot be zero") + if not participants: + raise ValueError("Participants cannot be empty") + if threshold < 1 or threshold > len(participants): + raise ValueError("Threshold must be greater than zero and less than or equal to the number of participants") + + subsigs = [MultisigSubsignature(public_key=public_key_from_address(address)) for address in participants] + return MultisigSignature(version=version, threshold=threshold, subsigs=subsigs) + + +def participants_from_multisig_signature(multisig_signature: MultisigSignature) -> list[str]: + return [address_from_public_key(subsig.public_key) for subsig in multisig_signature.subsigs] + + +def address_from_multisig_signature(multisig_signature: MultisigSignature) -> str: + participant_keys = [subsig.public_key for subsig in multisig_signature.subsigs] + + buffer = bytearray() + buffer.extend(_MULTISIG_DOMAIN_SEPARATOR) + buffer.append(multisig_signature.version) + buffer.append(multisig_signature.threshold) + for pk in participant_keys: + if len(pk) != PUBLIC_KEY_BYTE_LENGTH: + raise ValueError("Invalid participant public key length") + buffer.extend(pk) + + public_key = sha512_256(bytes(buffer)) + return address_from_public_key(public_key) + + +def apply_multisig_subsignature( + multisig_signature: MultisigSignature, participant: str, signature: bytes +) -> MultisigSignature: + found = False + updated = [] + participant_pk = public_key_from_address(participant) + for subsig in multisig_signature.subsigs: + if subsig.public_key == participant_pk: + found = True + updated.append(MultisigSubsignature(public_key=subsig.public_key, sig=signature)) + else: + updated.append(subsig) + if not found: + raise ValueError("Address not found in multisig signature") + return replace(multisig_signature, subsigs=updated) + + +def merge_multisignatures(multisig_a: MultisigSignature, multisig_b: MultisigSignature) -> MultisigSignature: + if multisig_a.version != multisig_b.version: + raise ValueError("Cannot merge multisig signatures with different versions") + if multisig_a.threshold != multisig_b.threshold: + raise ValueError("Cannot merge multisig signatures with different thresholds") + + participants_a = participants_from_multisig_signature(multisig_a) + participants_b = participants_from_multisig_signature(multisig_b) + if participants_a != participants_b: + raise ValueError("Cannot merge multisig signatures with different participants") + + merged_subsigs = [] + for subsig_a, subsig_b in zip(multisig_a.subsigs, multisig_b.subsigs, strict=False): + sig = subsig_b.sig if subsig_b.sig is not None else subsig_a.sig + merged_subsigs.append(MultisigSubsignature(public_key=subsig_a.public_key, sig=sig)) + return MultisigSignature( + version=multisig_a.version, + threshold=multisig_a.threshold, + subsigs=merged_subsigs, + ) diff --git a/src/algokit_transact/signing/types.py b/src/algokit_transact/signing/types.py new file mode 100644 index 00000000..119ebd0e --- /dev/null +++ b/src/algokit_transact/signing/types.py @@ -0,0 +1,38 @@ +from collections.abc import Mapping +from dataclasses import dataclass, field + +from algokit_transact.codec.serde import from_wire, to_wire, wire + + +def _encode_subsig_seq(value: object) -> object: + if value is None: + return None + if isinstance(value, tuple | list): + payload = [to_wire(subsig) for subsig in value] + return payload if payload else None + return value + + +def _decode_subsig_seq(value: object) -> object: + if isinstance(value, list): + decoded: list[MultisigSubsignature] = [] + for entry in value: + if isinstance(entry, Mapping): + decoded.append(from_wire(MultisigSubsignature, entry)) + return tuple(decoded) + return value + + +@dataclass(slots=True, frozen=True) +class MultisigSubsignature: + public_key: bytes = field(metadata=wire("pk")) + sig: bytes | None = field(default=None, metadata=wire("s")) + + +@dataclass(slots=True, frozen=True) +class MultisigSignature: + version: int = field(metadata=wire("v", keep_zero=True)) + threshold: int = field(metadata=wire("thr", keep_zero=True)) + subsigs: list[MultisigSubsignature] = field( + metadata=wire("subsig", encode=_encode_subsig_seq, decode=_decode_subsig_seq) + ) diff --git a/src/algokit_transact/signing/validation.py b/src/algokit_transact/signing/validation.py new file mode 100644 index 00000000..37867516 --- /dev/null +++ b/src/algokit_transact/signing/validation.py @@ -0,0 +1,63 @@ +"""Program validation utilities for TEAL bytecode. + +This module provides sanity checks for compiled TEAL programs to help +detect common errors such as passing source code instead of bytecode, +or passing base64-encoded programs. +""" + +import base64 + +from algokit_common.address import public_key_from_address + + +def sanity_check_program(program: bytes) -> None: + """Perform sanity checks on a compiled TEAL program. + + This function validates that the provided bytes appear to be compiled + TEAL bytecode rather than common mistakes like: + - Empty program + - An Algorand address string + - A base64-encoded string + - TEAL source code (ASCII text) + + Args: + program: The compiled TEAL program bytes to validate. + + Raises: + ValueError: If the program fails any sanity check: + - "empty program" if the program is None or empty + - "requesting program bytes, get Algorand address" if the bytes + decode to a valid Algorand address + - "program should not be b64 encoded" if the bytes appear to be + a base64-encoded string + - "program bytes are all ASCII printable characters, not looking + like Teal byte code" if all bytes are printable ASCII + """ + if not program: + raise ValueError("empty program") + + try: + ascii_str = program.decode("ascii") + except UnicodeDecodeError: + # not ascii, probably bytecode + return + + if any(not line.isprintable() for line in ascii_str.splitlines()): + # not printable, probably bytecode + return + + try: + public_key_from_address(ascii_str) + except (TypeError, ValueError): + pass + else: + raise ValueError("requesting program bytes, get Algorand address") + + try: + base64.b64decode(ascii_str) + except (TypeError, ValueError): + pass + else: + raise ValueError("program should not be b64 encoded") + + raise ValueError("program bytes are all ASCII printable characters, not looking like Teal byte code") diff --git a/src/algokit_utils/__init__.py b/src/algokit_utils/__init__.py index 399a81cd..87e19376 100644 --- a/src/algokit_utils/__init__.py +++ b/src/algokit_utils/__init__.py @@ -5,7 +5,8 @@ from algokit_utils.accounts import KmdAccountManager from algokit_utils.applications import AppClient - from algokit_utils.applications.app_spec import Arc52Contract + from algokit_utils.applications.app_spec import Arc56Contract + from algokit_utils.transact import Transaction, TransactionSigner etc. """ @@ -19,6 +20,4 @@ from algokit_utils.transactions import * # noqa: F403 from algokit_utils.errors import * # noqa: F403 from algokit_utils.algorand import * # noqa: F403 - -# Legacy types and utilities -from algokit_utils._legacy_v2 import * # noqa: F403 +from algokit_utils.transact import * # noqa: F403 diff --git a/src/algokit_utils/_debugging.py b/src/algokit_utils/_debugging.py index 957b2cbe..75940b0e 100644 --- a/src/algokit_utils/_debugging.py +++ b/src/algokit_utils/_debugging.py @@ -5,20 +5,22 @@ from dataclasses import dataclass, field from datetime import datetime, timezone from pathlib import Path +from typing import Any -from algosdk.atomic_transaction_composer import ( - AtomicTransactionComposer, - EmptySigner, - SimulateAtomicTransactionResponse, -) -from algosdk.encoding import checksum -from algosdk.v2client.models import SimulateRequest, SimulateRequestTransactionGroup, SimulateTraceConfig - -from algokit_utils._legacy_v2.common import Program +from algokit_common import ProgramSourceMap, sha512_256 +from algokit_common.serde import to_wire +from algokit_utils.applications.app_manager import AppManager +from algokit_utils.config import config from algokit_utils.models.application import CompiledTeal +from algokit_utils.transactions.transaction_composer import SendTransactionComposerResults, TransactionComposer if typing.TYPE_CHECKING: - from algosdk.v2client.algod import AlgodClient + from algosdk.atomic_transaction_composer import SimulateAtomicTransactionResponse # type: ignore[import-not-found] + + from algokit_algod_client import AlgodClient +else: + SimulateAtomicTransactionResponse = typing.Any # type: ignore[assignment] + AlgodClient = typing.Any # type: ignore[assignment] logger = logging.getLogger(__name__) @@ -29,6 +31,7 @@ DEBUG_TRACES_DIR = "debug_traces" TEAL_FILE_EXT = ".teal" TEAL_SOURCEMAP_EXT = ".teal.map" +TRACE_FILENAME_DATE_FORMAT = "%Y%m%d_%H%M%S" @dataclass @@ -69,7 +72,7 @@ def __init__( app_name: str, file_name: str, raw_teal: str | None = None, - compiled_teal: CompiledTeal | Program | None = None, + compiled_teal: CompiledTeal | None = None, ): self.compiled_teal = compiled_teal self.app_name = app_name @@ -81,9 +84,7 @@ def from_raw_teal(cls, raw_teal: str, app_name: str, file_name: str) -> "Persist return cls(app_name, file_name, raw_teal=raw_teal) @classmethod - def from_compiled_teal( - cls, compiled_teal: CompiledTeal | Program, app_name: str, file_name: str - ) -> "PersistSourceMapInput": + def from_compiled_teal(cls, compiled_teal: CompiledTeal, app_name: str, file_name: str) -> "PersistSourceMapInput": return cls(app_name, file_name, compiled_teal=compiled_teal) @property @@ -106,47 +107,40 @@ def strip_teal_extension(file_name: str) -> str: return file_name -def _load_or_create_sources(sources_path: Path) -> AVMDebuggerSourceMap: - if not sources_path.exists(): - return AVMDebuggerSourceMap(txn_group_sources=[]) - - with sources_path.open() as f: - return AVMDebuggerSourceMap.from_dict(json.load(f)) - - def _write_to_file(path: Path, content: str) -> None: path.parent.mkdir(parents=True, exist_ok=True) path.write_text(content) +def _compile_raw_teal(raw_teal: str, client: AlgodClient) -> tuple[bytes, ProgramSourceMap, str]: + teal_to_compile = AppManager.strip_teal_comments(raw_teal) + compiled = client.teal_compile(teal_to_compile.encode("utf-8"), sourcemap=True) + compiled_bytes = base64.b64decode(compiled.result) + sourcemap_dict = to_wire(compiled.sourcemap) if compiled.sourcemap else {} + return compiled_bytes, ProgramSourceMap(sourcemap_dict), raw_teal + + def _build_avm_sourcemap( *, app_name: str, file_name: str, output_path: Path, - client: "AlgodClient", + client: AlgodClient, raw_teal: str | None = None, - compiled_teal: CompiledTeal | Program | None = None, + compiled_teal: CompiledTeal | None = None, with_sources: bool = True, ) -> AVMDebuggerSourceMapEntry: if not raw_teal and not compiled_teal: raise ValueError("Either raw teal or compiled teal must be provided") - # Handle both legacy Program and new CompiledTeal - if isinstance(compiled_teal, Program): - program_hash = base64.b64encode(checksum(compiled_teal.raw_binary)).decode() - source_map = compiled_teal.source_map.__dict__ - teal_content = compiled_teal.teal - elif isinstance(compiled_teal, CompiledTeal): - program_hash = base64.b64encode(checksum(compiled_teal.compiled_base64_to_bytes)).decode() + if isinstance(compiled_teal, CompiledTeal): + program_hash = base64.b64encode(sha512_256(compiled_teal.compiled_base64_to_bytes)).decode() source_map = compiled_teal.source_map.__dict__ if compiled_teal.source_map else {} teal_content = compiled_teal.teal else: - # Handle raw TEAL case - result = Program(str(raw_teal), client=client) - program_hash = base64.b64encode(checksum(result.raw_binary)).decode() - source_map = result.source_map.__dict__ - teal_content = result.teal + compiled_bytes, source_map_obj, teal_content = _compile_raw_teal(str(raw_teal), client) + program_hash = base64.b64encode(sha512_256(compiled_bytes)).decode() + source_map = source_map_obj.__dict__ source_map["sources"] = [f"{file_name}{TEAL_FILE_EXT}"] if with_sources else [] @@ -178,11 +172,115 @@ def cleanup_old_trace_files(output_dir: Path, buffer_size_mb: float) -> None: oldest_file.unlink() +def _summarize_txn_types(trace: dict[str, Any]) -> str: + counts: dict[str, int] = {} + for group in trace.get("txn-groups", []): + for txn_result in group.get("txn-results", []): + txn = txn_result.get("txn-result", {}).get("txn", {}).get("txn", {}) + txn_type = txn.get("type") + if txn_type and not isinstance(txn_type, str): + txn_type = getattr(txn_type, "value", str(txn_type)) + if not txn_type: + continue + counts[txn_type] = counts.get(txn_type, 0) + 1 + return "_".join(f"{count}{txn_type}" for txn_type, count in counts.items()) + + +def _persist_simulation_trace( + trace: dict[str, Any], + project_root: Path, + *, + timestamp: datetime | None = None, + buffer_size_mb: float | None = None, +) -> Path: + project_root.mkdir(parents=True, exist_ok=True) + trace_dir = project_root / DEBUG_TRACES_DIR + trace_dir.mkdir(parents=True, exist_ok=True) + + now = timestamp or datetime.now(timezone.utc) + last_round = trace.get("last-round", 0) + txn_part = _summarize_txn_types(trace) + filename = ( + f"{now.astimezone(timezone.utc).strftime(TRACE_FILENAME_DATE_FORMAT)}_lr{last_round}_{txn_part}" + f"{TRACES_FILE_EXT}" + ) + output_path = trace_dir / filename + + def _default_encoder(value: object) -> str: + if isinstance(value, (bytes | bytearray | memoryview)): + return base64.b64encode(bytes(value)).decode("utf-8") + return getattr(value, "value", str(value)) + + _write_to_file(output_path, json.dumps(trace, default=_default_encoder)) + + if buffer_size_mb is not None: + cleanup_old_trace_files(trace_dir, buffer_size_mb) + + return output_path + + +def _extract_simulation_trace_from_algokit(result: SendTransactionComposerResults) -> dict[str, Any]: + if result.simulate_response is None: + raise ValueError("No simulate_response available to persist") + return to_wire(result.simulate_response) + + +def _extract_simulation_trace_from_atc(response: SimulateAtomicTransactionResponse) -> dict[str, Any]: + # algosdk simulate responses are already dict-like + return dict(response.simulate_response) if hasattr(response, "simulate_response") else dict(response) + + +def simulate_and_persist_response( + composer: TransactionComposer | object, + project_root: Path, + algod: AlgodClient, + *, + buffer_size_mb: float | None = None, + result: SendTransactionComposerResults | SimulateAtomicTransactionResponse | None = None, +) -> Path: + """ + Run a simulation on the provided composer and persist the trace to disk. + + :param composer: Transaction composer (AlgoKit or algosdk AtomicTransactionComposer) + :param project_root: Root directory where traces should be stored + :param algod: Algod client to use for simulation + :param buffer_size_mb: Optional buffer size to enforce via cleanup_old_trace_files + :param result: Optional existing simulation result to persist instead of re-running simulation + :return: Path to the persisted trace file + :raises TypeError: If the composer does not implement a compatible ``simulate`` method + """ + if result is None and isinstance(composer, TransactionComposer): + result = composer.simulate(_persist_trace=False) + trace = _extract_simulation_trace_from_algokit(result) + elif result is None and hasattr(composer, "simulate"): + result = composer.simulate(algod) + trace = _extract_simulation_trace_from_atc(result) + elif result is not None: + trace = ( + _extract_simulation_trace_from_algokit(result) + if isinstance(result, SendTransactionComposerResults) + else _extract_simulation_trace_from_atc(result) + ) + else: + raise TypeError("Composer must support simulate()") + + effective_root = config.project_root or project_root + effective_buffer = buffer_size_mb + if config.trace_all and buffer_size_mb is None: + effective_buffer = config.trace_buffer_size_mb + + return _persist_simulation_trace( + trace, + effective_root, + buffer_size_mb=effective_buffer, + ) + + def persist_sourcemaps( *, sources: list[PersistSourceMapInput], project_root: Path, - client: "AlgodClient", + client: AlgodClient, with_sources: bool = True, ) -> None: """ @@ -190,7 +288,7 @@ def persist_sourcemaps( :param sources: A list of PersistSourceMapInput objects. :param project_root: The root directory of the project. - :param client: An AlgodClient object for interacting with the Algorand blockchain. + :param client: An AlgodClient instance for interacting with the Algorand blockchain. :param with_sources: If True, it will dump teal source files along with sourcemaps. """ @@ -204,103 +302,3 @@ def persist_sourcemaps( client=client, with_sources=with_sources, ) - - -def simulate_response( - atc: AtomicTransactionComposer, - algod_client: "AlgodClient", - allow_more_logs: bool | None = None, - allow_empty_signatures: bool | None = None, - allow_unnamed_resources: bool | None = None, - extra_opcode_budget: int | None = None, - exec_trace_config: SimulateTraceConfig | None = None, - simulation_round: int | None = None, -) -> SimulateAtomicTransactionResponse: - """Simulate atomic transaction group execution""" - - unsigned_txn_groups = atc.build_group() - empty_signer = EmptySigner() - txn_list = [txn_group.txn for txn_group in unsigned_txn_groups] - fake_signed_transactions = empty_signer.sign_transactions(txn_list, []) - txn_group = [SimulateRequestTransactionGroup(txns=fake_signed_transactions)] - trace_config = SimulateTraceConfig(enable=True, stack_change=True, scratch_change=True, state_change=True) - - simulate_request = SimulateRequest( - txn_groups=txn_group, - allow_more_logs=allow_more_logs if allow_more_logs is not None else True, - round=simulation_round, - extra_opcode_budget=extra_opcode_budget if extra_opcode_budget is not None else 0, - allow_unnamed_resources=allow_unnamed_resources if allow_unnamed_resources is not None else True, - allow_empty_signatures=allow_empty_signatures if allow_empty_signatures is not None else True, - exec_trace_config=exec_trace_config if exec_trace_config is not None else trace_config, - ) - - return atc.simulate(algod_client, simulate_request) - - -def simulate_and_persist_response( - atc: AtomicTransactionComposer, - project_root: Path, - algod_client: "AlgodClient", - buffer_size_mb: float = 256, - allow_more_logs: bool | None = None, - allow_empty_signatures: bool | None = None, - allow_unnamed_resources: bool | None = None, - extra_opcode_budget: int | None = None, - exec_trace_config: SimulateTraceConfig | None = None, - simulation_round: int | None = None, -) -> SimulateAtomicTransactionResponse: - """Simulates atomic transactions and persists simulation response to a JSON file. - - Simulates the atomic transactions using the provided AtomicTransactionComposer and AlgodClient, - then persists the simulation response to an AlgoKit AVM Debugger compliant JSON file. - - :param atc: AtomicTransactionComposer containing transactions to simulate and persist - :param project_root: Root directory path of the project - :param algod_client: Algorand client instance - :param buffer_size_mb: Size of trace buffer in megabytes, defaults to 256 - :param allow_more_logs: Flag to allow additional logs, defaults to None - :param allow_empty_signatures: Flag to allow empty signatures, defaults to None - :param allow_unnamed_resources: Flag to allow unnamed resources, defaults to None - :param extra_opcode_budget: Additional opcode budget, defaults to None - :param exec_trace_config: Execution trace configuration, defaults to None - :param simulation_round: Round number for simulation, defa ults to None - :return: Simulated response after persisting for AlgoKit AVM Debugger consumption - """ - atc_to_simulate = atc.clone() - sp = algod_client.suggested_params() - - for txn_with_sign in atc_to_simulate.txn_list: - txn_with_sign.txn.first_valid_round = sp.first - txn_with_sign.txn.last_valid_round = sp.last - txn_with_sign.txn.genesis_hash = sp.gh - - response = simulate_response( - atc_to_simulate, - algod_client, - allow_more_logs, - allow_empty_signatures, - allow_unnamed_resources, - extra_opcode_budget, - exec_trace_config, - simulation_round, - ) - txn_results = response.simulate_response["txn-groups"] - - txn_types = [ - txn["txn-result"]["txn"]["txn"]["type"] for txn_result in txn_results for txn in txn_result["txn-results"] - ] - txn_types_count = {} - for txn_type in txn_types: - if txn_type not in txn_types_count: - txn_types_count[txn_type] = txn_types.count(txn_type) - txn_types_str = "_".join([f"{count}{txn_type}" for txn_type, count in txn_types_count.items()]) - - last_round = response.simulate_response["last-round"] - timestamp = datetime.now(tz=timezone.utc).strftime("%Y%m%d_%H%M%S") - output_file = project_root / DEBUG_TRACES_DIR / f"{timestamp}_lr{last_round}_{txn_types_str}{TRACES_FILE_EXT}" - - output_file.parent.mkdir(parents=True, exist_ok=True) - cleanup_old_trace_files(output_file.parent, buffer_size_mb) - output_file.write_text(json.dumps(response.simulate_response, indent=2)) - return response diff --git a/src/algokit_utils/_legacy_v2/__init__.py b/src/algokit_utils/_legacy_v2/__init__.py deleted file mode 100644 index 25c8b08f..00000000 --- a/src/algokit_utils/_legacy_v2/__init__.py +++ /dev/null @@ -1,177 +0,0 @@ -"""AlgoKit Python Utilities (Legacy V2) - a set of utilities for building solutions on Algorand - -This module provides commonly used utilities and types at the root level for convenience. -For more specific functionality, import directly from the relevant submodules: - - from algokit_utils.accounts import KmdAccountManager - from algokit_utils.applications import AppClient - from algokit_utils.applications.app_spec import Arc52Contract - etc. -""" - -# Debugging utilities -from algokit_utils._legacy_v2._ensure_funded import ( - EnsureBalanceParameters, - EnsureFundedResponse, - ensure_funded, -) -from algokit_utils._legacy_v2._transfer import ( - TransferAssetParameters, - TransferParameters, - transfer, - transfer_asset, -) -from algokit_utils._legacy_v2.account import ( - create_kmd_wallet_account, - get_account, - get_account_from_mnemonic, - get_dispenser_account, - get_kmd_wallet_account, - get_localnet_default_account, - get_or_create_kmd_wallet_account, -) -from algokit_utils._legacy_v2.application_client import ( - ApplicationClient, - execute_atc_with_logic_error, - get_next_version, - get_sender_from_signer, - num_extra_program_pages, -) -from algokit_utils._legacy_v2.application_specification import ( - ApplicationSpecification, - AppSpecStateDict, - CallConfig, - DefaultArgumentDict, - DefaultArgumentType, - MethodConfigDict, - MethodHints, - OnCompleteActionName, -) -from algokit_utils._legacy_v2.asset import opt_in, opt_out -from algokit_utils._legacy_v2.common import Program -from algokit_utils._legacy_v2.deploy import ( - NOTE_PREFIX, - ABICallArgs, - ABICallArgsDict, - ABICreateCallArgs, - ABICreateCallArgsDict, - AppDeployMetaData, - AppLookup, - AppMetaData, - AppReference, - DeployCallArgs, - DeployCallArgsDict, - DeployCreateCallArgs, - DeployCreateCallArgsDict, - DeploymentFailedError, - DeployResponse, - TemplateValueDict, - TemplateValueMapping, - get_app_id_from_tx_id, - get_creator_apps, - replace_template_variables, -) -from algokit_utils._legacy_v2.models import ( - ABIArgsDict, - ABIMethod, - ABITransactionResponse, - Account, - CommonCallParameters, - CommonCallParametersDict, - CreateCallParameters, - CreateCallParametersDict, - CreateTransactionParameters, - OnCompleteCallParameters, - OnCompleteCallParametersDict, - TransactionParameters, - TransactionParametersDict, - TransactionResponse, -) -from algokit_utils._legacy_v2.network_clients import ( - AlgoClientConfig, - get_algod_client, - get_algonode_config, - get_default_localnet_config, - get_indexer_client, - get_kmd_client_from_algod_client, - is_localnet, - is_mainnet, - is_testnet, -) - -__all__ = [ - "NOTE_PREFIX", - "ABIArgsDict", - "ABICallArgs", - "ABICallArgsDict", - "ABICreateCallArgs", - "ABICreateCallArgsDict", - "ABIMethod", - "ABITransactionResponse", - "Account", - "AlgoClientConfig", - "AppDeployMetaData", - "AppLookup", - "AppMetaData", - "AppReference", - "AppSpecStateDict", - "ApplicationClient", - "ApplicationSpecification", - "CallConfig", - "CommonCallParameters", - "CommonCallParametersDict", - "CreateCallParameters", - "CreateCallParametersDict", - "CreateTransactionParameters", - "DefaultArgumentDict", - "DefaultArgumentType", - "DeployCallArgs", - "DeployCallArgsDict", - "DeployCreateCallArgs", - "DeployCreateCallArgsDict", - "DeployResponse", - "DeploymentFailedError", - "EnsureBalanceParameters", - "EnsureFundedResponse", - "MethodConfigDict", - "MethodHints", - "OnCompleteActionName", - "OnCompleteCallParameters", - "OnCompleteCallParametersDict", - "Program", - "TemplateValueDict", - "TemplateValueMapping", - "TransactionParameters", - "TransactionParametersDict", - "TransactionResponse", - "TransferAssetParameters", - "TransferParameters", - # Legacy v2 functions - "create_kmd_wallet_account", - "ensure_funded", - "execute_atc_with_logic_error", - "get_account", - "get_account_from_mnemonic", - "get_algod_client", - "get_algonode_config", - "get_app_id_from_tx_id", - "get_creator_apps", - "get_default_localnet_config", - "get_dispenser_account", - "get_indexer_client", - "get_kmd_client_from_algod_client", - "get_kmd_wallet_account", - "get_localnet_default_account", - "get_next_version", - "get_or_create_kmd_wallet_account", - "get_sender_from_signer", - "is_localnet", - "is_mainnet", - "is_testnet", - "num_extra_program_pages", - "opt_in", - "opt_out", - "replace_template_variables", - "transfer", - "transfer_asset", -] diff --git a/src/algokit_utils/_legacy_v2/_ensure_funded.py b/src/algokit_utils/_legacy_v2/_ensure_funded.py deleted file mode 100644 index 9fc0ff26..00000000 --- a/src/algokit_utils/_legacy_v2/_ensure_funded.py +++ /dev/null @@ -1,148 +0,0 @@ -from dataclasses import dataclass - -from algosdk.account import address_from_private_key -from algosdk.atomic_transaction_composer import AccountTransactionSigner -from algosdk.transaction import SuggestedParams -from algosdk.v2client.algod import AlgodClient -from typing_extensions import deprecated - -from algokit_utils._legacy_v2._transfer import TransferParameters, transfer -from algokit_utils._legacy_v2.account import get_dispenser_account -from algokit_utils._legacy_v2.models import Account -from algokit_utils._legacy_v2.network_clients import is_testnet -from algokit_utils.clients.dispenser_api_client import TestNetDispenserApiClient - - -@deprecated("Use `algorand.account.ensure_funded()` instead") -@dataclass(kw_only=True) -class EnsureBalanceParameters: - """Parameters for ensuring an account has a minimum number of µALGOs""" - - account_to_fund: Account | AccountTransactionSigner | str - """The account address that will receive the µALGOs""" - - min_spending_balance_micro_algos: int - """The minimum balance of ALGOs that the account should have available to spend (i.e. on top of - minimum balance requirement)""" - - min_funding_increment_micro_algos: int = 0 - """When issuing a funding amount, the minimum amount to transfer (avoids many small transfers if this gets - called often on an active account)""" - - funding_source: Account | AccountTransactionSigner | TestNetDispenserApiClient | None = None - """The account (with private key) or signer that will send the µALGOs, - will use `get_dispenser_account` by default. Alternatively you can pass an instance of [`TestNetDispenserApiClient`](https://github.com/algorandfoundation/algokit-utils-py/blob/main/docs/source/capabilities/dispenser-client.md) - which will allow you to interact with [AlgoKit TestNet Dispenser API](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/dispenser.md).""" - - suggested_params: SuggestedParams | None = None - """(optional) transaction parameters""" - - note: str | bytes | None = None - """The (optional) transaction note, default: "Funding account to meet minimum requirement""" - - fee_micro_algos: int | None = None - """(optional) The flat fee you want to pay, useful for covering extra fees in a transaction group or app call""" - - max_fee_micro_algos: int | None = None - """(optional)The maximum fee that you are happy to pay (default: unbounded) - - if this is set it's possible the transaction could get rejected during network congestion""" - - -@dataclass(kw_only=True) -class EnsureFundedResponse: - """Response for ensuring an account has a minimum number of µALGOs""" - - """The transaction ID of the funding transaction""" - transaction_id: str - """The amount of µALGOs that were funded""" - amount: int - - -def _get_address_to_fund(parameters: EnsureBalanceParameters) -> str: - if isinstance(parameters.account_to_fund, str): - return parameters.account_to_fund - else: - return str(address_from_private_key(parameters.account_to_fund.private_key)) - - -def _get_account_info(client: AlgodClient, address_to_fund: str) -> dict: - account_info = client.account_info(address_to_fund) - assert isinstance(account_info, dict) - return account_info - - -def _calculate_fund_amount( - parameters: EnsureBalanceParameters, current_spending_balance_micro_algos: int -) -> int | None: - if parameters.min_spending_balance_micro_algos > current_spending_balance_micro_algos: - min_fund_amount_micro_algos = parameters.min_spending_balance_micro_algos - current_spending_balance_micro_algos - return max(min_fund_amount_micro_algos, parameters.min_funding_increment_micro_algos) - else: - return None - - -def _fund_using_dispenser_api( - dispenser_client: TestNetDispenserApiClient, address_to_fund: str, fund_amount_micro_algos: int -) -> EnsureFundedResponse | None: - response = dispenser_client.fund(address=address_to_fund, amount=fund_amount_micro_algos) - - return EnsureFundedResponse(transaction_id=response.tx_id, amount=response.amount) - - -def _fund_using_transfer( - client: AlgodClient, parameters: EnsureBalanceParameters, address_to_fund: str, fund_amount_micro_algos: int -) -> EnsureFundedResponse: - if isinstance(parameters.funding_source, TestNetDispenserApiClient): - raise Exception(f"Invalid funding source: {parameters.funding_source}") - - funding_source = parameters.funding_source or get_dispenser_account(client) - response = transfer( - client, - TransferParameters( - from_account=funding_source, - to_address=address_to_fund, - micro_algos=fund_amount_micro_algos, - note=parameters.note or "Funding account to meet minimum requirement", - suggested_params=parameters.suggested_params, - max_fee_micro_algos=parameters.max_fee_micro_algos, - fee_micro_algos=parameters.fee_micro_algos, - ), - ) - transaction_id = response.get_txid() - return EnsureFundedResponse(transaction_id=transaction_id, amount=response.amt) - - -@deprecated( - "Use `algorand.account.ensure_funded()`, `algorand.account.ensure_funded_from_environment()`, " - "or `algorand.account.ensure_funded_from_testnet_dispenser_api()` instead" -) -def ensure_funded( - client: AlgodClient, - parameters: EnsureBalanceParameters, -) -> EnsureFundedResponse | None: - """ - Funds a given account using a funding source to ensure it has sufficient spendable ALGOs. - - Ensures the target account has enough ALGOs free to spend after accounting for ALGOs locked in minimum balance - requirements. See https://dev.algorand.co/concepts/smart-contracts/costs-constraints#mbr for details on minimum - balance requirements. - - :param client: An instance of the AlgodClient class from the AlgoSDK library - :param parameters: Parameters specifying the account to fund and minimum spending balance requirements - :return: If funds are needed, returns payment transaction details or dispenser API response. Returns None if no funding needed - """ - - address_to_fund = _get_address_to_fund(parameters) - account_info = _get_account_info(client, address_to_fund) - balance_micro_algos = account_info.get("amount", 0) - minimum_balance_micro_algos = account_info.get("min-balance", 0) - current_spending_balance_micro_algos = balance_micro_algos - minimum_balance_micro_algos - fund_amount_micro_algos = _calculate_fund_amount(parameters, current_spending_balance_micro_algos) - - if fund_amount_micro_algos is not None: - if is_testnet(client) and isinstance(parameters.funding_source, TestNetDispenserApiClient): - return _fund_using_dispenser_api(parameters.funding_source, address_to_fund, fund_amount_micro_algos) - else: - return _fund_using_transfer(client, parameters, address_to_fund, fund_amount_micro_algos) - - return None diff --git a/src/algokit_utils/_legacy_v2/_transfer.py b/src/algokit_utils/_legacy_v2/_transfer.py deleted file mode 100644 index f9ae2cbe..00000000 --- a/src/algokit_utils/_legacy_v2/_transfer.py +++ /dev/null @@ -1,155 +0,0 @@ -import dataclasses -import logging -from typing import TYPE_CHECKING - -import algosdk.transaction -from algosdk.account import address_from_private_key -from algosdk.atomic_transaction_composer import AccountTransactionSigner -from algosdk.transaction import AssetTransferTxn, PaymentTxn, SuggestedParams -from typing_extensions import deprecated - -from algokit_utils._legacy_v2.models import Account - -if TYPE_CHECKING: - from algosdk.v2client.algod import AlgodClient - -__all__ = ["TransferAssetParameters", "TransferParameters", "transfer", "transfer_asset"] -logger = logging.getLogger(__name__) - - -@dataclasses.dataclass(kw_only=True) -class TransferParametersBase: - """Parameters for transferring µALGOs between accounts. - - This class contains the base parameters needed for transferring µALGOs between Algorand accounts. - - :ivar from_account: The account (with private key) or signer that will send the µALGOs - :ivar to_address: The account address that will receive the µALGOs - :ivar suggested_params: Transaction parameters, defaults to None - :ivar note: Transaction note, defaults to None - :ivar fee_micro_algos: The flat fee you want to pay, useful for covering extra fees in a transaction group or app call, defaults to None - :ivar max_fee_micro_algos: The maximum fee that you are happy to pay - if this is set it's possible the transaction could get rejected during network congestion, defaults to None - """ - - from_account: Account | AccountTransactionSigner - to_address: str - suggested_params: SuggestedParams | None = None - note: str | bytes | None = None - fee_micro_algos: int | None = None - max_fee_micro_algos: int | None = None - - -@deprecated("Use `algorand.send.payment(...)` / `algorand.create_transaction.payment(...)` instead") -@dataclasses.dataclass(kw_only=True) -class TransferParameters(TransferParametersBase): - """Parameters for transferring µALGOs between accounts""" - - micro_algos: int - - -@deprecated("Use `algorand.send.asset_transfer(...)` / `algorand.create_transaction.asset_transfer(...)` instead") -@dataclasses.dataclass(kw_only=True) -class TransferAssetParameters(TransferParametersBase): - """Parameters for transferring assets between accounts. - - Defines the parameters needed to transfer Algorand Standard Assets (ASAs) between accounts. - - :param asset_id: The asset id that will be transferred - :param amount: The amount of the asset to send - :param clawback_from: An address of a target account from which to perform a clawback operation. Please note, in such cases senderAccount must be equal to clawback field on ASA metadata, defaults to None - """ - - asset_id: int - amount: int - clawback_from: str | None = None - - -def _check_fee(transaction: PaymentTxn | AssetTransferTxn, max_fee: int | None) -> None: - if max_fee is not None: - # Once a transaction has been constructed by algosdk, transaction.fee indicates what the total transaction fee - # Will be based on the current suggested fee-per-byte value. - if transaction.fee > max_fee: - raise Exception( - f"Cancelled transaction due to high network congestion fees. " - f"Algorand suggested fees would cause this transaction to cost {transaction.fee} µALGOs. " - f"Cap for this transaction is {max_fee} µALGOs." - ) - if transaction.fee > algosdk.constants.MIN_TXN_FEE: - logger.warning( - f"Algorand network congestion fees are in effect. " - f"This transaction will incur a fee of {transaction.fee} µALGOs." - ) - - -@deprecated("Use `algorand.send.payment(...)` / `algorand.create_transaction.payment(...)` instead") -def transfer(client: "AlgodClient", parameters: TransferParameters) -> PaymentTxn: - """Transfer µALGOs between accounts""" - - params = parameters - params.suggested_params = parameters.suggested_params or client.suggested_params() - from_account = params.from_account - sender = _get_address(from_account) - transaction = PaymentTxn( - sender=sender, - receiver=params.to_address, - amt=params.micro_algos, - note=params.note.encode("utf-8") if isinstance(params.note, str) else params.note, - sp=params.suggested_params, - ) - - result = _send_transaction(client=client, transaction=transaction, parameters=params) - assert isinstance(result, PaymentTxn) - return result - - -@deprecated("Use `algorand.send.asset_transfer(...)` / `algorand.create_transaction.asset_transfer(...)` instead") -def transfer_asset(client: "AlgodClient", parameters: TransferAssetParameters) -> AssetTransferTxn: - """Transfer assets between accounts""" - - params = parameters - params.suggested_params = parameters.suggested_params or client.suggested_params() - sender = _get_address(parameters.from_account) - suggested_params = parameters.suggested_params or client.suggested_params() - xfer_txn = AssetTransferTxn( - sp=suggested_params, - sender=sender, - receiver=params.to_address, - close_assets_to=None, - revocation_target=params.clawback_from, - amt=params.amount, - note=params.note, - index=params.asset_id, - rekey_to=None, - ) - - result = _send_transaction(client=client, transaction=xfer_txn, parameters=params) - assert isinstance(result, AssetTransferTxn) - return result - - -def _send_transaction( - client: "AlgodClient", - transaction: PaymentTxn | AssetTransferTxn, - parameters: TransferAssetParameters | TransferParameters, -) -> PaymentTxn | AssetTransferTxn: - if parameters.fee_micro_algos: - transaction.fee = parameters.fee_micro_algos - - if parameters.suggested_params is not None and not parameters.suggested_params.flat_fee: - _check_fee(transaction, parameters.max_fee_micro_algos) - - signed_transaction = transaction.sign(parameters.from_account.private_key) # type: ignore[no-untyped-call] - client.send_transaction(signed_transaction) - - txid = transaction.get_txid() # type: ignore[no-untyped-call] - logger.debug(f"Sent transaction {txid} type={transaction.type} from {_get_address(parameters.from_account)}") - - return transaction - - -def _get_address(account: Account | AccountTransactionSigner) -> str: - if type(account) is Account: - return account.address - else: - address = address_from_private_key(account.private_key) - return str(address) diff --git a/src/algokit_utils/_legacy_v2/account.py b/src/algokit_utils/_legacy_v2/account.py deleted file mode 100644 index ecf6691f..00000000 --- a/src/algokit_utils/_legacy_v2/account.py +++ /dev/null @@ -1,203 +0,0 @@ -import logging -import os -from typing import TYPE_CHECKING, Any - -from algosdk.account import address_from_private_key -from algosdk.mnemonic import from_private_key, to_private_key -from algosdk.util import algos_to_microalgos -from typing_extensions import deprecated - -from algokit_utils._legacy_v2._transfer import TransferParameters, transfer -from algokit_utils._legacy_v2.models import Account -from algokit_utils._legacy_v2.network_clients import get_kmd_client_from_algod_client, is_localnet - -if TYPE_CHECKING: - from collections.abc import Callable - - from algosdk.kmd import KMDClient - from algosdk.v2client.algod import AlgodClient - -__all__ = [ - "create_kmd_wallet_account", - "get_account", - "get_account_from_mnemonic", - "get_dispenser_account", - "get_kmd_wallet_account", - "get_localnet_default_account", - "get_or_create_kmd_wallet_account", -] - -logger = logging.getLogger(__name__) -_DEFAULT_ACCOUNT_MINIMUM_BALANCE = 1_000_000_000 - - -@deprecated( - "Use `algorand.account.from_mnemonic()` instead. Example: `account = algorand.account.from_mnemonic(mnemonic)`" -) -def get_account_from_mnemonic(mnemonic: str) -> Account: - """Convert a mnemonic (25 word passphrase) into an Account""" - private_key = to_private_key(mnemonic) - address = str(address_from_private_key(private_key)) - return Account(private_key=private_key, address=address) - - -@deprecated( - "Use `algorand.account.kmd.get_or_create_wallet_account(name, fund_with)` or `KMDAccountManager(clientManager).get_or_create_wallet_account(name, fund_with)` instead" -) -def create_kmd_wallet_account(kmd_client: "KMDClient", name: str) -> Account: - """Creates a wallet with specified name""" - wallet_id = kmd_client.create_wallet(name, "")["id"] - wallet_handle = kmd_client.init_wallet_handle(wallet_id, "") - kmd_client.generate_key(wallet_handle) - - key_ids: list[str] = kmd_client.list_keys(wallet_handle) - account_key = key_ids[0] - - private_account_key = kmd_client.export_key(wallet_handle, "", account_key) - return get_account_from_mnemonic(from_private_key(private_account_key)) - - -@deprecated( - "Use `algorand.account.kmd.get_or_create_wallet_account(name, fund_with)` or `KMDAccountManager(clientManager).get_or_create_wallet_account(name, fund_with)` instead" -) -def get_or_create_kmd_wallet_account( - client: "AlgodClient", name: str, fund_with_algos: float = 1000, kmd_client: "KMDClient | None" = None -) -> Account: - """Returns a wallet with specified name, or creates one if not found""" - kmd_client = kmd_client or get_kmd_client_from_algod_client(client) - account = get_kmd_wallet_account(client, kmd_client, name) - - if account: - account_info = client.account_info(account.address) - assert isinstance(account_info, dict) - if account_info["amount"] > 0: - return account - logger.debug(f"Found existing account in LocalNet with name '{name}', but no funds in the account.") - else: - account = create_kmd_wallet_account(kmd_client, name) - - logger.debug( - f"Couldn't find existing account in LocalNet with name '{name}'. " - f"So created account {account.address} with keys stored in KMD." - ) - - logger.debug(f"Funding account {account.address} with {fund_with_algos} ALGOs") - - if fund_with_algos: - transfer( - client, - TransferParameters( - from_account=get_dispenser_account(client), - to_address=account.address, - micro_algos=algos_to_microalgos(fund_with_algos), - ), - ) - - return account - - -def _is_default_account(account: dict[str, Any]) -> bool: - return bool(account["status"] != "Offline" and account["amount"] > _DEFAULT_ACCOUNT_MINIMUM_BALANCE) - - -@deprecated( - "Use `algorand.account.localnet_dispenser()` or `algorand.account.from_kmd('unencrypted-default-wallet', lambda a: a['status'] != 'Offline' and a['amount'] > 1_000_000_000)`" -) -def get_localnet_default_account(client: "AlgodClient") -> Account: - """Returns the default Account in a LocalNet instance""" - if not is_localnet(client): - raise Exception("Can't get a default account from non LocalNet network") - - account = get_kmd_wallet_account( - client, get_kmd_client_from_algod_client(client), "unencrypted-default-wallet", _is_default_account - ) - assert account - return account - - -@deprecated( - "Use `algorand.account.dispenser_from_environment()` or `algorand.account.localnet_dispenser()` instead. " - "Example: `dispenser = algorand.account.dispenser_from_environment()`" -) -def get_dispenser_account(client: "AlgodClient") -> Account: - """Returns an Account based on DISPENSER_MNENOMIC environment variable or the default account on LocalNet""" - if is_localnet(client): - return get_localnet_default_account(client) - return get_account(client, "DISPENSER") - - -@deprecated( - "Use `algorand.account.from_kmd()` instead. Example: `account = algorand.account.from_kmd(name, predicate)`" -) -def get_kmd_wallet_account( - client: "AlgodClient", - kmd_client: "KMDClient", - name: str, - predicate: "Callable[[dict[str, Any]], bool] | None" = None, -) -> Account | None: - """Returns wallet matching specified name and predicate or None if not found""" - wallets: list[dict] = kmd_client.list_wallets() - - wallet = next((w for w in wallets if w["name"] == name), None) - if wallet is None: - return None - - wallet_id = wallet["id"] - wallet_handle = kmd_client.init_wallet_handle(wallet_id, "") - key_ids: list[str] = kmd_client.list_keys(wallet_handle) - matched_account_key = None - if predicate: - for key in key_ids: - account = client.account_info(key) - assert isinstance(account, dict) - if predicate(account): - matched_account_key = key - else: - matched_account_key = next(key_ids.__iter__(), None) - - if not matched_account_key: - return None - - private_account_key = kmd_client.export_key(wallet_handle, "", matched_account_key) - return get_account_from_mnemonic(from_private_key(private_account_key)) - - -@deprecated( - "Use `algorand.account.from_environment()` or `algorand.account.from_kmd()` or `algorand.account.random()` instead. " - "Example: " - "`account = algorand.account.from_environment('ACCOUNT', AlgoAmount.from_algo(1000))`" -) -def get_account( - client: "AlgodClient", name: str, fund_with_algos: float = 1000, kmd_client: "KMDClient | None" = None -) -> Account: - """Returns an Algorand account with private key loaded by convention based on the given name identifier. - Returns an Algorand account with private key loaded by convention based on the given name identifier. - - For non-LocalNet environments, loads the mnemonic secret from environment variable {name}_MNEMONIC. - For LocalNet environments, loads or creates an account from a KMD wallet named {name}. - - :example: - >>> # If you have a mnemonic secret loaded into `os.environ["ACCOUNT_MNEMONIC"]` then you can call: - >>> account = get_account('ACCOUNT', algod) - >>> # If that code runs against LocalNet then a wallet called 'ACCOUNT' will automatically be created - >>> # with an account that is automatically funded with 1000 (default) ALGOs from the default LocalNet dispenser. - - :param client: The Algorand client to use - :param name: The name identifier to use for loading/creating the account - :param fund_with_algos: Amount of Algos to fund new LocalNet accounts with, defaults to 1000 - :param kmd_client: Optional KMD client to use for LocalNet wallet operations - :raises Exception: If required environment variable is missing in non-LocalNet environment - :return: An Account object with loaded private key - """ - - mnemonic_key = f"{name.upper()}_MNEMONIC" - mnemonic = os.getenv(mnemonic_key) - if mnemonic: - return get_account_from_mnemonic(mnemonic) - - if is_localnet(client): - account = get_or_create_kmd_wallet_account(client, name, fund_with_algos, kmd_client) - os.environ[mnemonic_key] = from_private_key(account.private_key) - return account - - raise Exception(f"Missing environment variable '{mnemonic_key}' when looking for account '{name}'") diff --git a/src/algokit_utils/_legacy_v2/application_client.py b/src/algokit_utils/_legacy_v2/application_client.py deleted file mode 100644 index e0427c5d..00000000 --- a/src/algokit_utils/_legacy_v2/application_client.py +++ /dev/null @@ -1,1470 +0,0 @@ -from __future__ import annotations - -import base64 -import copy -import json -import logging -import re -import typing -from math import ceil -from pathlib import Path -from typing import Any, Literal, cast, overload - -import algosdk -from algosdk import transaction -from algosdk.abi import ABIType, Method, Returns -from algosdk.account import address_from_private_key -from algosdk.atomic_transaction_composer import ( - ABI_RETURN_HASH, - ABIResult, - AccountTransactionSigner, - AtomicTransactionComposer, - AtomicTransactionResponse, - LogicSigTransactionSigner, - MultisigTransactionSigner, - SimulateAtomicTransactionResponse, - TransactionSigner, - TransactionWithSigner, -) -from algosdk.constants import APP_PAGE_MAX_SIZE -from algosdk.logic import get_application_address -from algosdk.source_map import SourceMap -from typing_extensions import deprecated - -import algokit_utils._legacy_v2.application_specification as au_spec -import algokit_utils._legacy_v2.deploy as au_deploy -from algokit_utils._legacy_v2.common import Program -from algokit_utils._legacy_v2.logic_error import LogicError, parse_logic_error -from algokit_utils._legacy_v2.models import ( - ABIArgsDict, - ABIArgType, - ABIMethod, - ABITransactionResponse, - Account, - CreateCallParameters, - CreateCallParametersDict, - OnCompleteCallParameters, - OnCompleteCallParametersDict, - SimulationTrace, - TransactionParameters, - TransactionParametersDict, - TransactionResponse, -) -from algokit_utils.config import config - -if typing.TYPE_CHECKING: - from algosdk.v2client.algod import AlgodClient - from algosdk.v2client.indexer import IndexerClient - - -logger = logging.getLogger(__name__) - - -"""A dictionary `dict[str, Any]` representing ABI argument names and values""" - -__all__ = [ - "ApplicationClient", - "execute_atc_with_logic_error", - "get_next_version", - "get_sender_from_signer", - "num_extra_program_pages", -] - -"""Alias for {py:class}`pyteal.ABIReturnSubroutine`, {py:class}`algosdk.abi.method.Method` or a {py:class}`str` -representing an ABI method name or signature""" - - -@deprecated("Use 'algokit_utils.calculate_extra_program_pages' instead.") -def num_extra_program_pages(approval: bytes, clear: bytes) -> int: - """Calculate minimum number of extra_pages required for provided approval and clear programs""" - - return ceil(((len(approval) + len(clear)) - APP_PAGE_MAX_SIZE) / APP_PAGE_MAX_SIZE) - - -@deprecated( - "Use AppClient from algokit_utils.applications instead. Example:\n" - "```python\n" - "from algokit_utils import AlgorandClient\n" - "from algokit_utils.models.application import Arc56Contract\n" - "algorand_client = AlgorandClient.from_environment()\n" - "app_client = AppClient.from_network(app_spec=Arc56Contract.from_json(app_spec_json), " - "algorand=algorand_client, app_id=123)\n" - "```" -) -class ApplicationClient: - """A class that wraps an ARC-0032 app spec and provides high productivity methods to deploy and call the app - - ApplicationClient can be created with an app_id to interact with an existing application, alternatively - it can be created with a creator and indexer_client specified to find existing applications by name and creator. - - :param AlgodClient algod_client: AlgoSDK algod client - :param ApplicationSpecification | Path app_spec: An Application Specification or the path to one - :param int app_id: The app_id of an existing application, to instead find the application by creator and name - use the creator and indexer_client parameters - :param str | Account creator: The address or Account of the app creator to resolve the app_id - :param IndexerClient indexer_client: AlgoSDK indexer client, only required if deploying or finding app_id by - creator and app name - :param AppLookup existing_deployments: - :param TransactionSigner | Account signer: Account or signer to use to sign transactions, if not specified and - creator was passed as an Account will use that. - :param str sender: Address to use as the sender for all transactions, will use the address associated with the - signer if not specified. - :param TemplateValueMapping template_values: Values to use for TMPL_* template variables, dictionary keys should - *NOT* include the TMPL_ prefix - :param str | None app_name: Name of application to use when deploying, defaults to name defined on the - Application Specification - """ - - @overload - def __init__( - self, - algod_client: AlgodClient, - app_spec: au_spec.ApplicationSpecification | Path, - *, - app_id: int = 0, - signer: TransactionSigner | Account | None = None, - sender: str | None = None, - suggested_params: transaction.SuggestedParams | None = None, - template_values: au_deploy.TemplateValueMapping | None = None, - ): ... - - @overload - def __init__( - self, - algod_client: AlgodClient, - app_spec: au_spec.ApplicationSpecification | Path, - *, - creator: str | Account, - indexer_client: IndexerClient | None = None, - existing_deployments: au_deploy.AppLookup | None = None, - signer: TransactionSigner | Account | None = None, - sender: str | None = None, - suggested_params: transaction.SuggestedParams | None = None, - template_values: au_deploy.TemplateValueMapping | None = None, - app_name: str | None = None, - ): ... - - def __init__( # noqa: PLR0913 - self, - algod_client: AlgodClient, - app_spec: au_spec.ApplicationSpecification | Path, - *, - app_id: int = 0, - creator: str | Account | None = None, - indexer_client: IndexerClient | None = None, - existing_deployments: au_deploy.AppLookup | None = None, - signer: TransactionSigner | Account | None = None, - sender: str | None = None, - suggested_params: transaction.SuggestedParams | None = None, - template_values: au_deploy.TemplateValueMapping | None = None, - app_name: str | None = None, - ): - self.algod_client = algod_client - self.app_spec = ( - au_spec.ApplicationSpecification.from_json(app_spec.read_text()) if isinstance(app_spec, Path) else app_spec - ) - self._app_name = app_name - self._approval_program: Program | None = None - self._approval_source_map: SourceMap | None = None - self._clear_program: Program | None = None - - self.template_values: au_deploy.TemplateValueMapping = template_values or {} - self.existing_deployments = existing_deployments - self._indexer_client = indexer_client - if creator is not None: - if not self.existing_deployments and not self._indexer_client: - raise Exception( - "If using the creator parameter either existing_deployments or indexer_client must also be provided" - ) - self._creator: str | None = creator.address if isinstance(creator, Account) else creator - if self.existing_deployments and self.existing_deployments.creator != self._creator: - raise Exception( - "Attempt to create application client with invalid existing_deployments against" - f"a different creator ({self.existing_deployments.creator} instead of " - f"expected creator {self._creator}" - ) - self.app_id = 0 - else: - self.app_id = app_id - self._creator = None - - self.signer: TransactionSigner | None - if signer: - self.signer = ( - signer if isinstance(signer, TransactionSigner) else AccountTransactionSigner(signer.private_key) - ) - elif isinstance(creator, Account): - self.signer = AccountTransactionSigner(creator.private_key) - else: - self.signer = None - - self.sender = sender - self.suggested_params = suggested_params - - @property - def app_name(self) -> str: - return self._app_name or self.app_spec.contract.name - - @app_name.setter - def app_name(self, value: str) -> None: - self._app_name = value - - @property - def app_address(self) -> str: - return get_application_address(self.app_id) - - @property - def approval(self) -> Program | None: - return self._approval_program - - @property - def approval_source_map(self) -> SourceMap | None: - if self._approval_source_map: - return self._approval_source_map - if self._approval_program: - return self._approval_program.source_map - return None - - @approval_source_map.setter - def approval_source_map(self, value: SourceMap) -> None: - self._approval_source_map = value - - @property - def clear(self) -> Program | None: - return self._clear_program - - def prepare( - self, - signer: TransactionSigner | Account | None = None, - sender: str | None = None, - app_id: int | None = None, - template_values: au_deploy.TemplateValueDict | None = None, - ) -> ApplicationClient: - """Creates a copy of this ApplicationClient, using the new signer, sender and app_id values if provided. - Will also substitute provided template_values into the associated app_spec in the copy""" - new_client: ApplicationClient = copy.copy(self) - new_client._prepare(new_client, signer=signer, sender=sender, app_id=app_id, template_values=template_values) - return new_client - - def _prepare( - self, - target: ApplicationClient, - *, - signer: TransactionSigner | Account | None = None, - sender: str | None = None, - app_id: int | None = None, - template_values: au_deploy.TemplateValueDict | None = None, - ) -> None: - target.app_id = self.app_id if app_id is None else app_id - target.signer, target.sender = target.get_signer_sender( - AccountTransactionSigner(signer.private_key) if isinstance(signer, Account) else signer, sender - ) - target.template_values = {**self.template_values, **(template_values or {})} - - def deploy( # noqa: PLR0913 - self, - version: str | None = None, - *, - signer: TransactionSigner | None = None, - sender: str | None = None, - allow_update: bool | None = None, - allow_delete: bool | None = None, - on_update: au_deploy.OnUpdate = au_deploy.OnUpdate.Fail, - on_schema_break: au_deploy.OnSchemaBreak = au_deploy.OnSchemaBreak.Fail, - template_values: au_deploy.TemplateValueMapping | None = None, - create_args: au_deploy.ABICreateCallArgs - | au_deploy.ABICreateCallArgsDict - | au_deploy.DeployCreateCallArgs - | None = None, - update_args: au_deploy.ABICallArgs | au_deploy.ABICallArgsDict | au_deploy.DeployCallArgs | None = None, - delete_args: au_deploy.ABICallArgs | au_deploy.ABICallArgsDict | au_deploy.DeployCallArgs | None = None, - ) -> au_deploy.DeployResponse: - """Deploy an application and update client to reference it. - - Idempotently deploy (create, update/delete if changed) an app against the given name via the given creator - account, including deploy-time template placeholder substitutions. - To understand the architecture decisions behind this functionality please see - - - ```{note} - If there is a breaking state schema change to an existing app (and `on_schema_break` is set to - 'ReplaceApp' the existing app will be deleted and re-created. - ``` - - ```{note} - If there is an update (different TEAL code) to an existing app (and `on_update` is set to 'ReplaceApp') - the existing app will be deleted and re-created. - ``` - - :param str version: version to use when creating or updating app, if None version will be auto incremented - :param algosdk.atomic_transaction_composer.TransactionSigner signer: signer to use when deploying app - , if None uses self.signer - :param str sender: sender address to use when deploying app, if None uses self.sender - :param bool allow_delete: Used to set the `TMPL_DELETABLE` template variable to conditionally control if an app - can be deleted - :param bool allow_update: Used to set the `TMPL_UPDATABLE` template variable to conditionally control if an app - can be updated - :param OnUpdate on_update: Determines what action to take if an application update is required - :param OnSchemaBreak on_schema_break: Determines what action to take if an application schema requirements - has increased beyond the current allocation - :param dict[str, int|str|bytes] template_values: Values to use for `TMPL_*` template variables, dictionary keys - should *NOT* include the TMPL_ prefix - :param ABICreateCallArgs create_args: Arguments used when creating an application - :param ABICallArgs | ABICallArgsDict update_args: Arguments used when updating an application - :param ABICallArgs | ABICallArgsDict delete_args: Arguments used when deleting an application - :return DeployResponse: details action taken and relevant transactions - :raises DeploymentError: If the deployment failed - """ - # check inputs - if self.app_id: - raise au_deploy.DeploymentFailedError( - f"Attempt to deploy app which already has an app index of {self.app_id}" - ) - try: - resolved_signer, resolved_sender = self.resolve_signer_sender(signer, sender) - except ValueError as ex: - raise au_deploy.DeploymentFailedError(f"{ex}, unable to deploy app") from None - if not self._creator: - raise au_deploy.DeploymentFailedError("No creator provided, unable to deploy app") - if self._creator != resolved_sender: - raise au_deploy.DeploymentFailedError( - f"Attempt to deploy contract with a sender address {resolved_sender} that differs " - f"from the given creator address for this application client: {self._creator}" - ) - - # make a copy and prepare variables - template_values = {**self.template_values, **(template_values or {})} - au_deploy.add_deploy_template_variables(template_values, allow_update=allow_update, allow_delete=allow_delete) - - existing_app_metadata_or_reference = self._load_app_reference() - - self._approval_program, self._clear_program = substitute_template_and_compile( - self.algod_client, self.app_spec, template_values - ) - - if config.debug and config.project_root: - from algokit_utils._debugging import PersistSourceMapInput, persist_sourcemaps - - persist_sourcemaps( - sources=[ - PersistSourceMapInput( - compiled_teal=self._approval_program, app_name=self.app_name, file_name="approval.teal" - ), - PersistSourceMapInput( - compiled_teal=self._clear_program, app_name=self.app_name, file_name="clear.teal" - ), - ], - project_root=config.project_root, - client=self.algod_client, - with_sources=True, - ) - - deployer = au_deploy.Deployer( - app_client=self, - creator=self._creator, - signer=resolved_signer, - sender=resolved_sender, - new_app_metadata=self._get_app_deploy_metadata(version, allow_update, allow_delete), - existing_app_metadata_or_reference=existing_app_metadata_or_reference, - on_update=on_update, - on_schema_break=on_schema_break, - create_args=create_args, - update_args=update_args, - delete_args=delete_args, - ) - - return deployer.deploy() - - def compose_create( - self, - atc: AtomicTransactionComposer, - /, - call_abi_method: ABIMethod | bool | None = None, - transaction_parameters: CreateCallParameters | CreateCallParametersDict | None = None, - **abi_kwargs: ABIArgType, - ) -> None: - """Adds a signed transaction with application id == 0 and the schema and source of client's app_spec to atc""" - approval_program, clear_program = self._check_is_compiled() - transaction_parameters = _convert_transaction_parameters(transaction_parameters) - - extra_pages = transaction_parameters.extra_pages or num_extra_program_pages( - approval_program.raw_binary, clear_program.raw_binary - ) - - self.add_method_call( - atc, - app_id=0, - abi_method=call_abi_method, - abi_args=abi_kwargs, - on_complete=transaction_parameters.on_complete or transaction.OnComplete.NoOpOC, - call_config=au_spec.CallConfig.CREATE, - parameters=transaction_parameters, - approval_program=approval_program.raw_binary, - clear_program=clear_program.raw_binary, - global_schema=self.app_spec.global_state_schema, - local_schema=self.app_spec.local_state_schema, - extra_pages=extra_pages, - ) - - @overload - def create( - self, - call_abi_method: Literal[False], - transaction_parameters: CreateCallParameters | CreateCallParametersDict | None = ..., - ) -> TransactionResponse: ... - - @overload - def create( - self, - call_abi_method: ABIMethod | Literal[True], - transaction_parameters: CreateCallParameters | CreateCallParametersDict | None = ..., - **abi_kwargs: ABIArgType, - ) -> ABITransactionResponse: ... - - @overload - def create( - self, - call_abi_method: ABIMethod | bool | None = ..., - transaction_parameters: CreateCallParameters | CreateCallParametersDict | None = ..., - **abi_kwargs: ABIArgType, - ) -> TransactionResponse | ABITransactionResponse: ... - - def create( - self, - call_abi_method: ABIMethod | bool | None = None, - transaction_parameters: CreateCallParameters | CreateCallParametersDict | None = None, - **abi_kwargs: ABIArgType, - ) -> TransactionResponse | ABITransactionResponse: - """Submits a signed transaction with application id == 0 and the schema and source of client's app_spec""" - - atc = AtomicTransactionComposer() - - self.compose_create( - atc, - call_abi_method, - transaction_parameters, - **abi_kwargs, - ) - create_result = self._execute_atc_tr(atc) - self.app_id = au_deploy.get_app_id_from_tx_id(self.algod_client, create_result.tx_id) - return create_result - - def compose_update( - self, - atc: AtomicTransactionComposer, - /, - call_abi_method: ABIMethod | bool | None = None, - transaction_parameters: TransactionParameters | TransactionParametersDict | None = None, - **abi_kwargs: ABIArgType, - ) -> None: - """Adds a signed transaction with on_complete=UpdateApplication to atc""" - approval_program, clear_program = self._check_is_compiled() - - self.add_method_call( - atc=atc, - abi_method=call_abi_method, - abi_args=abi_kwargs, - parameters=transaction_parameters, - on_complete=transaction.OnComplete.UpdateApplicationOC, - approval_program=approval_program.raw_binary, - clear_program=clear_program.raw_binary, - ) - - @overload - def update( - self, - call_abi_method: ABIMethod | Literal[True], - transaction_parameters: TransactionParameters | TransactionParametersDict | None = ..., - **abi_kwargs: ABIArgType, - ) -> ABITransactionResponse: ... - - @overload - def update( - self, - call_abi_method: Literal[False], - transaction_parameters: TransactionParameters | TransactionParametersDict | None = ..., - ) -> TransactionResponse: ... - - @overload - def update( - self, - call_abi_method: ABIMethod | bool | None = ..., - transaction_parameters: TransactionParameters | TransactionParametersDict | None = ..., - **abi_kwargs: ABIArgType, - ) -> TransactionResponse | ABITransactionResponse: ... - - def update( - self, - call_abi_method: ABIMethod | bool | None = None, - transaction_parameters: TransactionParameters | TransactionParametersDict | None = None, - **abi_kwargs: ABIArgType, - ) -> TransactionResponse | ABITransactionResponse: - """Submits a signed transaction with on_complete=UpdateApplication""" - - atc = AtomicTransactionComposer() - self.compose_update( - atc, - call_abi_method, - transaction_parameters=transaction_parameters, - **abi_kwargs, - ) - return self._execute_atc_tr(atc) - - def compose_delete( - self, - atc: AtomicTransactionComposer, - /, - call_abi_method: ABIMethod | bool | None = None, - transaction_parameters: TransactionParameters | TransactionParametersDict | None = None, - **abi_kwargs: ABIArgType, - ) -> None: - """Adds a signed transaction with on_complete=DeleteApplication to atc""" - - self.add_method_call( - atc, - call_abi_method, - abi_args=abi_kwargs, - parameters=transaction_parameters, - on_complete=transaction.OnComplete.DeleteApplicationOC, - ) - - @overload - def delete( - self, - call_abi_method: ABIMethod | Literal[True], - transaction_parameters: TransactionParameters | TransactionParametersDict | None = ..., - **abi_kwargs: ABIArgType, - ) -> ABITransactionResponse: ... - - @overload - def delete( - self, - call_abi_method: Literal[False], - transaction_parameters: TransactionParameters | TransactionParametersDict | None = ..., - ) -> TransactionResponse: ... - - @overload - def delete( - self, - call_abi_method: ABIMethod | bool | None = ..., - transaction_parameters: TransactionParameters | TransactionParametersDict | None = ..., - **abi_kwargs: ABIArgType, - ) -> TransactionResponse | ABITransactionResponse: ... - - def delete( - self, - call_abi_method: ABIMethod | bool | None = None, - transaction_parameters: TransactionParameters | TransactionParametersDict | None = None, - **abi_kwargs: ABIArgType, - ) -> TransactionResponse | ABITransactionResponse: - """Submits a signed transaction with on_complete=DeleteApplication""" - - atc = AtomicTransactionComposer() - self.compose_delete( - atc, - call_abi_method, - transaction_parameters=transaction_parameters, - **abi_kwargs, - ) - return self._execute_atc_tr(atc) - - def compose_call( - self, - atc: AtomicTransactionComposer, - /, - call_abi_method: ABIMethod | bool | None = None, - transaction_parameters: OnCompleteCallParameters | OnCompleteCallParametersDict | None = None, - **abi_kwargs: ABIArgType, - ) -> None: - """Adds a signed transaction with specified parameters to atc""" - _parameters = _convert_transaction_parameters(transaction_parameters) - self.add_method_call( - atc, - abi_method=call_abi_method, - abi_args=abi_kwargs, - parameters=_parameters, - on_complete=_parameters.on_complete or transaction.OnComplete.NoOpOC, - ) - - @overload - def call( - self, - call_abi_method: ABIMethod | Literal[True], - transaction_parameters: OnCompleteCallParameters | OnCompleteCallParametersDict | None = ..., - **abi_kwargs: ABIArgType, - ) -> ABITransactionResponse: ... - - @overload - def call( - self, - call_abi_method: Literal[False], - transaction_parameters: OnCompleteCallParameters | OnCompleteCallParametersDict | None = ..., - ) -> TransactionResponse: ... - - @overload - def call( - self, - call_abi_method: ABIMethod | bool | None = ..., - transaction_parameters: OnCompleteCallParameters | OnCompleteCallParametersDict | None = ..., - **abi_kwargs: ABIArgType, - ) -> TransactionResponse | ABITransactionResponse: ... - - def call( - self, - call_abi_method: ABIMethod | bool | None = None, - transaction_parameters: OnCompleteCallParameters | OnCompleteCallParametersDict | None = None, - **abi_kwargs: ABIArgType, - ) -> TransactionResponse | ABITransactionResponse: - """Submits a signed transaction with specified parameters""" - atc = AtomicTransactionComposer() - _parameters = _convert_transaction_parameters(transaction_parameters) - self.compose_call( - atc, - call_abi_method=call_abi_method, - transaction_parameters=_parameters, - **abi_kwargs, - ) - - method = self._resolve_method( - call_abi_method, abi_kwargs, _parameters.on_complete or transaction.OnComplete.NoOpOC - ) - if method: - hints = self._method_hints(method) - if hints and hints.read_only: - if config.debug and config.project_root and config.trace_all: - from algokit_utils._debugging import simulate_and_persist_response - - simulate_and_persist_response( - atc, config.project_root, self.algod_client, config.trace_buffer_size_mb - ) - - return self._simulate_readonly_call(method, atc) - - return self._execute_atc_tr(atc) - - def compose_opt_in( - self, - atc: AtomicTransactionComposer, - /, - call_abi_method: ABIMethod | bool | None = None, - transaction_parameters: TransactionParameters | TransactionParametersDict | None = None, - **abi_kwargs: ABIArgType, - ) -> None: - """Adds a signed transaction with on_complete=OptIn to atc""" - self.add_method_call( - atc, - abi_method=call_abi_method, - abi_args=abi_kwargs, - parameters=transaction_parameters, - on_complete=transaction.OnComplete.OptInOC, - ) - - @overload - def opt_in( - self, - call_abi_method: ABIMethod | Literal[True] = ..., - transaction_parameters: TransactionParameters | TransactionParametersDict | None = None, - **abi_kwargs: ABIArgType, - ) -> ABITransactionResponse: ... - - @overload - def opt_in( - self, - call_abi_method: Literal[False] = ..., - transaction_parameters: TransactionParameters | TransactionParametersDict | None = None, - ) -> TransactionResponse: ... - - @overload - def opt_in( - self, - call_abi_method: ABIMethod | bool | None = ..., - transaction_parameters: TransactionParameters | TransactionParametersDict | None = ..., - **abi_kwargs: ABIArgType, - ) -> TransactionResponse | ABITransactionResponse: ... - - def opt_in( - self, - call_abi_method: ABIMethod | bool | None = None, - transaction_parameters: TransactionParameters | TransactionParametersDict | None = None, - **abi_kwargs: ABIArgType, - ) -> TransactionResponse | ABITransactionResponse: - """Submits a signed transaction with on_complete=OptIn""" - atc = AtomicTransactionComposer() - self.compose_opt_in( - atc, - call_abi_method=call_abi_method, - transaction_parameters=transaction_parameters, - **abi_kwargs, - ) - return self._execute_atc_tr(atc) - - def compose_close_out( - self, - atc: AtomicTransactionComposer, - /, - call_abi_method: ABIMethod | bool | None = None, - transaction_parameters: TransactionParameters | TransactionParametersDict | None = None, - **abi_kwargs: ABIArgType, - ) -> None: - """Adds a signed transaction with on_complete=CloseOut to ac""" - self.add_method_call( - atc, - abi_method=call_abi_method, - abi_args=abi_kwargs, - parameters=transaction_parameters, - on_complete=transaction.OnComplete.CloseOutOC, - ) - - @overload - def close_out( - self, - call_abi_method: ABIMethod | Literal[True], - transaction_parameters: TransactionParameters | TransactionParametersDict | None = ..., - **abi_kwargs: ABIArgType, - ) -> ABITransactionResponse: ... - - @overload - def close_out( - self, - call_abi_method: Literal[False], - transaction_parameters: TransactionParameters | TransactionParametersDict | None = ..., - ) -> TransactionResponse: ... - - @overload - def close_out( - self, - call_abi_method: ABIMethod | bool | None = ..., - transaction_parameters: TransactionParameters | TransactionParametersDict | None = ..., - **abi_kwargs: ABIArgType, - ) -> TransactionResponse | ABITransactionResponse: ... - - def close_out( - self, - call_abi_method: ABIMethod | bool | None = None, - transaction_parameters: TransactionParameters | TransactionParametersDict | None = None, - **abi_kwargs: ABIArgType, - ) -> TransactionResponse | ABITransactionResponse: - """Submits a signed transaction with on_complete=CloseOut""" - atc = AtomicTransactionComposer() - self.compose_close_out( - atc, - call_abi_method=call_abi_method, - transaction_parameters=transaction_parameters, - **abi_kwargs, - ) - return self._execute_atc_tr(atc) - - def compose_clear_state( - self, - atc: AtomicTransactionComposer, - /, - transaction_parameters: TransactionParameters | TransactionParametersDict | None = None, - app_args: list[bytes] | None = None, - ) -> None: - """Adds a signed transaction with on_complete=ClearState to atc""" - return self.add_method_call( - atc, - parameters=transaction_parameters, - on_complete=transaction.OnComplete.ClearStateOC, - app_args=app_args, - ) - - def clear_state( - self, - transaction_parameters: TransactionParameters | TransactionParametersDict | None = None, - app_args: list[bytes] | None = None, - ) -> TransactionResponse: - """Submits a signed transaction with on_complete=ClearState""" - atc = AtomicTransactionComposer() - self.compose_clear_state( - atc, - transaction_parameters=transaction_parameters, - app_args=app_args, - ) - return self._execute_atc_tr(atc) - - def get_global_state(self, *, raw: bool = False) -> dict[bytes | str, bytes | str | int]: - """Gets the global state info associated with app_id""" - global_state = self.algod_client.application_info(self.app_id) - assert isinstance(global_state, dict) - return cast( - dict[bytes | str, bytes | str | int], - _decode_state(global_state.get("params", {}).get("global-state", {}), raw=raw), - ) - - def get_local_state(self, account: str | None = None, *, raw: bool = False) -> dict[bytes | str, bytes | str | int]: - """Gets the local state info for associated app_id and account/sender""" - - if account is None: - _, account = self.resolve_signer_sender(self.signer, self.sender) - - acct_state = self.algod_client.account_application_info(account, self.app_id) - assert isinstance(acct_state, dict) - return cast( - dict[bytes | str, bytes | str | int], - _decode_state(acct_state.get("app-local-state", {}).get("key-value", {}), raw=raw), - ) - - def resolve(self, to_resolve: au_spec.DefaultArgumentDict) -> int | str | bytes: - """Resolves the default value for an ABI method, based on app_spec""" - - def _data_check(value: object) -> int | str | bytes: - if isinstance(value, int | str | bytes): - return value - raise ValueError(f"Unexpected type for constant data: {value}") - - match to_resolve: - case {"source": "constant", "data": data}: - return _data_check(data) - case {"source": "global-state", "data": str() as key}: - global_state = self.get_global_state(raw=True) - return global_state[key.encode()] - case {"source": "local-state", "data": str() as key}: - _, sender = self.resolve_signer_sender(self.signer, self.sender) - acct_state = self.get_local_state(sender, raw=True) - return acct_state[key.encode()] - case {"source": "abi-method", "data": dict() as method_dict}: - method = Method.undictify(method_dict) - response = self.call(method) - assert isinstance(response, ABITransactionResponse) - return _data_check(response.return_value) - - case {"source": source}: - raise ValueError(f"Unrecognized default argument source: {source}") - case _: - raise TypeError("Unable to interpret default argument specification") - - def _get_app_deploy_metadata( - self, version: str | None, allow_update: bool | None, allow_delete: bool | None - ) -> au_deploy.AppDeployMetaData: - updatable = ( - allow_update - if allow_update is not None - else au_deploy.get_deploy_control( - self.app_spec, au_deploy.UPDATABLE_TEMPLATE_NAME, transaction.OnComplete.UpdateApplicationOC - ) - ) - deletable = ( - allow_delete - if allow_delete is not None - else au_deploy.get_deploy_control( - self.app_spec, au_deploy.DELETABLE_TEMPLATE_NAME, transaction.OnComplete.DeleteApplicationOC - ) - ) - - app = self._load_app_reference() - - if version is None: - if app.app_id == 0: - version = "v1.0" - else: - assert isinstance(app, au_deploy.AppDeployMetaData) - version = get_next_version(app.version) - return au_deploy.AppDeployMetaData(self.app_name, version, updatable=updatable, deletable=deletable) - - def _check_is_compiled(self) -> tuple[Program, Program]: - if self._approval_program is None or self._clear_program is None: - self._approval_program, self._clear_program = substitute_template_and_compile( - self.algod_client, self.app_spec, self.template_values - ) - - if config.debug and config.project_root: - from algokit_utils._debugging import PersistSourceMapInput, persist_sourcemaps - - persist_sourcemaps( - sources=[ - PersistSourceMapInput( - compiled_teal=self._approval_program, app_name=self.app_name, file_name="approval.teal" - ), - PersistSourceMapInput( - compiled_teal=self._clear_program, app_name=self.app_name, file_name="clear.teal" - ), - ], - project_root=config.project_root, - client=self.algod_client, - with_sources=True, - ) - - return self._approval_program, self._clear_program - - def _simulate_readonly_call( - self, method: Method, atc: AtomicTransactionComposer - ) -> ABITransactionResponse | TransactionResponse: - from algokit_utils._debugging import simulate_response - - response = simulate_response(atc, self.algod_client) - traces = None - if config.debug: - traces = _create_simulate_traces(response) - if response.failure_message: - raise _try_convert_to_logic_error( - response.failure_message, - self.app_spec.approval_program, - self._get_approval_source_map, - traces, - ) or Exception(f"Simulate failed for readonly method {method.get_signature()}: {response.failure_message}") - - return TransactionResponse.from_atr(response) - - def _load_reference_and_check_app_id(self) -> None: - self._load_app_reference() - self._check_app_id() - - def _load_app_reference(self) -> au_deploy.AppReference | au_deploy.AppMetaData: - if not self.existing_deployments and self._creator: - assert self._indexer_client - self.existing_deployments = au_deploy.get_creator_apps(self._indexer_client, self._creator) - - if self.existing_deployments: - app = self.existing_deployments.apps.get(self.app_name) - if app: - if self.app_id == 0: - self.app_id = app.app_id - return app - - return au_deploy.AppReference(self.app_id, self.app_address) - - def _check_app_id(self) -> None: - if self.app_id == 0: - raise Exception( - "ApplicationClient is not associated with an app instance, to resolve either:\n" - "1.provide an app_id on construction OR\n" - "2.provide a creator address so an app can be searched for OR\n" - "3.create an app first using create or deploy methods" - ) - - def _resolve_method( - self, - abi_method: ABIMethod | bool | None, - args: ABIArgsDict | None, - on_complete: transaction.OnComplete, - call_config: au_spec.CallConfig = au_spec.CallConfig.CALL, - ) -> Method | None: - matches: list[Method | None] = [] - match abi_method: - case str() | Method(): # abi method specified - return self._resolve_abi_method(abi_method) - case bool() | None: # find abi method - has_bare_config = ( - call_config in au_deploy.get_call_config(self.app_spec.bare_call_config, on_complete) - or on_complete == transaction.OnComplete.ClearStateOC - ) - abi_methods = self._find_abi_methods(args, on_complete, call_config) - if abi_method is not False: - matches += abi_methods - if has_bare_config and abi_method is not True: - matches += [None] - case _: - return abi_method.method_spec() - - if len(matches) == 1: # exact match - return matches[0] - elif len(matches) > 1: # ambiguous match - signatures = ", ".join((m.get_signature() if isinstance(m, Method) else "bare") for m in matches) - raise Exception( - f"Could not find an exact method to use for {on_complete.name} with call_config of {call_config.name}, " - f"specify the exact method using abi_method and args parameters, considered: {signatures}" - ) - else: # no match - raise Exception( - f"Could not find any methods to use for {on_complete.name} with call_config of {call_config.name}" - ) - - def _get_approval_source_map(self) -> SourceMap | None: - if self.approval_source_map: - return self.approval_source_map - - try: - approval, _ = self._check_is_compiled() - except au_deploy.DeploymentFailedError: - return None - return approval.source_map - - def export_source_map(self) -> str | None: - """Export approval source map to JSON, can be later re-imported with `import_source_map`""" - source_map = self._get_approval_source_map() - if source_map: - return json.dumps( - { - "version": source_map.version, - "sources": source_map.sources, - "mappings": source_map.mappings, - } - ) - return None - - def import_source_map(self, source_map_json: str) -> None: - """Import approval source from JSON exported by `export_source_map`""" - source_map = json.loads(source_map_json) - self._approval_source_map = SourceMap(source_map) - - def add_method_call( # noqa: PLR0913 - self, - atc: AtomicTransactionComposer, - abi_method: ABIMethod | bool | None = None, - *, - abi_args: ABIArgsDict | None = None, - app_id: int | None = None, - parameters: TransactionParameters | TransactionParametersDict | None = None, - on_complete: transaction.OnComplete = transaction.OnComplete.NoOpOC, - local_schema: transaction.StateSchema | None = None, - global_schema: transaction.StateSchema | None = None, - approval_program: bytes | None = None, - clear_program: bytes | None = None, - extra_pages: int | None = None, - app_args: list[bytes] | None = None, - call_config: au_spec.CallConfig = au_spec.CallConfig.CALL, - ) -> None: - """Adds a transaction to the AtomicTransactionComposer passed""" - if app_id is None: - self._load_reference_and_check_app_id() - app_id = self.app_id - parameters = _convert_transaction_parameters(parameters) - method = self._resolve_method(abi_method, abi_args, on_complete, call_config) - sp = parameters.suggested_params or self.suggested_params or self.algod_client.suggested_params() - signer, sender = self.resolve_signer_sender(parameters.signer, parameters.sender) - if parameters.boxes is not None: - # TODO: algosdk actually does this, but it's type hints say otherwise... - encoded_boxes = [(id_, algosdk.encoding.encode_as_bytes(name)) for id_, name in parameters.boxes] - else: - encoded_boxes = None - - encoded_lease = parameters.lease.encode("utf-8") if isinstance(parameters.lease, str) else parameters.lease - - if not method: # not an abi method, treat as a regular call - if abi_args: - raise Exception(f"ABI arguments specified on a bare call: {', '.join(abi_args)}") - atc.add_transaction( - TransactionWithSigner( - txn=transaction.ApplicationCallTxn( - sender=sender, - sp=sp, - index=app_id, - on_complete=on_complete, - approval_program=approval_program, - clear_program=clear_program, - global_schema=global_schema, - local_schema=local_schema, - extra_pages=extra_pages, - accounts=parameters.accounts, - foreign_apps=parameters.foreign_apps, - foreign_assets=parameters.foreign_assets, - boxes=encoded_boxes, - note=parameters.note, - lease=encoded_lease, - rekey_to=parameters.rekey_to, - app_args=app_args, - ), - signer=signer, - ) - ) - return - # resolve ABI method args - args = self._get_abi_method_args(abi_args, method) - atc.add_method_call( - app_id, - method, - sender, - sp, - signer, - method_args=args, - on_complete=on_complete, - local_schema=local_schema, - global_schema=global_schema, - approval_program=approval_program, - clear_program=clear_program, - extra_pages=extra_pages or 0, - accounts=parameters.accounts, - foreign_apps=parameters.foreign_apps, - foreign_assets=parameters.foreign_assets, - boxes=encoded_boxes, - note=parameters.note.encode("utf-8") if isinstance(parameters.note, str) else parameters.note, - lease=encoded_lease, - rekey_to=parameters.rekey_to, - ) - - def _get_abi_method_args(self, abi_args: ABIArgsDict | None, method: Method) -> list: - args: list = [] - hints = self._method_hints(method) - # copy args so we don't mutate original - abi_args = dict(abi_args or {}) - for method_arg in method.args: - name = method_arg.name - if name in abi_args: - argument = abi_args.pop(name) - if isinstance(argument, dict): - if hints.structs is None or name not in hints.structs: - raise Exception(f"Argument missing struct hint: {name}. Check argument name and type") - - elements = hints.structs[name]["elements"] - - argument_tuple = tuple(argument[field_name] for field_name, field_type in elements) - args.append(argument_tuple) - else: - args.append(argument) - - elif hints.default_arguments is not None and name in hints.default_arguments: - default_arg = hints.default_arguments[name] - if default_arg is not None: - args.append(self.resolve(default_arg)) - else: - raise Exception(f"Unspecified argument: {name}") - if abi_args: - raise Exception(f"Unused arguments specified: {', '.join(abi_args)}") - return args - - def _method_matches( - self, - method: Method, - args: ABIArgsDict | None, - on_complete: transaction.OnComplete, - call_config: au_spec.CallConfig, - ) -> bool: - hints = self._method_hints(method) - if call_config not in au_deploy.get_call_config(hints.call_config, on_complete): - return False - method_args = {m.name for m in method.args} - provided_args = set(args or {}) | set(hints.default_arguments) - - # TODO: also match on types? - return method_args == provided_args - - def _find_abi_methods( - self, args: ABIArgsDict | None, on_complete: transaction.OnComplete, call_config: au_spec.CallConfig - ) -> list[Method]: - return [ - method - for method in self.app_spec.contract.methods - if self._method_matches(method, args, on_complete, call_config) - ] - - def _resolve_abi_method(self, method: ABIMethod) -> Method: - if isinstance(method, str): - try: - return next(iter(m for m in self.app_spec.contract.methods if m.get_signature() == method)) - except StopIteration: - pass - return self.app_spec.contract.get_method_by_name(method) - elif hasattr(method, "method_spec"): - return method.method_spec() - else: - return method - - def _method_hints(self, method: Method) -> au_spec.MethodHints: - sig = method.get_signature() - if sig not in self.app_spec.hints: - return au_spec.MethodHints() - return self.app_spec.hints[sig] - - def _execute_atc_tr(self, atc: AtomicTransactionComposer) -> TransactionResponse: - result = self.execute_atc(atc) - return TransactionResponse.from_atr(result) - - def execute_atc(self, atc: AtomicTransactionComposer) -> AtomicTransactionResponse: - return execute_atc_with_logic_error( - atc, - self.algod_client, - approval_program=self.app_spec.approval_program, - approval_source_map=self._get_approval_source_map, - ) - - def get_signer_sender( - self, signer: TransactionSigner | None = None, sender: str | None = None - ) -> tuple[TransactionSigner | None, str | None]: - """Return signer and sender, using default values on client if not specified - - Will use provided values if given, otherwise will fall back to values defined on client. - If no sender is specified then will attempt to obtain sender from signer""" - resolved_signer = signer or self.signer - resolved_sender = sender or get_sender_from_signer(signer) or self.sender or get_sender_from_signer(self.signer) - return resolved_signer, resolved_sender - - def resolve_signer_sender( - self, signer: TransactionSigner | None = None, sender: str | None = None - ) -> tuple[TransactionSigner, str]: - """Return signer and sender, using default values on client if not specified - - Will use provided values if given, otherwise will fall back to values defined on client. - If no sender is specified then will attempt to obtain sender from signer - - :raises ValueError: Raised if a signer or sender is not provided. See `get_signer_sender` - for variant with no exception""" - resolved_signer, resolved_sender = self.get_signer_sender(signer, sender) - if not resolved_signer: - raise ValueError("No signer provided") - if not resolved_sender: - raise ValueError("No sender provided") - return resolved_signer, resolved_sender - - # TODO: remove private implementation, kept in the 1.0.2 release to not impact existing beaker 1.0 installs - _resolve_signer_sender = resolve_signer_sender - - -def substitute_template_and_compile( - algod_client: AlgodClient, - app_spec: au_spec.ApplicationSpecification, - template_values: au_deploy.TemplateValueMapping, -) -> tuple[Program, Program]: - """Substitutes the provided template_values into app_spec and compiles""" - template_values = dict(template_values or {}) - clear = au_deploy.replace_template_variables(app_spec.clear_program, template_values) - - au_deploy.check_template_variables(app_spec.approval_program, template_values) - approval = au_deploy.replace_template_variables(app_spec.approval_program, template_values) - - approval_app, clear_app = Program(approval, algod_client), Program(clear, algod_client) - - return approval_app, clear_app - - -def get_next_version(current_version: str) -> str: - """Calculates the next version from `current_version` - - Next version is calculated by finding a semver like - version string and incrementing the lower. This function is used by {py:meth}`ApplicationClient.deploy` when - a version is not specified, and is intended mostly for convenience during local development. - - :params str current_version: An existing version string with a semver like version contained within it, - some valid inputs and incremented outputs: - `1` -> `2` - `1.0` -> `1.1` - `v1.1` -> `v1.2` - `v1.1-beta1` -> `v1.2-beta1` - `v1.2.3.4567` -> `v1.2.3.4568` - `v1.2.3.4567-alpha` -> `v1.2.3.4568-alpha` - :raises DeploymentFailedError: If `current_version` cannot be parsed""" - pattern = re.compile(r"(?P\w*)(?P(?:\d+\.)*\d+)(?P\w*)") - match = pattern.match(current_version) - if match: - version = match.group("version") - new_version = _increment_version(version) - - def replacement(m: re.Match) -> str: - return f"{m.group('prefix')}{new_version}{m.group('suffix')}" - - return re.sub(pattern, replacement, current_version) - raise au_deploy.DeploymentFailedError( - f"Could not auto increment {current_version}, please specify the next version using the version parameter" - ) - - -def _try_convert_to_logic_error( - source_ex: Exception | str, - approval_program: str, - approval_source_map: SourceMap | typing.Callable[[], SourceMap | None] | None = None, - simulate_traces: list[SimulationTrace] | None = None, -) -> Exception | None: - source_ex_str = str(source_ex) - logic_error_data = parse_logic_error(source_ex_str) - if logic_error_data: - return LogicError( - logic_error_str=source_ex_str, - logic_error=source_ex if isinstance(source_ex, Exception) else None, - program=approval_program, - source_map=approval_source_map() if callable(approval_source_map) else approval_source_map, - **logic_error_data, - traces=simulate_traces, - ) - - return None - - -@deprecated( - "The execute_atc_with_logic_error function is deprecated; use AppClient's error handling and TransactionComposer's " - "send method for equivalent functionality and improved error management." -) -def execute_atc_with_logic_error( - atc: AtomicTransactionComposer, - algod_client: AlgodClient, - approval_program: str, - wait_rounds: int = 4, - approval_source_map: SourceMap | typing.Callable[[], SourceMap | None] | None = None, -) -> AtomicTransactionResponse: - """Calls {py:meth}`AtomicTransactionComposer.execute` on provided `atc`, but will parse any errors - and raise a {py:class}`LogicError` if possible - - ```{note} - `approval_program` and `approval_source_map` are required to be able to parse any errors into a - {py:class}`LogicError` - ``` - """ - from algokit_utils._debugging import simulate_and_persist_response, simulate_response - - try: - if config.debug and config.project_root and config.trace_all: - simulate_and_persist_response(atc, config.project_root, algod_client, config.trace_buffer_size_mb) - - return atc.execute(algod_client, wait_rounds=wait_rounds) - except Exception as ex: - if config.debug: - simulate = None - if config.project_root and not config.trace_all: - # if trace_all is enabled, we already have the traces executed above - # hence we only need to simulate if trace_all is disabled and - # project_root is set - simulate = simulate_and_persist_response( - atc, config.project_root, algod_client, config.trace_buffer_size_mb - ) - else: - simulate = simulate_response(atc, algod_client) - traces = _create_simulate_traces(simulate) - else: - traces = None - logger.info("An error occurred while executing the transaction.") - logger.info("To see more details, enable debug mode by setting config.debug = True ") - - logic_error = _try_convert_to_logic_error(ex, approval_program, approval_source_map, traces) - if logic_error: - raise logic_error from ex - raise ex - - -def _create_simulate_traces(simulate: SimulateAtomicTransactionResponse) -> list[SimulationTrace]: - traces = [] - if hasattr(simulate, "simulate_response") and hasattr(simulate, "failed_at") and simulate.failed_at: - for txn_group in simulate.simulate_response["txn-groups"]: - app_budget_added = txn_group.get("app-budget-added", None) - app_budget_consumed = txn_group.get("app-budget-consumed", None) - failure_message = txn_group.get("failure-message", None) - txn_result = txn_group.get("txn-results", [{}])[0] - exec_trace = txn_result.get("exec-trace", {}) - traces.append( - SimulationTrace( - app_budget_added=app_budget_added, - app_budget_consumed=app_budget_consumed, - failure_message=failure_message, - exec_trace=exec_trace, - ) - ) - return traces - - -def _convert_transaction_parameters( - args: TransactionParameters | TransactionParametersDict | None, -) -> CreateCallParameters: - _args = args.__dict__ if isinstance(args, TransactionParameters) else (args or {}) - return CreateCallParameters(**_args) - - -def get_sender_from_signer(signer: TransactionSigner | None) -> str | None: - """Returns the associated address of a signer, return None if no address found""" - - if isinstance(signer, AccountTransactionSigner): - sender = address_from_private_key(signer.private_key) - assert isinstance(sender, str) - return sender - elif isinstance(signer, MultisigTransactionSigner): - sender = signer.msig.address() - assert isinstance(sender, str) - return sender - elif isinstance(signer, LogicSigTransactionSigner): - return signer.lsig.address() - return None - - -# TEMPORARY, use SDK one when available -def _parse_result( - methods: dict[int, Method], - txns: list[dict[str, Any]], - txids: list[str], -) -> list[ABIResult]: - method_results = [] - for i, tx_info in enumerate(txns): - raw_value = b"" - return_value = None - decode_error = None - - if i not in methods: - continue - - # Parse log for ABI method return value - try: - if methods[i].returns.type == Returns.VOID: - method_results.append( - ABIResult( - tx_id=txids[i], - raw_value=raw_value, - return_value=return_value, - decode_error=decode_error, - tx_info=tx_info, - method=methods[i], - ) - ) - continue - - logs = tx_info.get("logs", []) - - # Look for the last returned value in the log - if not logs: - raise Exception("No logs") - - result = logs[-1] - # Check that the first four bytes is the hash of "return" - result_bytes = base64.b64decode(result) - if len(result_bytes) < len(ABI_RETURN_HASH) or result_bytes[: len(ABI_RETURN_HASH)] != ABI_RETURN_HASH: - raise Exception("no logs") - - raw_value = result_bytes[4:] - abi_return_type = methods[i].returns.type - if isinstance(abi_return_type, ABIType): - return_value = abi_return_type.decode(raw_value) - else: - return_value = raw_value - - except Exception as e: - decode_error = e - - method_results.append( - ABIResult( - tx_id=txids[i], - raw_value=raw_value, - return_value=return_value, - decode_error=decode_error, - tx_info=tx_info, - method=methods[i], - ) - ) - - return method_results - - -def _increment_version(version: str) -> str: - split = list(map(int, version.split("."))) - split[-1] = split[-1] + 1 - return ".".join(str(x) for x in split) - - -def _str_or_hex(v: bytes) -> str: - decoded: str - try: - decoded = v.decode("utf-8") - except UnicodeDecodeError: - decoded = v.hex() - - return decoded - - -def _decode_state(state: list[dict[str, Any]], *, raw: bool = False) -> dict[str | bytes, bytes | str | int | None]: - decoded_state: dict[str | bytes, bytes | str | int | None] = {} - - for state_value in state: - raw_key = base64.b64decode(state_value["key"]) - - key: str | bytes = raw_key if raw else _str_or_hex(raw_key) - val: str | bytes | int | None - - action = state_value["value"]["action"] if "action" in state_value["value"] else state_value["value"]["type"] - - match action: - case 1: - raw_val = base64.b64decode(state_value["value"]["bytes"]) - val = raw_val if raw else _str_or_hex(raw_val) - case 2: - val = state_value["value"]["uint"] - case 3: - val = None - case _: - raise NotImplementedError - - decoded_state[key] = val - return decoded_state diff --git a/src/algokit_utils/_legacy_v2/application_specification.py b/src/algokit_utils/_legacy_v2/application_specification.py deleted file mode 100644 index 93001f82..00000000 --- a/src/algokit_utils/_legacy_v2/application_specification.py +++ /dev/null @@ -1,21 +0,0 @@ -from algokit_utils.applications.app_spec.arc32 import ( - AppSpecStateDict, - CallConfig, - DefaultArgumentDict, - DefaultArgumentType, - MethodConfigDict, - MethodHints, - OnCompleteActionName, -) -from algokit_utils.applications.app_spec.arc32 import Arc32Contract as ApplicationSpecification - -__all__ = [ - "AppSpecStateDict", - "ApplicationSpecification", - "CallConfig", - "DefaultArgumentDict", - "DefaultArgumentType", - "MethodConfigDict", - "MethodHints", - "OnCompleteActionName", -] diff --git a/src/algokit_utils/_legacy_v2/asset.py b/src/algokit_utils/_legacy_v2/asset.py deleted file mode 100644 index fd9a8bcc..00000000 --- a/src/algokit_utils/_legacy_v2/asset.py +++ /dev/null @@ -1,168 +0,0 @@ -import logging -from enum import Enum, auto - -from algosdk.atomic_transaction_composer import AtomicTransactionComposer, TransactionWithSigner -from algosdk.constants import TX_GROUP_LIMIT -from algosdk.transaction import AssetTransferTxn -from algosdk.v2client.algod import AlgodClient -from typing_extensions import deprecated - -from algokit_utils._legacy_v2.models import Account - -__all__ = ["opt_in", "opt_out"] -logger = logging.getLogger(__name__) - - -class ValidationType(Enum): - OPTIN = auto() - OPTOUT = auto() - - -def _ensure_account_is_valid(algod_client: "AlgodClient", account: Account) -> None: - try: - algod_client.account_info(account.address) - except Exception as err: - error_message = f"Account address{account.address} does not exist" - logger.debug(error_message) - raise err - - -def _ensure_asset_balance_conditions( - algod_client: "AlgodClient", account: Account, asset_ids: list, validation_type: ValidationType -) -> None: - invalid_asset_ids = [] - account_info = algod_client.account_info(account.address) - account_assets = account_info.get("assets", []) # type: ignore # noqa: PGH003 - for asset_id in asset_ids: - asset_exists_in_account_info = any(asset["asset-id"] == asset_id for asset in account_assets) - if validation_type == ValidationType.OPTIN: - if asset_exists_in_account_info: - logger.debug(f"Asset {asset_id} is already opted in for account {account.address}") - invalid_asset_ids.append(asset_id) - - elif validation_type == ValidationType.OPTOUT: - if not account_assets or not asset_exists_in_account_info: - logger.debug(f"Account {account.address} does not have asset {asset_id}") - invalid_asset_ids.append(asset_id) - else: - asset_balance = next((asset["amount"] for asset in account_assets if asset["asset-id"] == asset_id), 0) - if asset_balance != 0: - logger.debug(f"Asset {asset_id} balance is not zero") - invalid_asset_ids.append(asset_id) - - if len(invalid_asset_ids) > 0: - action = "opted out" if validation_type == ValidationType.OPTOUT else "opted in" - condition_message = ( - "their amount is zero and that the account has" - if validation_type == ValidationType.OPTOUT - else "they are valid and that the account has not" - ) - - error_message = ( - f"Assets {invalid_asset_ids} cannot be {action}. Ensure that " - f"{condition_message} previously opted into them." - ) - raise ValueError(error_message) - - -@deprecated( - "Use TransactionComposer.add_asset_opt_in() or AlgorandClient.asset.bulk_opt_in() instead. " - "Example: composer.add_asset_opt_in(AssetOptInParams(sender=account.address, asset_id=123))" -) -def opt_in(algod_client: "AlgodClient", account: Account, asset_ids: list[int]) -> dict[int, str]: - """ - Opt-in to a list of assets on the Algorand blockchain. Before an account can receive a specific asset, - it must `opt-in` to receive it. An opt-in transaction places an asset holding of 0 into the account and increases - its minimum balance by [100,000 microAlgos](https://dev.algorand.co/concepts/assets/overview). - - :param algod_client: An instance of the AlgodClient class from the algosdk library. - :param account: An instance of the Account class representing the account that wants to opt-in to the assets. - :param asset_ids: A list of integers representing the asset IDs to opt-in to. - :return: A dictionary where the keys are the asset IDs and the values are the transaction IDs for opting-in to each asset. - :rtype: dict[int, str] - """ - _ensure_account_is_valid(algod_client, account) - _ensure_asset_balance_conditions(algod_client, account, asset_ids, ValidationType.OPTIN) - suggested_params = algod_client.suggested_params() - result = {} - for i in range(0, len(asset_ids), TX_GROUP_LIMIT): - atc = AtomicTransactionComposer() - chunk = asset_ids[i : i + TX_GROUP_LIMIT] - for asset_id in chunk: - asset = algod_client.asset_info(asset_id) - xfer_txn = AssetTransferTxn( - sp=suggested_params, - sender=account.address, - receiver=account.address, - close_assets_to=None, - revocation_target=None, - amt=0, - note=f"opt in asset id ${asset_id}", - index=asset["index"], # type: ignore # noqa: PGH003 - rekey_to=None, - ) - - transaction_with_signer = TransactionWithSigner( - txn=xfer_txn, - signer=account.signer, - ) - atc.add_transaction(transaction_with_signer) - atc.execute(algod_client, 4) - - for index, asset_id in enumerate(chunk): - result[asset_id] = atc.tx_ids[index] - - return result - - -@deprecated( - "Use TransactionComposer.add_asset_opt_out() or AlgorandClient.asset.bulk_opt_out() instead. " - "Example: composer.add_asset_opt_out(AssetOptOutParams(sender=account.address, asset_id=123, creator=creator_address))" -) -def opt_out(algod_client: "AlgodClient", account: Account, asset_ids: list[int]) -> dict[int, str]: - """ - Opt out from a list of Algorand Standard Assets (ASAs) by transferring them back to their creators. - The account also recovers the Minimum Balance Requirement for the asset (100,000 microAlgos) - The `optOut` function manages the opt-out process, permitting the account to discontinue holding a group of assets. - - It's essential to note that an account can only opt_out of an asset if its balance of that asset is zero. - - :param AlgodClient algod_client: An instance of the AlgodClient class from the algosdk library. - :param Account account: An instance of the Account class representing the account that wants to opt-out from the assets. - :param list[int] asset_ids: A list of integers representing the asset IDs to opt-out from. - :return dict[int, str]: A dictionary where the keys are the asset IDs and the values are the transaction IDs of - the executed transactions. - """ - _ensure_account_is_valid(algod_client, account) - _ensure_asset_balance_conditions(algod_client, account, asset_ids, ValidationType.OPTOUT) - suggested_params = algod_client.suggested_params() - result = {} - for i in range(0, len(asset_ids), TX_GROUP_LIMIT): - atc = AtomicTransactionComposer() - chunk = asset_ids[i : i + TX_GROUP_LIMIT] - for asset_id in chunk: - asset = algod_client.asset_info(asset_id) - asset_creator = asset["params"]["creator"] # type: ignore # noqa: PGH003 - xfer_txn = AssetTransferTxn( - sp=suggested_params, - sender=account.address, - receiver=account.address, - close_assets_to=asset_creator, - revocation_target=None, - amt=0, - note=f"opt out asset id ${asset_id}", - index=asset["index"], # type: ignore # noqa: PGH003 - rekey_to=None, - ) - - transaction_with_signer = TransactionWithSigner( - txn=xfer_txn, - signer=account.signer, - ) - atc.add_transaction(transaction_with_signer) - atc.execute(algod_client, 4) - - for index, asset_id in enumerate(chunk): - result[asset_id] = atc.tx_ids[index] - - return result diff --git a/src/algokit_utils/_legacy_v2/common.py b/src/algokit_utils/_legacy_v2/common.py deleted file mode 100644 index 65051a60..00000000 --- a/src/algokit_utils/_legacy_v2/common.py +++ /dev/null @@ -1,28 +0,0 @@ -""" -This module contains common classes and methods that are reused in more than one file. -""" - -import base64 -import typing - -from algosdk.source_map import SourceMap - -from algokit_utils._legacy_v2.deploy import strip_comments - -if typing.TYPE_CHECKING: - from algosdk.v2client.algod import AlgodClient - - -class Program: - """A compiled TEAL program - - :param program: The TEAL program source code - :param client: The AlgodClient instance to use for compiling the program - """ - - def __init__(self, program: str, client: "AlgodClient"): - self.teal = program - result: dict = client.compile(strip_comments(self.teal), source_map=True) - self.raw_binary = base64.b64decode(result["result"]) - self.binary_hash: str = result["hash"] - self.source_map = SourceMap(result["sourcemap"]) diff --git a/src/algokit_utils/_legacy_v2/deploy.py b/src/algokit_utils/_legacy_v2/deploy.py deleted file mode 100644 index 222e847a..00000000 --- a/src/algokit_utils/_legacy_v2/deploy.py +++ /dev/null @@ -1,821 +0,0 @@ -import base64 -import dataclasses -import json -import logging -import re -from collections.abc import Iterable, Mapping, Sequence -from typing import TYPE_CHECKING, TypeAlias, TypedDict - -import algosdk -from algosdk import transaction -from algosdk.atomic_transaction_composer import AtomicTransactionComposer, TransactionSigner -from algosdk.transaction import StateSchema -from typing_extensions import deprecated - -from algokit_utils._legacy_v2.application_specification import ( - ApplicationSpecification, - CallConfig, - MethodConfigDict, - OnCompleteActionName, -) -from algokit_utils._legacy_v2.models import ( - ABIArgsDict, - ABIMethod, - Account, - CreateCallParameters, - TransactionResponse, -) -from algokit_utils.applications.app_manager import AppManager -from algokit_utils.applications.enums import OnSchemaBreak, OnUpdate, OperationPerformed - -if TYPE_CHECKING: - from algosdk.v2client.algod import AlgodClient - from algosdk.v2client.indexer import IndexerClient - - from algokit_utils._legacy_v2.application_client import ApplicationClient - - -__all__ = [ - "DELETABLE_TEMPLATE_NAME", - "NOTE_PREFIX", - "UPDATABLE_TEMPLATE_NAME", - "ABICallArgs", - "ABICallArgsDict", - "ABICreateCallArgs", - "ABICreateCallArgsDict", - "AppDeployMetaData", - "AppLookup", - "AppMetaData", - "AppReference", - "DeployCallArgs", - "DeployCallArgsDict", - "DeployCreateCallArgs", - "DeployCreateCallArgsDict", - "DeployResponse", - "Deployer", - "DeploymentFailedError", - "OnSchemaBreak", - "OnUpdate", - "OperationPerformed", - "TemplateValueDict", - "TemplateValueMapping", - "get_app_id_from_tx_id", - "get_creator_apps", - "replace_template_variables", -] - -logger = logging.getLogger(__name__) - -DEFAULT_INDEXER_MAX_API_RESOURCES_PER_ACCOUNT = 1000 -_UPDATABLE = "UPDATABLE" -_DELETABLE = "DELETABLE" -UPDATABLE_TEMPLATE_NAME = f"TMPL_{_UPDATABLE}" -"""Template variable name used to control if a smart contract is updatable or not at deployment""" -DELETABLE_TEMPLATE_NAME = f"TMPL_{_DELETABLE}" -"""Template variable name used to control if a smart contract is deletable or not at deployment""" -_TOKEN_PATTERN = re.compile(r"TMPL_[A-Z_]+") -TemplateValue: TypeAlias = int | str | bytes -TemplateValueDict: TypeAlias = dict[str, TemplateValue] -"""Dictionary of `dict[str, int | str | bytes]` representing template variable names and values""" -TemplateValueMapping: TypeAlias = Mapping[str, TemplateValue] -"""Mapping of `str` to `int | str | bytes` representing template variable names and values""" - -NOTE_PREFIX = "ALGOKIT_DEPLOYER:j" -"""ARC-0002 compliant note prefix for algokit_utils deployed applications""" -# This prefix is also used to filter for parsable transaction notes in get_creator_apps. -# However, as the note is base64 encoded first we need to consider it's base64 representation. -# When base64 encoding bytes, 3 bytes are stored in every 4 characters. -# So then we don't need to worry about the padding/changing characters of the prefix if it was followed by -# additional characters, assert the NOTE_PREFIX length is a multiple of 3. -assert len(NOTE_PREFIX) % 3 == 0 - - -class DeploymentFailedError(Exception): - pass - - -@dataclasses.dataclass -class AppReference: - """Information about an Algorand app""" - - app_id: int - app_address: str - - -@dataclasses.dataclass -class AppDeployMetaData: - """Metadata about an application stored in a transaction note during creation. - - The note is serialized as JSON and prefixed with {py:data}`NOTE_PREFIX` and stored in the transaction note field - as part of {py:meth}`ApplicationClient.deploy` - """ - - name: str - version: str - deletable: bool | None - updatable: bool | None - - @staticmethod - def from_json(value: str) -> "AppDeployMetaData": - json_value: dict = json.loads(value) - json_value.setdefault("deletable", None) - json_value.setdefault("updatable", None) - return AppDeployMetaData(**json_value) - - @classmethod - def from_b64(cls: type["AppDeployMetaData"], b64: str) -> "AppDeployMetaData": - return cls.decode(base64.b64decode(b64)) - - @classmethod - def decode(cls: type["AppDeployMetaData"], value: bytes) -> "AppDeployMetaData": - note = value.decode("utf-8") - assert note.startswith(NOTE_PREFIX) - return cls.from_json(note[len(NOTE_PREFIX) :]) - - def encode(self) -> bytes: - json_str = json.dumps(self.__dict__) - return f"{NOTE_PREFIX}{json_str}".encode() - - -@dataclasses.dataclass -class AppMetaData(AppReference, AppDeployMetaData): - """Metadata about a deployed app""" - - created_round: int - updated_round: int - created_metadata: AppDeployMetaData - deleted: bool - - -@dataclasses.dataclass -class AppLookup: - """Cache of {py:class}`AppMetaData` for a specific `creator` - - Can be used as an argument to {py:class}`ApplicationClient` to reduce the number of calls when deploying multiple - apps or discovering multiple app_ids - """ - - creator: str - apps: dict[str, AppMetaData] = dataclasses.field(default_factory=dict) - - -def _sort_by_round(txn: dict) -> tuple[int, int]: - confirmed = txn["confirmed-round"] - offset = txn["intra-round-offset"] - return confirmed, offset - - -def _parse_note(metadata_b64: str | None) -> AppDeployMetaData | None: - if not metadata_b64: - return None - # noinspection PyBroadException - try: - return AppDeployMetaData.from_b64(metadata_b64) - except Exception: - return None - - -@deprecated("Use algorand.app_deployer.get_creator_apps_by_name() instead. ") -def get_creator_apps(indexer: "IndexerClient", creator_account: Account | str) -> AppLookup: - """Returns a mapping of Application names to {py:class}`AppMetaData` for all Applications created by specified - creator that have a transaction note containing {py:class}`AppDeployMetaData` - """ - apps: dict[str, AppMetaData] = {} - - creator_address = creator_account if isinstance(creator_account, str) else creator_account.address - token = None - # TODO: paginated indexer call instead of N + 1 calls - while True: - response = indexer.lookup_account_application_by_creator( - creator_address, limit=DEFAULT_INDEXER_MAX_API_RESOURCES_PER_ACCOUNT, next_page=token - ) - if "message" in response: # an error occurred - raise Exception(f"Error querying applications for {creator_address}: {response}") - for app in response["applications"]: - app_id = app["id"] - app_created_at_round = app["created-at-round"] - app_deleted = app.get("deleted", False) - search_transactions_response = indexer.search_transactions( - min_round=app_created_at_round, - txn_type="appl", - application_id=app_id, - address=creator_address, - address_role="sender", - note_prefix=NOTE_PREFIX.encode("utf-8"), - ) - transactions: list[dict] = search_transactions_response["transactions"] - if not transactions: - continue - - created_transaction = next( - t - for t in transactions - if t["application-transaction"]["application-id"] == 0 and t["sender"] == creator_address - ) - - transactions.sort(key=_sort_by_round, reverse=True) - latest_transaction = transactions[0] - app_updated_at_round = latest_transaction["confirmed-round"] - - create_metadata = _parse_note(created_transaction.get("note")) - update_metadata = _parse_note(latest_transaction.get("note")) - - if create_metadata and create_metadata.name: - apps[create_metadata.name] = AppMetaData( - app_id=app_id, - app_address=algosdk.logic.get_application_address(app_id), - created_metadata=create_metadata, - created_round=app_created_at_round, - **(update_metadata or create_metadata).__dict__, - updated_round=app_updated_at_round, - deleted=app_deleted, - ) - - token = response.get("next-token") - if not token: - break - - return AppLookup(creator_address, apps) - - -def _state_schema(schema: dict[str, int]) -> StateSchema: - return StateSchema(schema.get("num-uint", 0), schema.get("num-byte-slice", 0)) - - -def _describe_schema_breaks(prefix: str, from_schema: StateSchema, to_schema: StateSchema) -> Iterable[str]: - if to_schema.num_uints > from_schema.num_uints: - yield f"{prefix} uints increased from {from_schema.num_uints} to {to_schema.num_uints}" - if to_schema.num_byte_slices > from_schema.num_byte_slices: - yield f"{prefix} byte slices increased from {from_schema.num_byte_slices} to {to_schema.num_byte_slices}" - - -@dataclasses.dataclass(kw_only=True) -class AppChanges: - app_updated: bool - schema_breaking_change: bool - schema_change_description: str | None - - -@deprecated("The algokit_utils.AppDeployer now handles checking for app changes implicitly as part of `deploy` method") -def check_for_app_changes( - algod_client: "AlgodClient", - *, - new_approval: bytes, - new_clear: bytes, - new_global_schema: StateSchema, - new_local_schema: StateSchema, - app_id: int, -) -> AppChanges: - application_info = algod_client.application_info(app_id) - assert isinstance(application_info, dict) - application_create_params = application_info["params"] - - current_approval = base64.b64decode(application_create_params["approval-program"]) - current_clear = base64.b64decode(application_create_params["clear-state-program"]) - current_global_schema = _state_schema(application_create_params["global-state-schema"]) - current_local_schema = _state_schema(application_create_params["local-state-schema"]) - - app_updated = current_approval != new_approval or current_clear != new_clear - - schema_changes: list[str] = [] - schema_changes.extend(_describe_schema_breaks("Global", current_global_schema, new_global_schema)) - schema_changes.extend(_describe_schema_breaks("Local", current_local_schema, new_local_schema)) - - return AppChanges( - app_updated=app_updated, - schema_breaking_change=bool(schema_changes), - schema_change_description=", ".join(schema_changes), - ) - - -def _is_valid_token_character(char: str) -> bool: - return char.isalnum() or char == "_" - - -def add_deploy_template_variables( - template_values: TemplateValueDict, allow_update: bool | None, allow_delete: bool | None -) -> None: - if allow_update is not None: - template_values[_UPDATABLE] = int(allow_update) - if allow_delete is not None: - template_values[_DELETABLE] = int(allow_delete) - - -def _find_unquoted_string(line: str, token: str, start: int = 0, end: int = -1) -> int | None: - """Find the first string within a line of TEAL. Only matches outside of quotes and base64 are returned. - Returns None if not found""" - - if end < 0: - end = len(line) - idx = start - in_quotes = in_base64 = False - while idx < end: - current_char = line[idx] - match current_char: - # enter base64 - case " " | "(" if not in_quotes and _last_token_base64(line, idx): - in_base64 = True - # exit base64 - case " " | ")" if not in_quotes and in_base64: - in_base64 = False - # escaped char - case "\\" if in_quotes: - # skip next character - idx += 1 - # quote boundary - case '"': - in_quotes = not in_quotes - # can test for match - case _ if not in_quotes and not in_base64 and line.startswith(token, idx): - # only match if not in quotes and string matches - return idx - idx += 1 - return None - - -def _last_token_base64(line: str, idx: int) -> bool: - try: - *_, last = line[:idx].split() - except ValueError: - return False - return last in ("base64", "b64") - - -def _find_template_token(line: str, token: str, start: int = 0, end: int = -1) -> int | None: - """Find the first template token within a line of TEAL. Only matches outside of quotes are returned. - Only full token matches are returned, i.e. TMPL_STR will not match against TMPL_STRING - Returns None if not found""" - if end < 0: - end = len(line) - - idx = start - while idx < end: - token_idx = _find_unquoted_string(line, token, idx, end) - if token_idx is None: - break - trailing_idx = token_idx + len(token) - if (token_idx == 0 or not _is_valid_token_character(line[token_idx - 1])) and ( # word boundary at start - trailing_idx >= len(line) or not _is_valid_token_character(line[trailing_idx]) # word boundary at end - ): - return token_idx - idx = trailing_idx - return None - - -def _strip_comment(line: str) -> str: - comment_idx = _find_unquoted_string(line, "//") - if comment_idx is None: - return line - return line[:comment_idx].rstrip() - - -def strip_comments(program: str) -> str: - return "\n".join(_strip_comment(line) for line in program.splitlines()) - - -def _has_token(program_without_comments: str, token: str) -> bool: - for line in program_without_comments.splitlines(): - token_idx = _find_template_token(line, token) - if token_idx is not None: - return True - return False - - -def _find_tokens(stripped_approval_program: str) -> list[str]: - return _TOKEN_PATTERN.findall(stripped_approval_program) - - -def check_template_variables(approval_program: str, template_values: TemplateValueDict) -> None: - approval_program = strip_comments(approval_program) - if _has_token(approval_program, UPDATABLE_TEMPLATE_NAME) and _UPDATABLE not in template_values: - raise DeploymentFailedError( - "allow_update must be specified if deploy time configuration of update is being used" - ) - if _has_token(approval_program, DELETABLE_TEMPLATE_NAME) and _DELETABLE not in template_values: - raise DeploymentFailedError( - "allow_delete must be specified if deploy time configuration of delete is being used" - ) - all_tokens = _find_tokens(approval_program) - missing_values = [token for token in all_tokens if token[len("TMPL_") :] not in template_values] - if missing_values: - raise DeploymentFailedError(f"The following template values were not provided: {', '.join(missing_values)}") - - for template_variable_name in template_values: - tmpl_variable = f"TMPL_{template_variable_name}" - if not _has_token(approval_program, tmpl_variable): - if template_variable_name == _UPDATABLE: - raise DeploymentFailedError( - "allow_update must only be specified if deploy time configuration of update is being used" - ) - if template_variable_name == _DELETABLE: - raise DeploymentFailedError( - "allow_delete must only be specified if deploy time configuration of delete is being used" - ) - logger.warning(f"{tmpl_variable} not found in approval program, but variable was provided") - - -@deprecated("Use `AppManager.replace_template_variables` instead") -def replace_template_variables(program: str, template_values: TemplateValueMapping) -> str: - """Replaces `TMPL_*` variables in `program` with `template_values` - - ```{note} - `template_values` keys should *NOT* be prefixed with `TMPL_` - ``` - """ - return AppManager.replace_template_variables(program, template_values) - - -def has_template_vars(app_spec: ApplicationSpecification) -> bool: - return "TMPL_" in strip_comments(app_spec.approval_program) or "TMPL_" in strip_comments(app_spec.clear_program) - - -def get_deploy_control( - app_spec: ApplicationSpecification, template_var: str, on_complete: transaction.OnComplete -) -> bool | None: - if template_var not in strip_comments(app_spec.approval_program): - return None - return get_call_config(app_spec.bare_call_config, on_complete) != CallConfig.NEVER or any( - h for h in app_spec.hints.values() if get_call_config(h.call_config, on_complete) != CallConfig.NEVER - ) - - -def get_call_config(method_config: MethodConfigDict, on_complete: transaction.OnComplete) -> CallConfig: - def get(key: OnCompleteActionName) -> CallConfig: - return method_config.get(key, CallConfig.NEVER) - - match on_complete: - case transaction.OnComplete.NoOpOC: - return get("no_op") - case transaction.OnComplete.UpdateApplicationOC: - return get("update_application") - case transaction.OnComplete.DeleteApplicationOC: - return get("delete_application") - case transaction.OnComplete.OptInOC: - return get("opt_in") - case transaction.OnComplete.CloseOutOC: - return get("close_out") - case transaction.OnComplete.ClearStateOC: - return get("clear_state") - - -@dataclasses.dataclass(kw_only=True) -class DeployResponse: - """Describes the action taken during deployment, related transactions and the {py:class}`AppMetaData`""" - - app: AppMetaData - create_response: TransactionResponse | None = None - delete_response: TransactionResponse | None = None - update_response: TransactionResponse | None = None - action_taken: OperationPerformed = OperationPerformed.Nothing - - -@dataclasses.dataclass(kw_only=True) -class DeployCallArgs: - """Parameters used to update or delete an application when calling - {py:meth}`~algokit_utils.ApplicationClient.deploy`""" - - suggested_params: transaction.SuggestedParams | None = None - lease: bytes | str | None = None - accounts: list[str] | None = None - foreign_apps: list[int] | None = None - foreign_assets: list[int] | None = None - boxes: Sequence[tuple[int, bytes | bytearray | str | int]] | None = None - rekey_to: str | None = None - - -@dataclasses.dataclass(kw_only=True) -class ABICall: - method: ABIMethod | bool | None = None - args: ABIArgsDict = dataclasses.field(default_factory=dict) - - -@dataclasses.dataclass(kw_only=True) -class DeployCreateCallArgs(DeployCallArgs): - """Parameters used to create an application when calling {py:meth}`~algokit_utils.ApplicationClient.deploy`""" - - extra_pages: int | None = None - on_complete: transaction.OnComplete | None = None - - -@dataclasses.dataclass(kw_only=True) -class ABICallArgs(DeployCallArgs, ABICall): - """ABI Parameters used to update or delete an application when calling - {py:meth}`~algokit_utils.ApplicationClient.deploy`""" - - -@dataclasses.dataclass(kw_only=True) -class ABICreateCallArgs(DeployCreateCallArgs, ABICall): - """ABI Parameters used to create an application when calling {py:meth}`~algokit_utils.ApplicationClient.deploy`""" - - -class DeployCallArgsDict(TypedDict, total=False): - """Parameters used to update or delete an application when calling - {py:meth}`~algokit_utils.ApplicationClient.deploy`""" - - suggested_params: transaction.SuggestedParams - lease: bytes | str - accounts: list[str] - foreign_apps: list[int] - foreign_assets: list[int] - boxes: Sequence[tuple[int, bytes | bytearray | str | int]] - rekey_to: str - - -class ABICallArgsDict(DeployCallArgsDict, TypedDict, total=False): - """ABI Parameters used to update or delete an application when calling - {py:meth}`~algokit_utils.ApplicationClient.deploy`""" - - method: ABIMethod | bool - args: ABIArgsDict - - -class DeployCreateCallArgsDict(DeployCallArgsDict, TypedDict, total=False): - """Parameters used to create an application when calling {py:meth}`~algokit_utils.ApplicationClient.deploy`""" - - extra_pages: int | None - on_complete: transaction.OnComplete - - -class ABICreateCallArgsDict(DeployCreateCallArgsDict, TypedDict, total=False): - """ABI Parameters used to create an application when calling {py:meth}`~algokit_utils.ApplicationClient.deploy`""" - - method: ABIMethod | bool - args: ABIArgsDict - - -@dataclasses.dataclass(kw_only=True) -class Deployer: - app_client: "ApplicationClient" - creator: str - signer: TransactionSigner - sender: str - existing_app_metadata_or_reference: AppReference | AppMetaData - new_app_metadata: AppDeployMetaData - on_update: OnUpdate - on_schema_break: OnSchemaBreak - create_args: ABICreateCallArgs | ABICreateCallArgsDict | DeployCreateCallArgs | None - update_args: ABICallArgs | ABICallArgsDict | DeployCallArgs | None - delete_args: ABICallArgs | ABICallArgsDict | DeployCallArgs | None - - def deploy(self) -> DeployResponse: - """Ensures app associated with app client's creator is present and up to date""" - assert self.app_client.approval - assert self.app_client.clear - - if self.existing_app_metadata_or_reference.app_id == 0: - logger.info(f"{self.new_app_metadata.name} not found in {self.creator} account, deploying app.") - return self._create_app() - - assert isinstance(self.existing_app_metadata_or_reference, AppMetaData) - logger.debug( - f"{self.existing_app_metadata_or_reference.name} found in {self.creator} account, " - f"with app id {self.existing_app_metadata_or_reference.app_id}, " - f"version={self.existing_app_metadata_or_reference.version}." - ) - - app_changes = check_for_app_changes( - self.app_client.algod_client, - new_approval=self.app_client.approval.raw_binary, - new_clear=self.app_client.clear.raw_binary, - new_global_schema=self.app_client.app_spec.global_state_schema, - new_local_schema=self.app_client.app_spec.local_state_schema, - app_id=self.existing_app_metadata_or_reference.app_id, - ) - - if app_changes.schema_breaking_change: - logger.warning(f"Detected a breaking app schema change: {app_changes.schema_change_description}") - return self._deploy_breaking_change() - - if app_changes.app_updated: - logger.info(f"Detected a TEAL update in app id {self.existing_app_metadata_or_reference.app_id}") - return self._deploy_update() - - logger.info("No detected changes in app, nothing to do.") - return DeployResponse(app=self.existing_app_metadata_or_reference) - - def _deploy_breaking_change(self) -> DeployResponse: - assert isinstance(self.existing_app_metadata_or_reference, AppMetaData) - if self.on_schema_break == OnSchemaBreak.Fail: - raise DeploymentFailedError( - "Schema break detected and on_schema_break=OnSchemaBreak.Fail, stopping deployment. " - "If you want to try deleting and recreating the app then " - "re-run with on_schema_break=OnSchemaBreak.ReplaceApp" - ) - if self.on_schema_break == OnSchemaBreak.AppendApp: - logger.info("Schema break detected and on_schema_break=AppendApp, will attempt to create new app") - return self._create_app() - - if self.existing_app_metadata_or_reference.deletable: - logger.info( - "App is deletable and on_schema_break=ReplaceApp, will attempt to create new app and delete old app" - ) - elif self.existing_app_metadata_or_reference.deletable is False: - logger.warning( - "App is not deletable but on_schema_break=ReplaceApp, " - "will attempt to delete app, delete will most likely fail" - ) - else: - logger.warning( - "Cannot determine if App is deletable but on_schema_break=ReplaceApp, will attempt to delete app" - ) - return self._create_and_delete_app() - - def _deploy_update(self) -> DeployResponse: - assert isinstance(self.existing_app_metadata_or_reference, AppMetaData) - if self.on_update == OnUpdate.Fail: - raise DeploymentFailedError( - "Update detected and on_update=Fail, stopping deployment. " - "If you want to try updating the app then re-run with on_update=UpdateApp" - ) - if self.on_update == OnUpdate.AppendApp: - logger.info("Update detected and on_update=AppendApp, will attempt to create new app") - return self._create_app() - elif self.existing_app_metadata_or_reference.updatable and self.on_update == OnUpdate.UpdateApp: - logger.info("App is updatable and on_update=UpdateApp, will update app") - return self._update_app() - elif self.existing_app_metadata_or_reference.updatable and self.on_update == OnUpdate.ReplaceApp: - logger.warning( - "App is updatable but on_update=ReplaceApp, will attempt to create new app and delete old app" - ) - return self._create_and_delete_app() - elif self.on_update == OnUpdate.ReplaceApp: - if self.existing_app_metadata_or_reference.updatable is False: - logger.warning( - "App is not updatable and on_update=ReplaceApp, will attempt to create new app and delete old app" - ) - else: - logger.warning( - "Cannot determine if App is updatable and on_update=ReplaceApp, " - "will attempt to create new app and delete old app" - ) - return self._create_and_delete_app() - else: - if self.existing_app_metadata_or_reference.updatable is False: - logger.warning( - "App is not updatable but on_update=UpdateApp, " - "will attempt to update app, update will most likely fail" - ) - else: - logger.warning( - "Cannot determine if App is updatable and on_update=UpdateApp, will attempt to update app" - ) - return self._update_app() - - def _create_app(self) -> DeployResponse: - assert self.app_client.existing_deployments - - method, abi_args, parameters = _convert_deploy_args( - self.create_args, self.new_app_metadata, self.signer, self.sender - ) - create_response = self.app_client.create( - method, - parameters, - **abi_args, - ) - logger.info( - f"{self.new_app_metadata.name} ({self.new_app_metadata.version}) deployed successfully, " - f"with app id {self.app_client.app_id}." - ) - assert create_response.confirmed_round is not None - app_metadata = _create_metadata(self.new_app_metadata, self.app_client.app_id, create_response.confirmed_round) - self.app_client.existing_deployments.apps[self.new_app_metadata.name] = app_metadata - return DeployResponse(app=app_metadata, create_response=create_response, action_taken=OperationPerformed.Create) - - def _create_and_delete_app(self) -> DeployResponse: - assert self.app_client.existing_deployments - assert isinstance(self.existing_app_metadata_or_reference, AppMetaData) - - logger.info( - f"Replacing {self.existing_app_metadata_or_reference.name} " - f"({self.existing_app_metadata_or_reference.version}) with " - f"{self.new_app_metadata.name} ({self.new_app_metadata.version}) in {self.creator} account." - ) - atc = AtomicTransactionComposer() - create_method, create_abi_args, create_parameters = _convert_deploy_args( - self.create_args, self.new_app_metadata, self.signer, self.sender - ) - self.app_client.compose_create( - atc, - create_method, - create_parameters, - **create_abi_args, - ) - create_txn_index = len(atc.txn_list) - 1 - delete_method, delete_abi_args, delete_parameters = _convert_deploy_args( - self.delete_args, self.new_app_metadata, self.signer, self.sender - ) - self.app_client.compose_delete( - atc, - delete_method, - delete_parameters, - **delete_abi_args, - ) - delete_txn_index = len(atc.txn_list) - 1 - create_delete_response = self.app_client.execute_atc(atc) - create_response = TransactionResponse.from_atr(create_delete_response, create_txn_index) - delete_response = TransactionResponse.from_atr(create_delete_response, delete_txn_index) - self.app_client.app_id = get_app_id_from_tx_id(self.app_client.algod_client, create_response.tx_id) - logger.info( - f"{self.new_app_metadata.name} ({self.new_app_metadata.version}) deployed successfully, " - f"with app id {self.app_client.app_id}." - ) - logger.info( - f"{self.existing_app_metadata_or_reference.name} " - f"({self.existing_app_metadata_or_reference.version}) with app id " - f"{self.existing_app_metadata_or_reference.app_id}, deleted successfully." - ) - - app_metadata = _create_metadata( - self.new_app_metadata, self.app_client.app_id, create_delete_response.confirmed_round - ) - self.app_client.existing_deployments.apps[self.new_app_metadata.name] = app_metadata - - return DeployResponse( - app=app_metadata, - create_response=create_response, - delete_response=delete_response, - action_taken=OperationPerformed.Replace, - ) - - def _update_app(self) -> DeployResponse: - assert self.app_client.existing_deployments - assert isinstance(self.existing_app_metadata_or_reference, AppMetaData) - - logger.info( - f"Updating {self.existing_app_metadata_or_reference.name} to {self.new_app_metadata.version} in " - f"{self.creator} account, with app id {self.existing_app_metadata_or_reference.app_id}" - ) - method, abi_args, parameters = _convert_deploy_args( - self.update_args, self.new_app_metadata, self.signer, self.sender - ) - update_response = self.app_client.update( - method, - parameters, - **abi_args, - ) - app_metadata = _create_metadata( - self.new_app_metadata, - self.app_client.app_id, - self.existing_app_metadata_or_reference.created_round, - updated_round=update_response.confirmed_round, - original_metadata=self.existing_app_metadata_or_reference.created_metadata, - ) - self.app_client.existing_deployments.apps[self.new_app_metadata.name] = app_metadata - return DeployResponse(app=app_metadata, update_response=update_response, action_taken=OperationPerformed.Update) - - -def _create_metadata( - app_spec_note: AppDeployMetaData, - app_id: int, - created_round: int, - updated_round: int | None = None, - original_metadata: AppDeployMetaData | None = None, -) -> AppMetaData: - return AppMetaData( - app_id=app_id, - app_address=algosdk.logic.get_application_address(app_id), - created_metadata=original_metadata or app_spec_note, - created_round=created_round, - updated_round=updated_round or created_round, - name=app_spec_note.name, - version=app_spec_note.version, - deletable=app_spec_note.deletable, - updatable=app_spec_note.updatable, - deleted=False, - ) - - -def _convert_deploy_args( - _args: DeployCallArgs | DeployCallArgsDict | None, - note: AppDeployMetaData, - signer: TransactionSigner | None, - sender: str | None, -) -> tuple[ABIMethod | bool | None, ABIArgsDict, CreateCallParameters]: - args = _args.__dict__ if isinstance(_args, DeployCallArgs) else dict(_args or {}) - - # return most derived type, unused parameters are ignored - parameters = CreateCallParameters( - note=note.encode(), - signer=signer, - sender=sender, - suggested_params=args.get("suggested_params"), - lease=args.get("lease"), - accounts=args.get("accounts"), - foreign_assets=args.get("foreign_assets"), - foreign_apps=args.get("foreign_apps"), - boxes=args.get("boxes"), - rekey_to=args.get("rekey_to"), - extra_pages=args.get("extra_pages"), - on_complete=args.get("on_complete"), - ) - - return args.get("method"), args.get("args") or {}, parameters - - -def get_app_id_from_tx_id(algod_client: "AlgodClient", tx_id: str) -> int: - """Finds the app_id for provided transaction id""" - result = algod_client.pending_transaction_info(tx_id) - assert isinstance(result, dict) - app_id = result["application-index"] - assert isinstance(app_id, int) - return app_id diff --git a/src/algokit_utils/_legacy_v2/logic_error.py b/src/algokit_utils/_legacy_v2/logic_error.py deleted file mode 100644 index 0c171cb7..00000000 --- a/src/algokit_utils/_legacy_v2/logic_error.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing_extensions import deprecated - -from algokit_utils.errors.logic_error import LogicError as NewLogicError -from algokit_utils.errors.logic_error import parse_logic_error - -__all__ = [ - "LogicError", - "parse_logic_error", -] - - -@deprecated("Use algokit_utils.models.error.LogicError instead") -class LogicError(NewLogicError): - pass diff --git a/src/algokit_utils/_legacy_v2/models.py b/src/algokit_utils/_legacy_v2/models.py deleted file mode 100644 index da9d129e..00000000 --- a/src/algokit_utils/_legacy_v2/models.py +++ /dev/null @@ -1,211 +0,0 @@ -import dataclasses -from collections.abc import Sequence -from typing import Any, Generic, Protocol, TypeAlias, TypedDict, TypeVar - -from algosdk import transaction -from algosdk.abi import Method -from algosdk.atomic_transaction_composer import ( - AtomicTransactionResponse, - SimulateAtomicTransactionResponse, - TransactionSigner, -) -from typing_extensions import deprecated - -from algokit_utils.models.account import SigningAccount -from algokit_utils.models.simulate import SimulationTrace - -# Imports from latest sdk version that rely on models previously used in legacy v2 (but moved to root models/*) - - -__all__ = [ - "ABIArgsDict", - "ABIMethod", - "ABITransactionResponse", - "Account", - "CreateCallParameters", - "CreateCallParametersDict", - "CreateTransactionParameters", - "OnCompleteCallParameters", - "OnCompleteCallParametersDict", - "SimulationTrace", - "TransactionParameters", - "TransactionResponse", -] - -ReturnType = TypeVar("ReturnType") - - -@deprecated("Use 'SigningAccount' instead") -@dataclasses.dataclass(kw_only=True) -class Account(SigningAccount): - """An account that can be used to sign transactions""" - - -@dataclasses.dataclass(kw_only=True) -class TransactionResponse: - """Response for a non ABI call""" - - tx_id: str - """Transaction Id""" - confirmed_round: int | None - """Round transaction was confirmed, `None` if call was a from a dry-run""" - - @staticmethod - def from_atr( - result: AtomicTransactionResponse | SimulateAtomicTransactionResponse, transaction_index: int = -1 - ) -> "TransactionResponse": - """Returns either an ABITransactionResponse or a TransactionResponse based on the type of the transaction - referred to by transaction_index - :param AtomicTransactionResponse result: Result containing one or more transactions - :param int transaction_index: Which transaction in the result to return, defaults to -1 (the last transaction) - """ - tx_id = result.tx_ids[transaction_index] - abi_result = next((r for r in result.abi_results if r.tx_id == tx_id), None) - confirmed_round = None if isinstance(result, SimulateAtomicTransactionResponse) else result.confirmed_round - if abi_result: - return ABITransactionResponse( - tx_id=tx_id, - raw_value=abi_result.raw_value, - return_value=abi_result.return_value, - decode_error=abi_result.decode_error, - tx_info=abi_result.tx_info, - method=abi_result.method, - confirmed_round=confirmed_round, - ) - else: - return TransactionResponse( - tx_id=tx_id, - confirmed_round=confirmed_round, - ) - - -@dataclasses.dataclass(kw_only=True) -class ABITransactionResponse(TransactionResponse, Generic[ReturnType]): - """Response for an ABI call""" - - raw_value: bytes - """The raw response before ABI decoding""" - return_value: ReturnType - """Decoded ABI result""" - decode_error: Exception | None - """Details of error that occurred when attempting to decode raw_value""" - tx_info: dict - """Details of transaction""" - method: Method - """ABI method used to make call""" - - -ABIArgType = Any -ABIArgsDict = dict[str, ABIArgType] - - -class ABIReturnSubroutine(Protocol): - def method_spec(self) -> Method: ... - - -ABIMethod: TypeAlias = ABIReturnSubroutine | Method | str - - -@dataclasses.dataclass(kw_only=True) -class TransactionParameters: - """Additional parameters that can be included in a transaction""" - - signer: TransactionSigner | None = None - """Signer to use when signing this transaction""" - sender: str | None = None - """Sender of this transaction""" - suggested_params: transaction.SuggestedParams | None = None - """SuggestedParams to use for this transaction""" - note: bytes | str | None = None - """Note for this transaction""" - lease: bytes | str | None = None - """Lease value for this transaction""" - boxes: Sequence[tuple[int, bytes | bytearray | str | int]] | None = None - """Box references to include in transaction. A sequence of (app id, box key) tuples""" - accounts: list[str] | None = None - """Accounts to include in transaction""" - foreign_apps: list[int] | None = None - """List of foreign apps (by app id) to include in transaction""" - foreign_assets: list[int] | None = None - """List of foreign assets (by asset id) to include in transaction""" - rekey_to: str | None = None - """Address to rekey to""" - - -# CreateTransactionParameters is used by algokit-client-generator clients -@dataclasses.dataclass(kw_only=True) -class CreateTransactionParameters(TransactionParameters): - """Additional parameters that can be included in a transaction when calling a create method""" - - extra_pages: int | None = None - - -@dataclasses.dataclass(kw_only=True) -class OnCompleteCallParameters(TransactionParameters): - """Additional parameters that can be included in a transaction when using the - ApplicationClient.call/compose_call methods""" - - on_complete: transaction.OnComplete | None = None - - -@dataclasses.dataclass(kw_only=True) -class CreateCallParameters(OnCompleteCallParameters): - """Additional parameters that can be included in a transaction when using the - ApplicationClient.create/compose_create methods""" - - extra_pages: int | None = None - - -class TransactionParametersDict(TypedDict, total=False): - """Additional parameters that can be included in a transaction""" - - signer: TransactionSigner - """Signer to use when signing this transaction""" - sender: str - """Sender of this transaction""" - suggested_params: transaction.SuggestedParams - """SuggestedParams to use for this transaction""" - note: bytes | str - """Note for this transaction""" - lease: bytes | str - """Lease value for this transaction""" - boxes: Sequence[tuple[int, bytes | bytearray | str | int]] - """Box references to include in transaction. A sequence of (app id, box key) tuples""" - accounts: list[str] - """Accounts to include in transaction""" - foreign_apps: list[int] - """List of foreign apps (by app id) to include in transaction""" - foreign_assets: list[int] - """List of foreign assets (by asset id) to include in transaction""" - rekey_to: str - """Address to rekey to""" - - -class OnCompleteCallParametersDict(TransactionParametersDict, total=False): - """Additional parameters that can be included in a transaction when using the - ApplicationClient.call/compose_call methods""" - - on_complete: transaction.OnComplete - - -class CreateCallParametersDict(OnCompleteCallParametersDict, total=False): - """Additional parameters that can be included in a transaction when using the - ApplicationClient.create/compose_create methods""" - - extra_pages: int - - -# Pre 1.3.1 backwards compatibility -@deprecated("Use TransactionParameters instead") -class RawTransactionParameters(TransactionParameters): - """Deprecated, use TransactionParameters instead""" - - -@deprecated("Use TransactionParameters instead") -class CommonCallParameters(TransactionParameters): - """Deprecated, use TransactionParameters instead""" - - -@deprecated("Use TransactionParametersDict instead") -class CommonCallParametersDict(TransactionParametersDict): - """Deprecated, use TransactionParametersDict instead""" diff --git a/src/algokit_utils/_legacy_v2/network_clients.py b/src/algokit_utils/_legacy_v2/network_clients.py deleted file mode 100644 index 47668dbe..00000000 --- a/src/algokit_utils/_legacy_v2/network_clients.py +++ /dev/null @@ -1,144 +0,0 @@ -import dataclasses -import os -from typing import Literal -from urllib import parse - -from algosdk.kmd import KMDClient -from algosdk.v2client.algod import AlgodClient -from algosdk.v2client.indexer import IndexerClient -from typing_extensions import deprecated - -__all__ = [ - "AlgoClientConfig", - "AlgoClientConfigs", - "get_algod_client", - "get_algonode_config", - "get_default_localnet_config", - "get_indexer_client", - "get_kmd_client", - "get_kmd_client_from_algod_client", - "is_localnet", - "is_mainnet", - "is_testnet", -] - - -@dataclasses.dataclass -class AlgoClientConfig: - """Connection details for connecting to an {py:class}`algosdk.v2client.algod.AlgodClient` or - {py:class}`algosdk.v2client.indexer.IndexerClient`""" - - server: str - """URL for the service e.g. `http://localhost:4001` or `https://testnet-api.algonode.cloud`""" - token: str - """API Token to authenticate with the service""" - - -@dataclasses.dataclass -class AlgoClientConfigs: - algod_config: AlgoClientConfig - indexer_config: AlgoClientConfig - kmd_config: AlgoClientConfig | None - - -@deprecated("Use `ClientManager.get_default_localnet_config(config)` instead") -def get_default_localnet_config(config: Literal["algod", "indexer", "kmd"]) -> AlgoClientConfig: - """Returns the client configuration to point to the default LocalNet""" - port = {"algod": 4001, "indexer": 8980, "kmd": 4002}[config] - return AlgoClientConfig(server=f"http://localhost:{port}", token="a" * 64) - - -@deprecated("Use `ClientManager.get_algonode_config(network, config)` instead") -def get_algonode_config( - network: Literal["testnet", "mainnet"], config: Literal["algod", "indexer"], token: str -) -> AlgoClientConfig: - client = "api" if config == "algod" else "idx" - return AlgoClientConfig( - server=f"https://{network}-{client}.algonode.cloud", - token=token, - ) - - -@deprecated( - "Use `ClientManager.get_algod_client(config)` or `ClientManager.get_algod_client_from_environment()` instead." -) -def get_algod_client(config: AlgoClientConfig | None = None) -> AlgodClient: - """Returns an {py:class}`algosdk.v2client.algod.AlgodClient` from `config` or environment - - If no configuration provided will use environment variables `ALGOD_SERVER`, `ALGOD_PORT` and `ALGOD_TOKEN`""" - config = config or _get_config_from_environment("ALGOD") - headers = {"X-Algo-API-Token": config.token} - return AlgodClient(config.token, config.server, headers) - - -@deprecated("Use `ClientManager.get_kmd_client(config)` or `ClientManager.get_kmd_client_from_environment()` instead.") -def get_kmd_client(config: AlgoClientConfig | None = None) -> KMDClient: - """Returns an {py:class}`algosdk.kmd.KMDClient` from `config` or environment - - If no configuration provided will use environment variables `KMD_SERVER`, `KMD_PORT` and `KMD_TOKEN`""" - config = config or _get_config_from_environment("KMD") - return KMDClient(config.token, config.server) - - -@deprecated( - "Use `ClientManager.get_indexer_client(config)` or `ClientManager.get_indexer_client_from_environment()` instead." -) -def get_indexer_client(config: AlgoClientConfig | None = None) -> IndexerClient: - """Returns an {py:class}`algosdk.v2client.indexer.IndexerClient` from `config` or environment. - - If no configuration provided will use environment variables `INDEXER_SERVER`, `INDEXER_PORT` and `INDEXER_TOKEN`""" - config = config or _get_config_from_environment("INDEXER") - headers = {"X-Indexer-API-Token": config.token} - return IndexerClient(config.token, config.server, headers) - - -@deprecated("Use AlgorandClient.client.is_localnet() instead") -def is_localnet(client: AlgodClient) -> bool: - """Returns True if client genesis is `devnet-v1` or `sandnet-v1`""" - params = client.suggested_params() - return params.gen in ["devnet-v1", "sandnet-v1", "dockernet-v1"] - - -@deprecated("Use AlgorandClient.client.is_mainnet() instead") -def is_mainnet(client: AlgodClient) -> bool: - """Returns True if client genesis is `mainnet-v1`""" - params = client.suggested_params() - return params.gen in ["mainnet-v1.0", "mainnet-v1", "mainnet"] - - -@deprecated("Use AlgorandClient.client.is_testnet() instead") -def is_testnet(client: AlgodClient) -> bool: - """Returns True if client genesis is `testnet-v1`""" - params = client.suggested_params() - return params.gen in ["testnet-v1.0", "testnet-v1", "testnet"] - - -@deprecated("Use `ClientManager.get_kmd_client(config)` or `ClientManager.get_kmd_client_from_environment()` instead.") -def get_kmd_client_from_algod_client(client: AlgodClient) -> KMDClient: - """Returns an {py:class}`algosdk.kmd.KMDClient` from supplied `client` - - Will use the same address as provided `client` but on port specified by `KMD_PORT` environment variable, - or 4002 by default""" - # We can only use Kmd on the LocalNet otherwise it's not exposed so this makes some assumptions - # (e.g. same token and server as algod and port 4002 by default) - port = os.getenv("KMD_PORT", "4002") - server = _replace_kmd_port(client.algod_address, port) - return KMDClient(client.algod_token, server) - - -def _replace_kmd_port(address: str, port: str) -> str: - parsed_algod = parse.urlparse(address) - kmd_host = parsed_algod.netloc.split(":", maxsplit=1)[0] + f":{port}" - kmd_parsed = parsed_algod._replace(netloc=kmd_host) - return parse.urlunparse(kmd_parsed) - - -def _get_config_from_environment(environment_prefix: str) -> AlgoClientConfig: - server = os.getenv(f"{environment_prefix}_SERVER") - if server is None: - raise Exception(f"Server environment variable not set: {environment_prefix}_SERVER") - port = os.getenv(f"{environment_prefix}_PORT") - if port: - parsed = parse.urlparse(server) - server = parsed._replace(netloc=f"{parsed.hostname}:{port}").geturl() - return AlgoClientConfig(server, os.getenv(f"{environment_prefix}_TOKEN", "")) diff --git a/src/algokit_utils/account.py b/src/algokit_utils/account.py deleted file mode 100644 index 1a049e5e..00000000 --- a/src/algokit_utils/account.py +++ /dev/null @@ -1,12 +0,0 @@ -import warnings - -warnings.warn( - """The legacy v2 account module is deprecated and will be removed in a future version. - Use `SigningAccount` abstraction from `algokit_utils.models` instead or - classes compliant with `TransactionSignerAccountProtocol` obtained from `AccountManager`. -""", - DeprecationWarning, - stacklevel=2, -) - -from algokit_utils._legacy_v2.account import * # noqa: F403, E402 diff --git a/src/algokit_utils/accounts/account_manager.py b/src/algokit_utils/accounts/account_manager.py index 3a0c480e..aee20aed 100644 --- a/src/algokit_utils/accounts/account_manager.py +++ b/src/algokit_utils/accounts/account_manager.py @@ -1,15 +1,23 @@ import os -from collections.abc import Callable +import warnings +from collections.abc import Callable, Sequence from dataclasses import dataclass -from typing import Any, overload - -import algosdk -from algosdk import mnemonic -from algosdk.atomic_transaction_composer import TransactionSigner -from algosdk.mnemonic import to_private_key -from algosdk.transaction import SuggestedParams -from typing_extensions import Self, deprecated - +from typing import Any + +import nacl.signing +from typing_extensions import Never, Self + +from algokit_algo25 import seed_from_mnemonic +from algokit_algod_client import models as algod_models +from algokit_common.serde import to_wire +from algokit_crypto import WrappedEd25519Secret, ed25519_signing_key_from_wrapped_secret +from algokit_transact.logicsig import LogicSig +from algokit_transact.signer import ( + AddressWithSigners, + AddressWithTransactionSigner, + TransactionSigner, + generate_address_with_signers, +) from algokit_utils.accounts.kmd_account_manager import KmdAccountManager from algokit_utils.clients.client_manager import ClientManager from algokit_utils.clients.dispenser_api_client import TestNetDispenserApiClient @@ -17,18 +25,16 @@ from algokit_utils.models.account import ( DISPENSER_ACCOUNT_NAME, LogicSigAccount, - MultiSigAccount, + MultisigAccount, MultisigMetadata, - SigningAccount, - TransactionSignerAccount, ) from algokit_utils.models.amount import AlgoAmount from algokit_utils.models.transaction import SendParams -from algokit_utils.protocols.account import TransactionSignerAccountProtocol from algokit_utils.transactions.transaction_composer import ( PaymentParams, - SendAtomicTransactionComposerResults, + SendTransactionComposerResults, TransactionComposer, + TransactionComposerParams, ) from algokit_utils.transactions.transaction_sender import SendSingleTransactionResult @@ -136,6 +142,10 @@ class AccountInformation: """Signature type for this account""" +# Type alias for accounts that can be stored in the account manager +StoredAccountType = AddressWithSigners | LogicSigAccount | MultisigAccount + + class AccountManager: """ Creates and keeps track of signing accounts that can sign transactions for a sending address. @@ -152,7 +162,7 @@ class AccountManager: def __init__(self, client_manager: ClientManager): self._client_manager = client_manager self._kmd_account_manager = KmdAccountManager(client_manager) - self._accounts = dict[str, TransactionSignerAccountProtocol]() + self._accounts: dict[str, StoredAccountType | AddressWithTransactionSigner] = {} self._default_signer: TransactionSigner | None = None @property @@ -166,7 +176,36 @@ def kmd(self) -> KmdAccountManager: """ return self._kmd_account_manager - def set_default_signer(self, signer: TransactionSigner | TransactionSignerAccountProtocol) -> Self: + def _signer_account(self, account: StoredAccountType) -> AddressWithSigners: + """ + Register account and return AddressWithSigners. + + Records the given account against its address for later retrieval and returns + an AddressWithSigners object. + + :param account: The account to register (AddressWithSigners, LogicSigAccount, or MultisigAccount) + :returns: AddressWithSigners for the account + """ + # Get the address from the account + addr = account.addr + + # Store the account + self._accounts[addr] = account + + # If it's already AddressWithSigners, return it directly + if isinstance(account, AddressWithSigners): + return account + + return AddressWithSigners( + addr=addr, + signer=account.signer, + delegated_lsig_signer=_placeholder_lsig_signer, + program_data_signer=_placeholder_program_data_signer, + bytes_signer=_placeholder_bytes_signer, + mx_bytes_signer=_placeholder_mx_bytes_signer, + ) + + def set_default_signer(self, signer: TransactionSigner | AddressWithTransactionSigner) -> Self: """ Sets the default signer to use if no other signer is specified. @@ -180,7 +219,11 @@ def set_default_signer(self, signer: TransactionSigner | TransactionSignerAccoun >>> signer_account = account_manager.random() >>> account_manager.set_default_signer(signer_account) """ - self._default_signer = signer if isinstance(signer, TransactionSigner) else signer.signer + # Check if signer is an AddressWithTransactionSigner (has .signer property) or is just a callable + if isinstance(signer, AddressWithTransactionSigner): + self._default_signer = signer.signer + else: + self._default_signer = signer return self def set_signer(self, sender: str, signer: TransactionSigner) -> Self: @@ -194,7 +237,15 @@ def set_signer(self, sender: str, signer: TransactionSigner) -> Self: :example: >>> account_manager.set_signer("SENDERADDRESS", transaction_signer) """ - self._accounts[sender] = TransactionSignerAccount(address=sender, signer=signer) + + self._accounts[sender] = AddressWithSigners( + addr=sender, + signer=signer, + delegated_lsig_signer=_placeholder_lsig_signer, + program_data_signer=_placeholder_program_data_signer, + bytes_signer=_placeholder_bytes_signer, + mx_bytes_signer=_placeholder_mx_bytes_signer, + ) return self def set_signers(self, *, another_account_manager: "AccountManager", overwrite_existing: bool = True) -> Self: @@ -215,51 +266,10 @@ def set_signers(self, *, another_account_manager: "AccountManager", overwrite_ex ) return self - @overload - def set_signer_from_account(self, account: TransactionSignerAccountProtocol) -> Self: - """ - Tracks the given account for later signing. - - Note: If you are generating accounts via the various methods on `AccountManager` - (like `random`, `from_mnemonic`, `logic_sig`, etc.) then they automatically get tracked. - - :param account: The account to register - :returns: The `AccountManager` instance for method chaining - - :example: - >>> account_manager = AccountManager(client_manager) - >>> account_manager.set_signer_from_account( - ... SigningAccount(private_key=algosdk.account.generate_account()[0]) - ... ) - >>> account_manager.set_signer_from_account(LogicSigAccount(AlgosdkLogicSigAccount(program, args))) - >>> account_manager.set_signer_from_account(MultiSigAccount(multisig_params, [account1, account2])) - """ - - @overload - @deprecated("Use set_signer_from_account(account) instead of set_signer_from_account(signer)") - def set_signer_from_account(self, signer: TransactionSignerAccountProtocol) -> Self: - """ - Tracks the given account for later signing. - - Note: If you are generating accounts via the various methods on `AccountManager` - (like `random`, `from_mnemonic`, `logic_sig`, etc.) then they automatically get tracked. - - :param signer: The account to register (deprecated, use account parameter instead) - :returns: The `AccountManager` instance for method chaining - - :example: - >>> account_manager = AccountManager(client_manager) - >>> account_manager.set_signer_from_account( - ... SigningAccount(private_key=algosdk.account.generate_account()[0]) - ... ) - >>> account_manager.set_signer_from_account(LogicSigAccount(AlgosdkLogicSigAccount(program, args))) - >>> account_manager.set_signer_from_account(MultiSigAccount(multisig_params, [account1, account2])) - """ - def set_signer_from_account( self, - *args: TransactionSignerAccountProtocol, - **kwargs: TransactionSignerAccountProtocol, + *args: AddressWithTransactionSigner, + **kwargs: AddressWithTransactionSigner, ) -> Self: """ Tracks the given account for later signing. @@ -270,9 +280,9 @@ def set_signer_from_account( The method accepts either a positional argument or a keyword argument named 'account' or 'signer'. The 'signer' parameter is deprecated and will show a warning when used. - :param *args: Variable positional arguments. The first argument should be a TransactionSignerAccountProtocol. + :param *args: Variable positional arguments. The first argument should be a AddressWithTransactionSigner. :param **kwargs: Variable keyword arguments. Can include 'account' or 'signer' (deprecated) as - TransactionSignerAccountProtocol. + AddressWithTransactionSigner. :returns: The `AccountManager` instance for method chaining :raises ValueError: If no account or signer argument is provided @@ -280,7 +290,7 @@ def set_signer_from_account( >>> account_manager = AccountManager(client_manager) >>> # Using positional argument >>> account_manager.set_signer_from_account( - ... SigningAccount(private_key=algosdk.account.generate_account()[0]) + ... AddressWithSigners(...) ... ) >>> # Using keyword argument 'account' >>> account_manager.set_signer_from_account( @@ -288,7 +298,7 @@ def set_signer_from_account( ... ) >>> # Using deprecated keyword argument 'signer' >>> account_manager.set_signer_from_account( - ... signer=MultiSigAccount(multisig_params, [account1, account2]) + ... signer=MultisigAccount(multisig_params, [account1, account2]) ... ) """ # Extract the account from either positional args or keyword args @@ -301,10 +311,10 @@ def set_signer_from_account( else: raise ValueError("Missing required argument: either 'account' or 'signer'") - self._accounts[account_obj.address] = account_obj + self._accounts[account_obj.addr] = account_obj return self - def get_signer(self, sender: str | TransactionSignerAccountProtocol) -> TransactionSigner: + def get_signer(self, sender: str | AddressWithTransactionSigner) -> TransactionSigner: """ Returns the `TransactionSigner` for the given sender address. @@ -313,115 +323,183 @@ def get_signer(self, sender: str | TransactionSignerAccountProtocol) -> Transact :param sender: The sender address or account :returns: The `TransactionSigner` :raises ValueError: If no signer is found and no default signer is set + :raises TypeError: If a registered signer has an unexpected type :example: >>> signer = account_manager.get_signer("SENDERADDRESS") """ - signer = self._accounts.get(self._get_address(sender)) or self._default_signer - if not signer: + signer_or_account = self._accounts.get(self._get_address(sender)) or self._default_signer + if not signer_or_account: raise ValueError(f"No signer found for address {sender}") - return signer if isinstance(signer, TransactionSigner) else signer.signer - - def get_account(self, sender: str) -> TransactionSignerAccountProtocol: + # Check for AddressWithSigners first (uses .addr and .signer, not .address) + if isinstance(signer_or_account, AddressWithSigners): + return signer_or_account.signer + if isinstance(signer_or_account, AddressWithTransactionSigner): + return signer_or_account.signer + # Assume it's a TransactionSigner callable + if callable(signer_or_account): + return signer_or_account + raise TypeError(f"Unexpected signer type {type(signer_or_account)}") + + def get_account(self, sender: str) -> StoredAccountType | AddressWithTransactionSigner: """ - Returns the `TransactionSignerAccountProtocol` for the given sender address. + Returns the registered account for the given sender address. :param sender: The sender address - :returns: The `TransactionSignerAccountProtocol` - :raises ValueError: If no account is found or if the account is not a regular account + :returns: The registered account (AddressWithSigners, LogicSigAccount, MultisigAccount, + or AddressWithTransactionSigner) + :raises ValueError: If no account is found for the address :example: - >>> sender = account_manager.random().address + >>> sender = account_manager.random().addr >>> # ... - >>> # Returns the `TransactionSignerAccountProtocol` for `sender` that has previously been registered + >>> # Returns the account for `sender` that has previously been registered >>> account = account_manager.get_account(sender) """ account = self._accounts.get(sender) if not account: raise ValueError(f"No account found for address {sender}") - if not isinstance(account, SigningAccount): - raise ValueError(f"Account {sender} is not a regular account") return account - def get_information(self, sender: str | TransactionSignerAccountProtocol) -> AccountInformation: + def get_information(self, sender: str | AddressWithTransactionSigner) -> AccountInformation: """ Returns the given sender account's current status, balance and spendable amounts. See ``_ for response data schema details. - :param sender: The address or account compliant with `TransactionSignerAccountProtocol` protocol to look up + :param sender: The address or account compliant with `AddressWithTransactionSigner` protocol to look up :returns: The account information :example: >>> address = "XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA" >>> account_info = account_manager.get_information(address) """ - info = self._client_manager.algod.account_info(self._get_address(sender)) - assert isinstance(info, dict) - info = {k.replace("-", "_"): v for k, v in info.items()} - for key, value in info.items(): - if key in ("amount", "amount_without_pending_rewards", "min_balance", "pending_rewards", "rewards"): - info[key] = AlgoAmount.from_micro_algo(value) - return AccountInformation(**info) + account_info = self._client_manager.algod.account_information(self._get_address(sender)) + return self._build_account_information(account_info) + + def _build_account_information(self, account_info: algod_models.Account) -> AccountInformation: + """Convert a typed algod account model into an AccountInformation dataclass.""" + return AccountInformation( + address=account_info.address, + amount=AlgoAmount.from_micro_algo(account_info.amount), + amount_without_pending_rewards=AlgoAmount.from_micro_algo(account_info.amount_without_pending_rewards), + min_balance=AlgoAmount.from_micro_algo(account_info.min_balance), + pending_rewards=AlgoAmount.from_micro_algo(account_info.pending_rewards), + rewards=AlgoAmount.from_micro_algo(account_info.rewards), + round=account_info.round_, + status=account_info.status, + total_apps_opted_in=account_info.total_apps_opted_in, + total_assets_opted_in=account_info.total_assets_opted_in, + total_box_bytes=getattr(account_info, "total_box_bytes", None), + total_boxes=getattr(account_info, "total_boxes", None), + total_created_apps=account_info.total_created_apps, + total_created_assets=account_info.total_created_assets, + apps_local_state=[to_wire(app) for app in account_info.apps_local_state] + if account_info.apps_local_state + else None, + apps_total_extra_pages=account_info.apps_total_extra_pages, + apps_total_schema=to_wire(account_info.apps_total_schema) if account_info.apps_total_schema else None, + assets=[to_wire(asset) for asset in account_info.assets] if account_info.assets else None, + auth_addr=account_info.auth_addr, + closed_at_round=getattr(account_info, "closed_at_round", None), + created_apps=[to_wire(app) for app in account_info.created_apps] if account_info.created_apps else None, + created_assets=[to_wire(asset) for asset in account_info.created_assets] + if account_info.created_assets + else None, + ) - def _register_account(self, private_key: str, address: str | None = None) -> SigningAccount: - """ - Helper method to create and register an account with its signer. + def from_mnemonic(self, *, mnemonic: str, sender: str | None = None) -> AddressWithSigners: + """Tracks and returns an Algorand account with secret key loaded by taking the mnemonic secret. + + .. deprecated:: + from_mnemonic is deprecated. Use from_secret with WrappedLegacyMnemonic instead. - :param private_key: The private key for the account - :param address: The address for the account - :returns: The registered Account instance + :param mnemonic: The mnemonic secret representing the private key of an account + :param sender: Optional address to use as the sender (for rekeyed accounts) + :returns: The account as AddressWithSigners + + .. warning:: + Be careful how the mnemonic is handled. Never commit it into source control and ideally load it + from the environment (ideally via a secret storage service) rather than the file system. + + :example: + >>> account = account_manager.from_mnemonic("mnemonic secret ...") """ - address = address or str(algosdk.account.address_from_private_key(private_key)) - account = SigningAccount(private_key=private_key, address=address) - self._accounts[address or account.address] = TransactionSignerAccount( - address=account.address, signer=account.signer + warnings.warn( + "from_mnemonic is deprecated. Use from_secret with WrappedLegacyMnemonic instead.", + DeprecationWarning, + stacklevel=2, ) - return account + seed = seed_from_mnemonic(mnemonic) + signing_key = nacl.signing.SigningKey(seed) + public_key = signing_key.verify_key.encode() - def _register_logicsig(self, program: bytes, args: list[bytes] | None = None) -> LogicSigAccount: - """ - Helper method to create and register a logic signature account. + def raw_signer(bytes_to_sign: bytes) -> bytes: + return signing_key.sign(bytes_to_sign).signature - :param program: The bytes that make up the compiled logic signature - :param args: The (binary) arguments to pass into the logic signature - :returns: The registered AlgosdkLogicSigAccount instance - """ - logic_sig = LogicSigAccount(program, args) - self._accounts[logic_sig.address] = logic_sig - return logic_sig + account = generate_address_with_signers( + ed25519_pubkey=public_key, + raw_ed25519_signer=raw_signer, + sending_address=sender, + ) + return self._signer_account(account) - def _register_multisig(self, metadata: MultisigMetadata, signing_accounts: list[SigningAccount]) -> MultiSigAccount: - """ - Helper method to create and register a multisig account. + def from_secret( + self, + *, + secret: WrappedEd25519Secret, + sender: str | None = None, + ) -> AddressWithSigners: + """Create and register an account from a wrapped secret. - :param metadata: The metadata for the multisig account - :param signing_accounts: The list of accounts that are present to sign - :returns: The registered MultisigAccount instance - """ - msig_account = MultiSigAccount(metadata, signing_accounts) - self._accounts[str(msig_account.address)] = MultiSigAccount(metadata, signing_accounts) - return msig_account + Supports Ed25519 seeds, HD extended private keys, HD mnemonics (BIP39), + and legacy Algorand mnemonics (25-word). - def from_mnemonic(self, *, mnemonic: str, sender: str | None = None) -> SigningAccount: - """ - Tracks and returns an Algorand account with secret key loaded by taking the mnemonic secret. + :param secret: A wrapped secret implementing one of the WrappedEd25519Secret protocols + :param sender: Optional sender address for rekeyed accounts + :returns: The created account with signer registered - :param mnemonic: The mnemonic secret representing the private key of an account - :param sender: Optional address to use as the sender - :returns: The account + .. note:: + The wrap methods in wrapped secret protocols are optional. If not implemented, + they default to no-op. This is useful for implementations where wrapping is + handled automatically (e.g., hardware wallets, keyring services). .. warning:: - Be careful how the mnemonic is handled. Never commit it into source control and ideally load it - from the environment (ideally via a secret storage service) rather than the file system. + Be careful how secrets are handled. Never commit them into source control and + ideally load them from the environment or a secure storage service. :example: - >>> account = account_manager.from_mnemonic("mnemonic secret ...") + >>> # Using Ed25519 seed + >>> class WrappedSeed: + ... def unwrap_ed25519_seed(self) -> bytearray: + ... return bytearray(seed) + >>> account = account_manager.from_secret(secret=WrappedSeed()) + >>> + >>> # Using HD mnemonic + >>> class WrappedMnemonic: + ... def unwrap_hd_mnemonic(self) -> str: + ... return "word1 word2 ..." + >>> account = account_manager.from_secret(secret=WrappedMnemonic()) + >>> + >>> # Using legacy mnemonic + >>> class WrappedLegacy: + ... def unwrap_legacy_mnemonic(self) -> str: + ... return "25 word mnemonic..." + >>> account = account_manager.from_secret(secret=WrappedLegacy()) """ - return self._register_account(to_private_key(mnemonic), sender) + signing_key = ed25519_signing_key_from_wrapped_secret(secret) + public_key = signing_key["ed25519_pubkey"] + raw_signer = signing_key["raw_ed25519_signer"] + + account = generate_address_with_signers( + ed25519_pubkey=public_key, + raw_ed25519_signer=raw_signer, + sending_address=sender, + ) + return self._signer_account(account) - def from_environment(self, name: str, fund_with: AlgoAmount | None = None) -> SigningAccount: + def from_environment(self, name: str, fund_with: AlgoAmount | None = None) -> AddressWithSigners: """ Tracks and returns an Algorand account with private key loaded by convention from environment variables. @@ -431,7 +509,7 @@ def from_environment(self, name: str, fund_with: AlgoAmount | None = None) -> Si :param name: The name identifier of the account :param fund_with: Optional amount to fund the account with when it gets created (when targeting LocalNet) - :returns: The account + :returns: The account as AddressWithSigners :raises ValueError: If environment variable {NAME}_MNEMONIC is missing when looking for account {NAME} .. note:: @@ -449,27 +527,27 @@ def from_environment(self, name: str, fund_with: AlgoAmount | None = None) -> Si >>> # with an account that is automatically funded with the specified amount from the LocalNet dispenser """ account_mnemonic = os.getenv(f"{name.upper()}_MNEMONIC") + sender = os.getenv(f"{name.upper()}_SENDER") if account_mnemonic: - private_key = mnemonic.to_private_key(account_mnemonic) - return self._register_account(private_key) + return self.from_mnemonic(mnemonic=account_mnemonic, sender=sender) if self._client_manager.is_localnet(): kmd_account = self._kmd_account_manager.get_or_create_wallet_account(name, fund_with) - return self._register_account(kmd_account.private_key) + return self._signer_account(kmd_account) raise ValueError(f"Missing environment variable {name.upper()}_MNEMONIC when looking for account {name}") def from_kmd( self, name: str, predicate: Callable[[dict[str, Any]], bool] | None = None, sender: str | None = None - ) -> SigningAccount: + ) -> AddressWithSigners: """ Tracks and returns an Algorand account with private key loaded from the given KMD wallet. :param name: The name of the wallet to retrieve an account from :param predicate: Optional filter to use to find the account :param sender: Optional sender address to use this signer for (aka a rekeyed account) - :returns: The account + :returns: The account as AddressWithSigners :raises ValueError: If unable to find KMD account with given name and predicate :example: @@ -482,72 +560,84 @@ def from_kmd( if not kmd_account: raise ValueError(f"Unable to find KMD account {name}{' with predicate' if predicate else ''}") - return self._register_account(kmd_account.private_key) + return self._signer_account(kmd_account) - def logicsig(self, program: bytes, args: list[bytes] | None = None) -> LogicSigAccount: + def logicsig(self, program: bytes, args: Sequence[bytes] = ()) -> AddressWithSigners: """ Tracks and returns an account that represents a logic signature. :param program: The bytes that make up the compiled logic signature :param args: Optional (binary) arguments to pass into the logic signature - :returns: A logic signature account wrapper + :returns: An AddressWithSigners wrapper for the logic signature account :example: - >>> account = account.logicsig(program, [new Uint8Array(3, ...)]) + >>> account = account_manager.logicsig(program, [b"arg1", b"arg2"]) """ - return self._register_logicsig(program, args) + logic_sig = LogicSigAccount(logic=program, args=args) + return self._signer_account(logic_sig) - def multisig(self, metadata: MultisigMetadata, signing_accounts: list[SigningAccount]) -> MultiSigAccount: + def multisig(self, metadata: MultisigMetadata, sub_signers: Sequence[AddressWithSigners]) -> AddressWithSigners: """ Tracks and returns an account that supports partial or full multisig signing. :param metadata: The metadata for the multisig account - :param signing_accounts: The signers that are currently present - :returns: A multisig account wrapper + :param sub_signers: The signers that are currently present + :returns: An AddressWithSigners wrapper for the multisig account :example: >>> account = account_manager.multi_sig( ... version=1, ... threshold=1, ... addrs=["ADDRESS1...", "ADDRESS2..."], - ... signing_accounts=[account1, account2] + ... sub_signers=[account1, account2] ... ) """ - return self._register_multisig(metadata, signing_accounts) + msig_account = MultisigAccount(metadata, sub_signers) + return self._signer_account(msig_account) - def random(self) -> SigningAccount: + def random(self) -> AddressWithSigners: """ Tracks and returns a new, random Algorand account. - :returns: The account + :returns: The account as AddressWithSigners :example: >>> account = account_manager.random() """ - private_key, _ = algosdk.account.generate_account() - return self._register_account(private_key) + # Generate random keypair using nacl + keypair = nacl.signing.SigningKey.generate() + public_key = keypair.verify_key.encode() + + def raw_signer(bytes_to_sign: bytes) -> bytes: + return keypair.sign(bytes_to_sign).signature - def localnet_dispenser(self) -> SigningAccount: + account = generate_address_with_signers( + ed25519_pubkey=public_key, + raw_ed25519_signer=raw_signer, + ) + return self._signer_account(account) + + def localnet_dispenser(self) -> AddressWithSigners: """ Returns an Algorand account with private key loaded for the default LocalNet dispenser account. This account can be used to fund other accounts. - :returns: The account + :returns: The account as AddressWithSigners :example: >>> account = account_manager.localnet_dispenser() """ kmd_account = self._kmd_account_manager.get_localnet_dispenser_account() - return self._register_account(kmd_account.private_key) + return self._signer_account(kmd_account) - def dispenser_from_environment(self) -> SigningAccount: + def dispenser_from_environment(self) -> AddressWithSigners: """ Returns an account (with private key loaded) that can act as a dispenser from environment variables. If environment variables are not present, returns the default LocalNet dispenser account. - :returns: The account + :returns: The account as AddressWithSigners :example: >>> account = account_manager.dispenser_from_environment() @@ -557,30 +647,35 @@ def dispenser_from_environment(self) -> SigningAccount: return self.from_environment(DISPENSER_ACCOUNT_NAME) return self.localnet_dispenser() - def rekeyed( - self, *, sender: str, account: TransactionSignerAccountProtocol - ) -> TransactionSignerAccount | SigningAccount: + def rekeyed(self, *, sender: str, account: AddressWithTransactionSigner | AddressWithSigners) -> AddressWithSigners: """ Tracks and returns an Algorand account that is a rekeyed version of the given account to a new sender. - :param sender: The account or address to use as the sender + :param sender: The address to use as the sender :param account: The account to use as the signer for this new rekeyed account - :returns: The rekeyed account + :returns: The rekeyed account as AddressWithSigners :example: >>> account = account.from_mnemonic("mnemonic secret ...") >>> rekeyed_account = account_manager.rekeyed(account, "SENDERADDRESS...") """ - sender_address = sender.address if isinstance(sender, SigningAccount) else sender - self._accounts[sender_address] = TransactionSignerAccount(address=sender_address, signer=account.signer) - if isinstance(account, SigningAccount): - return SigningAccount(address=sender_address, private_key=account.private_key) - return TransactionSignerAccount(address=sender_address, signer=account.signer) + + rekeyed_account = AddressWithSigners( + addr=sender, + signer=account.signer, + delegated_lsig_signer=_placeholder_lsig_signer, + program_data_signer=_placeholder_program_data_signer, + bytes_signer=_placeholder_bytes_signer, + mx_bytes_signer=_placeholder_mx_bytes_signer, + ) + + self._accounts[sender] = rekeyed_account + return rekeyed_account def rekey_account( # noqa: PLR0913 self, account: str, - rekey_to: str | TransactionSignerAccountProtocol, + rekey_to: str | AddressWithTransactionSigner, *, # Common transaction parameters signer: TransactionSigner | None = None, note: bytes | None = None, @@ -592,7 +687,7 @@ def rekey_account( # noqa: PLR0913 first_valid_round: int | None = None, last_valid_round: int | None = None, suppress_log: bool | None = None, - ) -> SendAtomicTransactionComposerResults: + ) -> SendTransactionComposerResults: """ Rekey an account to a new address. @@ -659,7 +754,7 @@ def rekey_account( # noqa: PLR0913 ) # If rekey_to is a signing account, set it as the signer for this account - if isinstance(rekey_to, SigningAccount): + if isinstance(rekey_to, AddressWithTransactionSigner | AddressWithSigners): self.rekeyed(sender=account, account=rekey_to) if not suppress_log: @@ -669,8 +764,8 @@ def rekey_account( # noqa: PLR0913 def ensure_funded( # noqa: PLR0913 self, - account_to_fund: str | SigningAccount, - dispenser_account: str | SigningAccount, + account_to_fund: str | AddressWithTransactionSigner | AddressWithSigners, + dispenser_account: str | AddressWithTransactionSigner | AddressWithSigners, min_spending_balance: AlgoAmount, min_funding_increment: AlgoAmount | None = None, # Sender params @@ -727,9 +822,11 @@ def ensure_funded( # noqa: PLR0913 ... suppress_log=True ... ) """ - account_to_fund = self._get_address(account_to_fund) - dispenser_account = self._get_address(dispenser_account) - amount_funded = self._get_ensure_funded_amount(account_to_fund, min_spending_balance, min_funding_increment) + account_to_fund_addr = self._get_address(account_to_fund) + dispenser_account_addr = self._get_address(dispenser_account) + amount_funded = self._get_ensure_funded_amount( + account_to_fund_addr, min_spending_balance, min_funding_increment + ) if not amount_funded: return None @@ -738,8 +835,8 @@ def ensure_funded( # noqa: PLR0913 self._get_composer() .add_payment( PaymentParams( - sender=dispenser_account, - receiver=account_to_fund, + sender=dispenser_account_addr, + receiver=account_to_fund_addr, amount=amount_funded, signer=signer, rekey_to=rekey_to, @@ -756,21 +853,16 @@ def ensure_funded( # noqa: PLR0913 .send(send_params) ) + base_result = SendSingleTransactionResult.from_composer_result(result) return EnsureFundedResult( - returns=result.returns, - transactions=result.transactions, - confirmations=result.confirmations, - tx_ids=result.tx_ids, - group_id=result.group_id, - transaction_id=result.tx_ids[0], - confirmation=result.confirmations[0], - transaction=result.transactions[0], + **vars(base_result), + transaction_id=base_result.tx_id or result.tx_ids[0], amount_funded=amount_funded, ) def ensure_funded_from_environment( # noqa: PLR0913 self, - account_to_fund: str | SigningAccount, + account_to_fund: str | AddressWithTransactionSigner | AddressWithSigners, min_spending_balance: AlgoAmount, *, # Force remaining params to be keyword-only min_funding_increment: AlgoAmount | None = None, @@ -832,10 +924,12 @@ def ensure_funded_from_environment( # noqa: PLR0913 ... suppress_log=True ... ) """ - account_to_fund = self._get_address(account_to_fund) + account_to_fund_addr = self._get_address(account_to_fund) dispenser_account = self.dispenser_from_environment() - amount_funded = self._get_ensure_funded_amount(account_to_fund, min_spending_balance, min_funding_increment) + amount_funded = self._get_ensure_funded_amount( + account_to_fund_addr, min_spending_balance, min_funding_increment + ) if not amount_funded: return None @@ -844,8 +938,8 @@ def ensure_funded_from_environment( # noqa: PLR0913 self._get_composer() .add_payment( PaymentParams( - sender=dispenser_account.address, - receiver=account_to_fund, + sender=dispenser_account.addr, + receiver=account_to_fund_addr, amount=amount_funded, signer=signer, rekey_to=rekey_to, @@ -862,21 +956,16 @@ def ensure_funded_from_environment( # noqa: PLR0913 .send(send_params) ) + base_result = SendSingleTransactionResult.from_composer_result(result) return EnsureFundedResult( - returns=result.returns, - transactions=result.transactions, - confirmations=result.confirmations, - tx_ids=result.tx_ids, - group_id=result.group_id, - transaction_id=result.tx_ids[0], - confirmation=result.confirmations[0], - transaction=result.transactions[0], + **vars(base_result), + transaction_id=base_result.tx_id or result.tx_ids[0], amount_funded=amount_funded, ) def ensure_funded_from_testnet_dispenser_api( self, - account_to_fund: str | SigningAccount, + account_to_fund: str | AddressWithTransactionSigner, dispenser_client: TestNetDispenserApiClient, min_spending_balance: AlgoAmount, *, @@ -914,42 +1003,43 @@ def ensure_funded_from_testnet_dispenser_api( ... min_funding_increment=AlgoAmount.from_algo(2) ... ) """ - account_to_fund = self._get_address(account_to_fund) + account_to_fund_addr = self._get_address(account_to_fund) if not self._client_manager.is_testnet(): raise ValueError("Attempt to fund using TestNet dispenser API on non TestNet network.") - amount_funded = self._get_ensure_funded_amount(account_to_fund, min_spending_balance, min_funding_increment) + amount_funded = self._get_ensure_funded_amount( + account_to_fund_addr, min_spending_balance, min_funding_increment + ) if not amount_funded: return None - result = dispenser_client.fund(address=account_to_fund, amount=amount_funded.micro_algo) + result = dispenser_client.fund(address=account_to_fund_addr, amount=amount_funded.micro_algo) return EnsureFundedFromTestnetDispenserApiResult( transaction_id=result.tx_id, amount_funded=AlgoAmount.from_micro_algo(result.amount), ) - def _get_address(self, sender: str | TransactionSignerAccountProtocol) -> str: - match sender: - case TransactionSignerAccountProtocol(): - return sender.address - case str(): - return sender - case _: - raise ValueError(f"Unknown sender type: {type(sender)}") + def _get_address(self, sender: str | AddressWithTransactionSigner | AddressWithSigners) -> str: + # Check isinstance first for proper type narrowing + if isinstance(sender, str): + return sender + # Both AddressWithSigners and AddressWithTransactionSigner now use 'addr' + return sender.addr - def _get_composer(self, get_suggested_params: Callable[[], SuggestedParams] | None = None) -> TransactionComposer: - if get_suggested_params is None: - - def _get_suggested_params() -> SuggestedParams: - return self._client_manager.algod.suggested_params() - - get_suggested_params = _get_suggested_params + def _get_composer( + self, get_suggested_params: Callable[[], algod_models.SuggestedParams] | None = None + ) -> TransactionComposer: + get_suggested_params = get_suggested_params or self._client_manager.algod.suggested_params return TransactionComposer( - algod=self._client_manager.algod, get_signer=self.get_signer, get_suggested_params=get_suggested_params + TransactionComposerParams( + algod=self._client_manager.algod, + get_signer=self.get_signer, + get_suggested_params=get_suggested_params, + ) ) def _calculate_fund_amount( @@ -978,3 +1068,22 @@ def _get_ensure_funded_amount( ) return AlgoAmount.from_micro_algo(amount_funded) if amount_funded is not None else None + + +# For LogicSigAccount and MultisigAccount, create an AddressWithSigners wrapper +# These accounts have a .signer property but may not have all the other signers +# We create placeholder signers for the other capabilities +def _placeholder_bytes_signer(_: bytes) -> Never: + raise NotImplementedError("bytes_signer not available for this account type") + + +def _placeholder_lsig_signer(_: LogicSigAccount, __: MultisigAccount | None = None) -> Never: + raise NotImplementedError("delegated_lsig_signer not available for this account type") + + +def _placeholder_program_data_signer(_: LogicSig, __: bytes) -> Never: + raise NotImplementedError("program_data_signer not available for this account type") + + +def _placeholder_mx_bytes_signer(_: bytes) -> Never: + raise NotImplementedError("mx_bytes_signer not available for this account type") diff --git a/src/algokit_utils/accounts/kmd_account_manager.py b/src/algokit_utils/accounts/kmd_account_manager.py index 7eecd408..987309b3 100644 --- a/src/algokit_utils/accounts/kmd_account_manager.py +++ b/src/algokit_utils/accounts/kmd_account_manager.py @@ -1,34 +1,32 @@ from collections.abc import Callable -from typing import Any, cast - -from algosdk.kmd import KMDClient - +from typing import Any + +from nacl.signing import SigningKey + +from algokit_common.serde import to_wire +from algokit_kmd_client.client import KmdClient +from algokit_kmd_client.models._create_wallet_request import CreateWalletRequest +from algokit_kmd_client.models._export_key_request import ExportKeyRequest +from algokit_kmd_client.models._generate_key_request import GenerateKeyRequest +from algokit_kmd_client.models._init_wallet_handle_token_request import InitWalletHandleTokenRequest +from algokit_kmd_client.models._list_keys_request import ListKeysRequest +from algokit_transact.signer import AddressWithSigners, generate_address_with_signers from algokit_utils.clients.client_manager import ClientManager from algokit_utils.config import config -from algokit_utils.models.account import SigningAccount from algokit_utils.models.amount import AlgoAmount -from algokit_utils.transactions.transaction_composer import PaymentParams, TransactionComposer - -__all__ = ["KmdAccount", "KmdAccountManager"] - - -class KmdAccount(SigningAccount): - """Account retrieved from KMD with signing capabilities, extending base Account. - - Provides an account implementation that can be used to sign transactions using keys stored in KMD. +from algokit_utils.transactions.transaction_composer import ( + PaymentParams, + TransactionComposer, + TransactionComposerParams, +) - :param private_key: Base64 encoded private key - :param address: Optional address override for rekeyed accounts, defaults to None - """ - - def __init__(self, private_key: str, address: str | None = None) -> None: - super().__init__(private_key=private_key, address=address or "") +__all__ = ["KmdAccountManager"] class KmdAccountManager: """Provides abstractions over KMD that makes it easier to get and manage accounts.""" - _kmd: KMDClient | None + _kmd: KmdClient | None def __init__(self, client_manager: ClientManager) -> None: self._client_manager = client_manager @@ -37,7 +35,7 @@ def __init__(self, client_manager: ClientManager) -> None: except ValueError: self._kmd = None - def kmd(self) -> KMDClient: + def kmd(self) -> KmdClient: """Returns the KMD client, initializing it if needed. :raises Exception: If KMD client is not configured and not running against LocalNet @@ -58,7 +56,7 @@ def get_wallet_account( wallet_name: str, predicate: Callable[[dict[str, Any]], bool] | None = None, sender: str | None = None, - ) -> KmdAccount | None: + ) -> AddressWithSigners | None: """Returns an Algorand signing account with private key loaded from the given KMD wallet. Retrieves an account from a KMD wallet that matches the given predicate, or a random account @@ -80,38 +78,60 @@ def _find_wallet_account( wallet_name: str, predicate_or_address: Callable[[dict[str, Any]], bool] | str | None = None, sender: str | None = None, - ) -> KmdAccount | None: + ) -> AddressWithSigners | None: kmd_client = self.kmd() - wallets = kmd_client.list_wallets() - wallet = next((w for w in wallets if w["name"] == wallet_name), None) + wallets = kmd_client.list_wallets().wallets or [] + wallet = next((w for w in wallets if w.name == wallet_name), None) if not wallet: return None - wallet_id = wallet["id"] - wallet_handle = kmd_client.init_wallet_handle(wallet_id, "") + wallet_id = wallet.id_ + wallet_handle = kmd_client.init_wallet_handle(InitWalletHandleTokenRequest(wallet_id, "")).wallet_handle_token + addresses = kmd_client.list_keys_in_wallet(ListKeysRequest(wallet_handle)).addresses or [] - matched_address = None - if isinstance(predicate_or_address, str): - matched_address = predicate_or_address - else: - addresses = kmd_client.list_keys(wallet_handle) - if addresses: - if callable(predicate_or_address): - for address in addresses: - account_info = self._client_manager.algod.account_info(address) - if predicate_or_address(cast(dict[str, Any], account_info)): - matched_address = address - break - else: - matched_address = addresses[0] + matched_address = self._find_matching_address(addresses, predicate_or_address) if not matched_address: return None - private_key = kmd_client.export_key(wallet_handle, "", matched_address) - return KmdAccount(private_key=private_key, address=sender) + private_key = kmd_client.export_key(ExportKeyRequest(matched_address, wallet_handle, "")).private_key + if not private_key: + raise Exception(f"Error exporting key for address {matched_address} from KMD wallet {wallet_name}") + + # private_key is 64 bytes from KMD (seed + public key) + seed = private_key[:32] + public_key = private_key[32:] + signing_key = SigningKey(seed) + + def raw_signer(bytes_to_sign: bytes) -> bytes: + return signing_key.sign(bytes_to_sign).signature + + return generate_address_with_signers( + ed25519_pubkey=public_key, + raw_ed25519_signer=raw_signer, + sending_address=sender, + ) + + def _find_matching_address( + self, + addresses: list[str], + predicate_or_address: Callable[[dict[str, Any]], bool] | str | None = None, + ) -> str | None: + if not addresses: + return None + + if callable(predicate_or_address): + for address in addresses: + account_info = self._client_manager.algod.account_information(address) + if predicate_or_address(to_wire(account_info)): + return address + return None + elif isinstance(predicate_or_address, str): + return predicate_or_address if predicate_or_address in addresses else None + else: + return addresses[0] - def get_or_create_wallet_account(self, name: str, fund_with: AlgoAmount | None = None) -> KmdAccount: + def get_or_create_wallet_account(self, name: str, fund_with: AlgoAmount | None = None) -> AddressWithSigners: """Gets or creates a funded account in a KMD wallet of the given name. Provides idempotent access to accounts from LocalNet without specifying the private key. @@ -119,6 +139,8 @@ def get_or_create_wallet_account(self, name: str, fund_with: AlgoAmount | None = :param name: The name of the wallet to retrieve / create :param fund_with: The number of Algos to fund the account with when created :return: An Algorand account with private key loaded + + :raises Exception: If error received while creating the wallet or funding the account """ fund_with = fund_with or AlgoAmount.from_algo(1000) @@ -127,33 +149,38 @@ def get_or_create_wallet_account(self, name: str, fund_with: AlgoAmount | None = return existing kmd_client = self.kmd() - wallet_id = kmd_client.create_wallet(name, "")["id"] - wallet_handle = kmd_client.init_wallet_handle(wallet_id, "") - kmd_client.generate_key(wallet_handle) + wallet = kmd_client.create_wallet(CreateWalletRequest(wallet_name=name, wallet_password="")).wallet + if not wallet: + raise Exception(f"Error creating KMD wallet with name {name}") + wallet_id = wallet.id_ + wallet_handle = kmd_client.init_wallet_handle(InitWalletHandleTokenRequest(wallet_id, "")).wallet_handle_token + kmd_client.generate_key(GenerateKeyRequest(wallet_handle_token=wallet_handle)) account = self.get_wallet_account(name) assert account is not None config.logger.info( - f"LocalNet account '{name}' doesn't yet exist; created account {account.address} " + f"LocalNet account '{name}' doesn't yet exist; created account {account.addr} " f"with keys stored in KMD and funding with {fund_with} ALGO" ) dispenser = self.get_localnet_dispenser_account() TransactionComposer( - algod=self._client_manager.algod, - get_signer=lambda _: dispenser.signer, - get_suggested_params=self._client_manager.algod.suggested_params, + TransactionComposerParams( + algod=self._client_manager.algod, + get_signer=lambda _: dispenser.signer, + get_suggested_params=self._client_manager.algod.suggested_params, + ) ).add_payment( PaymentParams( - sender=dispenser.address, - receiver=account.address, + sender=dispenser.addr, + receiver=account.addr, amount=fund_with, ) ).send() return account - def get_localnet_dispenser_account(self) -> KmdAccount: + def get_localnet_dispenser_account(self) -> AddressWithSigners: """Returns an Algorand account with private key loaded for the default LocalNet dispenser account. Retrieves the default funded account from LocalNet that can be used to fund other accounts. @@ -164,8 +191,8 @@ def get_localnet_dispenser_account(self) -> KmdAccount: if not self._client_manager.is_localnet(): raise Exception("Can't get LocalNet dispenser account from non LocalNet network") - genesis_response = cast(dict[str, Any], self._client_manager.algod.genesis()) - dispenser_addresses = [cast(str, a["addr"]) for a in genesis_response["alloc"] if a.get("comment") == "Wallet1"] + genesis_response = self._client_manager.algod.genesis() + dispenser_addresses = [a.addr for a in genesis_response.alloc if a.comment == "Wallet1"] if dispenser_addresses: dispenser = self._find_wallet_account( diff --git a/src/algokit_utils/algo25.py b/src/algokit_utils/algo25.py new file mode 100644 index 00000000..dc766a61 --- /dev/null +++ b/src/algokit_utils/algo25.py @@ -0,0 +1,49 @@ +"""Algorand 25-word mnemonic utilities. + +Re-exports from algokit_algo25 for convenient access via algokit_utils.algo25. + +Usage: + from algokit_utils import algo25 + mnemonic = algo25.mnemonic_from_seed(seed) + + # Or import directly: + from algokit_utils.algo25 import mnemonic_from_seed, seed_from_mnemonic +""" + +from algokit_algo25 import ( + FAIL_TO_DECODE_MNEMONIC_ERROR_MSG, + KEY_LEN_BYTES, + MNEMONIC_LEN, + NOT_IN_WORDS_LIST_ERROR_MSG, + InvalidMnemonicError, + InvalidSeedLengthError, + MnemonicError, + WordNotFoundError, + WrappedLegacyMnemonic, + master_derivation_key_to_mnemonic, + mnemonic_from_seed, + mnemonic_to_master_derivation_key, + secret_key_to_mnemonic, + seed_from_mnemonic, +) + +__all__ = [ + # Constants + "FAIL_TO_DECODE_MNEMONIC_ERROR_MSG", + "KEY_LEN_BYTES", + "MNEMONIC_LEN", + "NOT_IN_WORDS_LIST_ERROR_MSG", + # Exceptions + "InvalidMnemonicError", + "InvalidSeedLengthError", + "MnemonicError", + "WordNotFoundError", + # Protocols + "WrappedLegacyMnemonic", + # Functions + "master_derivation_key_to_mnemonic", + "mnemonic_from_seed", + "mnemonic_to_master_derivation_key", + "secret_key_to_mnemonic", + "seed_from_mnemonic", +] diff --git a/src/algokit_utils/algorand.py b/src/algokit_utils/algorand.py index 18be6aca..f1d1804c 100644 --- a/src/algokit_utils/algorand.py +++ b/src/algokit_utils/algorand.py @@ -2,22 +2,23 @@ import time import typing_extensions -from algosdk.atomic_transaction_composer import TransactionSigner -from algosdk.kmd import KMDClient -from algosdk.transaction import SuggestedParams -from algosdk.v2client.algod import AlgodClient -from algosdk.v2client.indexer import IndexerClient +from algokit_algod_client import AlgodClient +from algokit_algod_client import models as algod_models +from algokit_indexer_client import IndexerClient +from algokit_kmd_client.client import KmdClient +from algokit_transact.signer import AddressWithTransactionSigner from algokit_utils.accounts.account_manager import AccountManager from algokit_utils.applications.app_deployer import AppDeployer from algokit_utils.applications.app_manager import AppManager from algokit_utils.assets.asset_manager import AssetManager from algokit_utils.clients.client_manager import AlgoSdkClients, ClientManager from algokit_utils.models.network import AlgoClientConfigs, AlgoClientNetworkConfig -from algokit_utils.protocols.account import TransactionSignerAccountProtocol +from algokit_utils.protocols.signer import TransactionSigner from algokit_utils.transactions.transaction_composer import ( ErrorTransformer, TransactionComposer, + TransactionComposerParams, ) from algokit_utils.transactions.transaction_creator import AlgorandClientTransactionCreator from algokit_utils.transactions.transaction_sender import AlgorandClientTransactionSender @@ -48,7 +49,7 @@ def __init__(self, config: AlgoClientConfigs | AlgoSdkClients): new_group=lambda: self.new_group(), ) - self._cached_suggested_params: SuggestedParams | None = None + self._cached_suggested_params: algod_models.SuggestedParams | None = None self._cached_suggested_params_expiry: float | None = None self._cached_suggested_params_timeout: int = 3_000 # three seconds self._default_validity_window: int | None = None @@ -66,16 +67,14 @@ def set_default_validity_window(self, validity_window: int) -> typing_extensions self._default_validity_window = validity_window return self - def set_default_signer( - self, signer: TransactionSigner | TransactionSignerAccountProtocol - ) -> typing_extensions.Self: + def set_default_signer(self, signer: TransactionSigner | AddressWithTransactionSigner) -> typing_extensions.Self: """ Sets the default signer to use if no other signer is specified. - :param signer: The signer to use, either a `TransactionSigner` or a `TransactionSignerAccountProtocol` + :param signer: The signer to use, either a `TransactionSigner` or an `AddressWithTransactionSigner` :return: The `AlgorandClient` so method calls can be chained :example: - >>> signer = SigningAccount(private_key=..., address=...) + >>> signer = account_manager.random() # Returns AddressWithSigners >>> algorand = AlgorandClient.mainnet().set_default_signer(signer) """ self._account_manager.set_default_signer(signer) @@ -89,31 +88,31 @@ def set_signer(self, sender: str, signer: TransactionSigner) -> typing_extension :param signer: The signer to sign transactions with for the given sender :return: The `AlgorandClient` so method calls can be chained :example: - >>> signer = SigningAccount(private_key=..., address=...) - >>> algorand = AlgorandClient.mainnet().set_signer(signer.addr, signer.signer) + >>> account = account_manager.random() # Returns AddressWithSigners + >>> algorand = AlgorandClient.mainnet().set_signer(account.addr, account.signer) """ self._account_manager.set_signer(sender, signer) return self - def set_signer_from_account(self, signer: TransactionSignerAccountProtocol) -> typing_extensions.Self: + def set_signer_from_account(self, signer: AddressWithTransactionSigner) -> typing_extensions.Self: """ Sets the default signer to use if no other signer is specified. - :param signer: The signer to use, either a `TransactionSigner` or a `TransactionSignerAccountProtocol` + :param signer: The signer to use, either a `TransactionSigner` or an `AddressWithTransactionSigner` :return: The `AlgorandClient` so method calls can be chained :example: >>> accountManager = AlgorandClient.mainnet() - >>> accountManager.set_signer_from_account(TransactionSignerAccount(address=..., signer=...)) - >>> accountManager.set_signer_from_account(algosdk.LogicSigAccount(program, args)) - >>> accountManager.set_signer_from_account(SigningAccount(private_key=..., address=...)) - >>> accountManager.set_signer_from_account(MultisigAccount(metadata, signing_accounts)) + >>> accountManager.set_signer_from_account(AddressWithSigners(addr=..., signer=...)) + >>> accountManager.set_signer_from_account(LogicSigAccount(logic=..., args=...)) + >>> accountManager.set_signer_from_account(account_manager.random()) # AddressWithSigners + >>> accountManager.set_signer_from_account(MultisigAccount(metadata, sub_signers)) >>> accountManager.set_signer_from_account(account) """ self._account_manager.set_default_signer(signer) return self def set_suggested_params_cache( - self, suggested_params: SuggestedParams, until: float | None = None + self, suggested_params: algod_models.SuggestedParams, until: float | None = None ) -> typing_extensions.Self: """ Sets a cache value to use for suggested params. @@ -140,7 +139,7 @@ def set_suggested_params_cache_timeout(self, timeout: int) -> typing_extensions. self._cached_suggested_params_timeout = timeout return self - def get_suggested_params(self) -> SuggestedParams: + def get_suggested_params(self) -> algod_models.SuggestedParams: """ Get suggested params for a transaction (either cached or from algod if the cache is stale or empty) @@ -182,15 +181,18 @@ def new_group(self) -> TransactionComposer: :example: >>> composer = AlgorandClient.mainnet().new_group() - >>> result = await composer.add_transaction(payment).send() + >>> result = composer.add_transaction(payment).send() """ return TransactionComposer( - algod=self.client.algod, - get_signer=lambda addr: self.account.get_signer(addr), - get_suggested_params=self.get_suggested_params, - default_validity_window=self._default_validity_window, - error_transformers=list(self._error_transformers), + TransactionComposerParams( + algod=self.client.algod, + get_signer=lambda addr: self.account.get_signer(addr), + get_suggested_params=self.get_suggested_params, + default_validity_window=self._default_validity_window, + app_manager=self._app_manager, + error_transformers=list(self._error_transformers), + ) ) @property @@ -248,12 +250,13 @@ def send(self) -> AlgorandClientTransactionSender: Methods for sending a transaction and waiting for confirmation :example: - >>> result = await AlgorandClient.mainnet().send.payment( - >>> PaymentParams( - >>> sender="SENDERADDRESS", - >>> receiver="RECEIVERADDRESS", - >>> amount=AlgoAmount(algo-1) - >>> )) + >>> result = AlgorandClient.mainnet().send.payment( + >>> PaymentParams( + >>> sender="SENDERADDRESS", + >>> receiver="RECEIVERADDRESS", + >>> amount=AlgoAmount(algo=1) + >>> ) + >>> ) """ return self._transaction_sender @@ -328,7 +331,7 @@ def mainnet() -> "AlgorandClient": @staticmethod def from_clients( - algod: AlgodClient, indexer: IndexerClient | None = None, kmd: KMDClient | None = None + algod: AlgodClient, indexer: IndexerClient | None = None, kmd: KmdClient | None = None ) -> "AlgorandClient": """ Returns an `AlgorandClient` pointing to the given client(s). diff --git a/src/algokit_utils/application_client.py b/src/algokit_utils/application_client.py deleted file mode 100644 index a81118bd..00000000 --- a/src/algokit_utils/application_client.py +++ /dev/null @@ -1,11 +0,0 @@ -import warnings - -warnings.warn( - """The legacy v2 application_client module is deprecated and will be removed in a future version. - Use `AppClient` abstraction from `algokit_utils.applications` instead. -""", - DeprecationWarning, - stacklevel=2, -) - -from algokit_utils._legacy_v2.application_client import * # noqa: F403, E402 diff --git a/src/algokit_utils/application_specification.py b/src/algokit_utils/application_specification.py deleted file mode 100644 index f6d51c48..00000000 --- a/src/algokit_utils/application_specification.py +++ /dev/null @@ -1,48 +0,0 @@ -import warnings - -from typing_extensions import deprecated - -warnings.warn( - """The legacy v2 application_specification module is deprecated and will be removed in a future version. - Use `from algokit_utils.applications.app_spec.arc32 import ...` to access Arc32 app spec instead. - By default, the ARC52Contract is a recommended app spec to use, serving as a replacement - for legacy 'ApplicationSpecification' class. - To convert legacy app specs to ARC52, use `Arc56Contract.from_arc32`. -""", - DeprecationWarning, - stacklevel=2, -) - -from algokit_utils.applications.app_spec.arc32 import ( # noqa: E402 # noqa: E402 - AppSpecStateDict, - Arc32Contract, - CallConfig, - DefaultArgumentDict, - DefaultArgumentType, - MethodConfigDict, - MethodHints, - OnCompleteActionName, -) - - -@deprecated( - "Use `Arc32Contract` from algokit_utils.applications instead. Example:\n" - "```python\n" - "from algokit_utils.applications import Arc32Contract\n" - "app_spec = Arc32Contract.from_json(app_spec_json)\n" - "```" -) -class ApplicationSpecification(Arc32Contract): - """Deprecated class for ARC-0032 application specification""" - - -__all__ = [ - "AppSpecStateDict", - "ApplicationSpecification", - "CallConfig", - "DefaultArgumentDict", - "DefaultArgumentType", - "MethodConfigDict", - "MethodHints", - "OnCompleteActionName", -] diff --git a/src/algokit_utils/applications/abi.py b/src/algokit_utils/applications/abi.py index 2be639ba..a29dfc98 100644 --- a/src/algokit_utils/applications/abi.py +++ b/src/algokit_utils/applications/abi.py @@ -1,268 +1,273 @@ from __future__ import annotations +import base64 +import warnings +from collections.abc import Sequence from dataclasses import dataclass -from typing import TYPE_CHECKING, Any, TypeAlias +from typing import TypeAlias, cast -import algosdk -from algosdk.abi.method import Method as AlgorandABIMethod -from algosdk.atomic_transaction_composer import ABIResult +from typing_extensions import deprecated -from algokit_utils.applications.app_spec.arc56 import Arc56Contract, StructField -from algokit_utils.applications.app_spec.arc56 import Method as Arc56Method - -if TYPE_CHECKING: - from algokit_utils.models.state import BoxName +from algokit_abi import abi, arc56 +from algokit_algod_client import models as algod_models +from algokit_utils.models.state import BoxName ABIValue: TypeAlias = ( - bool | int | str | bytes | bytearray | list["ABIValue"] | tuple["ABIValue"] | dict[str, "ABIValue"] + bool | int | str | bytes | bytearray | list["ABIValue"] | tuple["ABIValue"] | dict[str, "ABIValue"] | object ) -ABIStruct: TypeAlias = dict[str, list[dict[str, "ABIValue"]]] +ABIStruct: TypeAlias = dict[str, list[dict[str, "ABIValue"]]] | object Arc56ReturnValueType: TypeAlias = ABIValue | ABIStruct | None +ABIType: TypeAlias = abi.ABIType +ABIArgumentType: TypeAlias = abi.ABIType | arc56.TransactionType | arc56.ReferenceType +Arc56Method: TypeAlias = arc56.Method +ConfirmationResponse: TypeAlias = algod_models.PendingTransactionResponse -ABIType: TypeAlias = algosdk.abi.ABIType -ABIArgumentType: TypeAlias = algosdk.abi.ABIType | algosdk.abi.ABITransactionType | algosdk.abi.ABIReferenceType +ABI_RETURN_HASH = b"\x15\x1f\x7c\x75" +ABI_RETURN_PREFIX_LENGTH = len(ABI_RETURN_HASH) -__all__ = [ - "ABIArgumentType", - "ABIReturn", - "ABIStruct", - "ABIType", - "ABIValue", - "Arc56ReturnValueType", - "BoxABIValue", - "get_abi_decoded_value", - "get_abi_encoded_value", - "get_abi_struct_from_abi_tuple", - "get_abi_tuple_from_abi_struct", - "get_abi_tuple_type_from_abi_struct_definition", - "get_arc56_value", -] + +def _warn_deprecated(message: str) -> None: + warnings.warn(message, DeprecationWarning, stacklevel=3) -@dataclass(kw_only=True) +@dataclass(slots=True) class ABIReturn: """Represents the return value from an ABI method call. - Wraps the raw return value and decoded value along with any decode errors. + Aligns with the Rust model: always carries the method, raw bytes, decoded value (if available), + and any decode error. Transaction context should live on the send result, not here. """ - raw_value: bytes | None = None - """The raw return value from the method call""" - value: ABIValue | None = None - """The decoded return value from the method call""" - method: AlgorandABIMethod | None = None - """The ABI method definition""" - decode_error: Exception | None = None - """The exception that occurred during decoding, if any""" - tx_info: dict[str, Any] | None = None - """The transaction info for the method call from raw algosdk `ABIResult`""" - - def __init__(self, result: ABIResult) -> None: - self.decode_error = result.decode_error - if not self.decode_error: - self.raw_value = result.raw_value - self.value = result.return_value - self.method = result.method - self.tx_info = result.tx_info + method: Arc56Method | None + raw_value: bytes + value: ABIValue | None + decode_error: Exception | None + _tx_info: ConfirmationResponse | None = None + + def __init__( + self, + *, + method: Arc56Method | None, + raw_value: bytes = b"", + value: ABIValue | None = None, + decode_error: Exception | None = None, + tx_info: ConfirmationResponse | None = None, + ) -> None: + self.method = method + self.raw_value = raw_value or b"" + self.value = value + self.decode_error = decode_error + self._tx_info = tx_info @property def is_success(self) -> bool: - """Returns True if the ABI call was successful (no decode error) - - :return: True if no decode error occurred, False otherwise - """ + """Returns True if the ABI call was decoded successfully.""" return self.decode_error is None - def get_arc56_value( - self, method: Arc56Method | AlgorandABIMethod, structs: dict[str, list[StructField]] - ) -> Arc56ReturnValueType: - """Gets the ARC-56 formatted return value. - - :param method: The ABI method definition - :param structs: Dictionary of struct definitions - :return: The decoded return value in ARC-56 format - """ + @property + @deprecated( + "ABIReturn.tx_info is deprecated; read the transaction confirmation from the send result " + "(e.g. SendAppTransactionResult.confirmation)." + ) + def tx_info(self) -> ConfirmationResponse | None: + """Deprecated: transaction info now lives on the send result.""" + _warn_deprecated( + "ABIReturn.tx_info is deprecated; read the transaction confirmation from the send result " + "(e.g. SendAppTransactionResult.confirmation)." + ) + return self._tx_info + + def get_arc56_value(self, method: arc56.Method, structs: dict[str, object] | None = None) -> Arc56ReturnValueType: + """Deprecated: use `value` directly.""" + _warn_deprecated("ABIReturn.get_arc56_value is deprecated; use `ABIReturn.value` instead.") return get_arc56_value(self, method, structs) +@dataclass(slots=True) +@deprecated("ABIResult is deprecated; call extract_abi_return_from_logs(...) and work with ABIReturn instead.") +class ABIResult(ABIReturn): + """Deprecated wrapper that previously carried tx context plus ABI data.""" + + tx_id: str | None = None + + def __init__( + self, + *, + tx_id: str | None = None, + raw_value: bytes = b"", + value: ABIValue | None = None, + decode_error: Exception | None = None, + tx_info: ConfirmationResponse | None = None, + method: Arc56Method | None = None, + ) -> None: + _warn_deprecated("ABIResult is deprecated; call extract_abi_return_from_logs(...) and use ABIReturn instead.") + super().__init__(method=method, raw_value=raw_value, value=value, decode_error=decode_error, tx_info=tx_info) + self.tx_id = tx_id + + @classmethod + @deprecated( + "ABIResult.from_abireturn is deprecated; keep the tx_id alongside the send result and use ABIReturn directly." + ) + def from_abireturn(cls, abi_return: ABIReturn, tx_id: str | None = None) -> ABIResult: + _warn_deprecated( + "ABIResult.from_abireturn is deprecated; keep the tx_id alongside the send result " + "and use ABIReturn directly." + ) + return cls( + tx_id=tx_id, + raw_value=abi_return.raw_value, + value=abi_return.value, + decode_error=abi_return.decode_error, + tx_info=abi_return._tx_info, # noqa: SLF001 + method=abi_return.method, + ) + + +def _decode_log_entry(log_entry: bytes | bytearray | memoryview | str) -> bytes: + return bytes(log_entry) if isinstance(log_entry, bytes | bytearray | memoryview) else base64.b64decode(log_entry) + + +def extract_abi_return_from_logs(confirmation: ConfirmationResponse, method: Arc56Method) -> ABIReturn: + """Decode ABI return value from a transaction confirmation log.""" + returns = method.returns + return_type = returns.type if returns else arc56.Void + + if return_type == arc56.Void: + return ABIReturn(method=method, raw_value=b"", value=None, decode_error=None, tx_info=confirmation) + + logs: Sequence[bytes | bytearray | memoryview | str | None] = confirmation.logs or [] + if not logs: + return ABIReturn( + method=method, + raw_value=b"", + value=None, + decode_error=ValueError("App call transaction did not log a return value"), + tx_info=confirmation, + ) + + last_log = logs[-1] + if last_log is None: + return ABIReturn( + method=method, + raw_value=b"", + value=None, + decode_error=ValueError("App call transaction did not log a return value"), + tx_info=confirmation, + ) + + result_bytes = _decode_log_entry(last_log) + if len(result_bytes) < ABI_RETURN_PREFIX_LENGTH or result_bytes[:ABI_RETURN_PREFIX_LENGTH] != ABI_RETURN_HASH: + return ABIReturn( + method=method, + raw_value=b"", + value=None, + decode_error=ValueError("App call transaction did not log a return value"), + tx_info=confirmation, + ) + + raw_value = result_bytes[ABI_RETURN_PREFIX_LENGTH:] + method_return_type = cast(abi.ABIType, return_type) + try: + decoded = method_return_type.decode(raw_value) + return ABIReturn( + method=method, + raw_value=raw_value, + value=decoded, + decode_error=None, + tx_info=confirmation, + ) + except Exception as err: + return ABIReturn( + method=method, + raw_value=raw_value, + value=None, + decode_error=err, + tx_info=confirmation, + ) + + +@deprecated("parse_abi_method_result is deprecated; call extract_abi_return_from_logs(confirmation, method) instead.") +def parse_abi_method_result(method: Arc56Method, tx_id: str, txn: ConfirmationResponse) -> ABIResult: + """Deprecated: use extract_abi_return_from_logs instead.""" + _warn_deprecated("parse_abi_method_result is deprecated; call extract_abi_return_from_logs(confirmation, method).") + abi_return = extract_abi_return_from_logs(txn, method) + return ABIResult.from_abireturn(abi_return, tx_id) + + +@deprecated("get_arc56_value is deprecated; use ABIReturn.value instead.") def get_arc56_value( - abi_return: ABIReturn, method: Arc56Method | AlgorandABIMethod, structs: dict[str, list[StructField]] + abi_return: ABIReturn, method: arc56.Method, structs: dict[str, object] | None = None ) -> Arc56ReturnValueType: - """Gets the ARC-56 formatted return value from an ABI return. - - :param abi_return: The ABI return value to decode - :param method: The ABI method definition - :param structs: Dictionary of struct definitions - :raises ValueError: If there was an error decoding the return value - :return: The decoded return value in ARC-56 format - """ - if isinstance(method, AlgorandABIMethod): - type_str = method.returns.type - struct = None # AlgorandABIMethod doesn't have struct info - else: - type_str = method.returns.type - struct = method.returns.struct - - if type_str == "void" or abi_return.value is None: - return None - + """Deprecated: use `ABIReturn.value` instead.""" + _warn_deprecated("get_arc56_value is deprecated; use ABIReturn.value instead.") + _ = method # Accepted for compatibility with generated clients + _ = structs # Accepted for compatibility with generated clients if abi_return.decode_error: raise ValueError(abi_return.decode_error) + return abi_return.value - raw_value = abi_return.raw_value - - # Handle AVM types - if type_str == "AVMBytes": - return raw_value - if type_str == "AVMString" and raw_value: - return raw_value.decode("utf-8") - if type_str == "AVMUint64" and raw_value: - return ABIType.from_string("uint64").decode(raw_value) # type: ignore[no-any-return] - - # Handle structs - if struct and struct in structs: - return_tuple = abi_return.value - return Arc56Contract.get_abi_struct_from_abi_tuple(return_tuple, structs[struct], structs) - # Return as-is - return abi_return.value +__all__ = [ + "ABIArgumentType", + "ABIResult", + "ABIReturn", + "ABIStruct", + "ABIType", + "ABIValue", + "Arc56ReturnValueType", + "BoxABIValue", + "extract_abi_return_from_logs", + "get_abi_decoded_value", + "get_abi_encoded_value", + "get_arc56_value", + "parse_abi_method_result", +] -def get_abi_encoded_value(value: Any, type_str: str, structs: dict[str, list[StructField]]) -> bytes: # noqa: PLR0911, ANN401 +def get_abi_encoded_value(value: object, abi_type: abi.ABIType | arc56.AVMType) -> bytes: """Encodes a value according to its ABI type. :param value: The value to encode - :param type_str: The ABI type string - :param structs: Dictionary of struct definitions - :raises ValueError: If the value cannot be encoded for the given type + :param abi_type: The ABI or AVM type :return: The ABI encoded bytes """ if isinstance(value, (bytes | bytearray)): - return value - if type_str == "AVMUint64": - return ABIType.from_string("uint64").encode(value) - if type_str in ("AVMBytes", "AVMString"): - if isinstance(value, str): - return value.encode("utf-8") - if not isinstance(value, (bytes | bytearray)): - raise ValueError(f"Expected bytes value for {type_str}, but got {type(value)}") - return value - if type_str in structs: - tuple_type = get_abi_tuple_type_from_abi_struct_definition(structs[type_str], structs) - if isinstance(value, (list | tuple)): - return tuple_type.encode(value) # type: ignore[arg-type] - else: - tuple_values = get_abi_tuple_from_abi_struct(value, structs[type_str], structs) - return tuple_type.encode(tuple_values) - else: - abi_type = ABIType.from_string(type_str) - return abi_type.encode(value) + return bytes(value) + if abi_type == arc56.AVMType.UINT64 and isinstance(value, int): + return abi.ABIType.from_string("uint64").encode(value) + if abi_type == arc56.AVMType.STRING and isinstance(value, str): + return value.encode("utf-8") + if abi_type == arc56.AVMType.BYTES and isinstance(value, bytes | bytearray): + return bytes(value) + assert not isinstance(abi_type, arc56.AVMType), "unexpected AVMType" + return abi_type.encode(value) def get_abi_decoded_value( - value: bytes | int | str, type_str: str | ABIArgumentType, structs: dict[str, list[StructField]] + value: bytes | int | str, + decode_type: arc56.AVMType | abi.ABIType | arc56.ReferenceType, ) -> ABIValue: """Decodes a value according to its ABI type. :param value: The value to decode - :param type_str: The ABI type string or type object - :param structs: Dictionary of struct definitions + :param decode_type: The ABI type string or type object :return: The decoded ABI value """ - type_value = str(type_str) - if type_value == "AVMBytes" or not isinstance(value, bytes): + # map reference types to their value equivalents + if decode_type in (arc56.ReferenceType.ASSET, arc56.ReferenceType.APPLICATION): + decode_type = abi.UintType(64) + elif decode_type == arc56.ReferenceType.ACCOUNT: + decode_type = abi.AddressType() + if decode_type == arc56.AVMType.UINT64: + decode_type = abi.UintType(64) + if decode_type == arc56.AVMType.BYTES or not isinstance(value, bytes): return value - if type_value == "AVMString": + if decode_type == arc56.AVMType.STRING: return value.decode("utf-8") - if type_value == "AVMUint64": - return ABIType.from_string("uint64").decode(value) # type: ignore[no-any-return] - if type_value in structs: - tuple_type = get_abi_tuple_type_from_abi_struct_definition(structs[type_value], structs) - decoded_tuple = tuple_type.decode(value) - return get_abi_struct_from_abi_tuple(decoded_tuple, structs[type_value], structs) - return ABIType.from_string(type_value).decode(value) # type: ignore[no-any-return] - - -def get_abi_tuple_from_abi_struct( - struct_value: dict[str, Any], - struct_fields: list[StructField], - structs: dict[str, list[StructField]], -) -> list[Any]: - """Converts an ABI struct to a tuple representation. - - :param struct_value: The struct value as a dictionary - :param struct_fields: List of struct field definitions - :param structs: Dictionary of struct definitions - :raises ValueError: If a required field is missing from the struct - :return: The struct as a tuple - """ - result = [] - for field in struct_fields: - key = field.name - if key not in struct_value: - raise ValueError(f"Missing value for field '{key}'") - value = struct_value[key] - field_type = field.type - if isinstance(field_type, str): - if field_type in structs: - value = get_abi_tuple_from_abi_struct(value, structs[field_type], structs) - elif isinstance(field_type, list): - value = get_abi_tuple_from_abi_struct(value, field_type, structs) - result.append(value) - return result - - -def get_abi_tuple_type_from_abi_struct_definition( - struct_def: list[StructField], structs: dict[str, list[StructField]] -) -> algosdk.abi.TupleType: - """Creates a TupleType from a struct definition. - - :param struct_def: The struct field definitions - :param structs: Dictionary of struct definitions - :raises ValueError: If a field type is invalid - :return: The TupleType representing the struct - """ - types = [] - for field in struct_def: - field_type = field.type - if isinstance(field_type, str): - if field_type in structs: - types.append(get_abi_tuple_type_from_abi_struct_definition(structs[field_type], structs)) - else: - types.append(ABIType.from_string(field_type)) # type: ignore[arg-type] - elif isinstance(field_type, list): - types.append(get_abi_tuple_type_from_abi_struct_definition(field_type, structs)) - else: - raise ValueError(f"Invalid field type: {field_type}") - return algosdk.abi.TupleType(types) - - -def get_abi_struct_from_abi_tuple( - decoded_tuple: Any, # noqa: ANN401 - struct_fields: list[StructField], - structs: dict[str, list[StructField]], -) -> dict[str, Any]: - """Converts a decoded tuple to an ABI struct. - - :param decoded_tuple: The tuple to convert - :param struct_fields: List of struct field definitions - :param structs: Dictionary of struct definitions - :return: The tuple as a struct dictionary - """ - result = {} - for i, field in enumerate(struct_fields): - key = field.name - field_type = field.type - value = decoded_tuple[i] - if isinstance(field_type, str): - if field_type in structs: - value = get_abi_struct_from_abi_tuple(value, structs[field_type], structs) - elif isinstance(field_type, list): - value = get_abi_struct_from_abi_tuple(value, field_type, structs) - result[key] = value - return result + assert isinstance(decode_type, abi.ABIType), "unexpected ABIType" + return decode_type.decode(value) # type: ignore[no-any-return] @dataclass(kw_only=True, frozen=True) diff --git a/src/algokit_utils/applications/app_client.py b/src/algokit_utils/applications/app_client.py index 2f12531c..3cda25cb 100644 --- a/src/algokit_utils/applications/app_client.py +++ b/src/algokit_utils/applications/app_client.py @@ -1,17 +1,18 @@ -from __future__ import annotations - import base64 import copy import json import os -from collections.abc import Sequence +from collections.abc import Callable, Sequence from dataclasses import asdict, dataclass, fields, replace from typing import TYPE_CHECKING, Any, Generic, Literal, TypedDict, TypeVar -import algosdk -from algosdk.source_map import SourceMap -from algosdk.transaction import OnComplete, Transaction +from typing_extensions import assert_never +from algokit_abi import abi, arc32, arc56 +from algokit_common import ProgramSourceMap, get_application_address +from algokit_transact.models.common import OnApplicationComplete +from algokit_transact.models.transaction import Transaction +from algokit_transact.signer import AddressWithTransactionSigner from algokit_utils._debugging import PersistSourceMapInput, persist_sourcemaps from algokit_utils.applications.abi import ( ABIReturn, @@ -22,20 +23,10 @@ BoxABIValue, get_abi_decoded_value, get_abi_encoded_value, - get_abi_tuple_from_abi_struct, -) -from algokit_utils.applications.app_spec.arc32 import Arc32Contract -from algokit_utils.applications.app_spec.arc56 import ( - Arc56Contract, - Method, - PcOffsetMethod, - ProgramSourceInfo, - SourceInfo, - StorageKey, - StorageMap, ) from algokit_utils.config import config from algokit_utils.errors.logic_error import LogicError, parse_logic_error +from algokit_utils.models.amount import AlgoAmount from algokit_utils.models.application import ( AppSourceMaps, AppState, @@ -43,7 +34,6 @@ ) from algokit_utils.models.state import BoxName, BoxValue from algokit_utils.models.transaction import SendParams -from algokit_utils.protocols.account import TransactionSignerAccountProtocol from algokit_utils.transactions.transaction_composer import ( AppCallMethodCallParams, AppCallParams, @@ -54,7 +44,7 @@ AppUpdateParams, BuiltTransactions, PaymentParams, - SendAtomicTransactionComposerResults, + SendTransactionComposerResults, ) from algokit_utils.transactions.transaction_sender import ( SendAppTransactionResult, @@ -63,15 +53,14 @@ ) if TYPE_CHECKING: - from collections.abc import Callable - - from algosdk.atomic_transaction_composer import TransactionSigner - from algokit_utils.algorand import AlgorandClient from algokit_utils.applications.app_deployer import ApplicationLookup from algokit_utils.applications.app_manager import AppManager - from algokit_utils.models.amount import AlgoAmount from algokit_utils.models.state import BoxIdentifier, BoxReference, TealTemplateParams + from algokit_utils.protocols.signer import TransactionSigner +else: + AlgorandClient = ApplicationLookup = AppManager = TransactionSigner = Any # type: ignore[assignment] + BoxIdentifier = BoxReference = TealTemplateParams = Any # type: ignore[assignment] __all__ = [ "AppClient", @@ -167,11 +156,11 @@ def get_constant_block_offset(program: bytes) -> int: # noqa: C901 CreateOnComplete = Literal[ - OnComplete.NoOpOC, - OnComplete.UpdateApplicationOC, - OnComplete.DeleteApplicationOC, - OnComplete.OptInOC, - OnComplete.CloseOutOC, + OnApplicationComplete.NoOp, + OnApplicationComplete.UpdateApplication, + OnApplicationComplete.DeleteApplication, + OnApplicationComplete.OptIn, + OnApplicationComplete.CloseOut, ] @@ -243,7 +232,7 @@ class CommonAppCallParams: """First valid round number""" last_valid_round: int | None = None """Last valid round number""" - on_complete: OnComplete | None = None + on_complete: OnApplicationComplete | None = None """Optional on complete action""" @@ -287,12 +276,14 @@ class AppClientBareCallParams(CommonAppCallParams): class AppClientBareCallCreateParams(CommonAppCallCreateParams): """Parameters for creating application with bare call.""" + args: list[bytes] | None = None + """Optional arguments""" on_complete: CreateOnComplete | None = None """Optional on complete action""" @dataclass(kw_only=True, frozen=True) -class BaseAppClientMethodCallParams(Generic[ArgsT, MethodT], CommonAppCallParams): +class BaseAppClientMethodCallParams(CommonAppCallParams, Generic[ArgsT, MethodT]): """Base parameters for application method calls.""" method: MethodT @@ -374,7 +365,7 @@ def get_map(self, map_name: str) -> dict[str, ABIValue]: class _StateAccessor: - def __init__(self, client: AppClient) -> None: + def __init__(self, client: "AppClient") -> None: self._client = client self._algorand = client._algorand self._app_id = client._app_id @@ -415,7 +406,7 @@ def get_value(name: str) -> ABIValue | None: """ metadata = self._app_spec.state.keys.box[name] value = self._algorand.app.get_box_value(self._app_id, base64.b64decode(metadata.key)) - return get_abi_decoded_value(value, metadata.value_type, self._app_spec.structs) + return get_abi_decoded_value(value, metadata.value_type) def get_map_value(map_name: str, key: bytes | Any) -> Any: # noqa: ANN401 """Get a value from a box map. @@ -429,10 +420,10 @@ def get_map_value(map_name: str, key: bytes | Any) -> Any: # noqa: ANN401 """ metadata = self._app_spec.state.maps.box[map_name] prefix = base64.b64decode(metadata.prefix or "") - encoded_key = get_abi_encoded_value(key, metadata.key_type, self._app_spec.structs) + encoded_key = get_abi_encoded_value(key, metadata.key_type) full_key = base64.b64encode(prefix + encoded_key).decode("utf-8") value = self._algorand.app.get_box_value(self._app_id, base64.b64decode(full_key)) - return get_abi_decoded_value(value, metadata.value_type, self._app_spec.structs) + return get_abi_decoded_value(value, metadata.value_type) def get_map(map_name: str) -> dict[str, ABIValue]: """Get all key-value pairs from a box map. @@ -453,11 +444,10 @@ def get_map(map_name: str) -> dict[str, ABIValue]: continue try: - key = get_abi_decoded_value(box.name_raw[len(prefix) :], metadata.key_type, self._app_spec.structs) + key = get_abi_decoded_value(box.name_raw[len(prefix) :], metadata.key_type) value = get_abi_decoded_value( self._algorand.app.get_box_value(self._app_id, box.name_raw), metadata.value_type, - self._app_spec.structs, ) result[str(key)] = value except Exception as e: @@ -475,8 +465,8 @@ def get_map(map_name: str) -> dict[str, ABIValue]: def _get_state_methods( # noqa: C901 self, state_getter: Callable[[], dict[str, AppState]], - key_getter: Callable[[], dict[str, StorageKey]], - map_getter: Callable[[], dict[str, StorageMap]], + key_getter: Callable[[], dict[str, arc56.StorageKey]], + map_getter: Callable[[], dict[str, arc56.StorageMap]], ) -> _AppClientStateMethods: def get_all() -> dict[str, Any]: state = state_getter() @@ -489,7 +479,7 @@ def get_value(name: str, app_state: dict[str, AppState] | None = None) -> ABIVal value = next((s for s in state.values() if s.key_base64 == key_info.key), None) if value and value.value_raw: - return get_abi_decoded_value(value.value_raw, key_info.value_type, self._app_spec.structs) + return get_abi_decoded_value(value.value_raw, key_info.value_type) return value.value if value else None @@ -498,11 +488,11 @@ def get_map_value(map_name: str, key: bytes | Any, app_state: dict[str, AppState metadata = map_getter()[map_name] prefix = base64.b64decode(metadata.prefix or "") - encoded_key = get_abi_encoded_value(key, metadata.key_type, self._app_spec.structs) + encoded_key = get_abi_encoded_value(key, metadata.key_type) full_key = base64.b64encode(prefix + encoded_key).decode("utf-8") value = next((s for s in state.values() if s.key_base64 == full_key), None) if value and value.value_raw: - return get_abi_decoded_value(value.value_raw, metadata.value_type, self._app_spec.structs) + return get_abi_decoded_value(value.value_raw, metadata.value_type) return value.value if value else None def get_map(map_name: str) -> dict[str, ABIValue]: @@ -518,17 +508,15 @@ def get_map(map_name: str) -> dict[str, ABIValue]: for key_encoded, value in prefixed_state.items(): key_bytes = key_encoded[len(prefix) :] try: - decoded_key = get_abi_decoded_value(key_bytes, metadata.key_type, self._app_spec.structs) + decoded_key = get_abi_decoded_value(key_bytes, metadata.key_type) except Exception as e: raise ValueError(f"Failed to decode key {key_encoded}") from e try: if value and value.value_raw: - decoded_value = get_abi_decoded_value( - value.value_raw, metadata.value_type, self._app_spec.structs - ) + decoded_value = get_abi_decoded_value(value.value_raw, metadata.value_type) else: - decoded_value = get_abi_decoded_value(value.value, metadata.value_type, self._app_spec.structs) + decoded_value = get_abi_decoded_value(value.value, metadata.value_type) except Exception as e: raise ValueError(f"Failed to decode value {value}") from e @@ -551,14 +539,14 @@ def get_global_state(self) -> dict[str, AppState]: class _BareParamsBuilder: - def __init__(self, client: AppClient) -> None: + def __init__(self, client: "AppClient") -> None: self._client = client self._algorand = client._algorand self._app_id = client._app_id self._app_spec = client._app_spec def _get_bare_params( - self, params: dict[str, Any] | None, on_complete: algosdk.transaction.OnComplete | None = None + self, params: dict[str, Any] | None, on_complete: OnApplicationComplete | None = None ) -> dict[str, Any]: params = params or {} sender = self._client._get_sender(params.get("sender")) @@ -567,7 +555,7 @@ def _get_bare_params( "app_id": self._app_id, "sender": sender, "signer": self._client._get_signer(params.get("sender"), params.get("signer")), - "on_complete": on_complete or OnComplete.NoOpOC, + "on_complete": on_complete or OnApplicationComplete.NoOp, } def update( @@ -580,7 +568,7 @@ def update( :return: Parameters for updating the application """ call_params: AppUpdateParams = AppUpdateParams( - **self._get_bare_params(params.__dict__ if params else {}, OnComplete.UpdateApplicationOC) + **self._get_bare_params(params.__dict__ if params else {}, OnApplicationComplete.UpdateApplication) ) return call_params @@ -591,7 +579,7 @@ def opt_in(self, params: AppClientBareCallParams | None = None) -> AppCallParams :return: Parameters for opting into the application """ call_params: AppCallParams = AppCallParams( - **self._get_bare_params(params.__dict__ if params else {}, OnComplete.OptInOC) + **self._get_bare_params(params.__dict__ if params else {}, OnApplicationComplete.OptIn) ) return call_params @@ -602,7 +590,7 @@ def delete(self, params: AppClientBareCallParams | None = None) -> AppCallParams :return: Parameters for deleting the application """ call_params: AppCallParams = AppCallParams( - **self._get_bare_params(params.__dict__ if params else {}, OnComplete.DeleteApplicationOC) + **self._get_bare_params(params.__dict__ if params else {}, OnApplicationComplete.DeleteApplication) ) return call_params @@ -613,7 +601,7 @@ def clear_state(self, params: AppClientBareCallParams | None = None) -> AppCallP :return: Parameters for clearing application state """ call_params: AppCallParams = AppCallParams( - **self._get_bare_params(params.__dict__ if params else {}, OnComplete.ClearStateOC) + **self._get_bare_params(params.__dict__ if params else {}, OnApplicationComplete.ClearState) ) return call_params @@ -624,27 +612,29 @@ def close_out(self, params: AppClientBareCallParams | None = None) -> AppCallPar :return: Parameters for closing out of the application """ call_params: AppCallParams = AppCallParams( - **self._get_bare_params(params.__dict__ if params else {}, OnComplete.CloseOutOC) + **self._get_bare_params(params.__dict__ if params else {}, OnApplicationComplete.CloseOut) ) return call_params def call( - self, params: AppClientBareCallParams | None = None, on_complete: OnComplete | None = OnComplete.NoOpOC + self, + params: AppClientBareCallParams | None = None, + on_complete: OnApplicationComplete | None = OnApplicationComplete.NoOp, ) -> AppCallParams: """Create parameters for calling an application. :param params: Optional call parameters with on complete action, defaults to None - :param on_complete: The OnComplete action, defaults to OnComplete.NoOpOC + :param on_complete: The OnApplicationComplete action, defaults to OnApplicationComplete.NoOp :return: Parameters for calling the application """ call_params: AppCallParams = AppCallParams( - **self._get_bare_params(params.__dict__ if params else {}, on_complete or OnComplete.NoOpOC) + **self._get_bare_params(params.__dict__ if params else {}, on_complete or OnApplicationComplete.NoOp) ) return call_params class _MethodParamsBuilder: - def __init__(self, client: AppClient) -> None: + def __init__(self, client: "AppClient") -> None: self._client = client self._algorand = client._algorand self._app_id = client._app_id @@ -689,7 +679,7 @@ def opt_in(self, params: AppClientMethodCallParams) -> AppCallMethodCallParams: :return: Parameters for opting into the application """ input_params = self._get_abi_params( - params.__dict__, on_complete=params.on_complete or algosdk.transaction.OnComplete.OptInOC + params.__dict__, on_complete=params.on_complete or OnApplicationComplete.OptIn ) return AppCallMethodCallParams(**input_params) @@ -700,7 +690,7 @@ def call(self, params: AppClientMethodCallParams) -> AppCallMethodCallParams: :return: Parameters for calling the application method """ input_params = self._get_abi_params( - params.__dict__, on_complete=params.on_complete or algosdk.transaction.OnComplete.NoOpOC + params.__dict__, on_complete=params.on_complete or OnApplicationComplete.NoOp ) return AppCallMethodCallParams(**input_params) @@ -711,7 +701,7 @@ def delete(self, params: AppClientMethodCallParams) -> AppDeleteMethodCallParams :return: Parameters for deleting the application """ input_params = self._get_abi_params( - params.__dict__, on_complete=params.on_complete or algosdk.transaction.OnComplete.DeleteApplicationOC + params.__dict__, on_complete=params.on_complete or OnApplicationComplete.DeleteApplication ) return AppDeleteMethodCallParams(**input_params) @@ -734,7 +724,7 @@ def update( input_params = { **self._get_abi_params( - params.__dict__, on_complete=params.on_complete or algosdk.transaction.OnComplete.UpdateApplicationOC + params.__dict__, on_complete=params.on_complete or OnApplicationComplete.UpdateApplication ), **compile_params, } @@ -750,11 +740,11 @@ def close_out(self, params: AppClientMethodCallParams) -> AppCallMethodCallParam :return: Parameters for closing out of the application """ input_params = self._get_abi_params( - params.__dict__, on_complete=params.on_complete or algosdk.transaction.OnComplete.CloseOutOC + params.__dict__, on_complete=params.on_complete or OnApplicationComplete.CloseOut ) return AppCallMethodCallParams(**input_params) - def _get_abi_params(self, params: dict[str, Any], on_complete: algosdk.transaction.OnComplete) -> dict[str, Any]: + def _get_abi_params(self, params: dict[str, Any], on_complete: OnApplicationComplete) -> dict[str, Any]: input_params = copy.deepcopy(params) input_params["app_id"] = self._app_id @@ -763,7 +753,7 @@ def _get_abi_params(self, params: dict[str, Any], on_complete: algosdk.transacti input_params["signer"] = self._client._get_signer(params["sender"], params["signer"]) if params.get("method"): - input_params["method"] = self._app_spec.get_arc56_method(params["method"]).to_abi_method() + input_params["method"] = self._app_spec.get_abi_method(params["method"]) input_params["args"] = self._client._get_abi_args_with_default_values( method_name_or_signature=params["method"], args=params.get("args"), @@ -774,7 +764,7 @@ def _get_abi_params(self, params: dict[str, Any], on_complete: algosdk.transacti class _AppClientBareCallCreateTransactionMethods: - def __init__(self, client: AppClient) -> None: + def __init__(self, client: "AppClient") -> None: self._client = client self._algorand = client._algorand @@ -839,23 +829,27 @@ def close_out(self, params: AppClientBareCallParams | None = None) -> Transactio ) def call( - self, params: AppClientBareCallParams | None = None, on_complete: OnComplete | None = OnComplete.NoOpOC + self, + params: AppClientBareCallParams | None = None, + on_complete: OnApplicationComplete | None = OnApplicationComplete.NoOp, ) -> Transaction: """Create a transaction to call an application. Creates a transaction that will call this application with the specified parameters. :param params: Parameters for the application call including on complete action, defaults to None - :param on_complete: The OnComplete action, defaults to OnComplete.NoOpOC + :param on_complete: The OnApplicationComplete action, defaults to OnApplicationComplete.NoOp :return: The constructed application call transaction """ return self._algorand.create_transaction.app_call( - self._client.params.bare.call(params or AppClientBareCallParams(), on_complete or OnComplete.NoOpOC) + self._client.params.bare.call( + params or AppClientBareCallParams(), on_complete or OnApplicationComplete.NoOp + ) ) class _TransactionCreator: - def __init__(self, client: AppClient) -> None: + def __init__(self, client: "AppClient") -> None: self._client = client self._algorand = client._algorand self._app_id = client._app_id @@ -928,7 +922,7 @@ def call(self, params: AppClientMethodCallParams) -> BuiltTransactions: class _AppClientBareSendAccessor: - def __init__(self, client: AppClient) -> None: + def __init__(self, client: "AppClient") -> None: self._client = client self._algorand = client._algorand self._app_id = client._app_id @@ -960,14 +954,13 @@ def update( "deletable": compilation.get("deletable"), } ) - bare_params = self._client.params.bare.update(params) - bare_params.__setattr__("approval_program", bare_params.approval_program or compiled.compiled_approval) - bare_params.__setattr__("clear_state_program", bare_params.clear_state_program or compiled.compiled_clear) - call_result = self._client._handle_call_errors(lambda: self._algorand.send.app_update(bare_params, send_params)) - return SendAppTransactionResult[ABIReturn]( - **{**call_result.__dict__, **(compiled.__dict__ if compiled else {})}, - abi_return=AppManager.get_abi_return(call_result.confirmation, getattr(params, "method", None)), + bare_call_params = self._client.params.bare.call(params, on_complete=OnApplicationComplete.UpdateApplication) + bare_update_params = AppUpdateParams( + **bare_call_params.__dict__, + approval_program=compiled.approval_program, + clear_state_program=compiled.clear_state_program, ) + return self._client._handle_call_errors(lambda: self._algorand.send.app_update(bare_update_params, send_params)) def opt_in( self, params: AppClientBareCallParams | None = None, send_params: SendParams | None = None @@ -1040,7 +1033,7 @@ def close_out( def call( self, params: AppClientBareCallParams | None = None, - on_complete: OnComplete | None = None, + on_complete: OnApplicationComplete | None = None, send_params: SendParams | None = None, ) -> SendAppTransactionResult[ABIReturn]: """Send an application call transaction. @@ -1048,7 +1041,7 @@ def call( Creates and sends a transaction that will call this application with the specified parameters. :param params: Parameters for the application call including transaction options, defaults to None - :param on_complete: The OnComplete action, defaults to None + :param on_complete: The OnApplicationComplete action, defaults to None :param send_params: Send parameters, defaults to None :return: The result of sending the transaction, including ABI return value if applicable """ @@ -1060,7 +1053,7 @@ def call( class _TransactionSender: - def __init__(self, client: AppClient) -> None: + def __init__(self, client: "AppClient") -> None: self._client = client self._algorand = client._algorand self._app_id = client._app_id @@ -1104,7 +1097,7 @@ def opt_in( return self._client._handle_call_errors( lambda: self._client._process_method_call_return( lambda: self._algorand.send.app_call_method_call(self._client.params.opt_in(params), send_params), - self._app_spec.get_arc56_method(params.method), + self._app_spec.get_abi_method(params.method), ) ) @@ -1122,7 +1115,7 @@ def delete( return self._client._handle_call_errors( lambda: self._client._process_method_call_return( lambda: self._algorand.send.app_delete_method_call(self._client.params.delete(params), send_params), - self._app_spec.get_arc56_method(params.method), + self._app_spec.get_abi_method(params.method), ) ) @@ -1146,7 +1139,7 @@ def update( lambda: self._algorand.send.app_update_method_call( self._client.params.update(params, compilation_params), send_params ), - self._app_spec.get_arc56_method(params.method), + self._app_spec.get_abi_method(params.method), ) ) assert isinstance(result, SendAppUpdateTransactionResult) @@ -1166,7 +1159,7 @@ def close_out( return self._client._handle_call_errors( lambda: self._client._process_method_call_return( lambda: self._algorand.send.app_call_method_call(self._client.params.close_out(params), send_params), - self._app_spec.get_arc56_method(params.method), + self._app_spec.get_abi_method(params.method), ) ) @@ -1183,12 +1176,16 @@ def call( :return: The result of sending or simulating the transaction, including ABI return value if applicable """ is_read_only_call = ( - params.on_complete == algosdk.transaction.OnComplete.NoOpOC or params.on_complete is None - ) and self._app_spec.get_arc56_method(params.method).readonly + params.on_complete == OnApplicationComplete.NoOp or params.on_complete is None + ) and self._app_spec.get_abi_method(params.method).readonly if is_read_only_call: readonly_params = params readonly_send_params = send_params or SendParams() + reported_fee = ( + params.static_fee.micro_algo if params.static_fee else self._algorand.get_suggested_params().min_fee + ) + reset_reported_fee = False # Read-only calls do not require fees to be paid, as they are only simulated on the network. # With maximum opcode budget provided, ensure_budget won't create inner transactions, @@ -1196,12 +1193,16 @@ def call( # If max_fee is provided, use it as static_fee for potential benefits. if readonly_send_params.get("cover_app_call_inner_transaction_fees") and params.max_fee is not None: readonly_params = replace(readonly_params, static_fee=params.max_fee, extra_fee=None) + elif readonly_params.static_fee is None: + fallback_fee = params.max_fee or AlgoAmount.from_micro_algo(MAX_SIMULATE_OPCODE_BUDGET) + readonly_params = replace(readonly_params, static_fee=fallback_fee, extra_fee=None) + reset_reported_fee = True method_call_to_simulate = self._algorand.new_group().add_app_call_method_call( self._client.params.call(readonly_params) ) - def run_simulate() -> SendAtomicTransactionComposerResults: + def run_simulate() -> SendTransactionComposerResults: try: return method_call_to_simulate.simulate( allow_unnamed_resources=readonly_send_params.get("populate_app_call_resources") or True, @@ -1215,7 +1216,7 @@ def run_simulate() -> SendAtomicTransactionComposerResults: except Exception as e: # For read-only calls with max opcode budget, fee issues should be rare # but we can still provide helpful error message if they occur - if readonly_send_params.get("cover_app_call_inner_transaction_fees") and "fee too small" in str(e): + if readonly_send_params.get("cover_app_call_inner_transaction_fees") and "too small" in str(e): raise ValueError( "Fees were too small. You may need to increase the transaction `maxFee`." ) from e @@ -1223,23 +1224,24 @@ def run_simulate() -> SendAtomicTransactionComposerResults: simulate_response = self._client._handle_call_errors(run_simulate) + wrapped_transactions = simulate_response.transactions + if reset_reported_fee: + wrapped_transactions = [replace(txn, fee=reported_fee) for txn in wrapped_transactions] return SendAppTransactionResult[Arc56ReturnValueType]( tx_ids=simulate_response.tx_ids, - transactions=simulate_response.transactions, - transaction=simulate_response.transactions[-1], - confirmation=simulate_response.confirmations[-1] if simulate_response.confirmations else b"", + transactions=wrapped_transactions, + transaction=wrapped_transactions[-1], + confirmation=simulate_response.confirmations[-1], confirmations=simulate_response.confirmations, group_id=simulate_response.group_id or "", returns=simulate_response.returns, - abi_return=simulate_response.returns[-1].get_arc56_value( - self._app_spec.get_arc56_method(params.method), self._app_spec.structs - ), + abi_return=simulate_response.returns[-1].value, ) return self._client._handle_call_errors( lambda: self._client._process_method_call_return( lambda: self._algorand.send.app_call_method_call(self._client.params.call(params), send_params), - self._app_spec.get_arc56_method(params.method), + self._app_spec.get_abi_method(params.method), ) ) @@ -1248,7 +1250,7 @@ def run_simulate() -> SendAtomicTransactionComposerResults: class AppClientParams: """Full parameters for creating an app client""" - app_spec: Arc56Contract | Arc32Contract | str + app_spec: arc56.Arc56Contract | arc32.Arc32Contract | str """The application specification""" algorand: AlgorandClient """The Algorand client""" @@ -1260,9 +1262,9 @@ class AppClientParams: """The default sender address""" default_signer: TransactionSigner | None = None """The default transaction signer""" - approval_source_map: SourceMap | None = None + approval_source_map: ProgramSourceMap | None = None """The approval source map""" - clear_source_map: SourceMap | None = None + clear_source_map: ProgramSourceMap | None = None """The clear source map""" @@ -1275,20 +1277,19 @@ class AppClient: :param params: Parameters for creating the app client :example: + >>> # Get a signer from account manager + >>> account = algorand.account.from_mnemonic("your mnemonic here...") >>> params = AppClientParams( - ... app_spec=Arc56Contract.from_json(app_spec_json), + ... app_spec=arc56.Arc56Contract.from_json(app_spec_json), ... algorand=algorand, ... app_id=1234567890, ... app_name="My App", - ... default_sender="SENDERADDRESS", - ... default_signer=TransactionSigner( - ... account="SIGNERACCOUNT", - ... private_key="SIGNERPRIVATEKEY", - ... ), - ... approval_source_map=SourceMap( + ... default_sender=account.addr, + ... default_signer=account.signer, + ... approval_source_map=ProgramSourceMap( ... source="APPROVALSOURCE", ... ), - ... clear_source_map=SourceMap( + ... clear_source_map=ProgramSourceMap( ... source="CLEARSOURCE", ... ), ... ) @@ -1299,7 +1300,7 @@ def __init__(self, params: AppClientParams) -> None: self._app_id = params.app_id self._app_spec = self.normalise_app_spec(params.app_spec) self._algorand = params.algorand - self._app_address = algosdk.logic.get_application_address(self._app_id) + self._app_address = get_application_address(self._app_id) self._app_name = params.app_name or self._app_spec.name self._default_sender = params.default_sender self._default_signer = params.default_signer @@ -1347,7 +1348,7 @@ def app_name(self) -> str: return self._app_name @property - def app_spec(self) -> Arc56Contract: + def app_spec(self) -> arc56.Arc56Contract: """Get the application specification. :return: The ARC-56 contract specification for this application @@ -1400,7 +1401,7 @@ def create_transaction(self) -> _TransactionCreator: return self._create_transaction_accessor @staticmethod - def normalise_app_spec(app_spec: Arc56Contract | Arc32Contract | str) -> Arc56Contract: + def normalise_app_spec(app_spec: arc56.Arc56Contract | arc32.Arc32Contract | str) -> arc56.Arc56Contract: """Normalize an application specification to ARC-56 format. :param app_spec: The application specification to normalize. Can be raw arc32 or arc56 json, @@ -1413,30 +1414,32 @@ def normalise_app_spec(app_spec: Arc56Contract | Arc32Contract | str) -> Arc56Co """ if isinstance(app_spec, str): spec_dict = json.loads(app_spec) - spec = Arc32Contract.from_json(app_spec) if "hints" in spec_dict else spec_dict + spec = arc32.Arc32Contract.from_json(app_spec) if "hints" in spec_dict else spec_dict else: spec = app_spec match spec: - case Arc56Contract(): + case arc56.Arc56Contract(): return spec - case Arc32Contract(): - return Arc56Contract.from_arc32(spec.to_json()) + case arc32.Arc32Contract(): + from algokit_abi import arc32_to_arc56 + + return arc32_to_arc56(spec.to_json()) case dict(): - return Arc56Contract.from_dict(spec) + return arc56.Arc56Contract.from_dict(spec) case _: raise ValueError("Invalid app spec format") @staticmethod def from_network( - app_spec: Arc56Contract | Arc32Contract | str, + app_spec: arc56.Arc56Contract | arc32.Arc32Contract | str, algorand: AlgorandClient, app_name: str | None = None, default_sender: str | None = None, default_signer: TransactionSigner | None = None, - approval_source_map: SourceMap | None = None, - clear_source_map: SourceMap | None = None, - ) -> AppClient: + approval_source_map: ProgramSourceMap | None = None, + clear_source_map: ProgramSourceMap | None = None, + ) -> "AppClient": """Create an AppClient instance from network information. :param app_spec: The application specification @@ -1450,19 +1453,18 @@ def from_network( :raises Exception: If no app ID is found for the network :example: + >>> # Get a signer from account manager + >>> account = algorand.account.from_mnemonic("your mnemonic here...") >>> client = AppClient.from_network( - ... app_spec=Arc56Contract.from_json(app_spec_json), + ... app_spec=arc56.Arc56Contract.from_json(app_spec_json), ... algorand=algorand, ... app_name="My App", - ... default_sender="SENDERADDRESS", - ... default_signer=TransactionSigner( - ... account="SIGNERACCOUNT", - ... private_key="SIGNERPRIVATEKEY", - ... ), - ... approval_source_map=SourceMap( + ... default_sender=account.addr, + ... default_signer=account.signer, + ... approval_source_map=ProgramSourceMap( ... source="APPROVALSOURCE", ... ), - ... clear_source_map=SourceMap( + ... clear_source_map=ProgramSourceMap( ... source="CLEARSOURCE", ... ), ... ) @@ -1503,15 +1505,15 @@ def from_network( def from_creator_and_name( creator_address: str, app_name: str, - app_spec: Arc56Contract | Arc32Contract | str, + app_spec: arc56.Arc56Contract | arc32.Arc32Contract | str, algorand: AlgorandClient, default_sender: str | None = None, default_signer: TransactionSigner | None = None, - approval_source_map: SourceMap | None = None, - clear_source_map: SourceMap | None = None, + approval_source_map: ProgramSourceMap | None = None, + clear_source_map: ProgramSourceMap | None = None, ignore_cache: bool | None = None, app_lookup_cache: ApplicationLookup | None = None, - ) -> AppClient: + ) -> "AppClient": """Create an AppClient instance from creator address and application name. :param creator_address: The address of the application creator @@ -1531,7 +1533,7 @@ def from_creator_and_name( >>> client = AppClient.from_creator_and_name( ... creator_address="CREATORADDRESS", ... app_name="APPNAME", - ... app_spec=Arc56Contract.from_json(app_spec_json), + ... app_spec=arc56.Arc56Contract.from_json(app_spec_json), ... algorand=algorand, ... ) """ @@ -1558,7 +1560,7 @@ def from_creator_and_name( @staticmethod def compile( - app_spec: Arc56Contract, + app_spec: arc56.Arc56Contract, app_manager: AppManager, compilation_params: AppClientCompilationParams | None = None, ) -> AppClientCompilationResult: @@ -1629,13 +1631,13 @@ def is_base64(s: str) -> bool: def _expose_logic_error_static( # noqa: C901 *, e: Exception, - app_spec: Arc56Contract, + app_spec: arc56.Arc56Contract, is_clear_state_program: bool = False, - approval_source_map: SourceMap | None = None, - clear_source_map: SourceMap | None = None, + approval_source_map: ProgramSourceMap | None = None, + clear_source_map: ProgramSourceMap | None = None, program: bytes | None = None, - approval_source_info: ProgramSourceInfo | None = None, - clear_source_info: ProgramSourceInfo | None = None, + approval_source_info: arc56.ProgramSourceInfo | None = None, + clear_source_info: arc56.ProgramSourceInfo | None = None, ) -> LogicError | Exception: source_map = clear_source_map if is_clear_state_program else approval_source_map @@ -1652,7 +1654,7 @@ def _expose_logic_error_static( # noqa: C901 cblocks_offset = 0 # If the program uses cblocks offset, then we need to adjust the PC accordingly - if program_source_info and program_source_info.pc_offset_method == PcOffsetMethod.CBLOCKS: + if program_source_info and program_source_info.pc_offset_method == arc56.PcOffsetMethod.CBLOCKS: if not program: raise Exception("Program bytes are required to calculate the ARC56 cblocks PC offset") @@ -1663,7 +1665,7 @@ def _expose_logic_error_static( # noqa: C901 source_info = None if program_source_info and program_source_info.source_info: source_info = next( - (s for s in program_source_info.source_info if isinstance(s, SourceInfo) and arc56_pc in s.pc), + (s for s in program_source_info.source_info if isinstance(s, arc56.SourceInfo) and arc56_pc in s.pc), None, ) error_message = source_info.error_message if source_info else None @@ -1691,6 +1693,8 @@ def get_line_for_pc(input_pc: int) -> int | None: custom_get_line_for_pc = get_line_for_pc if program_source: + # Preserve traces from TransactionComposerError if available + traces = getattr(e, "traces", None) e = LogicError( logic_error_str=str(e), program=program_source, @@ -1700,7 +1704,7 @@ def get_line_for_pc(input_pc: int) -> int | None: pc=error_details["pc"], logic_error=e, get_line_for_pc=custom_get_line_for_pc, - traces=None, + traces=traces, ) if error_message: import re @@ -1750,9 +1754,9 @@ def clone( app_name: str | None = _MISSING, # type: ignore[assignment] default_sender: str | None = _MISSING, # type: ignore[assignment] default_signer: TransactionSigner | None = _MISSING, # type: ignore[assignment] - approval_source_map: SourceMap | None = _MISSING, # type: ignore[assignment] - clear_source_map: SourceMap | None = _MISSING, # type: ignore[assignment] - ) -> AppClient: + approval_source_map: ProgramSourceMap | None = _MISSING, # type: ignore[assignment] + clear_source_map: ProgramSourceMap | None = _MISSING, # type: ignore[assignment] + ) -> "AppClient": """Create a cloned AppClient instance with optionally overridden parameters. :param app_name: Optional new application name @@ -1809,22 +1813,18 @@ def import_source_maps(self, source_maps: AppSourceMaps) -> None: if not source_maps.clear_source_map: raise ValueError("Clear source map is required") - if not isinstance(source_maps.approval_source_map, dict | SourceMap): - raise ValueError( - "Approval source map supplied is of invalid type. Must be a raw dict or `algosdk.source_map.SourceMap`" - ) - if not isinstance(source_maps.clear_source_map, dict | SourceMap): - raise ValueError( - "Clear source map supplied is of invalid type. Must be a raw dict or `algosdk.source_map.SourceMap`" - ) + if not isinstance(source_maps.approval_source_map, dict | ProgramSourceMap): + raise ValueError("Approval source map supplied is of invalid type. Must be a raw dict or `SourceMap`") + if not isinstance(source_maps.clear_source_map, dict | ProgramSourceMap): + raise ValueError("Clear source map supplied is of invalid type. Must be a raw dict or `SourceMap`") self._approval_source_map = ( - SourceMap(source_map=source_maps.approval_source_map) + ProgramSourceMap(source_map=source_maps.approval_source_map) if isinstance(source_maps.approval_source_map, dict) else source_maps.approval_source_map ) self._clear_source_map = ( - SourceMap(source_map=source_maps.clear_source_map) + ProgramSourceMap(source_map=source_maps.clear_source_map) if isinstance(source_maps.clear_source_map, dict) else source_maps.clear_source_map ) @@ -1971,19 +1971,13 @@ def _is_new_app_error_for_this_app(self, error: Exception) -> bool: txn = t break - if not txn or not hasattr(txn, "application_call"): + app_call = getattr(txn, "app_call", None) + if not txn or app_call is None: return False - def programs_defined_and_equal(a: bytes | None, b: bytes | None) -> bool: - if a is None or b is None: - return False - return a == b - - app_call = txn.application_call - return programs_defined_and_equal( - getattr(app_call, "clear_program", None), self._last_compiled.get("clear") - ) and programs_defined_and_equal( - getattr(app_call, "approval_program", None), self._last_compiled.get("approval") + return bool( + app_call.clear_state_program == self._last_compiled.get("clear") + and app_call.approval_program == self._last_compiled.get("approval") ) def _handle_call_errors_transform(self, error: Exception) -> Exception: @@ -2035,11 +2029,11 @@ def _get_sender(self, sender: str | None) -> str: return sender or self._default_sender # type: ignore[return-value] def _get_signer( - self, sender: str | None, signer: TransactionSigner | TransactionSignerAccountProtocol | None - ) -> TransactionSigner | TransactionSignerAccountProtocol | None: + self, sender: str | None, signer: TransactionSigner | AddressWithTransactionSigner | None + ) -> TransactionSigner | AddressWithTransactionSigner | None: return signer or (self._default_signer if not sender or sender == self._default_sender else None) - def _get_bare_params(self, params: dict[str, Any], on_complete: algosdk.transaction.OnComplete) -> dict[str, Any]: + def _get_bare_params(self, params: dict[str, Any], on_complete: OnApplicationComplete) -> dict[str, Any]: sender = self._get_sender(params.get("sender")) return { **params, @@ -2049,15 +2043,15 @@ def _get_bare_params(self, params: dict[str, Any], on_complete: algosdk.transact "on_complete": on_complete, } - def _get_abi_args_with_default_values( # noqa: C901, PLR0912 + def _get_abi_args_with_default_values( self, *, method_name_or_signature: str, args: Sequence[ABIValue | ABIStruct | AppMethodCallTransactionArgument | None] | None, sender: str, ) -> list[Any]: - method = self._app_spec.get_arc56_method(method_name_or_signature) - result: list[ABIValue | ABIStruct | AppMethodCallTransactionArgument | None] = [] + method = self._app_spec.get_abi_method(method_name_or_signature) + result = list[ABIValue | ABIStruct | AppMethodCallTransactionArgument | None]() if args and len(method.args) < len(args): raise ValueError( @@ -2068,85 +2062,99 @@ def _get_abi_args_with_default_values( # noqa: C901, PLR0912 arg_value = args[i] if args and i < len(args) else None if arg_value is not None: - if method_arg.struct and isinstance(arg_value, dict): - arg_value = get_abi_tuple_from_abi_struct( - arg_value, self._app_spec.structs[method_arg.struct], self._app_spec.structs - ) result.append(arg_value) continue default_value = method_arg.default_value - if default_value: - match default_value.source: - case "literal": - value_raw = base64.b64decode(default_value.data) - value_type = default_value.type or method_arg.type - result.append(get_abi_decoded_value(value_raw, value_type, self._app_spec.structs)) - - case "method": - default_method = self._app_spec.get_arc56_method(default_value.data) - empty_args = [None] * len(default_method.args) - call_result = self.send.call( - AppClientMethodCallParams( - method=default_value.data, - args=empty_args, - sender=sender, - ) - ) - - if not call_result.abi_return: - raise ValueError("Default value method call did not return a value") - - if isinstance(call_result.abi_return, dict): - result.append( - get_abi_tuple_from_abi_struct( - call_result.abi_return, - self._app_spec.structs[str(default_method.returns.struct)], - self._app_spec.structs, - ) - ) - elif call_result.abi_return: - result.append(call_result.abi_return) - - case "local" | "global": - state = ( - self.get_global_state() - if default_value.source == "global" - else self.get_local_state(sender) - ) - value = next((s for s in state.values() if s.key_base64 == default_value.data), None) - if not value: - raise ValueError( - f"Key '{default_value.data}' not found in {default_value.source} " - f"storage for argument {method_arg.name or f'arg{i + 1}'}" - ) - - if value.value_raw: - value_type = default_value.type or method_arg.type - result.append(get_abi_decoded_value(value.value_raw, value_type, self._app_spec.structs)) - else: - result.append(value.value) - - case "box": - box_name = base64.b64decode(default_value.data) - box_value = self._algorand.app.get_box_value(self._app_id, box_name) - value_type = default_value.type or method_arg.type - result.append(get_abi_decoded_value(box_value, value_type, self._app_spec.structs)) - - elif not algosdk.abi.is_abi_transaction_type(method_arg.type): - raise ValueError( - f"No value provided for required argument " - f"{method_arg.name or f'arg{i + 1}'} in call to method {method.name}" - ) - elif arg_value is None and default_value is None: - # At this point only allow explicit None values if no default value was identified + arg_type = method_arg.type + arg_name = method_arg.name or f"arg{i + 1}" + if isinstance(arg_type, arc56.TransactionType): result.append(None) + elif default_value: + assert isinstance(arg_type, arc56.ReferenceType | abi.ABIType) + result.append(self._get_abi_arg_default_value(arg_name, arg_type, default_value, sender)) + else: + raise ValueError(f"No value provided for required argument {arg_name} in call to method {method.name}") return result - def _get_abi_params(self, params: dict[str, Any], on_complete: algosdk.transaction.OnComplete) -> dict[str, Any]: + def _get_abi_arg_default_value( + self, + arg_name: str, + arg_type: abi.ABIType | arc56.ReferenceType, + default_value: arc56.DefaultValue, + sender: str, + ) -> ABIValue: + match default_value.source: + case "literal": + value_raw = base64.b64decode(default_value.data) + value_type = default_value.type or arg_type + return get_abi_decoded_value(value_raw, value_type) + + case "method": + default_method = self._app_spec.get_abi_method(default_value.data) + empty_args = [None] * len(default_method.args) + call_result = self.send.call( + AppClientMethodCallParams( + method=default_value.data, + args=empty_args, + sender=sender, + ) + ) + + if call_result.abi_return is None: + raise ValueError("Default value method call did not return a value") + assert isinstance(default_method.returns.type, abi.ABIType) + return call_result.abi_return + + case "local" | "global" | "box": + key = base64.b64decode(default_value.data) + try: + value, storage_key = self._get_storage_value(default_value.source, key, sender) + except KeyError: + raise ValueError( + f"Key '{default_value.data}' not found in {default_value.source} " + f"storage for argument {arg_name}" + ) from None + + decoded_value: ABIValue + if isinstance(value, bytes): + # special case to convert raw AVM bytes to a native string type suitable for encoding + if storage_key.value_type == arc56.AVMType.BYTES and isinstance(arg_type, abi.StringType): + decoded_value = value.decode("utf-8") + else: + decoded_value = get_abi_decoded_value(value, storage_key.value_type) + else: + decoded_value = value + return decoded_value + case _: + assert_never(default_value.source) + + def _get_storage_value( + self, source: Literal["local", "global", "box"], key: bytes, sender: str + ) -> tuple[bytes | int | str, arc56.StorageKey]: + state_keys = self.app_spec.state.keys + if source == "global": + state = {s.key_raw: s for s in self.get_global_state().values()}[key] + value = state.value_raw if state.value_raw is not None else state.value + storage_keys = state_keys.global_state + elif source == "local": + state = {s.key_raw: s for s in self.get_local_state(sender).values()}[key] + value = state.value_raw if state.value_raw is not None else state.value + storage_keys = state_keys.local_state + elif source == "box": + value = self.get_box_value(key) + storage_keys = state_keys.box + else: + assert_never(source) + + key_base64 = base64.b64encode(key).decode("ascii") + storage_key = {sk.key: sk for sk in storage_keys.values()}[key_base64] + return value, storage_key + + def _get_abi_params(self, params: dict[str, Any], on_complete: OnApplicationComplete) -> dict[str, Any]: sender = self._get_sender(params.get("sender")) - method = self._app_spec.get_arc56_method(params["method"]) + method = self._app_spec.get_abi_method(params["method"]) args = self._get_abi_args_with_default_values( method_name_or_signature=params["method"], args=params.get("args"), sender=sender ) @@ -2163,17 +2171,22 @@ def _get_abi_params(self, params: dict[str, Any], on_complete: algosdk.transacti def _process_method_call_return( self, result: Callable[[], SendAppUpdateTransactionResult[ABIReturn] | SendAppTransactionResult[ABIReturn]], - method: Method, + method: arc56.Method, ) -> SendAppUpdateTransactionResult[Arc56ReturnValueType] | SendAppTransactionResult[Arc56ReturnValueType]: + _ = method # kept for compatibility result_value = result() - abi_return = ( - result_value.abi_return.get_arc56_value(method, self._app_spec.structs) - if isinstance(result_value.abi_return, ABIReturn) - else None - ) + abi_return_value: Arc56ReturnValueType + if isinstance(result_value.abi_return, ABIReturn): + if result_value.abi_return.decode_error: + raise ValueError(result_value.abi_return.decode_error) + abi_return_value = result_value.abi_return.value + else: + abi_return_value = None if isinstance(result_value, SendAppUpdateTransactionResult): return SendAppUpdateTransactionResult[Arc56ReturnValueType]( - **{**result_value.__dict__, "abi_return": abi_return} + **{**result_value.__dict__, "abi_return": abi_return_value} ) - return SendAppTransactionResult[Arc56ReturnValueType](**{**result_value.__dict__, "abi_return": abi_return}) + return SendAppTransactionResult[Arc56ReturnValueType]( + **{**result_value.__dict__, "abi_return": abi_return_value} + ) diff --git a/src/algokit_utils/applications/app_deployer.py b/src/algokit_utils/applications/app_deployer.py index fa5c3e3c..7ff99468 100644 --- a/src/algokit_utils/applications/app_deployer.py +++ b/src/algokit_utils/applications/app_deployer.py @@ -1,12 +1,12 @@ import base64 import dataclasses import json -from dataclasses import asdict, dataclass -from typing import Literal - -from algosdk.logic import get_application_address -from algosdk.v2client.indexer import IndexerClient +from dataclasses import asdict, dataclass, fields +from typing import Literal, TypeVar +from algokit_algod_client import models as algod_models +from algokit_common import get_application_address +from algokit_indexer_client import IndexerClient from algokit_utils.applications.abi import ABIReturn from algokit_utils.applications.app_manager import AppManager from algokit_utils.applications.enums import OnSchemaBreak, OnUpdate, OperationPerformed @@ -108,7 +108,7 @@ def updatable(self) -> bool | None: class ApplicationLookup: """Cache of {py:class}`ApplicationMetaData` for a specific `creator` - Can be used as an argument to {py:class}`ApplicationClient` to reduce the number of calls when deploying multiple + Can be used as an argument to {py:class}`AppClient` to reduce the number of calls when deploying multiple apps or discovering multiple app_ids """ @@ -388,23 +388,21 @@ def _create_app( if isinstance(deployment.create_params, AppCreateMethodCallParams): create_result = self._transaction_sender.app_create_method_call( - AppCreateMethodCallParams( - **{ - **asdict(deployment.create_params), - "approval_program": approval_program, - "clear_state_program": clear_program, - } + extend( + AppCreateMethodCallParams, + deployment.create_params, + approval_program=approval_program, + clear_state_program=clear_program, ), send_params=deployment.send_params, ) else: create_result = self._transaction_sender.app_create( - AppCreateParams( - **{ - **asdict(deployment.create_params), - "approval_program": approval_program, - "clear_state_program": clear_program, - } + extend( + AppCreateParams, + deployment.create_params, + approval_program=approval_program, + clear_state_program=clear_program, ), send_params=deployment.send_params, ) @@ -414,12 +412,8 @@ def _create_app( app_id=create_result.app_id, app_address=get_application_address(create_result.app_id) ), deploy_metadata=deployment.metadata, - created_round=create_result.confirmation.get("confirmed-round", 0) - if isinstance(create_result.confirmation, dict) - else 0, - updated_round=create_result.confirmation.get("confirmed-round", 0) - if isinstance(create_result.confirmation, dict) - else 0, + created_round=_get_confirmed_round(create_result.confirmation), + updated_round=_get_confirmed_round(create_result.confirmation), deleted=False, ) @@ -497,12 +491,16 @@ def _replace_app( result, is_abi=has_abi_delete, index=-1 ) - app_id = int(result.confirmations[0]["application-index"]) # type: ignore[call-overload] + app_id_raw = result.confirmations[0].app_id + if app_id_raw is None: + raise ValueError("Could not determine app_id from transaction confirmation") + assert app_id_raw is not None + app_id = int(app_id_raw) app_metadata = ApplicationMetaData( reference=ApplicationReference(app_id=app_id, app_address=get_application_address(app_id)), deploy_metadata=deployment.metadata, - created_round=result.confirmations[0]["confirmed-round"], # type: ignore[call-overload] - updated_round=result.confirmations[0]["confirmed-round"], # type: ignore[call-overload] + created_round=_get_confirmed_round(result.confirmations[0]), + updated_round=_get_confirmed_round(result.confirmations[0]), deleted=False, ) self._update_app_lookup(deployment.create_params.sender, app_metadata) @@ -560,7 +558,7 @@ def _update_app( reference=ApplicationReference(app_id=existing_app.app_id, app_address=existing_app.app_address), deploy_metadata=deployment.metadata, created_round=existing_app.created_round, - updated_round=result.confirmation.get("confirmed-round", 0) if isinstance(result.confirmation, dict) else 0, + updated_round=_get_confirmed_round(result.confirmation), deleted=False, ) @@ -708,34 +706,39 @@ def get_creator_apps_by_name(self, *, creator_address: str, ignore_cache: bool = app_lookup: dict[str, ApplicationMetaData] = {} # Get all apps created by account - created_apps = self._indexer.search_applications(creator=creator_address) + # TODO: See if empty iterable responses can be changed to empty lists instead of None + created_apps = self._indexer.search_for_applications(creator=creator_address).applications or [] - for app in created_apps["applications"]: - app_id = app["id"] + encoded_note_prefix = base64.b64encode(APP_DEPLOY_NOTE_DAPP.encode()).decode() + + for app in created_apps: + app_id = app.id_ # Get creation transaction - creation_txns = self._indexer.search_transactions( + creation_txns = self._indexer.search_for_transactions( application_id=app_id, - min_round=app["created-at-round"], + min_round=app.created_at_round, address=creator_address, address_role="sender", - note_prefix=APP_DEPLOY_NOTE_DAPP.encode(), + note_prefix=encoded_note_prefix, limit=1, - ) + ).transactions - if not creation_txns["transactions"]: + if not creation_txns: continue - creation_txn = creation_txns["transactions"][0] + creation_txn = creation_txns[0] try: - note = base64.b64decode(creation_txn["note"]).decode() + if not creation_txn.note: + continue + note = base64.b64decode(creation_txn.note).decode() if not note.startswith(f"{APP_DEPLOY_NOTE_DAPP}:j"): continue metadata = json.loads(note[len(APP_DEPLOY_NOTE_DAPP) + 2 :]) - if metadata.get("name"): + if metadata.get("name") and creation_txn.confirmed_round: app_lookup[metadata["name"]] = ApplicationMetaData( reference=ApplicationReference(app_id=app_id, app_address=get_application_address(app_id)), deploy_metadata=AppDeploymentMetaData( @@ -744,9 +747,9 @@ def get_creator_apps_by_name(self, *, creator_address: str, ignore_cache: bool = deletable=metadata.get("deletable"), updatable=metadata.get("updatable"), ), - created_round=creation_txn["confirmed-round"], - updated_round=creation_txn["confirmed-round"], - deleted=app.get("deleted", False), + created_round=creation_txn.confirmed_round, + updated_round=creation_txn.confirmed_round, + deleted=app.deleted if app.deleted is not None else False, ) except Exception as e: config.logger.warning( @@ -757,3 +760,29 @@ def get_creator_apps_by_name(self, *, creator_address: str, ignore_cache: bool = lookup = ApplicationLookup(creator=creator_address, apps=app_lookup) self._app_lookups[creator_address] = lookup return lookup + + +_T = TypeVar("_T") + + +def extend(new_type: type[_T], base_instance: object, **changes: object) -> _T: + assert dataclasses.is_dataclass(new_type), "expected dataclass type" + base_type = type(base_instance) + assert dataclasses.is_dataclass(base_type), "expected dataclass instance" + old_type_fields = {f.name: f for f in fields(base_type)} + new_type_fields = fields(new_type) + for a in new_type_fields: + if not a.init: + continue + if a.name not in changes and a.name in old_type_fields: + changes[a.name] = getattr(base_instance, a.name) + + return new_type(**changes) + + +def _get_confirmed_round(confirmation: algod_models.PendingTransactionResponse | None) -> int: + """Extract the confirmed round from a typed response model.""" + + if confirmation is None: + return 0 + return confirmation.confirmed_round or 0 diff --git a/src/algokit_utils/applications/app_factory.py b/src/algokit_utils/applications/app_factory.py index 26dbb4c1..1281304a 100644 --- a/src/algokit_utils/applications/app_factory.py +++ b/src/algokit_utils/applications/app_factory.py @@ -4,18 +4,17 @@ from dataclasses import asdict, dataclass from typing import Any, Generic, TypeVar -from algosdk.atomic_transaction_composer import TransactionSigner -from algosdk.source_map import SourceMap -from algosdk.transaction import OnComplete, Transaction from typing_extensions import Self -from algokit_utils._legacy_v2.application_specification import ApplicationSpecification +from algokit_abi import arc56 +from algokit_common import ProgramSourceMap +from algokit_transact import OnApplicationComplete +from algokit_transact.models.transaction import Transaction from algokit_utils.algorand import AlgorandClient from algokit_utils.applications.abi import ( ABIReturn, Arc56ReturnValueType, get_abi_decoded_value, - get_abi_tuple_from_abi_struct, ) from algokit_utils.applications.app_client import ( AppClient, @@ -39,11 +38,9 @@ OperationPerformed, ) from algokit_utils.applications.app_manager import DELETABLE_TEMPLATE_NAME, UPDATABLE_TEMPLATE_NAME -from algokit_utils.applications.app_spec.arc56 import Arc56Contract, Method -from algokit_utils.models.application import ( - AppSourceMaps, -) +from algokit_utils.models.application import AppSourceMaps from algokit_utils.models.transaction import SendParams +from algokit_utils.protocols.signer import TransactionSigner from algokit_utils.transactions.transaction_composer import ( AppCreateMethodCallParams, AppCreateParams, @@ -78,7 +75,7 @@ @dataclass(kw_only=True, frozen=True) class AppFactoryParams: algorand: AlgorandClient - app_spec: Arc56Contract | ApplicationSpecification | str + app_spec: arc56.Arc56Contract | str app_name: str | None = None default_sender: str | None = None default_signer: TransactionSigner | None = None @@ -146,7 +143,7 @@ def from_deploy_result( cls, response: AppDeployResult, deploy_params: AppDeployParams, - app_spec: Arc56Contract, + app_spec: arc56.Arc56Contract, # noqa: ARG003 app_compilation_data: AppClientCompilationResult | None = None, ) -> Self: """ @@ -166,13 +163,18 @@ def to_factory_result( | None, params: Any, # noqa: ANN401 ) -> Any | None: # noqa: ANN401 + _ = params # kept for compatibility if not response_data: return None - response_data_dict = asdict(response_data) + response_data_dict = { + field.name: getattr(response_data, field.name) for field in dataclasses.fields(type(response_data)) + } abi_return = response_data.abi_return if abi_return and abi_return.method: - response_data_dict["abi_return"] = abi_return.get_arc56_value(params.method, app_spec.structs) + if abi_return.decode_error: + raise ValueError(abi_return.decode_error) + response_data_dict["abi_return"] = abi_return.value match response_data: case SendAppCreateTransactionResult(): @@ -247,7 +249,7 @@ def create( }, "sender": self._factory._get_sender(base_params.sender), "signer": self._factory._get_signer(base_params.sender, base_params.signer), - "on_complete": base_params.on_complete or OnComplete.NoOpOC, + "on_complete": base_params.on_complete or OnApplicationComplete.NoOp, } ) @@ -269,7 +271,7 @@ def deploy_update(self, params: AppClientBareCallParams | None = None) -> AppUpd "approval_program": "", "clear_state_program": "", "sender": self._factory._get_sender(params.sender if params else None), - "on_complete": OnComplete.UpdateApplicationOC, + "on_complete": OnApplicationComplete.UpdateApplication, "signer": self._factory._get_signer( params.sender if params else None, params.signer if params else None ), @@ -295,7 +297,7 @@ def deploy_delete(self, params: AppClientBareCallParams | None = None) -> AppDel "signer": self._factory._get_signer( params.sender if params else None, params.signer if params else None ), - "on_complete": OnComplete.DeleteApplicationOC, + "on_complete": OnApplicationComplete.DeleteApplication, } ) @@ -352,9 +354,9 @@ def create( "signer": self._factory._get_signer( params.sender if params else None, params.signer if params else None ), - "method": self._factory._app_spec.get_arc56_method(params.method).to_abi_method(), + "method": self._factory._app_spec.get_abi_method(params.method), "args": self._factory._get_create_abi_args_with_default_values(params.method, params.args), - "on_complete": params.on_complete or OnComplete.NoOpOC, + "on_complete": params.on_complete or OnApplicationComplete.NoOp, } ) @@ -379,9 +381,9 @@ def deploy_update(self, params: AppClientMethodCallParams) -> AppUpdateMethodCal "signer": self._factory._get_signer( params.sender if params else None, params.signer if params else None ), - "method": self._factory._app_spec.get_arc56_method(params.method).to_abi_method(), + "method": self._factory._app_spec.get_abi_method(params.method), "args": self._factory._get_create_abi_args_with_default_values(params.method, params.args), - "on_complete": OnComplete.UpdateApplicationOC, + "on_complete": OnApplicationComplete.UpdateApplication, } ) @@ -404,9 +406,9 @@ def deploy_delete(self, params: AppClientMethodCallParams) -> AppDeleteMethodCal "signer": self._factory._get_signer( params.sender if params else None, params.signer if params else None ), - "method": self._factory.app_spec.get_arc56_method(params.method).to_abi_method(), + "method": self._factory.app_spec.get_abi_method(params.method), "args": self._factory._get_create_abi_args_with_default_values(params.method, params.args), - "on_complete": OnComplete.DeleteApplicationOC, + "on_complete": OnApplicationComplete.DeleteApplication, } ) @@ -587,7 +589,7 @@ def create( lambda: self._algorand.send.app_create_method_call( self._factory.params.create(params, compilation_params), send_params ), - self._factory._app_spec.get_arc56_method(params.method), + self._factory._app_spec.get_abi_method(params.method), ) ) @@ -635,8 +637,8 @@ def __init__(self, params: AppFactoryParams) -> None: self._version = params.version or "1.0" self._default_sender = params.default_sender self._default_signer = params.default_signer - self._approval_source_map: SourceMap | None = None - self._clear_source_map: SourceMap | None = None + self._approval_source_map: ProgramSourceMap | None = None + self._clear_source_map: ProgramSourceMap | None = None self._params_accessor = _MethodParamsBuilder(self) self._send_accessor = _TransactionSender(self) self._create_transaction_accessor = _TransactionCreator(self) @@ -652,7 +654,7 @@ def app_name(self) -> str: return self._app_name @property - def app_spec(self) -> Arc56Contract: + def app_spec(self) -> arc56.Arc56Contract: """The app spec""" return self._app_spec @@ -882,8 +884,8 @@ def get_app_client_by_id( app_name: str | None = None, default_sender: str | None = None, # Address can be string or bytes default_signer: TransactionSigner | None = None, - approval_source_map: SourceMap | None = None, - clear_source_map: SourceMap | None = None, + approval_source_map: ProgramSourceMap | None = None, + clear_source_map: ProgramSourceMap | None = None, ) -> AppClient: """Returns a new `AppClient` client for an app instance of the given ID. @@ -919,8 +921,8 @@ def get_app_client_by_creator_and_name( default_signer: TransactionSigner | None = None, ignore_cache: bool | None = None, app_lookup_cache: ApplicationLookup | None = None, - approval_source_map: SourceMap | None = None, - clear_source_map: SourceMap | None = None, + approval_source_map: ProgramSourceMap | None = None, + clear_source_map: ProgramSourceMap | None = None, ) -> AppClient: """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). @@ -997,7 +999,7 @@ def compile(self, compilation_params: AppClientCompilationParams | None = None) return result - def _expose_logic_error(self, e: Exception, is_clear_state_program: bool = False) -> Exception: # noqa: FBT002 FBT001 + def _expose_logic_error(self, e: Exception, is_clear_state_program: bool = False) -> Exception: # noqa: FBT001, FBT002 """ Convert a low-level exception into a descriptive logic error. @@ -1069,22 +1071,29 @@ def _parse_method_call_return( result: Callable[ [], SendAppTransactionResult | SendAppCreateTransactionResult | SendAppUpdateTransactionResult ], - method: Method, + method: arc56.Method, ) -> AppFactoryCreateMethodCallResult[Arc56ReturnValueType]: + _ = method # kept for compatibility """ Parse the method call return value and convert the ABI return. :param result: A callable that returns the transaction result. :param method: The ABI method associated with the call. :return: An AppFactoryCreateMethodCallResult with the parsed ABI return. + :raises ValueError: If ABI return decoding failed. """ result_value = result() + abi_return_value: Arc56ReturnValueType + if isinstance(result_value.abi_return, ABIReturn): + if result_value.abi_return.decode_error: + raise ValueError(result_value.abi_return.decode_error) + abi_return_value = result_value.abi_return.value + else: + abi_return_value = None return AppFactoryCreateMethodCallResult[Arc56ReturnValueType]( **{ **result_value.__dict__, - "abi_return": result_value.abi_return.get_arc56_value(method, self._app_spec.structs) - if isinstance(result_value.abi_return, ABIReturn) - else None, + "abi_return": abi_return_value, } ) @@ -1097,19 +1106,14 @@ def _get_create_abi_args_with_default_values( Builds a list of ABI argument values for creation calls, applying default argument values when not provided. """ - method = self._app_spec.get_arc56_method(method_name_or_signature) + method = self._app_spec.get_abi_method(method_name_or_signature) results: list[Any] = [] for i, param in enumerate(method.args): if user_args and i < len(user_args): arg_value = user_args[i] - if param.struct and isinstance(arg_value, dict): - arg_value = get_abi_tuple_from_abi_struct( - arg_value, - self._app_spec.structs[param.struct], - self._app_spec.structs, - ) + results.append(arg_value) continue @@ -1117,8 +1121,11 @@ def _get_create_abi_args_with_default_values( if default_value: if default_value.source == "literal": raw_value = base64.b64decode(default_value.data) - value_type = default_value.type or str(param.type) - decoded_value = get_abi_decoded_value(raw_value, value_type, self._app_spec.structs) + value_type = default_value.type or param.type + assert not isinstance(value_type, arc56.TransactionType), ( + "transaction type cannot be a default value" + ) + decoded_value = get_abi_decoded_value(raw_value, value_type) results.append(decoded_value) else: raise ValueError( diff --git a/src/algokit_utils/applications/app_manager.py b/src/algokit_utils/applications/app_manager.py index f991660b..a8138f08 100644 --- a/src/algokit_utils/applications/app_manager.py +++ b/src/algokit_utils/applications/app_manager.py @@ -1,17 +1,13 @@ import base64 -from collections.abc import Mapping -from typing import Any, cast - -import algosdk -import algosdk.atomic_transaction_composer -import algosdk.box_reference -from algosdk.atomic_transaction_composer import AccountTransactionSigner -from algosdk.box_reference import BoxReference as AlgosdkBoxReference -from algosdk.logic import get_application_address -from algosdk.source_map import SourceMap -from algosdk.v2client import algod - -from algokit_utils.applications.abi import ABIReturn, ABIType, ABIValue +from collections.abc import Mapping, Sequence + +from algokit_abi import arc56 +from algokit_algod_client import AlgodClient +from algokit_algod_client import models as algod_models +from algokit_common import ProgramSourceMap, get_application_address, public_key_from_address +from algokit_common.serde import to_wire +from algokit_transact.signer import AddressWithTransactionSigner +from algokit_utils.applications.abi import ABIReturn, ABIType, ABIValue, extract_abi_return_from_logs from algokit_utils.models.application import ( AppInformation, AppState, @@ -124,7 +120,7 @@ class AppManager: >>> app_manager = AppManager(algod_client) """ - def __init__(self, algod_client: algod.AlgodClient): + def __init__(self, algod_client: AlgodClient): self._algod = algod_client self._compilation_results: dict[str, CompiledTeal] = {} @@ -138,13 +134,14 @@ def compile_teal(self, teal_code: str) -> CompiledTeal: if teal_code in self._compilation_results: return self._compilation_results[teal_code] - compiled = self._algod.compile(teal_code, source_map=True) + compiled = self._algod.teal_compile(teal_code.encode("utf-8"), sourcemap=True) + sourcemap_dict = to_wire(compiled.sourcemap) if compiled.sourcemap else {} result = CompiledTeal( teal=teal_code, - compiled=compiled["result"], - compiled_hash=compiled["hash"], - compiled_base64_to_bytes=base64.b64decode(compiled["result"]), - source_map=SourceMap(compiled.get("sourcemap", {})), + compiled=compiled.result, + compiled_hash=compiled.hash_, + compiled_base64_to_bytes=base64.b64decode(compiled.result), + source_map=ProgramSourceMap(sourcemap_dict), ) self._compilation_results[teal_code] = result return result @@ -205,22 +202,21 @@ def get_by_id(self, app_id: int) -> AppInformation: >>> app_info = app_manager.get_by_id(app_id) """ - app = self._algod.application_info(app_id) - assert isinstance(app, dict) - app_params = app["params"] + app = self._algod.application_by_id(app_id) + app_params = app.params return AppInformation( app_id=app_id, app_address=get_application_address(app_id), - approval_program=base64.b64decode(app_params["approval-program"]), - clear_state_program=base64.b64decode(app_params["clear-state-program"]), - creator=app_params["creator"], - local_ints=app_params["local-state-schema"]["num-uint"], - local_byte_slices=app_params["local-state-schema"]["num-byte-slice"], - global_ints=app_params["global-state-schema"]["num-uint"], - global_byte_slices=app_params["global-state-schema"]["num-byte-slice"], - extra_program_pages=app_params.get("extra-program-pages", 0), - global_state=self.decode_app_state(app_params.get("global-state", [])), + approval_program=app_params.approval_program, + clear_state_program=app_params.clear_state_program, + creator=app_params.creator, + local_ints=app_params.local_state_schema.num_uints if app_params.local_state_schema else 0, + local_byte_slices=app_params.local_state_schema.num_byte_slices if app_params.local_state_schema else 0, + global_ints=app_params.global_state_schema.num_uints if app_params.global_state_schema else 0, + global_byte_slices=app_params.global_state_schema.num_byte_slices if app_params.global_state_schema else 0, + extra_program_pages=app_params.extra_program_pages or 0, + global_state=self.decode_app_state(app_params.global_state), ) def get_global_state(self, app_id: int) -> dict[str, AppState]: @@ -252,11 +248,10 @@ def get_local_state(self, app_id: int, address: str) -> dict[str, AppState]: >>> local_state = app_manager.get_local_state(app_id, address) """ - app_info = self._algod.account_application_info(address, app_id) - assert isinstance(app_info, dict) - if not app_info.get("app-local-state", {}).get("key-value"): + app_info = self._algod.account_application_information(address, app_id) + if not app_info.app_local_state or not app_info.app_local_state.key_value: raise ValueError("Couldn't find local state") - return self.decode_app_state(app_info["app-local-state"]["key-value"]) + return self.decode_app_state(app_info.app_local_state.key_value) def get_box_names(self, app_id: int) -> list[BoxName]: """Get names of all boxes for an application. @@ -280,14 +275,13 @@ def utf8_decode_or_string_cast(b: bytes) -> str: return str(b) box_result = self._algod.application_boxes(app_id) - assert isinstance(box_result, dict) return [ BoxName( - name_raw=base64.b64decode(b["name"]), - name_base64=b["name"], - name=utf8_decode_or_string_cast(base64.b64decode(b["name"])), + name_raw=b.name, + name_base64=base64.b64encode(b.name).decode("utf-8"), + name=utf8_decode_or_string_cast(b.name), ) - for b in box_result["boxes"] + for b in (box_result.boxes or []) ] def get_box_value(self, app_id: int, box_name: BoxIdentifier) -> bytes: @@ -305,9 +299,11 @@ def get_box_value(self, app_id: int, box_name: BoxIdentifier) -> bytes: """ name = AppManager.get_box_reference(box_name)[1] - box_result = self._algod.application_box_by_name(app_id, name) - assert isinstance(box_result, dict) - return base64.b64decode(box_result["value"]) + box_result = self._algod.application_box_by_name( + app_id, + name if isinstance(name, bytes | bytearray | memoryview) else str(name).encode("utf-8"), + ) + return box_result.value def get_box_values(self, app_id: int, box_names: list[BoxIdentifier]) -> list[bytes]: """Get values for multiple boxes. @@ -344,9 +340,7 @@ def get_box_value_from_abi_type(self, app_id: int, box_name: BoxIdentifier, abi_ value = self.get_box_value(app_id, box_name) try: - parse_to_tuple = isinstance(abi_type, algosdk.abi.TupleType) - decoded_value = abi_type.decode(value) - return tuple(decoded_value) if parse_to_tuple else decoded_value + return abi_type.decode(value) # type: ignore[no-any-return] except Exception as e: raise ValueError(f"Failed to decode box value {value.decode('utf-8')} with ABI type {abi_type}") from e @@ -385,18 +379,16 @@ def get_box_reference(box_id: BoxIdentifier | BoxReference) -> tuple[int, bytes] >>> box_reference = app_manager.get_box_reference(box_name) """ - if isinstance(box_id, (BoxReference | AlgosdkBoxReference)): - return box_id.app_index, box_id.name + if isinstance(box_id, BoxReference): + return box_id.app_id, box_id.name name = b"" if isinstance(box_id, str): name = box_id.encode("utf-8") elif isinstance(box_id, bytes): name = box_id - elif isinstance(box_id, AccountTransactionSigner): - name = cast( - bytes, algosdk.encoding.decode_address(algosdk.account.address_from_private_key(box_id.private_key)) - ) + elif isinstance(box_id, AddressWithTransactionSigner): + name = public_key_from_address(box_id.addr) else: raise ValueError(f"Invalid box identifier type: {type(box_id)}") @@ -404,7 +396,8 @@ def get_box_reference(box_id: BoxIdentifier | BoxReference) -> tuple[int, bytes] @staticmethod def get_abi_return( - confirmation: algosdk.v2client.algod.AlgodResponseType, method: algosdk.abi.Method | None = None + confirmation: algod_models.PendingTransactionResponse, + method: arc56.Method | None = None, ) -> ABIReturn | None: """Get the ABI return value from a transaction confirmation. @@ -416,26 +409,16 @@ def get_abi_return( >>> app_manager = AppManager(algod_client) >>> app_id = 123 >>> method = "METHOD_NAME" - >>> confirmation = algod_client.pending_transaction_info(tx_id) + >>> confirmation = algod_client.pending_transaction_information(tx_id) >>> abi_return = app_manager.get_abi_return(confirmation, method) """ if not method: return None - atc = algosdk.atomic_transaction_composer.AtomicTransactionComposer() - abi_result = atc.parse_result( - method, - "dummy_txn", - confirmation, # type: ignore[arg-type] - ) - - if not abi_result: - return None - - return ABIReturn(abi_result) + return extract_abi_return_from_logs(confirmation, method) @staticmethod - def decode_app_state(state: list[dict[str, Any]]) -> dict[str, AppState]: + def decode_app_state(state: Sequence[algod_models.TealKeyValue] | None) -> dict[str, AppState]: """Decode application state from raw format. :param state: The raw application state @@ -457,17 +440,20 @@ def decode_bytes_to_str(value: bytes) -> str: except UnicodeDecodeError: return value.hex() + if not state: + return state_values + for state_val in state: - key_base64 = state_val["key"] - key_raw = base64.b64decode(key_base64) + key_raw = state_val.key + key_base64 = base64.b64encode(key_raw).decode("utf-8") key = decode_bytes_to_str(key_raw) - teal_value = state_val["value"] + teal_value = state_val.value - data_type_flag = teal_value.get("action", teal_value.get("type")) + data_type_flag = DataTypeFlag(teal_value.type_) if data_type_flag == DataTypeFlag.BYTES: - value_base64 = teal_value.get("bytes", "") - value_raw = base64.b64decode(value_base64) + value_raw = teal_value.bytes_ or b"" + value_base64 = base64.b64encode(value_raw).decode("utf-8") state_values[key] = AppState( key_raw=key_raw, key_base64=key_base64, @@ -476,13 +462,12 @@ def decode_bytes_to_str(value: bytes) -> str: value=decode_bytes_to_str(value_raw), ) elif data_type_flag == DataTypeFlag.UINT: - value = teal_value.get("uint", 0) state_values[key] = AppState( key_raw=key_raw, key_base64=key_base64, value_raw=None, value_base64=None, - value=int(value), + value=int(teal_value.uint or 0), ) else: raise ValueError(f"Received unknown state data type of {data_type_flag}") diff --git a/src/algokit_utils/applications/app_spec/__init__.py b/src/algokit_utils/applications/app_spec/__init__.py index dbbb41fb..9cee9101 100644 --- a/src/algokit_utils/applications/app_spec/__init__.py +++ b/src/algokit_utils/applications/app_spec/__init__.py @@ -1,2 +1,6 @@ -from algokit_utils.applications.app_spec.arc32 import * # noqa: F403 -from algokit_utils.applications.app_spec.arc56 import * # noqa: F403 +# app spec definitions used to be defined here, import new definitions from algokit_abi for backwards compatability +from algokit_abi import arc32, arc56 +from algokit_abi.arc32 import Arc32Contract +from algokit_abi.arc56 import Arc56Contract + +__all__ = ["Arc32Contract", "Arc56Contract", "arc32", "arc56"] diff --git a/src/algokit_utils/applications/app_spec/arc56.py b/src/algokit_utils/applications/app_spec/arc56.py deleted file mode 100644 index 590a14fc..00000000 --- a/src/algokit_utils/applications/app_spec/arc56.py +++ /dev/null @@ -1,989 +0,0 @@ -from __future__ import annotations - -import base64 -import json -from base64 import b64encode -from collections.abc import Callable, Sequence -from dataclasses import asdict, dataclass -from enum import Enum -from typing import Any, Literal, overload - -import algosdk -from algosdk.abi import Method as AlgosdkMethod - -from algokit_utils.applications.app_spec.arc32 import Arc32Contract - -__all__ = [ - "Actions", - "Arc56Contract", - "BareActions", - "Boxes", - "ByteCode", - "CallEnum", - "Compiler", - "CompilerInfo", - "CompilerVersion", - "CreateEnum", - "DefaultValue", - "Event", - "EventArg", - "Global", - "Keys", - "Local", - "Maps", - "Method", - "MethodArg", - "Network", - "PcOffsetMethod", - "ProgramSourceInfo", - "Recommendations", - "Returns", - "Schema", - "ScratchVariables", - "Source", - "SourceInfo", - "SourceInfoModel", - "State", - "StorageKey", - "StorageMap", - "StructField", - "TemplateVariables", -] - - -class _ActionType(str, Enum): - CALL = "CALL" - CREATE = "CREATE" - - -@dataclass -class StructField: - """Represents a field in a struct type.""" - - name: str - """The name of the struct field""" - type: list[StructField] | str - """The type of the struct field, either a string or list of StructFields""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> StructField: - if isinstance(data["type"], list): - data["type"] = [StructField.from_dict(item) for item in data["type"]] - return StructField(**data) - - -class CallEnum(str, Enum): - """Enum representing different call types for application transactions.""" - - CLEAR_STATE = "ClearState" - CLOSE_OUT = "CloseOut" - DELETE_APPLICATION = "DeleteApplication" - NO_OP = "NoOp" - OPT_IN = "OptIn" - UPDATE_APPLICATION = "UpdateApplication" - - -class CreateEnum(str, Enum): - """Enum representing different create types for application transactions.""" - - DELETE_APPLICATION = "DeleteApplication" - NO_OP = "NoOp" - OPT_IN = "OptIn" - - -@dataclass -class BareActions: - """Represents bare call and create actions for an application.""" - - call: list[CallEnum] - """The list of allowed call actions""" - create: list[CreateEnum] - """The list of allowed create actions""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> BareActions: - return BareActions(**data) - - -@dataclass -class ByteCode: - """Represents the approval and clear program bytecode.""" - - approval: str - """The base64 encoded approval program bytecode""" - clear: str - """The base64 encoded clear program bytecode""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> ByteCode: - return ByteCode(**data) - - -class Compiler(str, Enum): - """Enum representing different compiler types.""" - - ALGOD = "algod" - PUYA = "puya" - - -@dataclass -class CompilerVersion: - """Represents compiler version information.""" - - commit_hash: str | None = None - """The git commit hash of the compiler""" - major: int | None = None - """The major version number""" - minor: int | None = None - """The minor version number""" - patch: int | None = None - """The patch version number""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> CompilerVersion: - return CompilerVersion(**data) - - -@dataclass -class CompilerInfo: - """Information about the compiler used.""" - - compiler: Compiler - """The type of compiler used""" - compiler_version: CompilerVersion - """Version information for the compiler""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> CompilerInfo: - data["compiler_version"] = CompilerVersion.from_dict(data["compiler_version"]) - return CompilerInfo(**data) - - -@dataclass -class Network: - """Network-specific application information.""" - - app_id: int - """The application ID on the network""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> Network: - return Network(**data) - - -@dataclass -class ScratchVariables: - """Information about scratch space variables.""" - - slot: int - """The scratch slot number""" - type: str - """The type of the scratch variable""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> ScratchVariables: - return ScratchVariables(**data) - - -@dataclass -class Source: - """Source code for approval and clear programs.""" - - approval: str - """The base64 encoded approval program source""" - clear: str - """The base64 encoded clear program source""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> Source: - return Source(**data) - - def get_decoded_approval(self) -> str: - """Get decoded approval program source. - - :return: Decoded approval program source code - """ - return self._decode_source(self.approval) - - def get_decoded_clear(self) -> str: - """Get decoded clear program source. - - :return: Decoded clear program source code - """ - return self._decode_source(self.clear) - - def _decode_source(self, b64_text: str) -> str: - return base64.b64decode(b64_text).decode("utf-8") - - -@dataclass -class Global: - """Global state schema.""" - - bytes: int - """The number of byte slices in global state""" - ints: int - """The number of integers in global state""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> Global: - return Global(**data) - - -@dataclass -class Local: - """Local state schema.""" - - bytes: int - """The number of byte slices in local state""" - ints: int - """The number of integers in local state""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> Local: - return Local(**data) - - -@dataclass -class Schema: - """Application state schema.""" - - global_state: Global # actual schema field is "global" since it's a reserved word - """The global state schema""" - local_state: Local # actual schema field is "local" for consistency with renamed "global" - """The local state schema""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> Schema: - global_state = Global.from_dict(data["global"]) - local_state = Local.from_dict(data["local"]) - return Schema(global_state=global_state, local_state=local_state) - - -@dataclass -class TemplateVariables: - """Template variable information.""" - - type: str - """The type of the template variable""" - value: str | None = None - """The optional value of the template variable""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> TemplateVariables: - return TemplateVariables(**data) - - -@dataclass -class EventArg: - """Event argument information.""" - - type: str - """The type of the event argument""" - desc: str | None = None - """The optional description of the argument""" - name: str | None = None - """The optional name of the argument""" - struct: str | None = None - """The optional struct type name""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> EventArg: - return EventArg(**data) - - -@dataclass -class Event: - """Event information.""" - - args: list[EventArg] - """The list of event arguments""" - name: str - """The name of the event""" - desc: str | None = None - """The optional description of the event""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> Event: - data["args"] = [EventArg.from_dict(item) for item in data["args"]] - return Event(**data) - - -@dataclass -class Actions: - """Method actions information.""" - - call: list[CallEnum] | None = None - """The optional list of allowed call actions""" - create: list[CreateEnum] | None = None - """The optional list of allowed create actions""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> Actions: - return Actions(**data) - - -@dataclass -class DefaultValue: - """Default value information for method arguments.""" - - data: str - """The default value data""" - source: Literal["box", "global", "local", "literal", "method"] - """The source of the default value""" - type: str | None = None - """The optional type of the default value""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> DefaultValue: - return DefaultValue(**data) - - -@dataclass -class MethodArg: - """Method argument information.""" - - type: str - """The type of the argument""" - default_value: DefaultValue | None = None - """The optional default value""" - desc: str | None = None - """The optional description""" - name: str | None = None - """The optional name""" - struct: str | None = None - """The optional struct type name""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> MethodArg: - if data.get("default_value"): - data["default_value"] = DefaultValue.from_dict(data["default_value"]) - return MethodArg(**data) - - -@dataclass -class Boxes: - """Box storage requirements.""" - - key: str - """The box key""" - read_bytes: int - """The number of bytes to read""" - write_bytes: int - """The number of bytes to write""" - app: int | None = None - """The optional application ID""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> Boxes: - return Boxes(**data) - - -@dataclass -class Recommendations: - """Method execution recommendations.""" - - accounts: list[str] | None = None - """The optional list of accounts""" - apps: list[int] | None = None - """The optional list of applications""" - assets: list[int] | None = None - """The optional list of assets""" - boxes: Boxes | None = None - """The optional box storage requirements""" - inner_transaction_count: int | None = None - """The optional inner transaction count""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> Recommendations: - if data.get("boxes"): - data["boxes"] = Boxes.from_dict(data["boxes"]) - return Recommendations(**data) - - -@dataclass -class Returns: - """Method return information.""" - - type: str - """The type of the return value""" - desc: str | None = None - """The optional description""" - struct: str | None = None - """The optional struct type name""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> Returns: - return Returns(**data) - - -@dataclass -class Method: - """Method information.""" - - actions: Actions - """The allowed actions""" - args: list[MethodArg] - """The method arguments""" - name: str - """The method name""" - returns: Returns - """The return information""" - desc: str | None = None - """The optional description""" - events: list[Event] | None = None - """The optional list of events""" - readonly: bool | None = None - """The optional readonly flag""" - recommendations: Recommendations | None = None - """The optional execution recommendations""" - - _abi_method: AlgosdkMethod | None = None - - def __post_init__(self) -> None: - self._abi_method = AlgosdkMethod.undictify(asdict(self)) - - def to_abi_method(self) -> AlgosdkMethod: - """Convert to ABI method. - - :raises ValueError: If underlying ABI method is not initialized - :return: ABI method - """ - if self._abi_method is None: - raise ValueError("Underlying core ABI method class is not initialized!") - return self._abi_method - - @staticmethod - def from_dict(data: dict[str, Any]) -> Method: - data["actions"] = Actions.from_dict(data["actions"]) - data["args"] = [MethodArg.from_dict(item) for item in data["args"]] - data["returns"] = Returns.from_dict(data["returns"]) - if data.get("events"): - data["events"] = [Event.from_dict(item) for item in data["events"]] - if data.get("recommendations"): - data["recommendations"] = Recommendations.from_dict(data["recommendations"]) - return Method(**data) - - -class PcOffsetMethod(str, Enum): - """PC offset method types.""" - - CBLOCKS = "cblocks" - NONE = "none" - - -@dataclass -class SourceInfo: - """Source code location information.""" - - pc: list[int] - """The list of program counter values""" - error_message: str | None = None - """The optional error message""" - source: str | None = None - """The optional source code""" - teal: int | None = None - """The optional TEAL version""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> SourceInfo: - return SourceInfo(**data) - - -@dataclass -class StorageKey: - """Storage key information.""" - - key: str - """The storage key""" - key_type: str - """The type of the key""" - value_type: str - """The type of the value""" - desc: str | None = None - """The optional description""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> StorageKey: - return StorageKey(**data) - - -@dataclass -class StorageMap: - """Storage map information.""" - - key_type: str - """The type of the map keys""" - value_type: str - """The type of the map values""" - desc: str | None = None - """The optional description""" - prefix: str | None = None - """The optional key prefix""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> StorageMap: - return StorageMap(**data) - - -@dataclass -class Keys: - """Storage keys for different storage types.""" - - box: dict[str, StorageKey] - """The box storage keys""" - global_state: dict[str, StorageKey] # actual schema field is "global" since it's a reserved word - """The global state storage keys""" - local_state: dict[str, StorageKey] # actual schema field is "local" for consistency with renamed "global" - """The local state storage keys""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> Keys: - box = {key: StorageKey.from_dict(value) for key, value in data["box"].items()} - global_state = {key: StorageKey.from_dict(value) for key, value in data["global"].items()} - local_state = {key: StorageKey.from_dict(value) for key, value in data["local"].items()} - return Keys(box=box, global_state=global_state, local_state=local_state) - - -@dataclass -class Maps: - """Storage maps for different storage types.""" - - box: dict[str, StorageMap] - """The box storage maps""" - global_state: dict[str, StorageMap] # actual schema field is "global" since it's a reserved word - """The global state storage maps""" - local_state: dict[str, StorageMap] # actual schema field is "local" for consistency with renamed "global" - """The local state storage maps""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> Maps: - box = {key: StorageMap.from_dict(value) for key, value in data["box"].items()} - global_state = {key: StorageMap.from_dict(value) for key, value in data["global"].items()} - local_state = {key: StorageMap.from_dict(value) for key, value in data["local"].items()} - return Maps(box=box, global_state=global_state, local_state=local_state) - - -@dataclass -class State: - """Application state information.""" - - keys: Keys - """The storage keys""" - maps: Maps - """The storage maps""" - schema: Schema - """The state schema""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> State: - data["keys"] = Keys.from_dict(data["keys"]) - data["maps"] = Maps.from_dict(data["maps"]) - data["schema"] = Schema.from_dict(data["schema"]) - return State(**data) - - -@dataclass -class ProgramSourceInfo: - """Program source information.""" - - pc_offset_method: PcOffsetMethod - """The PC offset method""" - source_info: list[SourceInfo] - """The list of source info entries""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> ProgramSourceInfo: - data["source_info"] = [SourceInfo.from_dict(item) for item in data["source_info"]] - return ProgramSourceInfo(**data) - - -@dataclass -class SourceInfoModel: - """Source information for approval and clear programs.""" - - approval: ProgramSourceInfo - """The approval program source info""" - clear: ProgramSourceInfo - """The clear program source info""" - - @staticmethod - def from_dict(data: dict[str, Any]) -> SourceInfoModel: - data["approval"] = ProgramSourceInfo.from_dict(data["approval"]) - data["clear"] = ProgramSourceInfo.from_dict(data["clear"]) - return SourceInfoModel(**data) - - -# constants that define which parent keys mark a region whose inner keys should remain unchanged. -PROTECTED_TOP_DICTS = {"networks", "scratch_variables", "template_variables", "structs"} -STATE_PROTECTED_PARENTS = {"keys", "maps"} -STATE_PROTECTED_CHILDREN = {"global", "local", "box"} - - -def _is_protected_path(path: tuple[str, ...]) -> bool: - """ - Return True if the current recursion path indicates that we are inside a protected dictionary, - meaning that the keys should be left unchanged. - """ - return (len(path) >= 2 and path[-2] in STATE_PROTECTED_PARENTS and path[-1] in STATE_PROTECTED_CHILDREN) or ( # noqa: PLR2004 - len(path) >= 1 and path[-1] in PROTECTED_TOP_DICTS - ) - - -def _dict_keys_to_snake_case(value: Any, path: tuple[str, ...] = ()) -> Any: # noqa: ANN401 - """Recursively convert dictionary keys to snake_case except in protected sections. - - A dictionary is not converted if it is directly under: - - keys/maps sections ("global", "local", "box") - - or one of the top-level keys ("networks", "scratchVariables", "templateVariables", "structs") - (Note that once converted the parent key names become snake_case.) - """ - import re - - def camel_to_snake(s: str) -> str: - # Use a regular expression to insert an underscore before capital letters (except at start). - return re.sub(r"(? Arc56Contract: - source_data = self.arc32.get("source") - return Arc56Contract( - name=self.arc32["contract"]["name"], - desc=self.arc32["contract"].get("desc"), - arcs=[], - methods=self._convert_methods(self.arc32), - structs=self._convert_structs(self.arc32), - state=self._convert_state(self.arc32), - source=Source(**source_data) if source_data else None, - bare_actions=BareActions( - call=self._convert_actions(self.arc32.get("bare_call_config"), _ActionType.CALL), - create=self._convert_actions(self.arc32.get("bare_call_config"), _ActionType.CREATE), - ), - ) - - def _convert_storage_keys(self, schema: dict) -> dict[str, StorageKey]: - """Convert ARC32 schema declared fields to ARC56 storage keys.""" - return { - name: StorageKey( - key=b64encode(field["key"].encode()).decode(), - key_type="AVMString", - value_type="AVMUint64" if field["type"] == "uint64" else "AVMBytes", - desc=field.get("descr"), - ) - for name, field in schema.items() - } - - def _convert_state(self, arc32: dict) -> State: - """Convert ARC32 state and schema to ARC56 state specification.""" - state_data = arc32.get("state", {}) - return State( - schema=Schema( - global_state=Global( - ints=state_data.get("global", {}).get("num_uints", 0), - bytes=state_data.get("global", {}).get("num_byte_slices", 0), - ), - local_state=Local( - ints=state_data.get("local", {}).get("num_uints", 0), - bytes=state_data.get("local", {}).get("num_byte_slices", 0), - ), - ), - keys=Keys( - global_state=self._convert_storage_keys(arc32.get("schema", {}).get("global", {}).get("declared", {})), - local_state=self._convert_storage_keys(arc32.get("schema", {}).get("local", {}).get("declared", {})), - box={}, - ), - maps=Maps(global_state={}, local_state={}, box={}), - ) - - def _convert_structs(self, arc32: dict) -> dict[str, list[StructField]]: - """Extract and convert struct definitions from hints.""" - return { - struct["name"]: [StructField(name=elem[0], type=elem[1]) for elem in struct["elements"]] - for hint in arc32.get("hints", {}).values() - for struct in hint.get("structs", {}).values() - } - - def _convert_default_value(self, arg_type: str, default_arg: dict[str, Any] | None) -> DefaultValue | None: - """Convert ARC32 default argument to ARC56 format.""" - if not default_arg or not default_arg.get("source"): - return None - - source_mapping = { - "constant": "literal", - "global-state": "global", - "local-state": "local", - "abi-method": "method", - } - - mapped_source = source_mapping.get(default_arg["source"]) - if not mapped_source: - return None - elif mapped_source == "method": - return DefaultValue( - source=mapped_source, # type: ignore[arg-type] - data=default_arg.get("data", {}).get("name"), - ) - - arg_data = default_arg.get("data") - - if isinstance(arg_data, int): - arg_data = algosdk.abi.ABIType.from_string("uint64").encode(arg_data) - elif isinstance(arg_data, str): - arg_data = arg_data.encode() - else: - raise ValueError(f"Invalid default argument data type: {type(arg_data)}") - - return DefaultValue( - source=mapped_source, # type: ignore[arg-type] - data=base64.b64encode(arg_data).decode("utf-8"), - type=arg_type if arg_type != "string" else "AVMString", - ) - - @overload - def _convert_actions(self, config: dict | None, action_type: Literal[_ActionType.CALL]) -> list[CallEnum]: ... - - @overload - def _convert_actions(self, config: dict | None, action_type: Literal[_ActionType.CREATE]) -> list[CreateEnum]: ... - - def _convert_actions(self, config: dict | None, action_type: _ActionType) -> Sequence[CallEnum | CreateEnum]: - """Extract supported actions from call config.""" - if not config: - return [] - - actions: list[CallEnum | CreateEnum] = [] - mappings = { - "no_op": (CallEnum.NO_OP, CreateEnum.NO_OP), - "opt_in": (CallEnum.OPT_IN, CreateEnum.OPT_IN), - "close_out": (CallEnum.CLOSE_OUT, None), - "delete_application": (CallEnum.DELETE_APPLICATION, CreateEnum.DELETE_APPLICATION), - "update_application": (CallEnum.UPDATE_APPLICATION, None), - } - - for action, (call_enum, create_enum) in mappings.items(): - if action in config and config[action] in ["ALL", action_type]: - if action_type == "CALL" and call_enum: - actions.append(call_enum) - elif action_type == "CREATE" and create_enum: - actions.append(create_enum) - - return actions - - def _convert_method_actions(self, hint: dict | None) -> Actions: - """Convert method call config to ARC56 actions.""" - config = hint.get("call_config", {}) if hint else {} - return Actions( - call=self._convert_actions(config, _ActionType.CALL), - create=self._convert_actions(config, _ActionType.CREATE), - ) - - def _convert_methods(self, arc32: dict) -> list[Method]: - """Convert ARC32 methods to ARC56 format.""" - methods = [] - contract = arc32["contract"] - hints = arc32.get("hints", {}) - - for method in contract["methods"]: - args_sig = ",".join(a["type"] for a in method["args"]) - signature = f"{method['name']}({args_sig}){method['returns']['type']}" - hint = hints.get(signature, {}) - - methods.append( - Method( - name=method["name"], - desc=method.get("desc"), - readonly=hint.get("read_only"), - args=[ - MethodArg( - name=arg.get("name"), - type=arg["type"], - desc=arg.get("desc"), - struct=hint.get("structs", {}).get(arg.get("name", ""), {}).get("name"), - default_value=self._convert_default_value( - arg["type"], hint.get("default_arguments", {}).get(arg.get("name")) - ), - ) - for arg in method["args"] - ], - returns=Returns( - type=method["returns"]["type"], - desc=method["returns"].get("desc"), - struct=hint.get("structs", {}).get("output", {}).get("name"), - ), - actions=self._convert_method_actions(hint), - events=[], # ARC32 doesn't specify events - ) - ) - return methods - - -def _arc56_dict_factory() -> Callable[[list[tuple[str, Any]]], dict[str, Any]]: - """Creates a dict factory that handles ARC-56 JSON field naming conventions.""" - - word_map = {"global_state": "global", "local_state": "local"} - blocklist = ["_abi_method"] - - def to_camel(key: str) -> str: - key = word_map.get(key, key) - words = key.split("_") - return words[0] + "".join(word.capitalize() for word in words[1:]) - - def dict_factory(entries: list[tuple[str, Any]]) -> dict[str, Any]: - return {to_camel(k): v for k, v in entries if v is not None and k not in blocklist} - - return dict_factory - - -@dataclass -class Arc56Contract: - """ARC-0056 application specification. - - See https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0056.md - """ - - arcs: list[int] - """The list of supported ARC version numbers""" - bare_actions: BareActions - """The bare call and create actions""" - methods: list[Method] - """The list of contract methods""" - name: str - """The contract name""" - state: State - """The contract state information""" - structs: dict[str, list[StructField]] - """The contract struct definitions""" - byte_code: ByteCode | None = None - """The optional bytecode for approval and clear programs""" - compiler_info: CompilerInfo | None = None - """The optional compiler information""" - desc: str | None = None - """The optional contract description""" - events: list[Event] | None = None - """The optional list of contract events""" - networks: dict[str, Network] | None = None - """The optional network deployment information""" - scratch_variables: dict[str, ScratchVariables] | None = None - """The optional scratch variable information""" - source: Source | None = None - """The optional source code""" - source_info: SourceInfoModel | None = None - """The optional source code information""" - template_variables: dict[str, TemplateVariables] | None = None - """The optional template variable information""" - - @staticmethod - def from_dict(application_spec: dict) -> Arc56Contract: - """Create Arc56Contract from dictionary. - - :param application_spec: Dictionary containing contract specification - :return: Arc56Contract instance - """ - data = _dict_keys_to_snake_case(application_spec) - data["bare_actions"] = BareActions.from_dict(data["bare_actions"]) - data["methods"] = [Method.from_dict(item) for item in data["methods"]] - data["state"] = State.from_dict(data["state"]) - data["structs"] = { - key: [StructField.from_dict(item) for item in value] for key, value in application_spec["structs"].items() - } - if data.get("byte_code"): - data["byte_code"] = ByteCode.from_dict(data["byte_code"]) - if data.get("compiler_info"): - data["compiler_info"] = CompilerInfo.from_dict(data["compiler_info"]) - if data.get("events"): - data["events"] = [Event.from_dict(item) for item in data["events"]] - if data.get("networks"): - data["networks"] = {key: Network.from_dict(value) for key, value in data["networks"].items()} - if data.get("scratch_variables"): - data["scratch_variables"] = { - key: ScratchVariables.from_dict(value) for key, value in data["scratch_variables"].items() - } - if data.get("source"): - data["source"] = Source.from_dict(data["source"]) - if data.get("source_info"): - data["source_info"] = SourceInfoModel.from_dict(data["source_info"]) - if data.get("template_variables"): - data["template_variables"] = { - key: TemplateVariables.from_dict(value) for key, value in data["template_variables"].items() - } - return Arc56Contract(**data) - - @staticmethod - def from_json(application_spec: str) -> Arc56Contract: - return Arc56Contract.from_dict(json.loads(application_spec)) - - @staticmethod - def from_arc32(arc32_application_spec: str | Arc32Contract) -> Arc56Contract: - return _Arc32ToArc56Converter( - arc32_application_spec.to_json() - if isinstance(arc32_application_spec, Arc32Contract) - else arc32_application_spec - ).convert() - - @staticmethod - def get_abi_struct_from_abi_tuple( - decoded_tuple: Any, # noqa: ANN401 - struct_fields: list[StructField], - structs: dict[str, list[StructField]], - ) -> dict[str, Any]: - result = {} - for i, field in enumerate(struct_fields): - key = field.name - field_type = field.type - value = decoded_tuple[i] - if isinstance(field_type, str): - if field_type in structs: - value = Arc56Contract.get_abi_struct_from_abi_tuple(value, structs[field_type], structs) - elif isinstance(field_type, list): - value = Arc56Contract.get_abi_struct_from_abi_tuple(value, field_type, structs) - result[key] = value - return result - - def to_json(self, indent: int | None = None) -> str: - return json.dumps(self.dictify(), indent=indent) - - def dictify(self) -> dict: - return asdict(self, dict_factory=_arc56_dict_factory()) - - def get_arc56_method(self, method_name_or_signature: str) -> Method: - if "(" not in method_name_or_signature: - # Filter by method name - methods = [m for m in self.methods if m.name == method_name_or_signature] - if not methods: - raise ValueError(f"Unable to find method {method_name_or_signature} in {self.name} app.") - if len(methods) > 1: - signatures = [AlgosdkMethod.undictify(m.__dict__).get_signature() for m in self.methods] - raise ValueError( - f"Received a call to method {method_name_or_signature} in contract {self.name}, " - f"but this resolved to multiple methods; please pass in an ABI signature instead: " - f"{', '.join(signatures)}" - ) - method = methods[0] - else: - # Find by signature - method = None - for m in self.methods: - abi_method = AlgosdkMethod.undictify(asdict(m)) - if abi_method.get_signature() == method_name_or_signature: - method = m - break - - if method is None: - raise ValueError(f"Unable to find method {method_name_or_signature} in {self.name} app.") - - return method diff --git a/src/algokit_utils/asset.py b/src/algokit_utils/asset.py deleted file mode 100644 index c7087f0c..00000000 --- a/src/algokit_utils/asset.py +++ /dev/null @@ -1,32 +0,0 @@ -import warnings - -warnings.warn( - """The legacy v2 asset module is deprecated and will be removed in a future version. - -Replacements for opt_in/opt_out functionality: - -1. Using TransactionComposer: - composer.add_asset_opt_in(AssetOptInParams( - sender=account.address, - asset_id=123 - )) - composer.add_asset_opt_out(AssetOptOutParams( - sender=account.address, - asset_id=123, - creator=creator_address - )) - -2. Using AlgorandClient: - client.asset.opt_in(AssetOptInParams(...)) - client.asset.opt_out(AssetOptOutParams(...)) - -3. For bulk operations: - client.asset.bulk_opt_in(account, [asset_ids]) - client.asset.bulk_opt_out(account, [asset_ids]) - -Refer to AssetManager class from algokit_utils for more functionality.""", - DeprecationWarning, - stacklevel=2, -) - -from algokit_utils._legacy_v2.asset import * # noqa: F403, E402 diff --git a/src/algokit_utils/assets/asset_manager.py b/src/algokit_utils/assets/asset_manager.py index dbe39fb8..1bb7b4ba 100644 --- a/src/algokit_utils/assets/asset_manager.py +++ b/src/algokit_utils/assets/asset_manager.py @@ -1,11 +1,9 @@ from collections.abc import Callable from dataclasses import dataclass -import algosdk -from algosdk.atomic_transaction_composer import AccountTransactionSigner, TransactionSigner -from algosdk.v2client import algod - -from algokit_utils.models.account import SigningAccount +from algokit_algod_client import AlgodClient +from algokit_common import MAX_TRANSACTION_GROUP_SIZE +from algokit_transact.signer import AddressWithSigners, AddressWithTransactionSigner, TransactionSigner from algokit_utils.models.amount import AlgoAmount from algokit_utils.models.transaction import SendParams from algokit_utils.transactions.transaction_composer import ( @@ -90,72 +88,81 @@ class BulkAssetOptInOutResult: class AssetManager: """A manager for Algorand Standard Assets (ASAs). - :param algod_client: An algod client + :param algod_client: An AlgodClient instance :param new_group: A function that creates a new TransactionComposer transaction group :example: >>> asset_manager = AssetManager(algod_client) """ - def __init__(self, algod_client: algod.AlgodClient, new_group: Callable[[], TransactionComposer]): + def __init__(self, algod_client: AlgodClient, new_group: Callable[[], TransactionComposer]): self._algod = algod_client self._new_group = new_group def get_by_id(self, asset_id: int) -> AssetInformation: """Returns the current asset information for the asset with the given ID. - :param asset_id: The ID of the asset - :return: The asset information + Uses typed algod client `get_asset_by_id` and maps `asset.params.*` fields into an + `AssetInformation` dataclass. All values are sourced from typed model attributes + (e.g. `asset.params.total`, `asset.params.manager`, `asset.params.unit_name`) + rather than dictionary keys (legacy: `asset_info["params"]["total"]`, etc.). + + :param asset_id: The asset identifier + :return: `AssetInformation` with strongly typed fields :example: >>> asset_manager = AssetManager(algod_client) - >>> asset_info = asset_manager.get_by_id(1234567890) + >>> info = asset_manager.get_by_id(1234567890) + >>> print(info.total, info.creator, info.unit_name) """ - asset = self._algod.asset_info(asset_id) - assert isinstance(asset, dict) - params = asset["params"] + asset = self._algod.asset_by_id(asset_id) + params = asset.params return AssetInformation( asset_id=asset_id, - total=params["total"], - decimals=params["decimals"], - asset_name=params.get("name"), - asset_name_b64=params.get("name-b64"), - unit_name=params.get("unit-name"), - unit_name_b64=params.get("unit-name-b64"), - url=params.get("url"), - url_b64=params.get("url-b64"), - creator=params["creator"], - manager=params.get("manager"), - clawback=params.get("clawback"), - freeze=params.get("freeze"), - reserve=params.get("reserve"), - default_frozen=params.get("default-frozen"), - metadata_hash=params.get("metadata-hash"), + total=params.total, + decimals=params.decimals, + asset_name=params.name, + asset_name_b64=params.name_b64, + unit_name=params.unit_name, + unit_name_b64=params.unit_name_b64, + url=params.url, + url_b64=params.url_b64, + creator=params.creator, + manager=params.manager, + clawback=params.clawback, + freeze=params.freeze, + reserve=params.reserve, + default_frozen=bool(params.default_frozen) if params.default_frozen is not None else None, + metadata_hash=params.metadata_hash, ) def get_account_information( - self, sender: str | SigningAccount | TransactionSigner, asset_id: int + self, sender: str | AddressWithTransactionSigner, asset_id: int ) -> AccountAssetInformation: """Returns the given sender account's asset holding for a given asset. :param sender: The address of the sender/account to look up :param asset_id: The ID of the asset to return a holding for :return: The account asset holding information + :raises ValueError: If the account has no holding for the specified asset :example: >>> asset_manager = AssetManager(algod_client) >>> account_asset_info = asset_manager.get_account_information(sender, asset_id) """ address = self._get_address_from_sender(sender) - info = self._algod.account_asset_info(address, asset_id) - assert isinstance(info, dict) + info = self._algod.account_asset_information(address, asset_id) + holding = info.asset_holding + if holding is None: + raise ValueError("Account has no holding for the specified asset") return AccountAssetInformation( asset_id=asset_id, - balance=info["asset-holding"]["amount"], - frozen=info["asset-holding"]["is-frozen"], - round=info["round"], + balance=holding.amount, + # TODO: resolve bool val resolution in api generator + frozen=bool(holding.is_frozen) if holding.is_frozen is not None else False, + round=info.round_, ) def bulk_opt_in( # noqa: PLR0913 @@ -198,7 +205,7 @@ def bulk_opt_in( # noqa: PLR0913 results: list[BulkAssetOptInOutResult] = [] sender = self._get_address_from_sender(account) - for asset_group in _chunk_array(asset_ids, algosdk.constants.TX_GROUP_LIMIT): + for asset_group in _chunk_array(asset_ids, MAX_TRANSACTION_GROUP_SIZE): composer = self._new_group() for asset_id in asset_group: @@ -269,7 +276,7 @@ def bulk_opt_out( # noqa: C901, PLR0913 results: list[BulkAssetOptInOutResult] = [] sender = self._get_address_from_sender(account) - for asset_group in _chunk_array(asset_ids, algosdk.constants.TX_GROUP_LIMIT): + for asset_group in _chunk_array(asset_ids, MAX_TRANSACTION_GROUP_SIZE): composer = self._new_group() not_opted_in_asset_ids: list[int] = [] @@ -322,13 +329,14 @@ def bulk_opt_out( # noqa: C901, PLR0913 return results @staticmethod - def _get_address_from_sender(sender: str | SigningAccount | TransactionSigner) -> str: + def _get_address_from_sender( + sender: str | AddressWithTransactionSigner | AddressWithSigners, + ) -> str: if isinstance(sender, str): return sender - if isinstance(sender, SigningAccount): - return sender.address - if isinstance(sender, AccountTransactionSigner): - return str(algosdk.account.address_from_private_key(sender.private_key)) + # Both AddressWithSigners and AddressWithTransactionSigner now use 'addr' + if isinstance(sender, AddressWithSigners | AddressWithTransactionSigner): + return sender.addr raise ValueError(f"Unsupported sender type: {type(sender)}") diff --git a/src/algokit_utils/beta/_utils.py b/src/algokit_utils/beta/_utils.py deleted file mode 100644 index f28f96a3..00000000 --- a/src/algokit_utils/beta/_utils.py +++ /dev/null @@ -1,36 +0,0 @@ -from typing import NoReturn - - -def deprecated_import_error(old_path: str, new_path: str) -> NoReturn: - """Helper to create consistent deprecation error messages""" - raise ImportError( - f"WARNING: The module '{old_path}' has been removed in algokit-utils v3. " - f"Please update your imports to use '{new_path}' instead. " - "See the migration guide for more details: " - "https://github.com/algorandfoundation/algokit-utils-py/blob/main/docs/source/v3-migration-guide.md" - ) - - -def handle_getattr(name: str) -> NoReturn: - param_mappings = { - "ClientManager": "algokit_utils.ClientManager", - "AlgorandClient": "algokit_utils.AlgorandClient", - "AlgoSdkClients": "algokit_utils.AlgoSdkClients", - "AccountManager": "algokit_utils.AccountManager", - "PayParams": "algokit_utils.transactions.PaymentParams", - "AlgokitComposer": "algokit_utils.TransactionComposer", - "AssetCreateParams": "algokit_utils.transactions.AssetCreateParams", - "AssetConfigParams": "algokit_utils.transactions.AssetConfigParams", - "AssetFreezeParams": "algokit_utils.transactions.AssetFreezeParams", - "AssetDestroyParams": "algokit_utils.transactions.AssetDestroyParams", - "AssetTransferParams": "algokit_utils.transactions.AssetTransferParams", - "AssetOptInParams": "algokit_utils.transactions.AssetOptInParams", - "AppCallParams": "algokit_utils.transactions.AppCallParams", - "MethodCallParams": "algokit_utils.transactions.MethodCallParams", - "OnlineKeyRegParams": "algokit_utils.transactions.OnlineKeyRegistrationParams", - } - - if name in param_mappings: - deprecated_import_error(f"algokit_utils.beta.{name}", param_mappings[name]) - - raise AttributeError(f"module 'algokit_utils.beta' has no attribute '{name}'") diff --git a/src/algokit_utils/beta/account_manager.py b/src/algokit_utils/beta/account_manager.py deleted file mode 100644 index 90835e43..00000000 --- a/src/algokit_utils/beta/account_manager.py +++ /dev/null @@ -1,9 +0,0 @@ -from typing import Any - -from algokit_utils.beta._utils import handle_getattr - - -def __getattr__(name: str) -> Any: # noqa: ANN401 - """Handle deprecated imports of parameter classes""" - - handle_getattr(name) diff --git a/src/algokit_utils/beta/algorand_client.py b/src/algokit_utils/beta/algorand_client.py deleted file mode 100644 index 90835e43..00000000 --- a/src/algokit_utils/beta/algorand_client.py +++ /dev/null @@ -1,9 +0,0 @@ -from typing import Any - -from algokit_utils.beta._utils import handle_getattr - - -def __getattr__(name: str) -> Any: # noqa: ANN401 - """Handle deprecated imports of parameter classes""" - - handle_getattr(name) diff --git a/src/algokit_utils/beta/client_manager.py b/src/algokit_utils/beta/client_manager.py deleted file mode 100644 index 90835e43..00000000 --- a/src/algokit_utils/beta/client_manager.py +++ /dev/null @@ -1,9 +0,0 @@ -from typing import Any - -from algokit_utils.beta._utils import handle_getattr - - -def __getattr__(name: str) -> Any: # noqa: ANN401 - """Handle deprecated imports of parameter classes""" - - handle_getattr(name) diff --git a/src/algokit_utils/beta/composer.py b/src/algokit_utils/beta/composer.py deleted file mode 100644 index 90835e43..00000000 --- a/src/algokit_utils/beta/composer.py +++ /dev/null @@ -1,9 +0,0 @@ -from typing import Any - -from algokit_utils.beta._utils import handle_getattr - - -def __getattr__(name: str) -> Any: # noqa: ANN401 - """Handle deprecated imports of parameter classes""" - - handle_getattr(name) diff --git a/src/algokit_utils/clients/__init__.py b/src/algokit_utils/clients/__init__.py index 1a48b824..e8916665 100644 --- a/src/algokit_utils/clients/__init__.py +++ b/src/algokit_utils/clients/__init__.py @@ -1,2 +1,41 @@ -from algokit_utils.clients.client_manager import * # noqa: F403 -from algokit_utils.clients.dispenser_api_client import * # noqa: F403 +from algokit_algod_client import AlgodClient +from algokit_algod_client import models as algod_models +from algokit_algod_client.exceptions import UnexpectedStatusError +from algokit_indexer_client import IndexerClient +from algokit_kmd_client import KmdClient +from algokit_utils.clients.client_manager import ( + AlgoSdkClients, + ClientManager, + NetworkDetail, +) +from algokit_utils.clients.dispenser_api_client import ( + DISPENSER_ACCESS_TOKEN_KEY, + DISPENSER_ASSETS, + DISPENSER_REQUEST_TIMEOUT, + DispenserApiConfig, + DispenserAsset, + DispenserAssetName, + DispenserFundResponse, + DispenserLimitResponse, + TestNetDispenserApiClient, +) + +__all__ = [ + "DISPENSER_ACCESS_TOKEN_KEY", + "DISPENSER_ASSETS", + "DISPENSER_REQUEST_TIMEOUT", + "AlgoSdkClients", + "AlgodClient", + "ClientManager", + "DispenserApiConfig", + "DispenserAsset", + "DispenserAssetName", + "DispenserFundResponse", + "DispenserLimitResponse", + "IndexerClient", + "KmdClient", + "NetworkDetail", + "TestNetDispenserApiClient", + "UnexpectedStatusError", + "algod_models", +] diff --git a/src/algokit_utils/clients/client_manager.py b/src/algokit_utils/clients/client_manager.py index e3bf497b..407a2766 100644 --- a/src/algokit_utils/clients/client_manager.py +++ b/src/algokit_utils/clients/client_manager.py @@ -1,28 +1,26 @@ -from __future__ import annotations - import os from dataclasses import dataclass -from typing import TYPE_CHECKING, Literal, TypeVar +from typing import TYPE_CHECKING, Literal, Optional, TypeVar from urllib import parse -import algosdk -from algosdk.atomic_transaction_composer import TransactionSigner -from algosdk.kmd import KMDClient -from algosdk.source_map import SourceMap -from algosdk.transaction import SuggestedParams -from algosdk.v2client.algod import AlgodClient -from algosdk.v2client.indexer import IndexerClient - -from algokit_utils._legacy_v2.application_specification import ApplicationSpecification -from algokit_utils.applications.app_deployer import ApplicationLookup -from algokit_utils.applications.app_spec.arc56 import Arc56Contract +from algokit_abi import arc56 +from algokit_algod_client import AlgodClient +from algokit_algod_client import ClientConfig as AlgodClientConfig +from algokit_algod_client import models as algod_models +from algokit_common import ProgramSourceMap +from algokit_indexer_client import ClientConfig as IndexerClientConfig +from algokit_indexer_client import IndexerClient +from algokit_kmd_client import ClientConfig as KmdClientConfig +from algokit_kmd_client import KmdClient from algokit_utils.clients.dispenser_api_client import TestNetDispenserApiClient from algokit_utils.models.network import AlgoClientConfigs, AlgoClientNetworkConfig +from algokit_utils.protocols.signer import TransactionSigner from algokit_utils.protocols.typed_clients import TypedAppClientProtocol, TypedAppFactoryProtocol if TYPE_CHECKING: from algokit_utils.algorand import AlgorandClient from algokit_utils.applications.app_client import AppClient, AppClientCompilationParams + from algokit_utils.applications.app_deployer import ApplicationLookup from algokit_utils.applications.app_factory import AppFactory __all__ = [ @@ -40,16 +38,16 @@ class AlgoSdkClients: Holds references to Algod, Indexer and KMD clients. - :param algod: Algod client instance + :param algod: Algod client instance (protocol-compatible typed client) :param indexer: Optional Indexer client instance :param kmd: Optional KMD client instance """ def __init__( self, - algod: algosdk.v2client.algod.AlgodClient, + algod: AlgodClient, indexer: IndexerClient | None = None, - kmd: KMDClient | None = None, + kmd: KmdClient | None = None, ): self.algod = algod self.indexer = indexer @@ -92,21 +90,10 @@ class ClientManager: Provides access to Algod, Indexer and KMD clients and helper methods for working with them. :param clients_or_configs: Either client instances or client configurations - :param algorand_client: AlgorandClient instance - - :example: - >>> # Algod only - >>> client_manager = ClientManager(algod_client) - >>> # Algod and Indexer - >>> client_manager = ClientManager(algod_client, indexer_client) - >>> # Algod config only - >>> client_manager = ClientManager(ClientManager.get_algod_config_from_environment()) - >>> # Algod and Indexer config - >>> client_manager = ClientManager(ClientManager.get_algod_config_from_environment(), - ... ClientManager.get_indexer_config_from_environment()) + :param algorand_client: "AlgorandClient" instance """ - def __init__(self, clients_or_configs: AlgoClientConfigs | AlgoSdkClients, algorand_client: AlgorandClient): + def __init__(self, clients_or_configs: AlgoClientConfigs | AlgoSdkClients, algorand_client: "AlgorandClient"): if isinstance(clients_or_configs, AlgoSdkClients): _clients = clients_or_configs elif isinstance(clients_or_configs, AlgoClientConfigs): @@ -123,11 +110,11 @@ def __init__(self, clients_or_configs: AlgoClientConfigs | AlgoSdkClients, algor self._indexer = _clients.indexer self._kmd = _clients.kmd self._algorand = algorand_client - self._suggested_params: SuggestedParams | None = None + self._suggested_params: algod_models.SuggestedParams | None = None @property def algod(self) -> AlgodClient: - """Returns an algosdk Algod API client. + """Returns the typed Algod API client instance. :return: Algod client instance """ @@ -135,7 +122,7 @@ def algod(self) -> AlgodClient: @property def indexer(self) -> IndexerClient: - """Returns an algosdk Indexer API client. + """Returns an Indexer API client. :raises ValueError: If no Indexer client is configured :return: Indexer client instance @@ -153,8 +140,8 @@ def indexer_if_present(self) -> IndexerClient | None: return self._indexer @property - def kmd(self) -> KMDClient: - """Returns an algosdk KMD API client. + def kmd(self) -> KmdClient: + """Returns a KMD-compatible API client. :raises ValueError: If no KMD client is configured :return: KMD client instance @@ -172,15 +159,19 @@ def network(self) -> NetworkDetail: >>> client_manager = ClientManager(algod_client) >>> network_detail = client_manager.network() """ + import base64 + if self._suggested_params is None: self._suggested_params = self._algod.suggested_params() sp = self._suggested_params return NetworkDetail( - is_testnet=sp.gen in ["testnet-v1.0", "testnet-v1", "testnet"], - is_mainnet=sp.gen in ["mainnet-v1.0", "mainnet-v1", "mainnet"], - is_localnet=ClientManager.genesis_id_is_localnet(str(sp.gen)), - genesis_id=str(sp.gen), - genesis_hash=sp.gh, + is_testnet=sp.genesis_id in ["testnet-v1.0", "testnet-v1", "testnet"], + is_mainnet=sp.genesis_id in ["mainnet-v1.0", "mainnet-v1", "mainnet"], + is_localnet=ClientManager.genesis_id_is_localnet(str(sp.genesis_id)), + genesis_id=str(sp.genesis_id), + genesis_hash=base64.b64encode(sp.genesis_hash).decode("utf-8") + if isinstance(sp.genesis_hash, bytes) + else sp.genesis_hash, ) def is_localnet(self) -> bool: @@ -204,6 +195,20 @@ def is_mainnet(self) -> bool: """ return self.network().is_mainnet + def close(self) -> None: + """Close the underlying HTTP client connections. + + This method should be called when the ClientManager is no longer needed + to properly clean up resources. + + :example: + >>> client_manager = ClientManager(algod_client) + >>> # ... use client_manager ... + >>> client_manager.close() + """ + if isinstance(self._algod, AlgodClient): + self._algod.close() + def get_testnet_dispenser( self, auth_token: str | None = None, request_timeout: int | None = None ) -> TestNetDispenserApiClient: @@ -220,13 +225,13 @@ def get_testnet_dispenser( def get_app_factory( self, - app_spec: Arc56Contract | ApplicationSpecification | str, + app_spec: arc56.Arc56Contract | str, app_name: str | None = None, default_sender: str | None = None, default_signer: TransactionSigner | None = None, version: str | None = None, - compilation_params: AppClientCompilationParams | None = None, - ) -> AppFactory: + compilation_params: Optional["AppClientCompilationParams"] = None, + ) -> "AppFactory": """Get an application factory for deploying smart contracts. :param app_spec: Application specification @@ -257,14 +262,14 @@ def get_app_factory( def get_app_client_by_id( self, - app_spec: (Arc56Contract | ApplicationSpecification | str), + app_spec: arc56.Arc56Contract | str, app_id: int, app_name: str | None = None, default_sender: str | None = None, default_signer: TransactionSigner | None = None, - approval_source_map: SourceMap | None = None, - clear_source_map: SourceMap | None = None, - ) -> AppClient: + approval_source_map: ProgramSourceMap | None = None, + clear_source_map: ProgramSourceMap | None = None, + ) -> "AppClient": """Get an application client for an existing application by ID. :param app_spec: Application specification @@ -297,13 +302,13 @@ def get_app_client_by_id( def get_app_client_by_network( self, - app_spec: (Arc56Contract | ApplicationSpecification | str), + app_spec: (arc56.Arc56Contract | str), app_name: str | None = None, default_sender: str | None = None, default_signer: TransactionSigner | None = None, - approval_source_map: SourceMap | None = None, - clear_source_map: SourceMap | None = None, - ) -> AppClient: + approval_source_map: ProgramSourceMap | None = None, + clear_source_map: ProgramSourceMap | None = None, + ) -> "AppClient": """Get an application client for an existing application by network. :param app_spec: Application specification @@ -334,14 +339,14 @@ def get_app_client_by_creator_and_name( self, creator_address: str, app_name: str, - app_spec: Arc56Contract | ApplicationSpecification | str, + app_spec: arc56.Arc56Contract | str, default_sender: str | None = None, default_signer: TransactionSigner | None = None, ignore_cache: bool | None = None, - app_lookup_cache: ApplicationLookup | None = None, - approval_source_map: SourceMap | None = None, - clear_source_map: SourceMap | None = None, - ) -> AppClient: + app_lookup_cache: Optional["ApplicationLookup"] = None, + approval_source_map: ProgramSourceMap | None = None, + clear_source_map: ProgramSourceMap | None = None, + ) -> "AppClient": """Get an application client by creator address and name. :param creator_address: Creator address @@ -372,17 +377,16 @@ def get_app_client_by_creator_and_name( @staticmethod def get_algod_client(config: AlgoClientNetworkConfig) -> AlgodClient: - """Get an Algod client from config or environment. + """Get a typed Algod client from config. - :param config: Optional client configuration - :return: Algod client instance + :param config: Client configuration + :return: Typed Algod client instance """ - headers = {"X-Algo-API-Token": config.token or ""} - return AlgodClient( - algod_token=config.token or "", - algod_address=config.full_url(), - headers=headers, + client_config = AlgodClientConfig( + base_url=config.full_url(), + token=config.token or None, ) + return AlgodClient(client_config) @staticmethod def get_algod_client_from_environment() -> AlgodClient: @@ -393,16 +397,20 @@ def get_algod_client_from_environment() -> AlgodClient: return ClientManager.get_algod_client(ClientManager.get_algod_config_from_environment()) @staticmethod - def get_kmd_client(config: AlgoClientNetworkConfig) -> KMDClient: + def get_kmd_client(config: AlgoClientNetworkConfig) -> KmdClient: """Get a KMD client from config or environment. :param config: Optional client configuration :return: KMD client instance """ - return KMDClient(config.token, config.full_url()) + client_config = KmdClientConfig( + base_url=config.full_url(), + token=config.token or None, + ) + return KmdClient(client_config) @staticmethod - def get_kmd_client_from_environment() -> KMDClient: + def get_kmd_client_from_environment() -> KmdClient: """Get a KMD client from environment variables. :return: KMD client instance @@ -416,12 +424,11 @@ def get_indexer_client(config: AlgoClientNetworkConfig) -> IndexerClient: :param config: Optional client configuration :return: Indexer client instance """ - headers = {"X-Indexer-API-Token": config.token} - return IndexerClient( - indexer_token=config.token, - indexer_address=config.full_url(), - headers=headers, + client_config = IndexerClientConfig( + base_url=config.full_url(), + token=config.token or None, ) + return IndexerClient(client_config) @staticmethod def get_indexer_client_from_environment() -> IndexerClient: @@ -452,7 +459,7 @@ def get_typed_app_client_by_creator_and_name( default_sender: str | None = None, default_signer: TransactionSigner | None = None, ignore_cache: bool | None = None, - app_lookup_cache: ApplicationLookup | None = None, + app_lookup_cache: Optional["ApplicationLookup"] = None, ) -> TypedAppClientT: """Get a typed application client by creator address and name. @@ -495,8 +502,8 @@ def get_typed_app_client_by_id( app_name: str | None = None, default_sender: str | None = None, default_signer: TransactionSigner | None = None, - approval_source_map: SourceMap | None = None, - clear_source_map: SourceMap | None = None, + approval_source_map: ProgramSourceMap | None = None, + clear_source_map: ProgramSourceMap | None = None, ) -> TypedAppClientT: """Get a typed application client by ID. @@ -537,8 +544,8 @@ def get_typed_app_client_by_network( app_name: str | None = None, default_sender: str | None = None, default_signer: TransactionSigner | None = None, - approval_source_map: SourceMap | None = None, - clear_source_map: SourceMap | None = None, + approval_source_map: ProgramSourceMap | None = None, + clear_source_map: ProgramSourceMap | None = None, ) -> TypedAppClientT: """Returns a new typed client, resolves the app ID for the current network. @@ -581,7 +588,7 @@ def get_typed_app_factory( default_sender: str | None = None, default_signer: TransactionSigner | None = None, version: str | None = None, - compilation_params: AppClientCompilationParams | None = None, + compilation_params: Optional["AppClientCompilationParams"] = None, ) -> TypedFactoryT: """Get a typed application factory. diff --git a/src/algokit_utils/clients/dispenser_api_client.py b/src/algokit_utils/clients/dispenser_api_client.py index a72b4590..d3881ce7 100644 --- a/src/algokit_utils/clients/dispenser_api_client.py +++ b/src/algokit_utils/clients/dispenser_api_client.py @@ -2,10 +2,8 @@ import enum import os from dataclasses import dataclass -from typing import overload import httpx -from typing_extensions import deprecated from algokit_utils.config import config @@ -141,13 +139,6 @@ def _process_dispenser_request( config.logger.debug(f"{error_message}: {err}", exc_info=True) raise err - @overload - def fund(self, address: str, amount: int) -> DispenserFundResponse: ... - - @overload - @deprecated("Asset ID parameter is deprecated. Can now use `fund(address, amount)` instead.") - def fund(self, address: str, amount: int, asset_id: int | None = None) -> DispenserFundResponse: ... - def fund(self, address: str, amount: int, asset_id: int | None = None) -> DispenserFundResponse: # noqa: ARG002 """ Fund an account with Algos from the dispenser API diff --git a/src/algokit_utils/common.py b/src/algokit_utils/common.py index c0274574..e0986138 100644 --- a/src/algokit_utils/common.py +++ b/src/algokit_utils/common.py @@ -1,10 +1,40 @@ -import warnings +"""Common utilities - user-facing facade for algokit_common. -warnings.warn( - "The legacy v2 common module is deprecated and will be removed in a future version. " - "Refer to `CompiledTeal` class from `algokit_utils` instead.", - DeprecationWarning, - stacklevel=2, +Users should import from this module instead of algokit_common directly. +""" + +from algokit_common import ( + ADDRESS_LENGTH, + CHECKSUM_BYTE_LENGTH, + HASH_BYTES_LENGTH, + MAX_TRANSACTION_GROUP_SIZE, + MICROALGOS_TO_ALGOS_RATIO, + MIN_TXN_FEE, + PUBLIC_KEY_BYTE_LENGTH, + SIGNATURE_BYTE_LENGTH, + TRANSACTION_ID_LENGTH, + ZERO_ADDRESS, + ProgramSourceMap, + address_from_public_key, + get_application_address, + public_key_from_address, + sha512_256, ) -from algokit_utils._legacy_v2.common import * # noqa: F403, E402 +__all__ = [ + "ADDRESS_LENGTH", + "CHECKSUM_BYTE_LENGTH", + "HASH_BYTES_LENGTH", + "MAX_TRANSACTION_GROUP_SIZE", + "MICROALGOS_TO_ALGOS_RATIO", + "MIN_TXN_FEE", + "PUBLIC_KEY_BYTE_LENGTH", + "SIGNATURE_BYTE_LENGTH", + "TRANSACTION_ID_LENGTH", + "ZERO_ADDRESS", + "ProgramSourceMap", + "address_from_public_key", + "get_application_address", + "public_key_from_address", + "sha512_256", +] diff --git a/src/algokit_utils/config.py b/src/algokit_utils/config.py index eacf00d8..0a979b24 100644 --- a/src/algokit_utils/config.py +++ b/src/algokit_utils/config.py @@ -12,7 +12,7 @@ class AlgoKitLogger(logging.Logger): def __init__(self, name: str = "algokit-utils-py", level: int = logging.NOTSET): super().__init__(name, level) - def _log(self, level: int, msg: object, args, exc_info=None, extra=None, stack_info=False, stacklevel=1) -> None: # type: ignore[no-untyped-def] # noqa: FBT002, ANN001 + def _log(self, level: int, msg: object, args, exc_info=None, extra=None, stack_info=False, stacklevel=1) -> None: # type: ignore[no-untyped-def] # noqa: ANN001, FBT002 """ Overrides the base _log method to allow suppressing individual log calls. When a caller passes suppress_log=True in the extra keyword, the log call is ignored. diff --git a/src/algokit_utils/deploy.py b/src/algokit_utils/deploy.py deleted file mode 100644 index 9991b3ab..00000000 --- a/src/algokit_utils/deploy.py +++ /dev/null @@ -1,10 +0,0 @@ -import warnings - -warnings.warn( - "The legacy v2 deploy module is deprecated and will be removed in a future version. " - "Refer to `AppFactory` and `AppDeployer` abstractions from `algokit_utils` module instead.", - DeprecationWarning, - stacklevel=2, -) - -from algokit_utils._legacy_v2.deploy import * # noqa: F403, E402 diff --git a/src/algokit_utils/dispenser_api.py b/src/algokit_utils/dispenser_api.py deleted file mode 100644 index a338badc..00000000 --- a/src/algokit_utils/dispenser_api.py +++ /dev/null @@ -1,10 +0,0 @@ -import warnings - -warnings.warn( - "The legacy v2 dispenser api module is deprecated and will be removed in a future version. " - "Import from 'algokit_utils.clients.dispenser_api_client' instead.", - DeprecationWarning, - stacklevel=2, -) - -from algokit_utils.clients.dispenser_api_client import * # noqa: F403, E402 diff --git a/src/algokit_utils/errors/logic_error.py b/src/algokit_utils/errors/logic_error.py index 755b89e4..50801215 100644 --- a/src/algokit_utils/errors/logic_error.py +++ b/src/algokit_utils/errors/logic_error.py @@ -1,20 +1,22 @@ import base64 import re -from collections.abc import Callable +from collections.abc import Callable, Mapping, Sequence from copy import copy from typing import TYPE_CHECKING, TypedDict -from algosdk.atomic_transaction_composer import ( - SimulateAtomicTransactionResponse, +from algokit_algod_client.models import ( + PendingTransactionResponse, + SimulateTransactionResult, + SimulationTransactionExecTrace, ) - -from algokit_utils.models.simulate import SimulationTrace +from algokit_common import ProgramSourceMap if TYPE_CHECKING: - from algosdk.source_map import SourceMap as AlgoSourceMap + pass __all__ = [ "LogicError", "LogicErrorData", + "create_simulate_traces_for_logic_error", "parse_logic_error", ] @@ -50,12 +52,12 @@ def __init__( *, logic_error_str: str, program: str, - source_map: "AlgoSourceMap | None", + source_map: "ProgramSourceMap | None", transaction_id: str, message: str, pc: int, logic_error: Exception | None = None, - traces: list[SimulationTrace] | None = None, + traces: list[SimulateTransactionResult] | None = None, get_line_for_pc: Callable[[int], int | None] | None = None, ): self.logic_error = logic_error @@ -90,7 +92,7 @@ def trace(self, lines: int = 5) -> str: return """ Could not determine TEAL source line for the error as no approval source map was provided, to receive a trace of the error please provide an approval SourceMap. Either by: - 1.Providing template_values when creating the ApplicationClient, so a SourceMap can be obtained automatically OR + 1.Providing template_values when creating the AppClient, so a SourceMap can be obtained automatically OR 2.Set approval_source_map from a previously compiled approval program OR 3.Import a previously exported source map using import_source_map""" @@ -101,21 +103,58 @@ def trace(self, lines: int = 5) -> str: return "\n\t" + "\n\t".join(program_lines[lines_before:lines_after]) -def create_simulate_traces_for_logic_error(simulate: SimulateAtomicTransactionResponse) -> list[SimulationTrace]: - traces = [] - if hasattr(simulate, "simulate_response") and hasattr(simulate, "failed_at") and simulate.failed_at: - for txn_group in simulate.simulate_response["txn-groups"]: - app_budget_added = txn_group.get("app-budget-added", None) - app_budget_consumed = txn_group.get("app-budget-consumed", None) - failure_message = txn_group.get("failure-message", None) - txn_result = txn_group.get("txn-results", [{}])[0] - exec_trace = txn_result.get("exec-trace", {}) +def create_simulate_traces_for_logic_error(simulate: object) -> list[SimulateTransactionResult]: + """Extract simulation traces from a simulate response for logic error debugging. + + Args: + simulate: An object with simulate_response and failed_at attributes. + + Returns: + A list of SimulateTransactionResult objects extracted from the simulation response. + """ + traces: list[SimulateTransactionResult] = [] + simulate_response = getattr(simulate, "simulate_response", None) + failed_at = getattr(simulate, "failed_at", None) + + if not failed_at or not isinstance(simulate_response, Mapping): + return traces + + txn_groups = simulate_response.get("txn-groups", []) + if not isinstance(txn_groups, Sequence): + return traces + + for txn_group in txn_groups: + if not isinstance(txn_group, Mapping): + continue + txn_results = txn_group.get("txn-results", []) + + if not isinstance(txn_results, Sequence): + continue + + for txn_result in txn_results: + if not isinstance(txn_result, Mapping): + continue + exec_trace_raw = txn_result.get("exec-trace") + app_budget_consumed = txn_result.get("app-budget-consumed") + logic_sig_budget_consumed = txn_result.get("logic-sig-budget-consumed") + txn_result_inner = txn_result.get("txn-result", {}) + logs_raw = txn_result_inner.get("logs", []) if isinstance(txn_result_inner, Mapping) else [] + logs = [base64.b64decode(log) if isinstance(log, str) else log for log in logs_raw] if logs_raw else None + + # Create PendingTransactionResponse with logs for the SimulateTransactionResult + # Note: txn is required but we don't have it from raw JSON, use placeholder + pending_response = PendingTransactionResponse( + txn=None, # type: ignore[arg-type] # placeholder for raw response parsing + logs=logs, + ) + + # Create SimulateTransactionResult with available data traces.append( - SimulationTrace( - app_budget_added=app_budget_added, + SimulateTransactionResult( + txn_result=pending_response, app_budget_consumed=app_budget_consumed, - failure_message=failure_message, - exec_trace=exec_trace, + logic_sig_budget_consumed=logic_sig_budget_consumed, + exec_trace=exec_trace_raw if isinstance(exec_trace_raw, SimulationTransactionExecTrace) else None, ) ) return traces diff --git a/src/algokit_utils/logic_error.py b/src/algokit_utils/logic_error.py deleted file mode 100644 index 462895f7..00000000 --- a/src/algokit_utils/logic_error.py +++ /dev/null @@ -1,10 +0,0 @@ -import warnings - -warnings.warn( - "The legacy v2 logic error module is deprecated and will be removed in a future version. " - "Use 'from algokit_utils.errors import LogicError' instead.", - DeprecationWarning, - stacklevel=2, -) - -from algokit_utils.errors.logic_error import * # noqa: F403, E402 diff --git a/src/algokit_utils/models/__init__.py b/src/algokit_utils/models/__init__.py index d4790dc4..25094897 100644 --- a/src/algokit_utils/models/__init__.py +++ b/src/algokit_utils/models/__init__.py @@ -1,4 +1,3 @@ -from algokit_utils._legacy_v2.models import * # noqa: F403 from algokit_utils.models.account import * # noqa: F403 from algokit_utils.models.amount import * # noqa: F403 from algokit_utils.models.application import * # noqa: F403 diff --git a/src/algokit_utils/models/account.py b/src/algokit_utils/models/account.py index 587a0631..1de24cda 100644 --- a/src/algokit_utils/models/account.py +++ b/src/algokit_utils/models/account.py @@ -1,217 +1,12 @@ -import dataclasses - -import algosdk -import algosdk.atomic_transaction_composer -from algosdk.atomic_transaction_composer import AccountTransactionSigner, LogicSigTransactionSigner, TransactionSigner -from algosdk.transaction import LogicSigAccount as AlgosdkLogicSigAccount -from algosdk.transaction import Multisig, MultisigTransaction -from typing_extensions import deprecated +from algokit_transact import AddressWithSigners, LogicSigAccount, MultisigAccount, MultisigMetadata __all__ = [ "DISPENSER_ACCOUNT_NAME", + "AddressWithSigners", "LogicSigAccount", - "MultiSigAccount", + "MultisigAccount", "MultisigMetadata", - "SigningAccount", - "TransactionSignerAccount", ] DISPENSER_ACCOUNT_NAME = "DISPENSER" - - -@dataclasses.dataclass(kw_only=True) -class TransactionSignerAccount: - """A basic transaction signer account.""" - - address: str - signer: TransactionSigner - - def __post_init__(self) -> None: - if not isinstance(self.address, str): - raise TypeError("Address must be a string") - if not isinstance(self.signer, TransactionSigner): - raise TypeError("Signer must be a TransactionSigner instance") - - -@dataclasses.dataclass(kw_only=True) -class SigningAccount: - """Holds the private key and address for an account. - - Provides access to the account's private key, address, public key and transaction signer. - """ - - private_key: str - """Base64 encoded private key""" - address: str = dataclasses.field(default="") - """Address for this account""" - - def __post_init__(self) -> None: - if not self.address: - self.address = str(algosdk.account.address_from_private_key(self.private_key)) - - @property - def public_key(self) -> bytes: - """The public key for this account. - - :return: The public key as bytes - """ - public_key = algosdk.encoding.decode_address(self.address) - assert isinstance(public_key, bytes) - return public_key - - @property - def signer(self) -> AccountTransactionSigner: - """Get an AccountTransactionSigner for this account. - - :return: A transaction signer for this account - """ - return AccountTransactionSigner(self.private_key) - - @deprecated( - "Use `algorand.account.random()` or `SigningAccount(private_key=algosdk.account.generate_account()[0])` instead" - ) - @staticmethod - def new_account() -> "SigningAccount": - """Create a new random account. - - :return: A new Account instance - """ - private_key, address = algosdk.account.generate_account() - return SigningAccount(private_key=private_key) - - -@dataclasses.dataclass(kw_only=True) -class MultisigMetadata: - """Metadata for a multisig account. - - Contains the version, threshold and addresses for a multisig account. - """ - - version: int - threshold: int - addresses: list[str] - - -@dataclasses.dataclass(kw_only=True) -class MultiSigAccount: - """Account wrapper that supports partial or full multisig signing. - - Provides functionality to manage and sign transactions for a multisig account. - - :param multisig_params: The parameters for the multisig account - :param signing_accounts: The list of accounts that can sign - """ - - _params: MultisigMetadata - _signing_accounts: list[SigningAccount] - _addr: str - _signer: TransactionSigner - _multisig: Multisig - - def __init__(self, multisig_params: MultisigMetadata, signing_accounts: list[SigningAccount]) -> None: - self._params = multisig_params - self._signing_accounts = signing_accounts - self._multisig = Multisig(multisig_params.version, multisig_params.threshold, multisig_params.addresses) - self._addr = str(self._multisig.address()) - self._signer = algosdk.atomic_transaction_composer.MultisigTransactionSigner( - self._multisig, - [account.private_key for account in signing_accounts], - ) - - @property - def multisig(self) -> Multisig: - """Get the underlying `algosdk.transaction.Multisig` object instance. - - :return: The `algosdk.transaction.Multisig` object instance - """ - return self._multisig - - @property - def params(self) -> MultisigMetadata: - """Get the parameters for the multisig account. - - :return: The multisig account parameters - """ - return self._params - - @property - def signing_accounts(self) -> list[SigningAccount]: - """Get the list of accounts that are present to sign. - - :return: The list of signing accounts - """ - return self._signing_accounts - - @property - def address(self) -> str: - """Get the address of the multisig account. - - :return: The multisig account address - """ - return self._addr - - @property - def signer(self) -> TransactionSigner: - """Get the transaction signer for this multisig account. - - :return: The multisig transaction signer - """ - return self._signer - - def sign(self, transaction: algosdk.transaction.Transaction) -> MultisigTransaction: - """Sign the given transaction with all present signers. - - :param transaction: Either a transaction object or a raw, partially signed transaction - :return: The transaction signed by the present signers - """ - msig_txn = MultisigTransaction( - transaction, - self._multisig, - ) - for signer in self._signing_accounts: - msig_txn.sign(signer.private_key) - - return msig_txn - - -@dataclasses.dataclass(kw_only=True) -class LogicSigAccount: - """Account wrapper that supports logic sig signing. - - Provides functionality to manage and sign transactions for a logic sig account. - """ - - _signer: LogicSigTransactionSigner - - def __init__(self, program: bytes, args: list[bytes] | None) -> None: - self._signer = LogicSigTransactionSigner(AlgosdkLogicSigAccount(program, args)) - - @property - def lsig(self) -> AlgosdkLogicSigAccount: - """Get the underlying `algosdk.transaction.LogicSigAccount` object instance. - - :return: The `algosdk.transaction.LogicSigAccount` object instance - """ - return self._signer.lsig - - @property - def address(self) -> str: - """Get the address of the logic sig account. - - If the LogicSig is delegated to another account, this will return the address of that account. - - If the LogicSig is not delegated to another account, this will return an escrow address that is the hash of - the LogicSig's program code. - - :return: The logic sig account address - """ - return self._signer.lsig.address() - - @property - def signer(self) -> LogicSigTransactionSigner: - """Get the transaction signer for this multisig account. - - :return: The multisig transaction signer - """ - return self._signer diff --git a/src/algokit_utils/models/amount.py b/src/algokit_utils/models/amount.py index 01017f6f..859a36a6 100644 --- a/src/algokit_utils/models/amount.py +++ b/src/algokit_utils/models/amount.py @@ -1,14 +1,15 @@ -from __future__ import annotations - from decimal import Decimal +from functools import total_ordering from typing import overload -import algosdk from typing_extensions import Self +from algokit_common import MICROALGOS_TO_ALGOS_RATIO + __all__ = ["ALGORAND_MIN_TX_FEE", "AlgoAmount", "algo", "micro_algo", "transaction_fees"] +@total_ordering class AlgoAmount: """Wrapper class to ensure safe, explicit conversion between µAlgo, Algo and numbers. @@ -37,7 +38,7 @@ def __init__( if micro_algo is not None: self.amount_in_micro_algo = int(micro_algo) elif algo is not None: - self.amount_in_micro_algo = int(algo * algosdk.constants.MICROALGOS_TO_ALGOS_RATIO) + self.amount_in_micro_algo = int(algo * MICROALGOS_TO_ALGOS_RATIO) else: raise ValueError("Invalid amount provided") @@ -55,10 +56,10 @@ def algo(self) -> Decimal: :returns: The amount in Algo. """ - return algosdk.util.microalgos_to_algos(self.amount_in_micro_algo) # type: ignore[no-any-return] + return Decimal(self.amount_in_micro_algo) / Decimal(MICROALGOS_TO_ALGOS_RATIO) @staticmethod - def from_algo(amount: int | Decimal) -> AlgoAmount: + def from_algo(amount: int | Decimal) -> "AlgoAmount": """Create an AlgoAmount object representing the given number of Algo. :param amount: The amount in Algo. @@ -70,7 +71,7 @@ def from_algo(amount: int | Decimal) -> AlgoAmount: return AlgoAmount(algo=amount) @staticmethod - def from_micro_algo(amount: int) -> AlgoAmount: + def from_micro_algo(amount: int) -> "AlgoAmount": """Create an AlgoAmount object representing the given number of µAlgo. :param amount: The amount in µAlgo. @@ -81,94 +82,91 @@ def from_micro_algo(amount: int) -> AlgoAmount: """ return AlgoAmount(micro_algo=amount) + def _coerce_micro_algos(self, other: object, op: str, *, allow_int: bool = False) -> int: + if isinstance(other, AlgoAmount): + return other.micro_algo + if allow_int and isinstance(other, int): + return int(other) + raise TypeError(f"Unsupported operand type(s) for {op}: 'AlgoAmount' and '{type(other).__name__}'") + + def _coerce_int_scalar(self, other: object, op: str) -> int: + if isinstance(other, int): + return int(other) + raise TypeError(f"Unsupported operand type(s) for {op}: 'AlgoAmount' and '{type(other).__name__}'") + def __str__(self) -> str: return f"{self.micro_algo:,} µALGO" def __int__(self) -> int: return self.micro_algo - def __add__(self, other: AlgoAmount) -> AlgoAmount: - if isinstance(other, AlgoAmount): - total_micro_algos = self.micro_algo + other.micro_algo - else: - raise TypeError(f"Unsupported operand type(s) for +: 'AlgoAmount' and '{type(other).__name__}'") + def __add__(self, other: object) -> "AlgoAmount": + total_micro_algos = self.micro_algo + self._coerce_micro_algos(other, "+", allow_int=True) return AlgoAmount.from_micro_algo(total_micro_algos) - def __radd__(self, other: AlgoAmount) -> AlgoAmount: + def __radd__(self, other: object) -> "AlgoAmount": return self.__add__(other) - def __iadd__(self, other: AlgoAmount) -> Self: - if isinstance(other, AlgoAmount): - self.amount_in_micro_algo += other.micro_algo - else: - raise TypeError(f"Unsupported operand type(s) for +: 'AlgoAmount' and '{type(other).__name__}'") + def __iadd__(self, other: object) -> Self: + self.amount_in_micro_algo += self._coerce_micro_algos(other, "+", allow_int=True) return self def __eq__(self, other: object) -> bool: - if isinstance(other, AlgoAmount): - return self.amount_in_micro_algo == other.amount_in_micro_algo - elif isinstance(other, int): - return self.amount_in_micro_algo == int(other) - raise TypeError(f"Unsupported operand type(s) for ==: 'AlgoAmount' and '{type(other).__name__}'") - - def __ne__(self, other: object) -> bool: - if isinstance(other, AlgoAmount): - return self.amount_in_micro_algo != other.amount_in_micro_algo - elif isinstance(other, int): - return self.amount_in_micro_algo != int(other) - raise TypeError(f"Unsupported operand type(s) for !=: 'AlgoAmount' and '{type(other).__name__}'") + try: + return self.amount_in_micro_algo == self._coerce_micro_algos(other, "==", allow_int=True) + except TypeError: + return False def __lt__(self, other: object) -> bool: - if isinstance(other, AlgoAmount): - return self.amount_in_micro_algo < other.amount_in_micro_algo - elif isinstance(other, int): - return self.amount_in_micro_algo < int(other) - raise TypeError(f"Unsupported operand type(s) for <: 'AlgoAmount' and '{type(other).__name__}'") + other_micro_algos = self._coerce_micro_algos(other, "<", allow_int=True) + return self.amount_in_micro_algo < other_micro_algos - def __le__(self, other: object) -> bool: - if isinstance(other, AlgoAmount): - return self.amount_in_micro_algo <= other.amount_in_micro_algo - elif isinstance(other, int): - return self.amount_in_micro_algo <= int(other) - raise TypeError(f"Unsupported operand type(s) for <=: 'AlgoAmount' and '{type(other).__name__}'") + def __sub__(self, other: object) -> "AlgoAmount": + total_micro_algos = self.micro_algo - self._coerce_micro_algos(other, "-", allow_int=True) + return AlgoAmount.from_micro_algo(total_micro_algos) - def __gt__(self, other: object) -> bool: - if isinstance(other, AlgoAmount): - return self.amount_in_micro_algo > other.amount_in_micro_algo - elif isinstance(other, int): - return self.amount_in_micro_algo > int(other) - raise TypeError(f"Unsupported operand type(s) for >: 'AlgoAmount' and '{type(other).__name__}'") + def __rsub__(self, other: object) -> "AlgoAmount": + total_micro_algos = self._coerce_micro_algos(other, "-", allow_int=True) - self.micro_algo + return AlgoAmount.from_micro_algo(total_micro_algos) - def __ge__(self, other: object) -> bool: - if isinstance(other, AlgoAmount): - return self.amount_in_micro_algo >= other.amount_in_micro_algo - elif isinstance(other, int): - return self.amount_in_micro_algo >= int(other) - raise TypeError(f"Unsupported operand type(s) for >=: 'AlgoAmount' and '{type(other).__name__}'") + def __isub__(self, other: object) -> Self: + self.amount_in_micro_algo -= self._coerce_micro_algos(other, "-", allow_int=True) + return self - def __sub__(self, other: AlgoAmount) -> AlgoAmount: - if isinstance(other, AlgoAmount): - total_micro_algos = self.micro_algo - other.micro_algo - else: - raise TypeError(f"Unsupported operand type(s) for -: 'AlgoAmount' and '{type(other).__name__}'") - return AlgoAmount.from_micro_algo(total_micro_algos) + def __mul__(self, other: object) -> "AlgoAmount": + factor = self._coerce_int_scalar(other, "*") + return AlgoAmount.from_micro_algo(self.micro_algo * factor) - def __rsub__(self, other: int) -> AlgoAmount: - if isinstance(other, (int)): - total_micro_algos = int(other) - self.micro_algo - return AlgoAmount.from_micro_algo(total_micro_algos) - raise TypeError(f"Unsupported operand type(s) for -: '{type(other).__name__}' and 'AlgoAmount'") + def __rmul__(self, other: object) -> "AlgoAmount": + return self.__mul__(other) - def __isub__(self, other: AlgoAmount) -> Self: - if isinstance(other, AlgoAmount): - self.amount_in_micro_algo -= other.micro_algo - else: - raise TypeError(f"Unsupported operand type(s) for -: 'AlgoAmount' and '{type(other).__name__}'") - return self + def __truediv__(self, other: object) -> "AlgoAmount": + divisor = self._coerce_int_scalar(other, "/") + if divisor == 0: + raise ZeroDivisionError("division by zero") + return AlgoAmount.from_micro_algo(self.micro_algo // divisor) + + def __rtruediv__(self, other: object) -> Decimal: + numerator = self._coerce_int_scalar(other, "/") + if self.micro_algo == 0: + raise ZeroDivisionError("division by zero") + return Decimal(numerator) / Decimal(self.micro_algo) + + def __floordiv__(self, other: object) -> "AlgoAmount": + divisor = self._coerce_int_scalar(other, "//") + if divisor == 0: + raise ZeroDivisionError("division by zero") + return AlgoAmount.from_micro_algo(self.micro_algo // divisor) + + def __rfloordiv__(self, other: object) -> Decimal: + numerator = self._coerce_int_scalar(other, "//") + if self.micro_algo == 0: + raise ZeroDivisionError("division by zero") + return Decimal(numerator // self.micro_algo) # Helper functions -def algo(algo: int) -> AlgoAmount: +def algo(algo: int) -> "AlgoAmount": """Create an AlgoAmount object representing the given number of Algo. :param algo: The number of Algo to create an AlgoAmount object for. @@ -177,7 +175,7 @@ def algo(algo: int) -> AlgoAmount: return AlgoAmount.from_algo(algo) -def micro_algo(micro_algo: int) -> AlgoAmount: +def micro_algo(micro_algo: int) -> "AlgoAmount": """Create an AlgoAmount object representing the given number of µAlgo. :param micro_algo: The number of µAlgo to create an AlgoAmount object for. @@ -189,7 +187,7 @@ def micro_algo(micro_algo: int) -> AlgoAmount: ALGORAND_MIN_TX_FEE = micro_algo(1_000) -def transaction_fees(number_of_transactions: int) -> AlgoAmount: +def transaction_fees(number_of_transactions: int) -> "AlgoAmount": """Calculate the total transaction fees for a given number of transactions. :param number_of_transactions: The number of transactions to calculate the fees for. diff --git a/src/algokit_utils/models/application.py b/src/algokit_utils/models/application.py index a9187c8f..4bc1a209 100644 --- a/src/algokit_utils/models/application.py +++ b/src/algokit_utils/models/application.py @@ -1,8 +1,7 @@ from dataclasses import dataclass from typing import TYPE_CHECKING -import algosdk -from algosdk.source_map import SourceMap +from algokit_common import ProgramSourceMap if TYPE_CHECKING: pass @@ -68,7 +67,7 @@ class CompiledTeal: """The compiled hash""" compiled_base64_to_bytes: bytes """The compiled base64 to bytes""" - source_map: algosdk.source_map.SourceMap | None + source_map: ProgramSourceMap | None @dataclass(kw_only=True, frozen=True) @@ -85,7 +84,7 @@ class AppCompilationResult: class AppSourceMaps: """The source maps for the application""" - approval_source_map: SourceMap | None = None + approval_source_map: ProgramSourceMap | None = None """The source map for the approval program""" - clear_source_map: SourceMap | None = None + clear_source_map: ProgramSourceMap | None = None """The source map for the clear state program""" diff --git a/src/algokit_utils/models/network.py b/src/algokit_utils/models/network.py index 5a7dfb99..a6d393f4 100644 --- a/src/algokit_utils/models/network.py +++ b/src/algokit_utils/models/network.py @@ -8,8 +8,8 @@ @dataclasses.dataclass class AlgoClientNetworkConfig: - """Connection details for connecting to an {py:class}`algosdk.v2client.algod.AlgodClient` or - {py:class}`algosdk.v2client.indexer.IndexerClient`""" + """Connection details for connecting to an {py:class}`algokit_algod_client.AlgodClient` or + {py:class}`algokit_indexer_client.IndexerClient` instance.""" server: str """URL for the service e.g. `http://localhost` or `https://testnet-api.algonode.cloud`""" diff --git a/src/algokit_utils/models/simulate.py b/src/algokit_utils/models/simulate.py index bd200495..11ed41d3 100644 --- a/src/algokit_utils/models/simulate.py +++ b/src/algokit_utils/models/simulate.py @@ -1,11 +1,7 @@ -from dataclasses import dataclass +# Re-export SimulateTransactionResult from algod client for simulation traces. +# Previously this module defined a custom SimulationTrace wrapper class, but +# now we use the algod client type directly for cross-language consistency. -__all__ = ["SimulationTrace"] +from algokit_algod_client.models import SimulateTransactionResult - -@dataclass -class SimulationTrace: - app_budget_added: int | None - app_budget_consumed: int | None - failure_message: str | None - exec_trace: dict[str, object] +__all__ = ["SimulateTransactionResult"] diff --git a/src/algokit_utils/models/state.py b/src/algokit_utils/models/state.py index 3a950996..6ddbc8fa 100644 --- a/src/algokit_utils/models/state.py +++ b/src/algokit_utils/models/state.py @@ -1,11 +1,10 @@ -import base64 from collections.abc import Mapping from dataclasses import dataclass from enum import IntEnum from typing import TypeAlias -from algosdk.atomic_transaction_composer import AccountTransactionSigner -from algosdk.box_reference import BoxReference as AlgosdkBoxReference +from algokit_transact import BoxReference as AlgoKitTransactBoxReference +from algokit_transact.signer import AddressWithTransactionSigner __all__ = [ "BoxIdentifier", @@ -48,22 +47,7 @@ class DataTypeFlag(IntEnum): TealTemplateParams: TypeAlias = Mapping[str, str | int | bytes] | dict[str, str | int | bytes] -BoxIdentifier: TypeAlias = str | bytes | AccountTransactionSigner +BoxIdentifier: TypeAlias = str | bytes | AddressWithTransactionSigner -class BoxReference(AlgosdkBoxReference): - def __init__(self, app_id: int, name: bytes | str): - super().__init__(app_index=app_id, name=self._b64_decode(name)) - - def __eq__(self, other: object) -> bool: - if isinstance(other, (BoxReference | AlgosdkBoxReference)): - return self.app_index == other.app_index and self.name == other.name - return False - - def _b64_decode(self, value: str | bytes) -> bytes: - if isinstance(value, str): - try: - return base64.b64decode(value) - except Exception: - return value.encode("utf-8") - return value +BoxReference = AlgoKitTransactBoxReference diff --git a/src/algokit_utils/models/transaction.py b/src/algokit_utils/models/transaction.py index 413e0d35..dd8702c7 100644 --- a/src/algokit_utils/models/transaction.py +++ b/src/algokit_utils/models/transaction.py @@ -1,6 +1,4 @@ -from typing import Any, Literal, TypedDict, TypeVar - -import algosdk +from typing import Any, Literal, TypedDict __all__ = [ "Arc2TransactionNote", @@ -10,7 +8,6 @@ "StringFormatArc2Note", "TransactionNote", "TransactionNoteData", - "TransactionWrapper", ] @@ -42,59 +39,11 @@ class JsonFormatArc2Note(BaseArc2Note): TransactionNoteData = str | None | int | list[Any] | dict[str, Any] TransactionNote = bytes | TransactionNoteData | Arc2TransactionNote -TxnTypeT = TypeVar("TxnTypeT", bound=algosdk.transaction.Transaction) - - -class TransactionWrapper: - """Wrapper around algosdk.transaction.Transaction with optional property validators""" - - def __init__(self, transaction: algosdk.transaction.Transaction) -> None: - self._raw = transaction - - @property - def raw(self) -> algosdk.transaction.Transaction: - return self._raw - - @property - def payment(self) -> algosdk.transaction.PaymentTxn: - return self._return_if_type( - algosdk.transaction.PaymentTxn, - ) - - @property - def keyreg(self) -> algosdk.transaction.KeyregTxn: - return self._return_if_type(algosdk.transaction.KeyregTxn) - - @property - def asset_config(self) -> algosdk.transaction.AssetConfigTxn: - return self._return_if_type(algosdk.transaction.AssetConfigTxn) - - @property - def asset_transfer(self) -> algosdk.transaction.AssetTransferTxn: - return self._return_if_type(algosdk.transaction.AssetTransferTxn) - - @property - def asset_freeze(self) -> algosdk.transaction.AssetFreezeTxn: - return self._return_if_type(algosdk.transaction.AssetFreezeTxn) - - @property - def application_call(self) -> algosdk.transaction.ApplicationCallTxn: - return self._return_if_type(algosdk.transaction.ApplicationCallTxn) - - @property - def state_proof(self) -> algosdk.transaction.StateProofTxn: - return self._return_if_type(algosdk.transaction.StateProofTxn) - - def _return_if_type(self, txn_type: type[TxnTypeT]) -> TxnTypeT: - if isinstance(self._raw, txn_type): - return self._raw - raise ValueError(f"Transaction is not of type {txn_type.__name__}") - class SendParams(TypedDict, total=False): """Parameters for sending a transaction""" - max_rounds_to_wait: int | None - suppress_log: bool | None - populate_app_call_resources: bool | None - cover_app_call_inner_transaction_fees: bool | None + max_rounds_to_wait: int + suppress_log: bool + populate_app_call_resources: bool + cover_app_call_inner_transaction_fees: bool diff --git a/src/algokit_utils/network_clients.py b/src/algokit_utils/network_clients.py deleted file mode 100644 index 798100de..00000000 --- a/src/algokit_utils/network_clients.py +++ /dev/null @@ -1,9 +0,0 @@ -import warnings - -warnings.warn( - "The legacy v2 network clients module is deprecated and will be removed in a future version.", - DeprecationWarning, - stacklevel=2, -) - -from algokit_utils._legacy_v2.network_clients import * # noqa: F403, E402 diff --git a/src/algokit_utils/protocols/__init__.py b/src/algokit_utils/protocols/__init__.py index d77d8625..3c4a736a 100644 --- a/src/algokit_utils/protocols/__init__.py +++ b/src/algokit_utils/protocols/__init__.py @@ -1,2 +1,3 @@ from algokit_utils.protocols.account import * # noqa: F403 +from algokit_utils.protocols.signer import * # noqa: F403 from algokit_utils.protocols.typed_clients import * # noqa: F403 diff --git a/src/algokit_utils/protocols/account.py b/src/algokit_utils/protocols/account.py index b50c94a3..ffaa4d00 100644 --- a/src/algokit_utils/protocols/account.py +++ b/src/algokit_utils/protocols/account.py @@ -1,22 +1,11 @@ -from typing import Protocol, runtime_checkable +"""Account protocols - re-exported for convenience.""" -from algosdk.atomic_transaction_composer import TransactionSigner +from algokit_utils.transact import ( + AddressWithSigners, + AddressWithTransactionSigner, +) -__all__ = ["TransactionSignerAccountProtocol"] - - -@runtime_checkable -class TransactionSignerAccountProtocol(Protocol): - """An account that has a transaction signer. - Implemented by SigningAccount, LogicSigAccount, MultiSigAccount and TransactionSignerAccount abstractions. - """ - - @property - def address(self) -> str: - """The address of the account.""" - ... - - @property - def signer(self) -> TransactionSigner: - """The transaction signer for the account.""" - ... +__all__ = [ + "AddressWithSigners", + "AddressWithTransactionSigner", +] diff --git a/src/algokit_utils/protocols/signer.py b/src/algokit_utils/protocols/signer.py new file mode 100644 index 00000000..149efed4 --- /dev/null +++ b/src/algokit_utils/protocols/signer.py @@ -0,0 +1,17 @@ +"""Signer type aliases - re-exported for convenience.""" + +from algokit_utils.transact import ( + BytesSigner, + DelegatedLsigSigner, + MxBytesSigner, + ProgramDataSigner, + TransactionSigner, +) + +__all__ = [ + "BytesSigner", + "DelegatedLsigSigner", + "MxBytesSigner", + "ProgramDataSigner", + "TransactionSigner", +] diff --git a/src/algokit_utils/protocols/typed_clients.py b/src/algokit_utils/protocols/typed_clients.py index 70eee8a9..0085b272 100644 --- a/src/algokit_utils/protocols/typed_clients.py +++ b/src/algokit_utils/protocols/typed_clients.py @@ -1,12 +1,9 @@ -from __future__ import annotations - from typing import TYPE_CHECKING, Any, Generic, Protocol, TypeVar -from algosdk.atomic_transaction_composer import TransactionSigner -from algosdk.source_map import SourceMap from typing_extensions import Self -from algokit_utils.models import SendParams +from algokit_common import ProgramSourceMap +from algokit_utils.protocols.signer import TransactionSigner if TYPE_CHECKING: from algokit_utils.algorand import AlgorandClient @@ -22,6 +19,7 @@ OnUpdate, ) from algokit_utils.applications.app_factory import AppFactoryDeployResult + from algokit_utils.models import SendParams __all__ = [ "TypedAppClientProtocol", @@ -30,6 +28,8 @@ class TypedAppClientProtocol(Protocol): + """App Client protocol""" + @classmethod def from_creator_and_name( cls, @@ -39,8 +39,8 @@ def from_creator_and_name( default_sender: str | None = None, default_signer: TransactionSigner | None = None, ignore_cache: bool | None = None, - app_lookup_cache: ApplicationLookup | None = None, - algorand: AlgorandClient, + app_lookup_cache: "ApplicationLookup | None" = None, + algorand: "AlgorandClient", ) -> Self: ... @classmethod @@ -50,9 +50,9 @@ def from_network( app_name: str | None = None, default_sender: str | None = None, default_signer: TransactionSigner | None = None, - approval_source_map: SourceMap | None = None, - clear_source_map: SourceMap | None = None, - algorand: AlgorandClient, + approval_source_map: ProgramSourceMap | None = None, + clear_source_map: ProgramSourceMap | None = None, + algorand: "AlgorandClient", ) -> Self: ... def __init__( @@ -62,9 +62,9 @@ def __init__( app_name: str | None = None, default_sender: str | None = None, default_signer: TransactionSigner | None = None, - algorand: AlgorandClient, - approval_source_map: SourceMap | None = None, - clear_source_map: SourceMap | None = None, + algorand: "AlgorandClient", + approval_source_map: ProgramSourceMap | None = None, + clear_source_map: ProgramSourceMap | None = None, ) -> None: ... @@ -86,23 +86,25 @@ def __init__( class TypedAppFactoryProtocol(Protocol, Generic[CreateParamsT, UpdateParamsT, DeleteParamsT]): + """App factory protocol""" + def __init__( self, - algorand: AlgorandClient, + algorand: "AlgorandClient", **kwargs: Any, ) -> None: ... def deploy( self, *, - on_update: OnUpdate | None = None, - on_schema_break: OnSchemaBreak | None = None, + on_update: "OnUpdate | None" = None, + on_schema_break: "OnSchemaBreak | None" = None, create_params: CreateParamsT | None = None, update_params: UpdateParamsT | None = None, delete_params: DeleteParamsT | None = None, - existing_deployments: ApplicationLookup | None = None, + existing_deployments: "ApplicationLookup | None" = None, ignore_cache: bool = False, app_name: str | None = None, - send_params: SendParams | None = None, - compilation_params: AppClientCompilationParams | None = None, - ) -> tuple[TypedAppClientProtocol, AppFactoryDeployResult]: ... + send_params: "SendParams | None" = None, + compilation_params: "AppClientCompilationParams | None" = None, + ) -> tuple[TypedAppClientProtocol, "AppFactoryDeployResult"]: ... diff --git a/src/algokit_utils/transact.py b/src/algokit_utils/transact.py new file mode 100644 index 00000000..b440ff29 --- /dev/null +++ b/src/algokit_utils/transact.py @@ -0,0 +1,191 @@ +"""Transaction and signing types - user-facing facade for algokit_transact. + +Users should import from this module instead of algokit_transact directly. +""" + +from algokit_transact import ( + # Signer protocols and types + Addressable, + AddressWithDelegatedLsigSigner, + AddressWithMxBytesSigner, + AddressWithProgramDataSigner, + AddressWithSigners, + AddressWithTransactionSigner, + # Exceptions + AlgokitTransactError, + # Transaction field types + AppCallTransactionFields, + AssetConfigTransactionFields, + AssetFreezeTransactionFields, + AssetTransferTransactionFields, + BoxReference, + BytesSigner, + DelegatedLsigSigner, + # State proof types + FalconSignatureStruct, + FalconVerifier, + HashFactory, + HeartbeatProof, + HeartbeatTransactionFields, + HoldingReference, + KeyRegistrationTransactionFields, + LocalsReference, + # Logic signature + LogicSigAccount, + LogicSigSignature, + MerkleArrayProof, + MerkleSignatureVerifier, + # Multisig types + MultisigAccount, + MultisigMetadata, + MultisigSignature, + MultisigSubsignature, + MxBytesSigner, + # Transaction types + OnApplicationComplete, + Participant, + PaymentTransactionFields, + ProgramDataSigner, + ResourceReference, + Reveal, + SignedTransaction, + SigslotCommit, + StateProof, + StateProofMessage, + StateProofTransactionFields, + StateSchema, + Transaction, + TransactionSigner, + TransactionType, + TransactionValidationError, + # Validation types + ValidationIssue, + ValidationIssueCode, + # Multisig functions + address_from_multisig_signature, + apply_multisig_subsignature, + # Fee functions + assign_fee, + # Signer functions + calculate_fee, + # Codec functions + decode_logic_signature, + decode_signed_transaction, + decode_signed_transactions, + decode_transaction, + decode_transactions, + encode_signed_transaction, + encode_signed_transactions, + encode_transaction, + encode_transaction_raw, + encode_transactions, + estimate_transaction_size, + from_transaction_dto, + generate_address_with_signers, + get_encoded_transaction_type, + # ID functions + get_transaction_id, + get_transaction_id_raw, + # Group functions + group_transactions, + make_basic_account_transaction_signer, + make_empty_transaction_signer, + merge_multisignatures, + new_multisig_signature, + participants_from_multisig_signature, + # Validation functions + sanity_check_program, + to_transaction_dto, + validate_app_call_fields, + validate_asset_config_fields, + validate_asset_freeze_fields, + validate_asset_transfer_fields, + validate_key_registration_fields, + validate_transaction, +) + +__all__ = [ + "AddressWithDelegatedLsigSigner", + "AddressWithMxBytesSigner", + "AddressWithProgramDataSigner", + "AddressWithSigners", + "AddressWithTransactionSigner", + "Addressable", + "AlgokitTransactError", + "AppCallTransactionFields", + "AssetConfigTransactionFields", + "AssetFreezeTransactionFields", + "AssetTransferTransactionFields", + "BoxReference", + "BytesSigner", + "DelegatedLsigSigner", + "FalconSignatureStruct", + "FalconVerifier", + "HashFactory", + "HeartbeatProof", + "HeartbeatTransactionFields", + "HoldingReference", + "KeyRegistrationTransactionFields", + "LocalsReference", + "LogicSigAccount", + "LogicSigSignature", + "MerkleArrayProof", + "MerkleSignatureVerifier", + "MultisigAccount", + "MultisigMetadata", + "MultisigSignature", + "MultisigSubsignature", + "MxBytesSigner", + "OnApplicationComplete", + "Participant", + "PaymentTransactionFields", + "ProgramDataSigner", + "ResourceReference", + "Reveal", + "SignedTransaction", + "SigslotCommit", + "StateProof", + "StateProofMessage", + "StateProofTransactionFields", + "StateSchema", + "Transaction", + "TransactionSigner", + "TransactionType", + "TransactionValidationError", + "ValidationIssue", + "ValidationIssueCode", + "address_from_multisig_signature", + "apply_multisig_subsignature", + "assign_fee", + "calculate_fee", + "decode_logic_signature", + "decode_signed_transaction", + "decode_signed_transactions", + "decode_transaction", + "decode_transactions", + "encode_signed_transaction", + "encode_signed_transactions", + "encode_transaction", + "encode_transaction_raw", + "encode_transactions", + "estimate_transaction_size", + "from_transaction_dto", + "generate_address_with_signers", + "get_encoded_transaction_type", + "get_transaction_id", + "get_transaction_id_raw", + "group_transactions", + "make_basic_account_transaction_signer", + "make_empty_transaction_signer", + "merge_multisignatures", + "new_multisig_signature", + "participants_from_multisig_signature", + "sanity_check_program", + "to_transaction_dto", + "validate_app_call_fields", + "validate_asset_config_fields", + "validate_asset_freeze_fields", + "validate_asset_transfer_fields", + "validate_key_registration_fields", + "validate_transaction", +] diff --git a/src/algokit_utils/transactions/builders/__init__.py b/src/algokit_utils/transactions/builders/__init__.py new file mode 100644 index 00000000..45a342d6 --- /dev/null +++ b/src/algokit_utils/transactions/builders/__init__.py @@ -0,0 +1,67 @@ +from .app import ( + build_app_call_transaction, + build_app_create_transaction, + build_app_delete_transaction, + build_app_method_call_transaction, + build_app_update_transaction, +) +from .asset import ( + build_asset_config_transaction, + build_asset_create_transaction, + build_asset_destroy_transaction, + build_asset_freeze_transaction, + build_asset_opt_in_transaction, + build_asset_opt_out_transaction, + build_asset_transfer_transaction, +) +from .common import ( + BuiltTransaction, + FeeConfig, + SuggestedParamsLike, + TransactionHeader, + apply_transaction_fees, + build_transaction, + build_transaction_header, + encode_lease, +) +from .keyreg import ( + build_offline_key_registration_transaction, + build_online_key_registration_transaction, +) +from .method_call import ( + build_app_call_method_call_transaction, + build_app_create_method_call_transaction, + build_app_delete_method_call_transaction, + build_app_update_method_call_transaction, +) +from .payment import build_payment_transaction + +__all__ = [ + "BuiltTransaction", + "FeeConfig", + "SuggestedParamsLike", + "TransactionHeader", + "apply_transaction_fees", + "build_app_call_method_call_transaction", + "build_app_call_transaction", + "build_app_create_method_call_transaction", + "build_app_create_transaction", + "build_app_delete_method_call_transaction", + "build_app_delete_transaction", + "build_app_method_call_transaction", + "build_app_update_method_call_transaction", + "build_app_update_transaction", + "build_asset_config_transaction", + "build_asset_create_transaction", + "build_asset_destroy_transaction", + "build_asset_freeze_transaction", + "build_asset_opt_in_transaction", + "build_asset_opt_out_transaction", + "build_asset_transfer_transaction", + "build_offline_key_registration_transaction", + "build_online_key_registration_transaction", + "build_payment_transaction", + "build_transaction", + "build_transaction_header", + "encode_lease", +] diff --git a/src/algokit_utils/transactions/builders/app.py b/src/algokit_utils/transactions/builders/app.py new file mode 100644 index 00000000..c08ea261 --- /dev/null +++ b/src/algokit_utils/transactions/builders/app.py @@ -0,0 +1,248 @@ +from collections.abc import Sequence + +from algokit_transact.models.app_call import AppCallTransactionFields +from algokit_transact.models.app_call import BoxReference as TxBoxReference +from algokit_transact.models.common import OnApplicationComplete, StateSchema +from algokit_transact.models.transaction import TransactionType +from algokit_utils.applications.app_manager import AppManager +from algokit_utils.models.state import BoxIdentifier, BoxReference +from algokit_utils.transactions.builders.common import ( + BuiltTransaction, + SuggestedParamsLike, + apply_transaction_fees, + build_transaction, + build_transaction_header, +) +from algokit_utils.transactions.helpers import calculate_extra_program_pages +from algokit_utils.transactions.types import ( + AppCallParams, + AppCreateParams, + AppCreateSchema, + AppDeleteParams, + AppMethodCallParams, + AppUpdateParams, +) + +AppParams = AppCallParams | AppCreateParams | AppDeleteParams | AppMethodCallParams | AppUpdateParams + +__all__ = [ + "build_app_call_transaction", + "build_app_create_transaction", + "build_app_delete_transaction", + "build_app_method_call_transaction", + "build_app_update_transaction", +] + + +def build_app_create_transaction( + params: AppCreateParams, + suggested_params: SuggestedParamsLike, + *, + app_manager: AppManager, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + approval = _compile_program(app_manager, params.approval_program) + clear = _compile_program(app_manager, params.clear_state_program) + + schema = params.schema or AppCreateSchema( + global_ints=0, + global_byte_slices=0, + local_ints=0, + local_byte_slices=0, + ) + global_schema = StateSchema(num_uints=schema["global_ints"], num_byte_slices=schema["global_byte_slices"]) + local_schema = StateSchema(num_uints=schema["local_ints"], num_byte_slices=schema["local_byte_slices"]) + + fields = _build_app_call_fields( + params, + app_id=0, + approval_program=approval, + clear_state_program=clear, + global_state_schema=global_schema, + local_state_schema=local_schema, + extra_program_pages=params.extra_program_pages or calculate_extra_program_pages(approval, clear), + app_manager=app_manager, + ) + return _build_app_transaction( + params=params, + suggested_params=suggested_params, + fields=fields, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + + +def build_app_update_transaction( + params: AppUpdateParams, + suggested_params: SuggestedParamsLike, + *, + app_manager: AppManager, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + approval = _compile_program(app_manager, params.approval_program) + clear = _compile_program(app_manager, params.clear_state_program) + fields = _build_app_call_fields( + params, + app_id=params.app_id, + approval_program=approval, + clear_state_program=clear, + app_manager=app_manager, + ) + return _build_app_transaction( + params=params, + suggested_params=suggested_params, + fields=fields, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + + +def build_app_delete_transaction( + params: AppDeleteParams, + suggested_params: SuggestedParamsLike, + *, + app_manager: AppManager, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + fields = _build_app_call_fields( + params, + app_id=params.app_id, + app_manager=app_manager, + ) + return _build_app_transaction( + params=params, + suggested_params=suggested_params, + fields=fields, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + + +def build_app_call_transaction( + params: AppCallParams, + suggested_params: SuggestedParamsLike, + *, + app_manager: AppManager, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + fields = _build_app_call_fields( + params, + app_id=params.app_id, + app_manager=app_manager, + ) + return _build_app_transaction( + params=params, + suggested_params=suggested_params, + fields=fields, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + + +def build_app_method_call_transaction( + params: AppMethodCallParams, + suggested_params: SuggestedParamsLike, + *, + app_manager: AppManager, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + fields = _build_app_call_fields( + params, + app_id=params.app_id, + app_manager=app_manager, + ) + return _build_app_transaction( + params=params, + suggested_params=suggested_params, + fields=fields, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + + +def _build_app_transaction( + params: AppParams, + suggested_params: SuggestedParamsLike, + *, + fields: AppCallTransactionFields, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + header, fee_config = build_transaction_header( + params, + suggested_params, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + txn = build_transaction(TransactionType.AppCall, header, application_call=fields) + return apply_transaction_fees(txn, params, fee_config) + + +def _build_app_call_fields( + params: AppParams, + *, + app_id: int, + app_manager: AppManager, + approval_program: bytes | None = None, + clear_state_program: bytes | None = None, + global_state_schema: StateSchema | None = None, + local_state_schema: StateSchema | None = None, + extra_program_pages: int | None = None, +) -> AppCallTransactionFields: + return AppCallTransactionFields( + app_id=app_id, + on_complete=params.on_complete or OnApplicationComplete.NoOp, + approval_program=approval_program, + clear_state_program=clear_state_program, + global_state_schema=global_state_schema, + local_state_schema=local_state_schema, + args=_to_tuple(params.args), + account_references=_to_tuple(params.account_references), + app_references=_to_tuple(params.app_references), + asset_references=_to_tuple(params.asset_references), + extra_program_pages=extra_program_pages, + box_references=_convert_box_references(params.box_references, app_manager), + ) + + +def _compile_program(app_manager: AppManager, program: bytes | str) -> bytes: + if isinstance(program, bytes): + return program + compiled = app_manager.compile_teal(program) + return compiled.compiled_base64_to_bytes + + +def _to_tuple(items: Sequence | None) -> list | None: + if not items: + return None + return list(items) + + +def _convert_box_references( + box_refs: list[BoxReference | BoxIdentifier] | None, + app_manager: AppManager, +) -> list[TxBoxReference] | None: + if not box_refs: + return None + converted: list[TxBoxReference] = [] + for ref in box_refs: + app_id, name = app_manager.get_box_reference(ref) + converted.append(TxBoxReference(app_id=app_id, name=name)) + return converted if converted else None diff --git a/src/algokit_utils/transactions/builders/asset.py b/src/algokit_utils/transactions/builders/asset.py new file mode 100644 index 00000000..be7f85fa --- /dev/null +++ b/src/algokit_utils/transactions/builders/asset.py @@ -0,0 +1,256 @@ +from algokit_transact.models.asset_config import AssetConfigTransactionFields +from algokit_transact.models.asset_freeze import AssetFreezeTransactionFields +from algokit_transact.models.asset_transfer import AssetTransferTransactionFields +from algokit_transact.models.transaction import TransactionType +from algokit_utils.transactions.builders.common import ( + BuiltTransaction, + SuggestedParamsLike, + apply_transaction_fees, + build_transaction, + build_transaction_header, +) +from algokit_utils.transactions.types import ( + AssetConfigParams, + AssetCreateParams, + AssetDestroyParams, + AssetFreezeParams, + AssetOptInParams, + AssetOptOutParams, + AssetTransferParams, + CommonTxnParams, +) + +AssetFieldPayload = AssetConfigTransactionFields | AssetFreezeTransactionFields | AssetTransferTransactionFields + +__all__ = [ + "build_asset_config_transaction", + "build_asset_create_transaction", + "build_asset_destroy_transaction", + "build_asset_freeze_transaction", + "build_asset_opt_in_transaction", + "build_asset_opt_out_transaction", + "build_asset_transfer_transaction", +] + + +def _build_transaction( + params: CommonTxnParams, + suggested_params: SuggestedParamsLike, + *, + txn_type: TransactionType, + field_payload: AssetFieldPayload, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + header, fee_config = build_transaction_header( + params, + suggested_params, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + txn = build_transaction( + txn_type, + header, + asset_config=field_payload if isinstance(field_payload, AssetConfigTransactionFields) else None, + asset_transfer=field_payload if isinstance(field_payload, AssetTransferTransactionFields) else None, + asset_freeze=field_payload if isinstance(field_payload, AssetFreezeTransactionFields) else None, + ) + return apply_transaction_fees(txn, params, fee_config) + + +def build_asset_create_transaction( + params: AssetCreateParams, + suggested_params: SuggestedParamsLike, + *, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + fields = AssetConfigTransactionFields( + asset_id=0, + total=params.total, + decimals=params.decimals, + default_frozen=params.default_frozen, + unit_name=params.unit_name, + asset_name=params.asset_name, + url=params.url, + metadata_hash=params.metadata_hash, + manager=params.manager, + reserve=params.reserve, + freeze=params.freeze, + clawback=params.clawback, + ) + return _build_transaction( + params, + suggested_params, + txn_type=TransactionType.AssetConfig, + field_payload=fields, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + + +def build_asset_config_transaction( + params: AssetConfigParams, + suggested_params: SuggestedParamsLike, + *, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + fields = AssetConfigTransactionFields( + asset_id=params.asset_id, + manager=params.manager, + reserve=params.reserve, + freeze=params.freeze, + clawback=params.clawback, + ) + return _build_transaction( + params, + suggested_params, + txn_type=TransactionType.AssetConfig, + field_payload=fields, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + + +def build_asset_destroy_transaction( + params: AssetDestroyParams, + suggested_params: SuggestedParamsLike, + *, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + fields = AssetConfigTransactionFields(asset_id=params.asset_id) + return _build_transaction( + params, + suggested_params, + txn_type=TransactionType.AssetConfig, + field_payload=fields, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + + +def build_asset_freeze_transaction( + params: AssetFreezeParams, + suggested_params: SuggestedParamsLike, + *, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + fields = AssetFreezeTransactionFields( + asset_id=params.asset_id, + freeze_target=params.account, + frozen=params.frozen, + ) + return _build_transaction( + params, + suggested_params, + txn_type=TransactionType.AssetFreeze, + field_payload=fields, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + + +def build_asset_transfer_transaction( + params: AssetTransferParams, + suggested_params: SuggestedParamsLike, + *, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + fields = AssetTransferTransactionFields( + asset_id=params.asset_id, + amount=params.amount, + receiver=params.receiver, + close_remainder_to=params.close_asset_to, + asset_sender=params.clawback_target, + ) + return _build_transaction( + params, + suggested_params, + txn_type=TransactionType.AssetTransfer, + field_payload=fields, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + + +def build_asset_opt_in_transaction( + params: AssetOptInParams, + suggested_params: SuggestedParamsLike, + *, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + transfer_params = AssetTransferParams( + sender=params.sender, + signer=params.signer, + rekey_to=params.rekey_to, + note=params.note, + lease=params.lease, + static_fee=params.static_fee, + extra_fee=params.extra_fee, + max_fee=params.max_fee, + validity_window=params.validity_window, + first_valid_round=params.first_valid_round, + last_valid_round=params.last_valid_round, + asset_id=params.asset_id, + amount=0, + receiver=params.sender, + ) + return build_asset_transfer_transaction( + transfer_params, + suggested_params, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + + +def build_asset_opt_out_transaction( + params: AssetOptOutParams, + suggested_params: SuggestedParamsLike, + *, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + transfer_params = AssetTransferParams( + sender=params.sender, + signer=params.signer, + rekey_to=params.rekey_to, + note=params.note, + lease=params.lease, + static_fee=params.static_fee, + extra_fee=params.extra_fee, + max_fee=params.max_fee, + validity_window=params.validity_window, + first_valid_round=params.first_valid_round, + last_valid_round=params.last_valid_round, + asset_id=params.asset_id, + amount=0, + receiver=params.sender, + close_asset_to=params.creator, + ) + return build_asset_transfer_transaction( + transfer_params, + suggested_params, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) diff --git a/src/algokit_utils/transactions/builders/common.py b/src/algokit_utils/transactions/builders/common.py new file mode 100644 index 00000000..37a7c74c --- /dev/null +++ b/src/algokit_utils/transactions/builders/common.py @@ -0,0 +1,266 @@ +import base64 +from dataclasses import dataclass, replace +from typing import Protocol, runtime_checkable + +from algokit_algod_client import models as algod_models +from algokit_transact import validate_transaction +from algokit_transact.models.app_call import AppCallTransactionFields +from algokit_transact.models.asset_config import AssetConfigTransactionFields +from algokit_transact.models.asset_freeze import AssetFreezeTransactionFields +from algokit_transact.models.asset_transfer import AssetTransferTransactionFields +from algokit_transact.models.key_registration import KeyRegistrationTransactionFields +from algokit_transact.models.payment import PaymentTransactionFields +from algokit_transact.models.transaction import Transaction, TransactionType +from algokit_transact.ops.fees import assign_fee +from algokit_utils.models.amount import AlgoAmount +from algokit_utils.transactions.fee_coverage import FeeDelta +from algokit_utils.transactions.types import CommonTxnParams + +LEASE_MIN_LENGTH = 1 +LEASE_MAX_LENGTH = 32 + + +@runtime_checkable +class AlgoSuggestedParams(Protocol): + fee: int + first: int + last: int + gen: str + gh: str + flat_fee: bool + consensus_version: str + min_fee: int + + +SuggestedParamsLike = AlgoSuggestedParams | algod_models.SuggestedParams + +__all__ = [ + "BuiltTransaction", + "FeeConfig", + "SuggestedParamsLike", + "TransactionHeader", + "apply_transaction_fees", + "build_transaction", + "build_transaction_header", + "calculate_inner_fee_delta", + "encode_lease", +] + + +@dataclass(slots=True) +class TransactionHeader: + sender: str + first_valid: int + last_valid: int + genesis_hash: bytes + genesis_id: str | None + note: bytes | None + lease: bytes | None + rekey_to: str | None + + +@dataclass(slots=True) +class FeeConfig: + fee_per_byte: int + min_fee: int + flat_fee: bool + + +@dataclass(slots=True) +class BuiltTransaction: + txn: Transaction + logical_max_fee: AlgoAmount | None + + +def build_transaction_header( + params: CommonTxnParams, + suggested_params: SuggestedParamsLike, + *, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> tuple[TransactionHeader, FeeConfig]: + normalized = _normalize_suggested_params(suggested_params) + first_valid = params.first_valid_round or normalized.first_valid + + if params.last_valid_round: + last_valid = params.last_valid_round + else: + window = params.validity_window + if window is None: + window = 1000 if is_localnet and not default_validity_window_is_explicit else default_validity_window + last_valid = first_valid + window + + header = TransactionHeader( + sender=params.sender, + first_valid=first_valid, + last_valid=last_valid, + genesis_hash=normalized.genesis_hash, + genesis_id=normalized.genesis_id, + note=params.note, + lease=encode_lease(params.lease), + rekey_to=params.rekey_to, + ) + fee_config = FeeConfig( + fee_per_byte=normalized.fee, + min_fee=normalized.min_fee, + flat_fee=normalized.flat_fee, + ) + return header, fee_config + + +def build_transaction( + txn_type: TransactionType, + header: TransactionHeader, + *, + payment: PaymentTransactionFields | None = None, + asset_transfer: AssetTransferTransactionFields | None = None, + asset_config: AssetConfigTransactionFields | None = None, + asset_freeze: AssetFreezeTransactionFields | None = None, + application_call: AppCallTransactionFields | None = None, + key_registration: KeyRegistrationTransactionFields | None = None, +) -> Transaction: + txn = Transaction( + transaction_type=txn_type, + sender=header.sender, + first_valid=header.first_valid, + last_valid=header.last_valid, + genesis_hash=header.genesis_hash, + genesis_id=header.genesis_id, + note=header.note, + rekey_to=header.rekey_to, + lease=header.lease, + payment=payment, + asset_transfer=asset_transfer, + asset_config=asset_config, + asset_freeze=asset_freeze, + application_call=application_call, + key_registration=key_registration, + ) + validate_transaction(txn) + return txn + + +def apply_transaction_fees( + txn: Transaction, + params: CommonTxnParams, + fee_config: FeeConfig, +) -> BuiltTransaction: + extra_fee = params.extra_fee.micro_algo if params.extra_fee else None + max_fee = params.max_fee.micro_algo if params.max_fee else None + + if params.static_fee: + fee = params.static_fee.micro_algo + if extra_fee: + fee += extra_fee + if max_fee is not None and fee > max_fee: + raise ValueError( + f"Transaction fee {fee} µALGO is greater than max fee {max_fee} µALGO", + ) + txn_with_fee = replace(txn, fee=fee) + else: + txn_with_fee = assign_fee( + txn, + fee_per_byte=0 if fee_config.flat_fee else fee_config.fee_per_byte, + min_fee=fee_config.min_fee, + extra_fee=extra_fee, + max_fee=max_fee, + ) + + logical_max_fee = _logical_max_fee(params) + return BuiltTransaction(txn=txn_with_fee, logical_max_fee=logical_max_fee) + + +def encode_lease(lease: str | bytes | None) -> bytes | None: + if lease is None: + return None + if isinstance(lease, bytes): + if not (LEASE_MIN_LENGTH <= len(lease) <= LEASE_MAX_LENGTH): + raise ValueError( + ( + "Received invalid lease; expected something with length between " + f"{LEASE_MIN_LENGTH} and {LEASE_MAX_LENGTH}, but received bytes with length {len(lease)}" + ), + ) + if len(lease) == LEASE_MAX_LENGTH: + return lease + data = bytearray(LEASE_MAX_LENGTH) + data[: len(lease)] = lease + return bytes(data) + encoded = lease.encode("utf-8") + if not (LEASE_MIN_LENGTH <= len(encoded) <= LEASE_MAX_LENGTH): + raise ValueError( + ( + "Received invalid lease; expected something with length between " + f"{LEASE_MIN_LENGTH} and {LEASE_MAX_LENGTH}, but received '{lease}' with length {len(lease)}" + ), + ) + data = bytearray(LEASE_MAX_LENGTH) + data[: len(encoded)] = encoded + return bytes(data) + + +@dataclass(slots=True) +class _NormalizedSuggestedParams: + first_valid: int + last_valid: int + genesis_hash: bytes + genesis_id: str | None + fee: int + min_fee: int + flat_fee: bool + + +def _normalize_suggested_params(sp: SuggestedParamsLike) -> _NormalizedSuggestedParams: + if isinstance(sp, AlgoSuggestedParams): + genesis_hash = base64.b64decode(sp.gh) if isinstance(sp.gh, str) else sp.gh + return _NormalizedSuggestedParams( + first_valid=sp.first, + last_valid=sp.last, + genesis_hash=genesis_hash, + genesis_id=sp.gen, + fee=sp.fee, + min_fee=sp.min_fee, + flat_fee=sp.flat_fee, + ) + # Typed client SuggestedParams + genesis_hash = sp.genesis_hash if isinstance(sp.genesis_hash, bytes) else bytes(sp.genesis_hash) + return _NormalizedSuggestedParams( + first_valid=sp.first_valid, + last_valid=sp.last_valid, + genesis_hash=genesis_hash, + genesis_id=sp.genesis_id, + fee=sp.fee, + min_fee=sp.min_fee, + flat_fee=sp.flat_fee, + ) + + +def _logical_max_fee(params: CommonTxnParams) -> AlgoAmount | None: + if params.max_fee and (params.static_fee is None or params.max_fee.micro_algo > params.static_fee.micro_algo): + return params.max_fee + return params.static_fee + + +def calculate_inner_fee_delta( + inner_txns: list[algod_models.PendingTransactionResponse] | None, + min_fee: int, + acc: FeeDelta | None = None, +) -> FeeDelta | None: + if not inner_txns: + return acc + + current = acc + for inner in reversed(inner_txns): + recursive_delta = calculate_inner_fee_delta(inner.inner_txns, min_fee, current) + txn_fee = inner.txn.txn.fee or 0 + txn_fee_delta = FeeDelta.from_int(min_fee - txn_fee) + combined = FeeDelta.add(recursive_delta, txn_fee_delta) + + if combined and FeeDelta.is_surplus(combined): + current = None + continue + + current = combined + + return current diff --git a/src/algokit_utils/transactions/builders/keyreg.py b/src/algokit_utils/transactions/builders/keyreg.py new file mode 100644 index 00000000..38dac893 --- /dev/null +++ b/src/algokit_utils/transactions/builders/keyreg.py @@ -0,0 +1,103 @@ +import base64 + +from algokit_transact.models.key_registration import KeyRegistrationTransactionFields +from algokit_transact.models.transaction import TransactionType +from algokit_utils.transactions.builders.common import ( + BuiltTransaction, + SuggestedParamsLike, + apply_transaction_fees, + build_transaction, + build_transaction_header, +) +from algokit_utils.transactions.types import OfflineKeyRegistrationParams, OnlineKeyRegistrationParams + +__all__ = ["build_offline_key_registration_transaction", "build_online_key_registration_transaction"] + +STATE_PROOF_KEY_LENGTH = 64 + + +def build_online_key_registration_transaction( + params: OnlineKeyRegistrationParams, + suggested_params: SuggestedParamsLike, + *, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + header, fee_config = build_transaction_header( + params, + suggested_params, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + fields = KeyRegistrationTransactionFields( + vote_key=_decode_key(params.vote_key), + selection_key=_decode_key(params.selection_key), + vote_first=params.vote_first, + vote_last=params.vote_last, + vote_key_dilution=params.vote_key_dilution, + state_proof_key=_decode_state_proof_key(params.state_proof_key), + non_participation=params.nonparticipation, + ) + txn = build_transaction( + TransactionType.KeyRegistration, + header, + key_registration=fields, + ) + return apply_transaction_fees(txn, params, fee_config) + + +def build_offline_key_registration_transaction( + params: OfflineKeyRegistrationParams, + suggested_params: SuggestedParamsLike, + *, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + header, fee_config = build_transaction_header( + params, + suggested_params, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + fields = KeyRegistrationTransactionFields( + non_participation=params.prevent_account_from_ever_participating_again, + ) + txn = build_transaction(TransactionType.KeyRegistration, header, key_registration=fields) + return apply_transaction_fees(txn, params, fee_config) + + +def _decode_key(value: str | bytes | None) -> bytes | None: + if value is None: + return None + if isinstance(value, bytes): + return value + try: + return base64.b64decode(value) + except Exception as exc: + raise ValueError("Vote/selection keys must be base64-encoded strings") from exc + + +def _decode_state_proof_key(value: str | bytes | None) -> bytes | None: + if value is None: + return None + if isinstance(value, bytes): + if len(value) == STATE_PROOF_KEY_LENGTH: + return value + try: + decoded = base64.b64decode(value) + except Exception as exc: + raise ValueError("State proof keys must be 64 bytes or base64-encoded strings") from exc + if len(decoded) != STATE_PROOF_KEY_LENGTH: + raise ValueError("State proof keys must be 64 bytes or base64-encoded strings") + return decoded + try: + decoded = base64.b64decode(value) + except Exception as exc: + raise ValueError("State proof keys must be base64-encoded strings") from exc + if len(decoded) != STATE_PROOF_KEY_LENGTH: + raise ValueError("State proof keys must decode to 64 bytes") + return decoded diff --git a/src/algokit_utils/transactions/builders/method_call.py b/src/algokit_utils/transactions/builders/method_call.py new file mode 100644 index 00000000..c162c0e9 --- /dev/null +++ b/src/algokit_utils/transactions/builders/method_call.py @@ -0,0 +1,386 @@ +from collections.abc import Sequence +from dataclasses import dataclass + +from typing_extensions import assert_never, assert_type + +from algokit_abi import abi, arc56 +from algokit_transact.models.app_call import AppCallTransactionFields +from algokit_transact.models.common import OnApplicationComplete, StateSchema +from algokit_transact.models.transaction import TransactionType +from algokit_utils.applications.app_manager import AppManager +from algokit_utils.transactions.builders.app import _compile_program, _convert_box_references +from algokit_utils.transactions.builders.common import ( + BuiltTransaction, + SuggestedParamsLike, + TransactionHeader, + apply_transaction_fees, + build_transaction, + build_transaction_header, +) +from algokit_utils.transactions.helpers import calculate_extra_program_pages +from algokit_utils.transactions.types import ( + AppCallMethodCallParams, + AppCreateMethodCallParams, + AppDeleteMethodCallParams, + AppUpdateMethodCallParams, +) + +_ARGS_TUPLE_PACKING_THRESHOLD = 15 + +__all__ = [ + "build_app_call_method_call_transaction", + "build_app_create_method_call_transaction", + "build_app_delete_method_call_transaction", + "build_app_update_method_call_transaction", +] + + +def build_app_call_method_call_transaction( + params: AppCallMethodCallParams | AppDeleteMethodCallParams, + suggested_params: SuggestedParamsLike, + *, + method_args: Sequence | None, + app_manager: AppManager, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + header, fee_config = build_transaction_header( + params, + suggested_params, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + common = _build_method_call_common( + params.app_id, + params.method, + method_args, + header, + params.account_references, + params.app_references, + params.asset_references, + ) + fields = AppCallTransactionFields( + app_id=params.app_id, + on_complete=params.on_complete or OnApplicationComplete.NoOp, + args=common.args, + account_references=_to_maybe_list(common.account_references), + app_references=_to_maybe_list(common.app_references), + asset_references=_to_maybe_list(common.asset_references), + box_references=_convert_box_references(params.box_references, app_manager), + ) + txn = build_transaction(TransactionType.AppCall, header, application_call=fields) + return apply_transaction_fees(txn, params, fee_config) + + +def build_app_delete_method_call_transaction( + params: AppDeleteMethodCallParams, + suggested_params: SuggestedParamsLike, + *, + method_args: Sequence | None, + app_manager: AppManager, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + return build_app_call_method_call_transaction( + params, + suggested_params, + method_args=method_args, + app_manager=app_manager, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + + +def build_app_create_method_call_transaction( + params: AppCreateMethodCallParams, + suggested_params: SuggestedParamsLike, + *, + method_args: Sequence | None, + app_manager: AppManager, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + header, fee_config = build_transaction_header( + params, + suggested_params, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + approval_program = _compile_program(app_manager, params.approval_program) + clear_state_program = _compile_program(app_manager, params.clear_state_program) + schema = params.schema + global_schema = StateSchema( + num_uints=schema["global_ints"] if schema else 0, + num_byte_slices=schema["global_byte_slices"] if schema else 0, + ) + local_schema = StateSchema( + num_uints=schema["local_ints"] if schema else 0, + num_byte_slices=schema["local_byte_slices"] if schema else 0, + ) + extra_pages = params.extra_program_pages or calculate_extra_program_pages(approval_program, clear_state_program) + common = _build_method_call_common( + 0, + params.method, + method_args, + header, + params.account_references, + params.app_references, + params.asset_references, + ) + fields = AppCallTransactionFields( + app_id=0, + on_complete=params.on_complete or OnApplicationComplete.NoOp, + approval_program=approval_program, + clear_state_program=clear_state_program, + global_state_schema=global_schema, + local_state_schema=local_schema, + extra_program_pages=extra_pages, + args=common.args, + account_references=_to_maybe_list(common.account_references), + app_references=_to_maybe_list(common.app_references), + asset_references=_to_maybe_list(common.asset_references), + box_references=_convert_box_references(params.box_references, app_manager), + ) + txn = build_transaction(TransactionType.AppCall, header, application_call=fields) + return apply_transaction_fees(txn, params, fee_config) + + +def build_app_update_method_call_transaction( + params: AppUpdateMethodCallParams, + suggested_params: SuggestedParamsLike, + *, + method_args: Sequence | None, + app_manager: AppManager, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + header, fee_config = build_transaction_header( + params, + suggested_params, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + approval_program = _compile_program(app_manager, params.approval_program) + clear_state_program = _compile_program(app_manager, params.clear_state_program) + common = _build_method_call_common( + params.app_id, + params.method, + method_args, + header, + params.account_references, + params.app_references, + params.asset_references, + ) + fields = AppCallTransactionFields( + app_id=params.app_id, + on_complete=OnApplicationComplete.UpdateApplication, + approval_program=approval_program, + clear_state_program=clear_state_program, + args=common.args, + account_references=_to_maybe_list(common.account_references), + app_references=_to_maybe_list(common.app_references), + asset_references=_to_maybe_list(common.asset_references), + box_references=_convert_box_references(params.box_references, app_manager), + ) + txn = build_transaction(TransactionType.AppCall, header, application_call=fields) + return apply_transaction_fees(txn, params, fee_config) + + +@dataclass(slots=True) +class _MethodCallCommon: + args: list[bytes] + account_references: list[str] + app_references: list[int] + asset_references: list[int] + + +def _build_method_call_common( + app_id: int, + method: arc56.Method, + method_args: Sequence | None, + header: TransactionHeader, + account_references: Sequence[str] | None, + app_references: Sequence[int] | None, + asset_references: Sequence[int] | None, +) -> _MethodCallCommon: + accounts, apps, assets = _populate_method_args_into_reference_arrays( + header.sender, + app_id, + method, + method_args or [], + account_references, + app_references, + asset_references, + ) + encoded_args = _encode_method_arguments( + method, + method_args or [], + header.sender, + app_id, + accounts, + apps, + assets, + ) + return _MethodCallCommon( + args=encoded_args, account_references=accounts, app_references=apps, asset_references=assets + ) + + +def _populate_method_args_into_reference_arrays( + sender: str, + app_id: int, + method: arc56.Method, + method_args: Sequence, + account_references: Sequence[str] | None, + app_references: Sequence[int] | None, + asset_references: Sequence[int] | None, +) -> tuple[list[str], list[int], list[int]]: + accounts = list(account_references or []) + apps = list(app_references or []) + assets = list(asset_references or []) + + for arg_value, arg in zip(method_args, method.args, strict=False): + if arg_value is None: + continue + arg_type = arg.type + if ( + arg_type == arc56.ReferenceType.ACCOUNT + and isinstance(arg_value, str) + and arg_value != sender + and arg_value not in accounts + ): + accounts.append(arg_value) + elif arg_type == arc56.ReferenceType.ASSET and isinstance(arg_value, int) and arg_value not in assets: + assets.append(arg_value) + elif ( + arg_type == arc56.ReferenceType.APPLICATION + and isinstance(arg_value, int) + and arg_value != app_id + and arg_value not in apps + ): + apps.append(arg_value) + # Non-reference args do not change reference arrays + return accounts, apps, assets + + +def _encode_method_arguments( + method: arc56.Method, + method_args: Sequence, + sender: str, + app_id: int, + account_references: Sequence[str], + app_references: Sequence[int], + asset_references: Sequence[int], +) -> list[bytes]: + encoded_args = list[bytes]() + encoded_args.append(method.selector) + + abi_types = list[abi.ABIType]() + abi_values = [] + + for arg, arg_value in zip(method.args, method_args, strict=False): + if arg_value is None: + continue + arg_type = arg.type + if isinstance(arg_type, arc56.TransactionType): + continue + if isinstance(arg_type, abi.ABIType): + abi_type = arg_type + abi_value = arg_value + else: + assert_type(arg_type, arc56.ReferenceType) + index = _calculate_reference_index( + arg_value, + arg_type, + sender, + app_id, + account_references, + app_references, + asset_references, + ) + abi_type = abi.UintType(8) + abi_value = index + abi_types.append(abi_type) + abi_values.append(abi_value) + + if len(abi_types) != len(abi_values): + raise ValueError("Mismatch between ABI argument types and values") + + encoded_args.extend(_encode_args_with_tuple_packing(abi_types, abi_values)) + return encoded_args + + +def _calculate_reference_index( + value: str | int, + reference_type: arc56.ReferenceType, + sender: str, + app_id: int, + account_references: Sequence[str], + app_references: Sequence[int], + asset_references: Sequence[int], +) -> int: + if reference_type == arc56.ReferenceType.ACCOUNT: + return _calculate_account_reference_index(value, sender, account_references) + if reference_type == arc56.ReferenceType.ASSET: + return _calculate_asset_reference_index(value, asset_references) + if reference_type == arc56.ReferenceType.APPLICATION: + return _calculate_application_reference_index(value, app_id, app_references) + assert_never(reference_type) + + +def _calculate_account_reference_index(value: str | int, sender: str, account_references: Sequence[str]) -> int: + if not isinstance(value, str): + raise ValueError("Account reference arguments must be base32 addresses") + if value == sender: + return 0 + if value not in account_references: + raise ValueError(f"Account reference {value} not present in reference array") + return account_references.index(value) + 1 + + +def _calculate_asset_reference_index(value: str | int, asset_references: Sequence[int]) -> int: + if not isinstance(value, int): + raise ValueError("Asset reference arguments must be integers") + if value not in asset_references: + raise ValueError(f"Asset reference {value} not present in reference array") + return asset_references.index(value) + + +def _calculate_application_reference_index(value: str | int, app_id: int, app_references: Sequence[int]) -> int: + if not isinstance(value, int): + raise ValueError("Application reference arguments must be integers") + if value == app_id: + return 0 + if value not in app_references: + raise ValueError(f"Application reference {value} not present in reference array") + return app_references.index(value) + 1 + + +def _encode_args_with_tuple_packing(abi_types: Sequence[abi.ABIType], abi_values: Sequence) -> list[bytes]: + type_value_pairs = list(zip(abi_types, abi_values, strict=True)) + if len(type_value_pairs) > _ARGS_TUPLE_PACKING_THRESHOLD: + # if the threshold has been exceeded then need to leave 1 element at the end + # for the packed tuple + split_at = _ARGS_TUPLE_PACKING_THRESHOLD - 1 + else: + split_at = len(type_value_pairs) + unpacked_pairs = type_value_pairs[:split_at] + packed_pairs = type_value_pairs[split_at:] + encoded = [abi_type.encode(abi_value) for abi_type, abi_value in unpacked_pairs] + + if packed_pairs: + tuple_type = abi.TupleType([t[0] for t in packed_pairs]) + encoded.append(tuple_type.encode([t[1] for t in packed_pairs])) + return encoded + + +def _to_maybe_list(values: Sequence | None) -> list | None: + return list(values) if values else None diff --git a/src/algokit_utils/transactions/builders/payment.py b/src/algokit_utils/transactions/builders/payment.py new file mode 100644 index 00000000..5e184906 --- /dev/null +++ b/src/algokit_utils/transactions/builders/payment.py @@ -0,0 +1,43 @@ +from algokit_transact.models.payment import PaymentTransactionFields +from algokit_transact.models.transaction import TransactionType +from algokit_utils.transactions.builders.common import ( + BuiltTransaction, + SuggestedParamsLike, + apply_transaction_fees, + build_transaction, + build_transaction_header, +) +from algokit_utils.transactions.types import PaymentParams + +__all__ = ["build_payment_transaction"] + + +def build_payment_transaction( + params: PaymentParams, + suggested_params: SuggestedParamsLike, + *, + default_validity_window: int, + default_validity_window_is_explicit: bool, + is_localnet: bool, +) -> BuiltTransaction: + header, fee_config = build_transaction_header( + params, + suggested_params, + default_validity_window=default_validity_window, + default_validity_window_is_explicit=default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + + payment_fields = PaymentTransactionFields( + amount=params.amount.micro_algo, + receiver=params.receiver, + close_remainder_to=params.close_remainder_to, + ) + + txn = build_transaction( + TransactionType.Payment, + header, + payment=payment_fields, + ) + + return apply_transaction_fees(txn, params, fee_config) diff --git a/src/algokit_utils/transactions/composer_resources.py b/src/algokit_utils/transactions/composer_resources.py new file mode 100644 index 00000000..31ebee82 --- /dev/null +++ b/src/algokit_utils/transactions/composer_resources.py @@ -0,0 +1,409 @@ +from dataclasses import dataclass, replace +from enum import Enum +from typing import Any + +from algokit_algod_client import models as algod_models +from algokit_common import get_application_address +from algokit_common.constants import MAX_ACCOUNT_REFERENCES, MAX_OVERALL_REFERENCES +from algokit_transact.models.app_call import AppCallTransactionFields, BoxReference +from algokit_transact.models.transaction import Transaction, TransactionType + + +def populate_transaction_resources( # noqa: C901, PLR0912 + transaction: Transaction, + resources_accessed: algod_models.SimulateUnnamedResourcesAccessed, + group_index: int, +) -> Transaction: + """ + Populate transaction-level resources for app call transactions + """ + if transaction.transaction_type != TransactionType.AppCall or transaction.application_call is None: + return transaction + + # Check for unexpected resources at transaction level + if resources_accessed.boxes or resources_accessed.extra_box_refs: + raise ValueError("Unexpected boxes at the transaction level") + if resources_accessed.app_locals: + raise ValueError("Unexpected app locals at the transaction level") + if resources_accessed.asset_holdings: + raise ValueError("Unexpected asset holdings at the transaction level") + + app_call = transaction.application_call + updated_app_call = app_call + accounts_count = len(app_call.account_references or []) + apps_count = len(app_call.app_references or []) + assets_count = len(app_call.asset_references or []) + boxes_count = len(app_call.box_references or []) + + # Populate accounts + if resources_accessed.accounts: + current_accounts = list(app_call.account_references or []) + for account in resources_accessed.accounts: + normalized = _normalize_address(account) + if normalized not in current_accounts: + current_accounts.append(normalized) + if len(current_accounts) != accounts_count: + updated_app_call = replace(updated_app_call, account_references=current_accounts) + accounts_count = len(current_accounts) + + # Populate apps + if resources_accessed.apps: + current_apps = list(updated_app_call.app_references or []) + for app_id in resources_accessed.apps: + if app_id not in current_apps: + current_apps.append(app_id) + if len(current_apps) != apps_count: + updated_app_call = replace(updated_app_call, app_references=current_apps) + apps_count = len(current_apps) + + # Populate assets + if resources_accessed.assets: + current_assets = list(updated_app_call.asset_references or []) + for asset_id in resources_accessed.assets: + if asset_id not in current_assets: + current_assets.append(asset_id) + if len(current_assets) != assets_count: + updated_app_call = replace(updated_app_call, asset_references=current_assets) + assets_count = len(current_assets) + + # Validate reference limits + if accounts_count + assets_count + apps_count + boxes_count > MAX_OVERALL_REFERENCES: + raise ValueError(f"Resource reference limit of {MAX_OVERALL_REFERENCES} exceeded in transaction {group_index}") + + if updated_app_call is app_call: + return transaction + return replace(transaction, application_call=updated_app_call) + + +class GroupResourceType(Enum): + """Describes different group resources""" + + Account = "Account" + App = "App" + Asset = "Asset" + Box = "Box" + ExtraBoxRef = "ExtraBoxRef" + AssetHolding = "AssetHolding" + AppLocal = "AppLocal" + + +@dataclass(slots=True) +class GroupResourceToPopulate: + type: GroupResourceType + data: Any + + +def populate_group_resources( # noqa: C901, PLR0912 + transactions: list[Transaction], + group_resources: algod_models.SimulateUnnamedResourcesAccessed, +) -> None: + """ + Populate group-level resources for app call transactions + """ + remaining_accounts = list(group_resources.accounts or []) + remaining_apps = list(group_resources.apps or []) + remaining_assets = list(group_resources.assets or []) + remaining_boxes = list(group_resources.boxes or []) + + # Process cross-reference resources first (app locals and asset holdings) as they are most restrictive + if group_resources.app_locals: + for app_local in group_resources.app_locals: + _populate_group_resource(transactions, GroupResourceToPopulate(GroupResourceType.AppLocal, app_local)) + # Remove resources from remaining if we're adding them here + if app_local.address in remaining_accounts: + remaining_accounts.remove(app_local.address) + if app_local.app_id in remaining_apps: + remaining_apps.remove(app_local.app_id) + + if group_resources.asset_holdings: + for asset_holding in group_resources.asset_holdings: + _populate_group_resource( + transactions, GroupResourceToPopulate(GroupResourceType.AssetHolding, asset_holding) + ) + # Remove resources from remaining if we're adding them here + if asset_holding.address in remaining_accounts: + remaining_accounts.remove(asset_holding.address) + if asset_holding.asset_id in remaining_assets: + remaining_assets.remove(asset_holding.asset_id) + + # Process accounts next + for account in remaining_accounts: + _populate_group_resource(transactions, GroupResourceToPopulate(GroupResourceType.Account, account)) + + # Process boxes + for box_ref in remaining_boxes: + _populate_group_resource( + transactions, + GroupResourceToPopulate( + GroupResourceType.Box, + BoxReference(app_id=box_ref.app_id, name=box_ref.name), + ), + ) + # Remove apps as resource if we're adding it here + if box_ref.app_id in remaining_apps: + remaining_apps.remove(box_ref.app_id) + + # Process assets + for asset in remaining_assets: + _populate_group_resource(transactions, GroupResourceToPopulate(GroupResourceType.Asset, asset)) + + # Process remaining apps + for app in remaining_apps: + _populate_group_resource(transactions, GroupResourceToPopulate(GroupResourceType.App, app)) + + # Handle extra box refs + if group_resources.extra_box_refs: + for _ in range(group_resources.extra_box_refs): + _populate_group_resource(transactions, GroupResourceToPopulate(GroupResourceType.ExtraBoxRef, None)) + + +def _is_app_call_below_resource_limit(txn: Transaction) -> bool: + if txn.transaction_type != TransactionType.AppCall or txn.application_call is None: + return False + if txn.application_call.access_references: + return False + + accounts_count = len(txn.application_call.account_references or []) + assets_count = len(txn.application_call.asset_references or []) + apps_count = len(txn.application_call.app_references or []) + boxes_count = len(txn.application_call.box_references or []) + + return accounts_count + assets_count + apps_count + boxes_count < MAX_OVERALL_REFERENCES + + +def _get_app_address(app_id: int) -> str: + return get_application_address(app_id) + + +def _populate_group_resource( # noqa: C901, PLR0912, PLR0915 + transactions: list[Transaction], + resource: GroupResourceToPopulate, +) -> None: + # For asset holdings and app locals, first try to find a transaction that already has the account available + if resource.type in (GroupResourceType.AssetHolding, GroupResourceType.AppLocal): + account = _normalize_address(resource.data.address) + + # Try to find a transaction that already has the account available + group_index1 = -1 + for i, txn in enumerate(transactions): + if not _is_app_call_below_resource_limit(txn): + continue + + app_call = txn.application_call + assert app_call is not None + + # Check if account is in foreign accounts array + if app_call.account_references and account in app_call.account_references: + group_index1 = i + break + + # Check if account is available as an app account + if app_call.app_references: + found = False + for app_id in app_call.app_references: + if account == _get_app_address(app_id): + found = True + break + if found: + group_index1 = i + break + + # Check if account appears in any app call transaction fields + if txn.sender == account: + group_index1 = i + break + + if group_index1 != -1: + app_call = transactions[group_index1].application_call + assert app_call is not None + if resource.type == GroupResourceType.AssetHolding: + current_assets = list(app_call.asset_references or []) + if resource.data.asset_id not in current_assets: + current_assets.append(resource.data.asset_id) + app_call = replace(app_call, asset_references=current_assets) + _set_app_call(transactions, group_index1, app_call) + else: + current_apps = list(app_call.app_references or []) + if resource.data.app_id not in current_apps: + current_apps.append(resource.data.app_id) + app_call = replace(app_call, app_references=current_apps) + _set_app_call(transactions, group_index1, app_call) + return + + # Try to find a transaction that has the asset/app available and space for account + group_index2 = -1 + for i, txn in enumerate(transactions): + if not _is_app_call_below_resource_limit(txn): + continue + + app_call = txn.application_call + assert app_call is not None + if len(app_call.account_references or []) >= MAX_ACCOUNT_REFERENCES: + continue + + if resource.type == GroupResourceType.AssetHolding: + if app_call.asset_references and resource.data.asset_id in app_call.asset_references: + group_index2 = i + break + elif ( + app_call.app_references and resource.data.app_id in app_call.app_references + ) or app_call.app_id == resource.data.app_id: + group_index2 = i + break + + if group_index2 != -1: + app_call = transactions[group_index2].application_call + assert app_call is not None + current_accounts = list(app_call.account_references or []) + if account not in current_accounts: + current_accounts.append(account) + app_call = replace(app_call, account_references=current_accounts) + _set_app_call(transactions, group_index2, app_call) + return + + # For boxes, first try to find a transaction that already has the app available + if resource.type == GroupResourceType.Box: + group_index = -1 + for i, txn in enumerate(transactions): + if not _is_app_call_below_resource_limit(txn): + continue + + app_call = txn.application_call + assert app_call is not None + if ( + app_call.app_references and resource.data.app_id in app_call.app_references + ) or app_call.app_id == resource.data.app_id: + group_index = i + break + + if group_index != -1: + app_call = transactions[group_index].application_call + assert app_call is not None + current_boxes = list(app_call.box_references or []) + exists = any(b.app_id == resource.data.app_id and b.name == resource.data.name for b in current_boxes) + if not exists: + current_boxes.append(BoxReference(app_id=resource.data.app_id, name=resource.data.name)) + app_call = replace(app_call, box_references=current_boxes) + _set_app_call(transactions, group_index, app_call) + return + + # Find the first transaction that can accommodate the resource + group_index = -1 + for i, txn in enumerate(transactions): + if txn.transaction_type != TransactionType.AppCall or txn.application_call is None: + continue + if txn.application_call.access_references: + continue + + app_call = txn.application_call + accounts_count = len(app_call.account_references or []) + assets_count = len(app_call.asset_references or []) + apps_count = len(app_call.app_references or []) + boxes_count = len(app_call.box_references or []) + + if resource.type == GroupResourceType.Account: + if accounts_count + assets_count + apps_count + boxes_count < MAX_OVERALL_REFERENCES: + group_index = i + break + elif resource.type in (GroupResourceType.AssetHolding, GroupResourceType.AppLocal): + if accounts_count + assets_count + apps_count + boxes_count < MAX_OVERALL_REFERENCES - 1: + group_index = i + break + elif resource.type == GroupResourceType.Box: + if resource.data.app_id != 0: + if accounts_count + assets_count + apps_count + boxes_count < MAX_OVERALL_REFERENCES - 1: + group_index = i + break + elif accounts_count + assets_count + apps_count + boxes_count < MAX_OVERALL_REFERENCES: + group_index = i + break + elif accounts_count + assets_count + apps_count + boxes_count < MAX_OVERALL_REFERENCES: + group_index = i + break + + if group_index == -1: + raise ValueError("No more transactions below reference limit. Add another app call to the group.") + + app_call = transactions[group_index].application_call + assert app_call is not None + + if resource.type == GroupResourceType.Account: + current_accounts = list(app_call.account_references or []) + account = _normalize_address(resource.data) + if account not in current_accounts: + current_accounts.append(account) + app_call = replace(app_call, account_references=current_accounts) + _set_app_call(transactions, group_index, app_call) + + elif resource.type == GroupResourceType.App: + current_apps = list(app_call.app_references or []) + if resource.data not in current_apps: + current_apps.append(resource.data) + app_call = replace(app_call, app_references=current_apps) + _set_app_call(transactions, group_index, app_call) + + elif resource.type == GroupResourceType.Box: + current_boxes = list(app_call.box_references or []) + exists = any(b.app_id == resource.data.app_id and b.name == resource.data.name for b in current_boxes) + if not exists: + current_boxes.append(BoxReference(app_id=resource.data.app_id, name=resource.data.name)) + app_call = replace(app_call, box_references=current_boxes) + _set_app_call(transactions, group_index, app_call) + + if resource.data.app_id != 0: + current_apps = list(app_call.app_references or []) + if resource.data.app_id not in current_apps: + current_apps.append(resource.data.app_id) + app_call = replace(app_call, app_references=current_apps) + _set_app_call(transactions, group_index, app_call) + + elif resource.type == GroupResourceType.ExtraBoxRef: + current_boxes = list(app_call.box_references or []) + current_boxes.append(BoxReference(app_id=0, name=b"")) + app_call = replace(app_call, box_references=current_boxes) + _set_app_call(transactions, group_index, app_call) + + elif resource.type == GroupResourceType.AssetHolding: + current_assets = list(app_call.asset_references or []) + if resource.data.asset_id not in current_assets: + current_assets.append(resource.data.asset_id) + app_call = replace(app_call, asset_references=current_assets) + _set_app_call(transactions, group_index, app_call) + + current_accounts = list(app_call.account_references or []) + account = _normalize_address(resource.data.address) + if account not in current_accounts: + current_accounts.append(account) + app_call = replace(app_call, account_references=current_accounts) + _set_app_call(transactions, group_index, app_call) + + elif resource.type == GroupResourceType.AppLocal: + current_apps = list(app_call.app_references or []) + if resource.data.app_id not in current_apps: + current_apps.append(resource.data.app_id) + app_call = replace(app_call, app_references=current_apps) + _set_app_call(transactions, group_index, app_call) + + current_accounts = list(app_call.account_references or []) + account = _normalize_address(resource.data.address) + if account not in current_accounts: + current_accounts.append(account) + app_call = replace(app_call, account_references=current_accounts) + _set_app_call(transactions, group_index, app_call) + + elif resource.type == GroupResourceType.Asset: + current_assets = list(app_call.asset_references or []) + if resource.data not in current_assets: + current_assets.append(resource.data) + app_call = replace(app_call, asset_references=current_assets) + _set_app_call(transactions, group_index, app_call) + + +def _set_app_call(transactions: list[Transaction], index: int, app_call: AppCallTransactionFields) -> None: + transactions[index] = replace(transactions[index], application_call=app_call) + + +def _normalize_address(value: str | bytes) -> str: + if isinstance(value, bytes): + return value.decode("utf-8") + return value diff --git a/src/algokit_utils/transactions/fee_coverage.py b/src/algokit_utils/transactions/fee_coverage.py new file mode 100644 index 00000000..bd38b349 --- /dev/null +++ b/src/algokit_utils/transactions/fee_coverage.py @@ -0,0 +1,79 @@ +from collections.abc import Callable +from dataclasses import dataclass +from enum import Enum, auto +from typing import ClassVar + + +class FeeDeltaType(Enum): + """Describes the type of fee delta""" + + DEFICIT = auto() + SURPLUS = auto() + + +@dataclass(slots=True, frozen=True) +class FeeDelta: + """Represents a difference between required and provided fee amounts.""" + + type: FeeDeltaType + data: int + + @staticmethod + def from_int(value: int) -> "FeeDelta | None": + if value > 0: + return FeeDelta(FeeDeltaType.DEFICIT, value) + if value < 0: + return FeeDelta(FeeDeltaType.SURPLUS, -value) + return None + + @staticmethod + def add(lhs: "FeeDelta | None", rhs: "FeeDelta | None") -> "FeeDelta | None": + if lhs is None: + return rhs + if rhs is None: + return lhs + return FeeDelta.from_int(FeeDelta.to_int(lhs) + FeeDelta.to_int(rhs)) + + @staticmethod + def to_int(delta: "FeeDelta") -> int: + return delta.data if delta.type is FeeDeltaType.DEFICIT else -delta.data + + @staticmethod + def amount(delta: "FeeDelta") -> int: + return delta.data + + @staticmethod + def is_deficit(delta: "FeeDelta") -> bool: + return delta.type is FeeDeltaType.DEFICIT + + @staticmethod + def is_surplus(delta: "FeeDelta") -> bool: + return delta.type is FeeDeltaType.SURPLUS + + +@dataclass(slots=True, frozen=True, order=True) +class FeePriority: + """Priority wrapper used when deciding which transactions need additional fees applied first.""" + + priority_level: int + deficit_amount: int + Covered: ClassVar["FeePriority"] + ModifiableDeficit: ClassVar[Callable[[int], "FeePriority"]] + ImmutableDeficit: ClassVar[Callable[[int], "FeePriority"]] + + @staticmethod + def covered() -> "FeePriority": + return FeePriority(0, 0) + + @staticmethod + def modifiable_deficit(amount: int) -> "FeePriority": + return FeePriority(1, amount) + + @staticmethod + def immutable_deficit(amount: int) -> "FeePriority": + return FeePriority(2, amount) + + +FeePriority.Covered = FeePriority.covered() +FeePriority.ModifiableDeficit = staticmethod(FeePriority.modifiable_deficit) +FeePriority.ImmutableDeficit = staticmethod(FeePriority.immutable_deficit) diff --git a/src/algokit_utils/transactions/helpers.py b/src/algokit_utils/transactions/helpers.py new file mode 100644 index 00000000..d0715d1f --- /dev/null +++ b/src/algokit_utils/transactions/helpers.py @@ -0,0 +1,9 @@ +from algokit_common import PROGRAM_PAGE_SIZE + +__all__ = ["calculate_extra_program_pages"] + + +def calculate_extra_program_pages(approval: bytes | None, clear: bytes | None) -> int: + """Calculate minimum number of extra_pages required for provided approval and clear programs.""" + total = len(approval or b"") + len(clear or b"") + return max(0, (total - 1) // PROGRAM_PAGE_SIZE) diff --git a/src/algokit_utils/transactions/transaction_composer.py b/src/algokit_utils/transactions/transaction_composer.py index 326077de..f5b4bde7 100644 --- a/src/algokit_utils/transactions/transaction_composer.py +++ b/src/algokit_utils/transactions/transaction_composer.py @@ -1,50 +1,81 @@ -from __future__ import annotations - import base64 import json import re -from collections.abc import Callable -from copy import deepcopy -from dataclasses import dataclass -from typing import TYPE_CHECKING, Any, TypedDict, Union, cast - -import algosdk -import algosdk.atomic_transaction_composer -import algosdk.v2client.models -from algosdk import logic, transaction -from algosdk.atomic_transaction_composer import ( - AtomicTransactionComposer, - SimulateAtomicTransactionResponse, - TransactionSigner, - TransactionWithSigner, -) -from algosdk.transaction import OnComplete, SuggestedParams -from algosdk.v2client.algod import AlgodClient -from algosdk.v2client.models.simulate_request import SimulateRequest -from typing_extensions import deprecated - -from algokit_utils.applications.abi import ABIReturn, ABIValue +from collections.abc import Callable, Sequence +from dataclasses import dataclass, replace +from typing import Any, TypeAlias, TypedDict, cast + +from algokit_abi import arc56 +from algokit_algod_client import AlgodClient +from algokit_algod_client import models as algod_models +from algokit_algod_client.exceptions import UnexpectedStatusError +from algokit_algod_client.models import SimulateTransactionResult +from algokit_common.constants import MAX_TRANSACTION_GROUP_SIZE +from algokit_transact import make_empty_transaction_signer +from algokit_transact.codec.signed import decode_signed_transactions +from algokit_transact.models.transaction import Transaction, TransactionType +from algokit_transact.ops.fees import calculate_fee +from algokit_transact.ops.group import group_transactions +from algokit_transact.ops.ids import get_transaction_id +from algokit_transact.ops.validate import validate_transaction +from algokit_transact.signer import AddressWithTransactionSigner, TransactionSigner +from algokit_utils.applications.abi import ABIReturn from algokit_utils.applications.app_manager import AppManager -from algokit_utils.applications.app_spec.arc56 import Method as Arc56Method +from algokit_utils.clients.client_manager import ClientManager from algokit_utils.config import config -from algokit_utils.models.state import BoxIdentifier, BoxReference -from algokit_utils.models.transaction import SendParams, TransactionWrapper -from algokit_utils.protocols.account import TransactionSignerAccountProtocol - -if TYPE_CHECKING: - from algosdk.abi import Method - from algosdk.v2client.models import SimulateTraceConfig - - from algokit_utils.models.amount import AlgoAmount - from algokit_utils.models.transaction import Arc2TransactionNote - -# Type for error transformer function -# Note: The return type is Any rather than Exception to allow runtime validation -# that the transformer actually returns an Exception instance -ErrorTransformer = Callable[[Exception], Any] +from algokit_utils.models.amount import AlgoAmount +from algokit_utils.models.transaction import Arc2TransactionNote, SendParams +from algokit_utils.transactions.builders import ( + build_app_call_method_call_transaction, + build_app_call_transaction, + build_app_create_method_call_transaction, + build_app_create_transaction, + build_app_delete_method_call_transaction, + build_app_delete_transaction, + build_app_update_method_call_transaction, + build_app_update_transaction, + build_asset_config_transaction, + build_asset_create_transaction, + build_asset_destroy_transaction, + build_asset_freeze_transaction, + build_asset_opt_in_transaction, + build_asset_opt_out_transaction, + build_asset_transfer_transaction, + build_offline_key_registration_transaction, + build_online_key_registration_transaction, + build_payment_transaction, +) +from algokit_utils.transactions.builders.common import calculate_inner_fee_delta +from algokit_utils.transactions.composer_resources import populate_group_resources, populate_transaction_resources +from algokit_utils.transactions.fee_coverage import FeeDelta, FeePriority +from algokit_utils.transactions.helpers import calculate_extra_program_pages +from algokit_utils.transactions.types import ( + AppCallMethodCallParams, + AppCallParams, + AppCreateMethodCallParams, + AppCreateParams, + AppCreateSchema, + AppDeleteMethodCallParams, + AppDeleteParams, + AppUpdateMethodCallParams, + AppUpdateParams, + AssetConfigParams, + AssetCreateParams, + AssetDestroyParams, + AssetFreezeParams, + AssetOptInParams, + AssetOptOutParams, + AssetTransferParams, + OfflineKeyRegistrationParams, + OnlineKeyRegistrationParams, + PaymentParams, + TxnParams, +) +ABIMethod: TypeAlias = arc56.Method __all__ = [ + "MAX_TRANSACTION_GROUP_SIZE", "AppCallMethodCallParams", "AppCallParams", "AppCreateMethodCallParams", @@ -64,2519 +95,1496 @@ "AssetTransferParams", "BuiltTransactions", "ErrorTransformer", - "MethodCallParams", + "ErrorTransformerError", + "InvalidErrorTransformerValueError", "OfflineKeyRegistrationParams", "OnlineKeyRegistrationParams", "PaymentParams", - "SendAtomicTransactionComposerResults", + "SendParams", + "SendTransactionComposerResults", "TransactionComposer", - "TransactionComposerBuildResult", + "TransactionComposerConfig", + "TransactionComposerError", + "TransactionComposerParams", + "TransactionWithSigner", "TxnParams", "calculate_extra_program_pages", - "populate_app_call_resources", - "prepare_group_for_sending", - "send_atomic_transaction_composer", ] +AppMethodCallTransactionArgument = Any +TxnParamTypes = ( + PaymentParams + | AssetCreateParams + | AssetConfigParams + | AssetFreezeParams + | AssetDestroyParams + | AssetTransferParams + | AssetOptInParams + | AssetOptOutParams + | AppCreateParams + | AppUpdateParams + | AppDeleteParams + | AppCallParams + | OnlineKeyRegistrationParams + | OfflineKeyRegistrationParams +) +MethodCallTxnParamTypes = ( + AppCreateMethodCallParams | AppUpdateMethodCallParams | AppDeleteMethodCallParams | AppCallMethodCallParams +) -MAX_TRANSACTION_GROUP_SIZE = 16 -MAX_APP_CALL_FOREIGN_REFERENCES = 8 -MAX_APP_CALL_ACCOUNT_REFERENCES = 4 +class ErrorTransformerError(RuntimeError): + """Raised when an error transformer throws.""" -class InvalidErrorTransformerValueError(Exception): - """Raised when an error transformer returns a non-error value.""" - def __init__(self, original_error: Exception, value: object) -> None: - super().__init__( - f"An error transformer returned a non-error value: {value}. " - f"The original error before any transformation: {original_error}" - ) +ErrorTransformer = Callable[[Exception], Exception] -class ErrorTransformerError(Exception): - """Raised when an error transformer throws an error.""" +class InvalidErrorTransformerValueError(RuntimeError): + """Raised when an error transformer returns a non-error value.""" - def __init__(self, original_error: Exception, cause: Exception) -> None: + def __init__(self, original_error: Exception, value: object) -> None: super().__init__( - f"An error transformer threw an error: {cause}. " + f"An error transformer returned a non-error value: {value}. " f"The original error before any transformation: {original_error}" ) - self.__cause__ = cause -@dataclass(kw_only=True, frozen=True) -class _CommonTxnParams: - sender: str - """The account that will send the transaction""" - signer: TransactionSigner | TransactionSignerAccountProtocol | None = None - """The signer for the transaction, defaults to None""" - rekey_to: str | None = None - """The account to rekey to, defaults to None""" - note: bytes | None = None - """The note for the transaction, defaults to None""" - lease: bytes | None = None - """The lease for the transaction, defaults to None""" - static_fee: AlgoAmount | None = None - """The static fee for the transaction, defaults to None""" - extra_fee: AlgoAmount | None = None - """The extra fee for the transaction, defaults to None""" - max_fee: AlgoAmount | None = None - """The maximum fee for the transaction, defaults to None""" - validity_window: int | None = None - """The validity window for the transaction, defaults to None""" - first_valid_round: int | None = None - """The first valid round for the transaction, defaults to None""" - last_valid_round: int | None = None - """The last valid round for the transaction, defaults to None""" - - -@dataclass(kw_only=True, frozen=True) -class AdditionalAtcContext: - max_fees: dict[int, AlgoAmount] | None = None - """The maximum fees for each transaction, defaults to None""" - suggested_params: SuggestedParams | None = None - """The suggested parameters for the transaction, defaults to None""" - - -@dataclass(kw_only=True, frozen=True) -class PaymentParams(_CommonTxnParams): - """Parameters for a payment transaction.""" - - receiver: str - """The account that will receive the ALGO""" - amount: AlgoAmount - """Amount to send""" - close_remainder_to: str | None = None - """If given, close the sender account and send the remaining balance to this address, defaults to None""" - - -@dataclass(kw_only=True, frozen=True) -class AssetCreateParams(_CommonTxnParams): - """Parameters for creating a new asset.""" - - total: int - """The total amount of the smallest divisible unit to create""" - asset_name: str | None = None - """The full name of the asset""" - unit_name: str | None = None - """The short ticker name for the asset""" - url: str | None = None - """The metadata URL for the asset""" - decimals: int | None = None - """The amount of decimal places the asset should have""" - default_frozen: bool | None = None - """Whether the asset is frozen by default in the creator address""" - manager: str | None = None - """The address that can change the manager, reserve, clawback, and freeze addresses""" - reserve: str | None = None - """The address that holds the uncirculated supply""" - freeze: str | None = None - """The address that can freeze the asset in any account""" - clawback: str | None = None - """The address that can clawback the asset from any account""" - metadata_hash: bytes | None = None - """Hash of the metadata contained in the metadata URL""" - - -@dataclass(kw_only=True, frozen=True) -class AssetConfigParams(_CommonTxnParams): - """Parameters for configuring an existing asset.""" - - asset_id: int - """The ID of the asset""" - manager: str | None = None - """The address that can change the manager, reserve, clawback, and freeze addresses, defaults to None""" - reserve: str | None = None - """The address that holds the uncirculated supply, defaults to None""" - freeze: str | None = None - """The address that can freeze the asset in any account, defaults to None""" - clawback: str | None = None - """The address that can clawback the asset from any account, defaults to None""" - - -@dataclass(kw_only=True, frozen=True) -class AssetFreezeParams(_CommonTxnParams): - """Parameters for freezing an asset.""" - - asset_id: int - """The ID of the asset""" - account: str - """The account to freeze or unfreeze""" - frozen: bool - """Whether the assets in the account should be frozen""" - - -@dataclass(kw_only=True, frozen=True) -class AssetDestroyParams(_CommonTxnParams): - """Parameters for destroying an asset.""" - - asset_id: int - """The ID of the asset""" - - -@dataclass(kw_only=True, frozen=True) -class OnlineKeyRegistrationParams(_CommonTxnParams): - """Parameters for online key registration.""" - - vote_key: str - """The root participation public key""" - selection_key: str - """The VRF public key""" - vote_first: int - """The first round that the participation key is valid""" - vote_last: int - """The last round that the participation key is valid""" - vote_key_dilution: int - """The dilution for the 2-level participation key""" - state_proof_key: bytes | None = None - """The 64 byte state proof public key commitment, defaults to None""" - - -@dataclass(kw_only=True, frozen=True) -class OfflineKeyRegistrationParams(_CommonTxnParams): - """Parameters for offline key registration.""" - - prevent_account_from_ever_participating_again: bool - """Whether to prevent the account from ever participating again""" - - -@dataclass(kw_only=True, frozen=True) -class AssetTransferParams(_CommonTxnParams): - """Parameters for transferring an asset.""" - - asset_id: int - """The ID of the asset""" - amount: int - """The amount of the asset to transfer (smallest divisible unit)""" - receiver: str - """The account to send the asset to""" - clawback_target: str | None = None - """The account to take the asset from, defaults to None""" - close_asset_to: str | None = None - """The account to close the asset to, defaults to None""" - - -@dataclass(kw_only=True, frozen=True) -class AssetOptInParams(_CommonTxnParams): - """Parameters for opting into an asset.""" - - asset_id: int - """The ID of the asset""" - - -@dataclass(kw_only=True, frozen=True) -class AssetOptOutParams(_CommonTxnParams): - """Parameters for opting out of an asset.""" - - asset_id: int - """The ID of the asset""" - creator: str - """The creator address of the asset""" - - -@dataclass(kw_only=True, frozen=True) -class AppCallParams(_CommonTxnParams): - """Parameters for calling an application.""" - - on_complete: OnComplete - """The OnComplete action, defaults to None""" - app_id: int | None = None - """The ID of the application, defaults to None""" - approval_program: str | bytes | None = None - """The program to execute for all OnCompletes other than ClearState, defaults to None""" - clear_state_program: str | bytes | None = None - """The program to execute for ClearState OnComplete, defaults to None""" - schema: dict[str, int] | None = None - """The state schema for the app, defaults to None""" - args: list[bytes] | None = None - """Application arguments, defaults to None""" - account_references: list[str] | None = None - """Account references, defaults to None""" - app_references: list[int] | None = None - """App references, defaults to None""" - asset_references: list[int] | None = None - """Asset references, defaults to None""" - extra_pages: int | None = None - """Number of extra pages required for the programs, defaults to None""" - box_references: list[BoxReference | BoxIdentifier] | None = None - """Box references, defaults to None""" - - -class AppCreateSchema(TypedDict): - global_ints: int - """The number of global ints in the schema""" - global_byte_slices: int - """The number of global byte slices in the schema""" - local_ints: int - """The number of local ints in the schema""" - local_byte_slices: int - """The number of local byte slices in the schema""" - - -@dataclass(kw_only=True, frozen=True) -class AppCreateParams(_CommonTxnParams): - """Parameters for creating an application.""" - - approval_program: str | bytes - """The program to execute for all OnCompletes other than ClearState""" - clear_state_program: str | bytes - """The program to execute for ClearState OnComplete""" - schema: AppCreateSchema | None = None - """The state schema for the app, defaults to None""" - on_complete: OnComplete | None = None - """The OnComplete action, defaults to None""" - args: list[bytes] | None = None - """Application arguments, defaults to None""" - account_references: list[str] | None = None - """Account references, defaults to None""" - app_references: list[int] | None = None - """App references, defaults to None""" - asset_references: list[int] | None = None - """Asset references, defaults to None""" - box_references: list[BoxReference | BoxIdentifier] | None = None - """Box references, defaults to None""" - extra_program_pages: int | None = None - """Number of extra pages required for the programs, defaults to None""" - - -@dataclass(kw_only=True, frozen=True) -class AppUpdateParams(_CommonTxnParams): - """Parameters for updating an application.""" - - app_id: int - """The ID of the application""" - approval_program: str | bytes - """The program to execute for all OnCompletes other than ClearState""" - clear_state_program: str | bytes - """The program to execute for ClearState OnComplete""" - args: list[bytes] | None = None - """Application arguments, defaults to None""" - account_references: list[str] | None = None - """Account references, defaults to None""" - app_references: list[int] | None = None - """App references, defaults to None""" - asset_references: list[int] | None = None - """Asset references, defaults to None""" - box_references: list[BoxReference | BoxIdentifier] | None = None - """Box references, defaults to None""" - on_complete: OnComplete | None = None - """The OnComplete action, defaults to None""" - - -@dataclass(kw_only=True, frozen=True) -class AppDeleteParams(_CommonTxnParams): - """Parameters for deleting an application.""" - - app_id: int - """The ID of the application""" - args: list[bytes] | None = None - """Application arguments, defaults to None""" - account_references: list[str] | None = None - """Account references, defaults to None""" - app_references: list[int] | None = None - """App references, defaults to None""" - asset_references: list[int] | None = None - """Asset references, defaults to None""" - box_references: list[BoxReference | BoxIdentifier] | None = None - """Box references, defaults to None""" - on_complete: OnComplete = OnComplete.DeleteApplicationOC - """The OnComplete action, defaults to DeleteApplicationOC""" - - -@dataclass(kw_only=True, frozen=True) -class _BaseAppMethodCall(_CommonTxnParams): - app_id: int - """The ID of the application""" - method: Method - """The ABI method to call""" - args: list | None = None - """Arguments to the ABI method, defaults to None""" - account_references: list[str] | None = None - """Account references, defaults to None""" - app_references: list[int] | None = None - """App references, defaults to None""" - asset_references: list[int] | None = None - """Asset references, defaults to None""" - box_references: list[BoxReference | BoxIdentifier] | None = None - """Box references, defaults to None""" - schema: AppCreateSchema | None = None - """The state schema for the app, defaults to None""" - on_complete: OnComplete | None = None - """The OnComplete action, defaults to None""" - - -@dataclass(kw_only=True, frozen=True) -class AppMethodCallParams(_CommonTxnParams): - """Parameters for calling an application method.""" - - app_id: int - """The ID of the application""" - method: Method - """The ABI method to call""" - args: list[bytes] | None = None - """Arguments to the ABI method, defaults to None""" - on_complete: OnComplete | None = None - """The OnComplete action, defaults to None""" - account_references: list[str] | None = None - """Account references, defaults to None""" - app_references: list[int] | None = None - """App references, defaults to None""" - asset_references: list[int] | None = None - """Asset references, defaults to None""" - box_references: list[BoxReference | BoxIdentifier] | None = None - """Box references, defaults to None""" - - -@dataclass(kw_only=True, frozen=True) -class AppCallMethodCallParams(_BaseAppMethodCall): - """Parameters for a regular ABI method call.""" - - app_id: int - """The ID of the application""" - on_complete: OnComplete | None = None - """The OnComplete action, defaults to None""" - - -@dataclass(kw_only=True, frozen=True) -class AppCreateMethodCallParams(_BaseAppMethodCall): - """Parameters for an ABI method call that creates an application.""" - - approval_program: str | bytes - """The program to execute for all OnCompletes other than ClearState""" - clear_state_program: str | bytes - """The program to execute for ClearState OnComplete""" - schema: AppCreateSchema | None = None - """The state schema for the app, defaults to None""" - on_complete: OnComplete | None = None - """The OnComplete action (cannot be ClearState), defaults to None""" - extra_program_pages: int | None = None - """Number of extra pages required for the programs, defaults to None""" - - -@dataclass(kw_only=True, frozen=True) -class AppUpdateMethodCallParams(_BaseAppMethodCall): - """Parameters for an ABI method call that updates an application.""" - - app_id: int - """The ID of the application""" - approval_program: str | bytes - """The program to execute for all OnCompletes other than ClearState""" - clear_state_program: str | bytes - """The program to execute for ClearState OnComplete""" - on_complete: OnComplete = OnComplete.UpdateApplicationOC - """The OnComplete action""" - - -@dataclass(kw_only=True, frozen=True) -class AppDeleteMethodCallParams(_BaseAppMethodCall): - """Parameters for an ABI method call that deletes an application.""" - - app_id: int - """The ID of the application""" - on_complete: OnComplete = OnComplete.DeleteApplicationOC - """The OnComplete action""" - - -MethodCallParams = ( - AppCallMethodCallParams | AppCreateMethodCallParams | AppUpdateMethodCallParams | AppDeleteMethodCallParams -) +class TransactionComposerError(RuntimeError): + """Error raised when transaction composer fails to send transactions. + Contains detailed debugging information including simulation traces and sent transactions. + """ -AppMethodCallTransactionArgument = ( - TransactionWithSigner - | algosdk.transaction.Transaction - | AppCreateMethodCallParams - | AppUpdateMethodCallParams - | AppCallMethodCallParams -) - - -TxnParams = Union[ # noqa: UP007 - PaymentParams, - AssetCreateParams, - AssetConfigParams, - AssetFreezeParams, - AssetDestroyParams, - OnlineKeyRegistrationParams, - AssetTransferParams, - AssetOptInParams, - AssetOptOutParams, - AppCallParams, - AppCreateParams, - AppUpdateParams, - AppDeleteParams, - MethodCallParams, - OfflineKeyRegistrationParams, -] - - -@dataclass(frozen=True, kw_only=True) -class TransactionContext: - """Contextual information for a transaction.""" - - max_fee: AlgoAmount | None = None - abi_method: Method | None = None + def __init__( + self, + message: str, + *, + cause: Exception | None = None, + traces: list[SimulateTransactionResult] | None = None, + sent_transactions: list[Transaction] | None = None, + simulate_response: algod_models.SimulateResponse | None = None, + ) -> None: + super().__init__(message) + self.__cause__ = cause + self.traces = traces + self.sent_transactions = sent_transactions + self.simulate_response = simulate_response - @staticmethod - def empty() -> TransactionContext: - return TransactionContext(max_fee=None, abi_method=None) +@dataclass(slots=True) +class TransactionComposerConfig: + cover_app_call_inner_transaction_fees: bool = False + populate_app_call_resources: bool = True -class TransactionWithContext: - """Combines Transaction with additional context.""" - def __init__(self, txn: algosdk.transaction.Transaction, context: TransactionContext): - self.txn = txn - self.context = context +@dataclass(slots=True) +class TransactionComposerParams: + algod: AlgodClient + get_signer: Callable[[str], TransactionSigner] + get_suggested_params: Callable[[], algod_models.SuggestedParams] | None = None + default_validity_window: int | None = None + app_manager: AppManager | None = None + error_transformers: list[ErrorTransformer] | None = None + composer_config: TransactionComposerConfig | None = None -class TransactionWithSignerAndContext(TransactionWithSigner): - """Combines TransactionWithSigner with additional context.""" +class _BuilderKwargs(TypedDict): + suggested_params: algod_models.SuggestedParams + default_validity_window: int + default_validity_window_is_explicit: bool + is_localnet: bool - def __init__(self, txn: algosdk.transaction.Transaction, signer: TransactionSigner, context: TransactionContext): - super().__init__(txn, signer) - self.context = context - @staticmethod - def from_txn_with_context( - txn_with_context: TransactionWithContext, signer: TransactionSigner - ) -> TransactionWithSignerAndContext: - return TransactionWithSignerAndContext( - txn=txn_with_context.txn, signer=signer, context=txn_with_context.context - ) +@dataclass(slots=True, frozen=True) +class TransactionWithSigner: + txn: Transaction + signer: TransactionSigner + method: ABIMethod | None = None -@dataclass(frozen=True) +@dataclass(slots=True, frozen=True) class BuiltTransactions: - """Set of transactions built by TransactionComposer.""" - - transactions: list[algosdk.transaction.Transaction] - """The built transactions""" - method_calls: dict[int, Method] - """Map of transaction index to ABI method""" + transactions: list[Transaction] + method_calls: dict[int, ABIMethod] signers: dict[int, TransactionSigner] - """Map of transaction index to TransactionSigner""" - - -@dataclass -class TransactionComposerBuildResult: - """Result of building transactions with TransactionComposer.""" - - atc: AtomicTransactionComposer - """The AtomicTransactionComposer instance""" - transactions: list[TransactionWithSigner] - """The list of transactions with signers""" - method_calls: dict[int, Method] - """Map of transaction index to ABI method""" -@dataclass -class SendAtomicTransactionComposerResults: - """Results from sending an AtomicTransactionComposer transaction group.""" - - group_id: str - """The group ID if this was a transaction group""" - confirmations: list[algosdk.v2client.algod.AlgodResponseType] - """The confirmation info for each transaction""" +@dataclass(slots=True, frozen=True) +class SendTransactionComposerResults: tx_ids: list[str] - """The transaction IDs that were sent""" - transactions: list[TransactionWrapper] - """The transactions that were sent""" + transactions: list[Transaction] + confirmations: list[algod_models.PendingTransactionResponse] returns: list[ABIReturn] - """The ABI return values from any ABI method calls""" - simulate_response: dict[str, Any] | None = None - """The simulation response if simulation was performed, defaults to None""" - - -class UnnamedResourcesAccessed: - """Information about unnamed resource access.""" + group_id: str | None = None + simulate_response: algod_models.SimulateResponse | None = None - def __init__(self, resources_accessed: dict[str, Any] | None = None): - resources = resources_accessed or {} - if not isinstance(resources, dict): - raise TypeError(f"Expected dictionary object, got {type(resources_accessed)}") - - self.accounts: list[str] | None = resources.get("accounts", None) - self.app_locals: list[dict[str, Any]] | None = resources.get("app-locals", None) - self.apps: list[int] | None = resources.get("apps", None) - self.asset_holdings: list[dict[str, Any]] | None = resources.get("asset-holdings", None) - self.assets: list[int] | None = resources.get("assets", None) - self.boxes: list[dict[str, Any]] | None = resources.get("boxes", None) - self.extra_box_refs: int | None = resources.get("extra-box-refs", None) - - -@dataclass -class ExecutionInfoTxn: - """Execution info for a transaction.""" - - unnamed_resources_accessed: UnnamedResourcesAccessed | None = None - """The unnamed resources accessed in the transaction""" - required_fee_delta: int = 0 - """The required fee delta for the transaction""" - - -@dataclass -class ExecutionInfo: - """Information about transaction execution from simulation.""" - - group_unnamed_resources_accessed: UnnamedResourcesAccessed | None = None - """The unnamed resources accessed in the group""" - txns: list[ExecutionInfoTxn] | None = None - """The execution info for each transaction""" - - -@dataclass -class _TransactionWithPriority: - txn: algosdk.transaction.Transaction - priority: int - fee_delta: int - index: int - - -MAX_LEASE_LENGTH = 32 -NULL_SIGNER: TransactionSigner = algosdk.atomic_transaction_composer.EmptySigner() - - -def _encode_lease(lease: str | bytes | None) -> bytes | None: - if lease is None: - return None - elif isinstance(lease, bytes): - if not (1 <= len(lease) <= MAX_LEASE_LENGTH): - raise ValueError( - f"Received invalid lease; expected something with length between 1 and {MAX_LEASE_LENGTH}, " - f"but received bytes with length {len(lease)}" - ) - if len(lease) == MAX_LEASE_LENGTH: - return lease - lease32 = bytearray(32) - lease32[: len(lease)] = lease - return bytes(lease32) - elif isinstance(lease, str): - encoded = lease.encode("utf-8") - if not (1 <= len(encoded) <= MAX_LEASE_LENGTH): - raise ValueError( - f"Received invalid lease; expected something with length between 1 and {MAX_LEASE_LENGTH}, " - f"but received '{lease}' with length {len(lease)}" - ) - lease32 = bytearray(MAX_LEASE_LENGTH) - lease32[: len(encoded)] = encoded - return bytes(lease32) - else: - raise TypeError(f"Unknown lease type received of {type(lease)}") +@dataclass(slots=True) +class _QueuedTransaction: + txn: Transaction | TxnParams + signer: TransactionSigner | AddressWithTransactionSigner | None + max_fee: AlgoAmount | None = None -def _get_group_execution_info( # noqa: C901 - atc: AtomicTransactionComposer, - algod: AlgodClient, - populate_app_call_resources: bool | None = None, - cover_app_call_inner_transaction_fees: bool | None = None, - additional_atc_context: AdditionalAtcContext | None = None, -) -> ExecutionInfo: - # Create simulation request - suggested_params = additional_atc_context.suggested_params if additional_atc_context else None - max_fees = additional_atc_context.max_fees if additional_atc_context else None - - simulate_request = SimulateRequest( - txn_groups=[], - allow_unnamed_resources=True, - allow_empty_signatures=True, - ) - - # Clone ATC with null signers - empty_signer_atc = atc.clone() - - # Track app call indexes without max fees - app_call_indexes_without_max_fees = [] - - # Copy transactions with null signers - for i, txn in enumerate(empty_signer_atc.txn_list): - txn_with_signer = TransactionWithSigner(txn=txn.txn, signer=NULL_SIGNER) - - if cover_app_call_inner_transaction_fees and isinstance(txn.txn, algosdk.transaction.ApplicationCallTxn): - if not suggested_params: - raise ValueError("suggested_params required when cover_app_call_inner_transaction_fees enabled") - - max_fee = max_fees.get(i).micro_algo if max_fees and i in max_fees else None # type: ignore[union-attr] - if max_fee is None: - app_call_indexes_without_max_fees.append(i) - else: - txn_with_signer.txn.fee = max_fee +@dataclass(slots=True) +class _BuiltTxnSpec: + txn: Transaction + signer: TransactionSigner | None + logical_max_fee: AlgoAmount | None + method: ABIMethod | None = None - if cover_app_call_inner_transaction_fees and app_call_indexes_without_max_fees: - raise ValueError( - f"Please provide a `max_fee` for each app call transaction when `cover_app_call_inner_transaction_fees` is enabled. " # noqa: E501 - f"Required for transactions: {', '.join(str(i) for i in app_call_indexes_without_max_fees)}" - ) - # Simulate transactions - result = empty_signer_atc.simulate(algod, simulate_request) +@dataclass(slots=True) +class _TransactionAnalysis: + required_fee_delta: FeeDelta | None + unnamed_resources_accessed: algod_models.SimulateUnnamedResourcesAccessed | None - group_response = result.simulate_response["txn-groups"][0] - if group_response.get("failure-message"): - msg = group_response["failure-message"] - if cover_app_call_inner_transaction_fees and "fee too small" in msg: - raise ValueError( - "Fees were too small to resolve execution info via simulate. " - "You may need to increase an app call transaction maxFee." - ) - failed_at = group_response.get("failed-at", [0])[0] - raise ValueError( - f"Error resolving execution info via simulate in transaction {failed_at}: " - f"{group_response['failure-message']}" - ) +@dataclass(slots=True) +class _GroupAnalysis: + transactions: list[_TransactionAnalysis] + unnamed_resources_accessed: algod_models.SimulateUnnamedResourcesAccessed | None - # Build execution info - txn_results = [] - for i, txn_result_raw in enumerate(group_response["txn-results"]): - txn_result = txn_result_raw.get("txn-result") - if not txn_result: - continue - - original_txn = atc.build_group()[i].txn - - required_fee_delta = 0 - if cover_app_call_inner_transaction_fees: - required_fee_delta = _calculate_required_fee_delta( - original_txn, - txn_result, - per_byte_txn_fee=suggested_params.fee if suggested_params else 0, - min_txn_fee=int(suggested_params.min_fee) if suggested_params else 1000, - ) - txn_results.append( - ExecutionInfoTxn( - unnamed_resources_accessed=UnnamedResourcesAccessed(txn_result_raw.get("unnamed-resources-accessed")) - if populate_app_call_resources +class TransactionComposer: + """Light-weight transaction composer built on top of algokit_transact.""" + + def __init__(self, params: TransactionComposerParams) -> None: + self._algod = params.algod + self._get_signer = params.get_signer + self._get_suggested_params = params.get_suggested_params or self._algod.suggested_params + self._config = params.composer_config or TransactionComposerConfig() + self._error_transformers = params.error_transformers or [] + self._default_validity_window = params.default_validity_window or 10 + self._default_validity_window_is_explicit = params.default_validity_window is not None + self._app_manager = params.app_manager or AppManager(params.algod) + + self._queued: list[_QueuedTransaction] = [] + self._transactions_with_signers: list[TransactionWithSigner] | None = None + self._signed_transactions: list[bytes] | None = None + self._raw_built_transactions: list[Transaction] | None = None + + def clone(self, composer_config: TransactionComposerConfig | None = None) -> "TransactionComposer": + """Create a shallow copy of this composer, optionally overriding config flags.""" + config_override = composer_config or self._config + cloned = TransactionComposer( + TransactionComposerParams( + algod=self._algod, + get_signer=self._get_signer, + get_suggested_params=self._get_suggested_params, + default_validity_window=self._default_validity_window + if self._default_validity_window_is_explicit else None, - required_fee_delta=required_fee_delta, - ) - ) - - return ExecutionInfo( - group_unnamed_resources_accessed=UnnamedResourcesAccessed(group_response.get("unnamed-resources-accessed")) - if populate_app_call_resources - else None, - txns=txn_results, - ) - - -def _calculate_required_fee_delta( - txn: transaction.Transaction, txn_result: dict[str, Any], *, per_byte_txn_fee: int, min_txn_fee: int -) -> int: - # Calculate parent transaction fee - original_txn_size = txn.estimate_size() - assert isinstance(original_txn_size, int), "expected txn size to be an int" - parent_per_byte_fee = per_byte_txn_fee * (original_txn_size + 75) - parent_min_fee = max(parent_per_byte_fee, min_txn_fee) - original_txn_fee = txn.fee - assert isinstance(original_txn_fee, int), "expected original txn fee to be an int" - parent_fee_delta = parent_min_fee - original_txn_fee - - if isinstance(txn, algosdk.transaction.ApplicationCallTxn): - # Calculate inner transaction fees recursively - def calculate_inner_fee_delta(inner_txns: list[dict], acc: int = 0) -> int: - for inner_txn in reversed(inner_txns): - current_fee_delta = ( - calculate_inner_fee_delta(inner_txn["inner-txns"], acc) if inner_txn.get("inner-txns") else acc - ) + (min_txn_fee - inner_txn["txn"]["txn"].get("fee", 0)) - acc = max(0, current_fee_delta) - return acc - - inner_fee_delta = calculate_inner_fee_delta(txn_result.get("inner-txns", [])) - return inner_fee_delta + parent_fee_delta - else: - return parent_fee_delta - - -def _find_available_transaction_index( - txns: list[TransactionWithSigner], reference_type: str, reference: str | dict[str, Any] | int -) -> int: - """Find index of first transaction that can accommodate the new reference.""" - - def check_transaction(txn: TransactionWithSigner) -> bool: - # Skip if not an application call transaction - if txn.txn.type != "appl": - return False - - # Get current counts (using get() with default 0 for Pythonic null handling) - accounts = len(getattr(txn.txn, "accounts", []) or []) - assets = len(getattr(txn.txn, "foreign_assets", []) or []) - apps = len(getattr(txn.txn, "foreign_apps", []) or []) - boxes = len(getattr(txn.txn, "boxes", []) or []) - - # For account references, only check account limit - if reference_type == "account": - return accounts < MAX_APP_CALL_ACCOUNT_REFERENCES - - # For asset holdings or local state, need space for both account and other reference - if reference_type in ("asset_holding", "app_local"): - return ( - accounts + assets + apps + boxes < MAX_APP_CALL_FOREIGN_REFERENCES - 1 - and accounts < MAX_APP_CALL_ACCOUNT_REFERENCES - ) - - # For boxes with non-zero app ID, need space for box and app reference - if reference_type == "box" and reference and int(getattr(reference, "app", 0)) != 0: - return accounts + assets + apps + boxes < MAX_APP_CALL_FOREIGN_REFERENCES - 1 - - # Default case - just check total references - return accounts + assets + apps + boxes < MAX_APP_CALL_FOREIGN_REFERENCES - - # Return first matching index or -1 if none found - return next((i for i, txn in enumerate(txns) if check_transaction(txn)), -1) - - -def calculate_extra_program_pages(approval: bytes | None, clear: bytes | None) -> int: - """Calculate minimum number of extra_pages required for provided approval and clear programs""" - total = len(approval or b"") + len(clear or b"") - return max(0, (total - 1) // algosdk.constants.APP_PAGE_MAX_SIZE) - - -def populate_app_call_resources(atc: AtomicTransactionComposer, algod: AlgodClient) -> AtomicTransactionComposer: - """Populate application call resources based on simulation results. - - :param atc: The AtomicTransactionComposer containing transactions - :param algod: Algod client for simulation - :return: Modified AtomicTransactionComposer with populated resources - """ - return prepare_group_for_sending(atc, algod, populate_app_call_resources=True) - - -def prepare_group_for_sending( # noqa: C901, PLR0912, PLR0915 - atc: AtomicTransactionComposer, - algod: AlgodClient, - populate_app_call_resources: bool | None = None, - cover_app_call_inner_transaction_fees: bool | None = None, - additional_atc_context: AdditionalAtcContext | None = None, -) -> AtomicTransactionComposer: - """Take an existing Atomic Transaction Composer and return a new one with changes applied to the transactions - based on the supplied parameters to prepare it for sending. - Please note, that before calling `.execute()` on the returned ATC, you must call `.build_group()`. - - :param atc: The AtomicTransactionComposer containing transactions - :param algod: Algod client for simulation - :param populate_app_call_resources: Whether to populate app call resources - :param cover_app_call_inner_transaction_fees: Whether to cover inner txn fees - :param additional_atc_context: Additional context for the AtomicTransactionComposer - :return: Modified AtomicTransactionComposer ready for sending - """ - # Get execution info via simulation - execution_info = _get_group_execution_info( - atc, - algod, - populate_app_call_resources if populate_app_call_resources is not None else config.populate_app_call_resource, - cover_app_call_inner_transaction_fees, - additional_atc_context, - ) - max_fees = additional_atc_context.max_fees if additional_atc_context else None - - group = atc.build_group() - - # Handle transaction fees if needed - if cover_app_call_inner_transaction_fees: - # Sort transactions by fee priority - txns_with_priority: list[_TransactionWithPriority] = [] - for i, txn_info in enumerate(execution_info.txns or []): - if not txn_info: - continue - txn = group[i].txn - max_fee = max_fees.get(i).micro_algo if max_fees and i in max_fees else None # type: ignore[union-attr] - immutable_fee = max_fee is not None and max_fee == txn.fee - priority_multiplier = ( - 1000 - if ( - txn_info.required_fee_delta > 0 - and (immutable_fee or not isinstance(txn, algosdk.transaction.ApplicationCallTxn)) - ) - else 1 - ) - - txns_with_priority.append( - _TransactionWithPriority( - txn=txn, - index=i, - fee_delta=txn_info.required_fee_delta, - priority=txn_info.required_fee_delta * priority_multiplier - if txn_info.required_fee_delta > 0 - else -1, - ) - ) - - # Sort by priority descending - txns_with_priority.sort(key=lambda x: x.priority, reverse=True) - - # Calculate surplus fees and additional fees needed - surplus_fees = sum( - txn_info.required_fee_delta * -1 - for txn_info in execution_info.txns or [] - if txn_info is not None and txn_info.required_fee_delta < 0 - ) - - additional_fees = {} - - # Distribute surplus fees to cover deficits - for txn_obj in txns_with_priority: - if txn_obj.fee_delta > 0: - if surplus_fees >= txn_obj.fee_delta: - surplus_fees -= txn_obj.fee_delta - else: - additional_fees[txn_obj.index] = txn_obj.fee_delta - surplus_fees - surplus_fees = 0 - - def populate_group_resource( # noqa: PLR0915, PLR0912, C901 - txns: list[TransactionWithSigner], reference: str | dict[str, Any] | int, ref_type: str - ) -> None: - """Helper function to populate group-level resources.""" - - def is_appl_below_limit(t: TransactionWithSigner) -> bool: - if not isinstance(t.txn, transaction.ApplicationCallTxn): - return False - - accounts = len(getattr(t.txn, "accounts", []) or []) - assets = len(getattr(t.txn, "foreign_assets", []) or []) - apps = len(getattr(t.txn, "foreign_apps", []) or []) - boxes = len(getattr(t.txn, "boxes", []) or []) - - return accounts + assets + apps + boxes < MAX_APP_CALL_FOREIGN_REFERENCES - - # Handle asset holding and app local references first - if ref_type in ("assetHolding", "appLocal"): - ref_dict = cast(dict[str, Any], reference) - account = ref_dict["account"] - - # First try to find transaction with account already available - txn_idx = next( - ( - i - for i, t in enumerate(txns) - if is_appl_below_limit(t) - and isinstance(t.txn, transaction.ApplicationCallTxn) - and ( - account in (getattr(t.txn, "accounts", []) or []) - or account - in ( - logic.get_application_address(app_id) - for app_id in (getattr(t.txn, "foreign_apps", []) or []) - ) - or any(str(account) in str(v) for v in t.txn.__dict__.values()) - ) - ), - -1, - ) - - if txn_idx >= 0: - app_txn = cast(transaction.ApplicationCallTxn, txns[txn_idx].txn) - if ref_type == "assetHolding": - asset_id = ref_dict["asset"] - app_txn.foreign_assets = [*list(getattr(app_txn, "foreign_assets", []) or []), asset_id] - else: - app_id = ref_dict["app"] - app_txn.foreign_apps = [*list(getattr(app_txn, "foreign_apps", []) or []), app_id] - return - - # Try to find transaction that already has the app/asset available - txn_idx = next( - ( - i - for i, t in enumerate(txns) - if is_appl_below_limit(t) - and isinstance(t.txn, transaction.ApplicationCallTxn) - and len(getattr(t.txn, "accounts", []) or []) < MAX_APP_CALL_ACCOUNT_REFERENCES - and ( - ( - ref_type == "assetHolding" - and ref_dict["asset"] in (getattr(t.txn, "foreign_assets", []) or []) - ) - or ( - ref_type == "appLocal" - and ( - ref_dict["app"] in (getattr(t.txn, "foreign_apps", []) or []) - or t.txn.index == ref_dict["app"] - ) - ) - ) + app_manager=self._app_manager, + error_transformers=list(self._error_transformers), + composer_config=TransactionComposerConfig( + cover_app_call_inner_transaction_fees=config_override.cover_app_call_inner_transaction_fees, + populate_app_call_resources=config_override.populate_app_call_resources, ), - -1, - ) - - if txn_idx >= 0: - app_txn = cast(transaction.ApplicationCallTxn, txns[txn_idx].txn) - accounts = list(getattr(app_txn, "accounts", []) or []) - accounts.append(account) - app_txn.accounts = accounts - return - - # Handle box references - if ref_type == "box": - box_ref = (reference["app"], base64.b64decode(reference["name"])) # type: ignore[index] - - # Try to find transaction that already has the app available - txn_idx = next( - ( - i - for i, t in enumerate(txns) - if is_appl_below_limit(t) - and isinstance(t.txn, transaction.ApplicationCallTxn) - and (box_ref[0] in (getattr(t.txn, "foreign_apps", []) or []) or t.txn.index == box_ref[0]) - ), - -1, - ) - - if txn_idx >= 0: - app_txn = cast(transaction.ApplicationCallTxn, txns[txn_idx].txn) - boxes = list(getattr(app_txn, "boxes", []) or []) - boxes.append(BoxReference.translate_box_reference(box_ref, app_txn.foreign_apps or [], app_txn.index)) # type: ignore[arg-type] - app_txn.boxes = boxes - return - - # Find available transaction for the resource - txn_idx = _find_available_transaction_index(txns, ref_type, reference) - - if txn_idx == -1: - raise ValueError("No more transactions below reference limit. Add another app call to the group.") - - app_txn = cast(transaction.ApplicationCallTxn, txns[txn_idx].txn) - - if ref_type == "account": - accounts = list(getattr(app_txn, "accounts", []) or []) - accounts.append(cast(str, reference)) - app_txn.accounts = accounts - elif ref_type == "app": - app_id = int(cast(str | int, reference)) - foreign_apps = list(getattr(app_txn, "foreign_apps", []) or []) - foreign_apps.append(app_id) - app_txn.foreign_apps = foreign_apps - elif ref_type == "box": - # ensure app_id is added before calling translate_box_reference - app_id = box_ref[0] - if app_id != 0: - foreign_apps = list(getattr(app_txn, "foreign_apps", []) or []) - foreign_apps.append(app_id) - app_txn.foreign_apps = foreign_apps - boxes = list(getattr(app_txn, "boxes", []) or []) - boxes.append(BoxReference.translate_box_reference(box_ref, app_txn.foreign_apps or [], app_txn.index)) # type: ignore[arg-type] - app_txn.boxes = boxes - elif ref_type == "asset": - asset_id = int(cast(str | int, reference)) - foreign_assets = list(getattr(app_txn, "foreign_assets", []) or []) - foreign_assets.append(asset_id) - app_txn.foreign_assets = foreign_assets - elif ref_type == "assetHolding": - ref_dict = cast(dict[str, Any], reference) - foreign_assets = list(getattr(app_txn, "foreign_assets", []) or []) - foreign_assets.append(ref_dict["asset"]) - app_txn.foreign_assets = foreign_assets - accounts = list(getattr(app_txn, "accounts", []) or []) - accounts.append(ref_dict["account"]) - app_txn.accounts = accounts - elif ref_type == "appLocal": - ref_dict = cast(dict[str, Any], reference) - foreign_apps = list(getattr(app_txn, "foreign_apps", []) or []) - foreign_apps.append(ref_dict["app"]) - app_txn.foreign_apps = foreign_apps - accounts = list(getattr(app_txn, "accounts", []) or []) - accounts.append(ref_dict["account"]) - app_txn.accounts = accounts - - # Process transaction-level resources - for i, txn_info in enumerate(execution_info.txns or []): - if not txn_info: - continue - - # Validate no unexpected resources - is_app_txn = isinstance(group[i].txn, algosdk.transaction.ApplicationCallTxn) - resources = txn_info.unnamed_resources_accessed - if resources and is_app_txn: - app_txn = group[i].txn - if resources.boxes or resources.extra_box_refs: - raise ValueError("Unexpected boxes at transaction level") - if resources.app_locals: - raise ValueError("Unexpected app local at transaction level") - if resources.asset_holdings: - raise ValueError("Unexpected asset holding at transaction level") - - # Update application call fields - accounts = list(getattr(app_txn, "accounts", []) or []) - foreign_apps = list(getattr(app_txn, "foreign_apps", []) or []) - foreign_assets = list(getattr(app_txn, "foreign_assets", []) or []) - boxes = list(getattr(app_txn, "boxes", []) or []) - - # Add new resources - accounts.extend(resources.accounts or []) - foreign_apps.extend(resources.apps or []) - foreign_assets.extend(resources.assets or []) - boxes.extend(resources.boxes or []) - - # Validate limits - if len(accounts) > MAX_APP_CALL_ACCOUNT_REFERENCES: - raise ValueError( - f"Account reference limit of {MAX_APP_CALL_ACCOUNT_REFERENCES} exceeded in transaction {i}" - ) - - total_refs = len(accounts) + len(foreign_assets) + len(foreign_apps) + len(boxes) - if total_refs > MAX_APP_CALL_FOREIGN_REFERENCES: - raise ValueError( - f"Resource reference limit of {MAX_APP_CALL_FOREIGN_REFERENCES} exceeded in transaction {i}" - ) - - # Update transaction - app_txn.accounts = accounts # type: ignore[attr-defined] - app_txn.foreign_apps = foreign_apps # type: ignore[attr-defined] - app_txn.foreign_assets = foreign_assets # type: ignore[attr-defined] - app_txn.boxes = boxes # type: ignore[attr-defined] - - # Update fees if needed - if cover_app_call_inner_transaction_fees and i in additional_fees: - cur_txn = group[i].txn - additional_fee = additional_fees[i] - if not isinstance(cur_txn, algosdk.transaction.ApplicationCallTxn): - raise ValueError( - f"An additional fee of {additional_fee} µALGO is required for non app call transaction {i}" - ) - - transaction_fee = cur_txn.fee + additional_fee - max_fee = max_fees.get(i).micro_algo if max_fees and i in max_fees else None # type: ignore[union-attr] - - if max_fee is None or transaction_fee > max_fee: - raise ValueError( - f"Calculated transaction fee {transaction_fee} µALGO is greater " - f"than max of {max_fee or 'undefined'} " - f"for transaction {i}" - ) - cur_txn.fee = transaction_fee - - # Process group-level resources - group_resources = execution_info.group_unnamed_resources_accessed - if group_resources: - # Handle cross-reference resources first - for app_local in group_resources.app_locals or []: - populate_group_resource(group, app_local, "appLocal") - # Remove processed resources - if group_resources.accounts: - group_resources.accounts = [acc for acc in group_resources.accounts if acc != app_local["account"]] - if group_resources.apps: - group_resources.apps = [app for app in group_resources.apps if int(app) != int(app_local["app"])] - - for asset_holding in group_resources.asset_holdings or []: - populate_group_resource(group, asset_holding, "assetHolding") - # Remove processed resources - if group_resources.accounts: - group_resources.accounts = [acc for acc in group_resources.accounts if acc != asset_holding["account"]] - if group_resources.assets: - group_resources.assets = [ - asset for asset in group_resources.assets if int(asset) != int(asset_holding["asset"]) - ] - - # Handle remaining resources - for account in group_resources.accounts or []: - populate_group_resource(group, account, "account") - - for box in group_resources.boxes or []: - populate_group_resource(group, box, "box") - if group_resources.apps: - group_resources.apps = [app for app in group_resources.apps if int(app) != int(box["app"])] - - for asset in group_resources.assets or []: - populate_group_resource(group, asset, "asset") - - for app in group_resources.apps or []: - populate_group_resource(group, app, "app") - - # Handle extra box references - extra_box_refs = group_resources.extra_box_refs or 0 - for _ in range(extra_box_refs): - populate_group_resource(group, {"app": 0, "name": ""}, "box") - - # Create new ATC with updated transactions - new_atc = AtomicTransactionComposer() - for txn_with_signer in group: - txn_with_signer.txn.group = None - new_atc.add_transaction(txn_with_signer) - new_atc.method_dict = deepcopy(atc.method_dict) - - return new_atc - - -def send_atomic_transaction_composer( # noqa: C901, PLR0912 - atc: AtomicTransactionComposer, - algod: AlgodClient, - *, - max_rounds_to_wait: int | None = 5, - skip_waiting: bool = False, - suppress_log: bool | None = None, - populate_app_call_resources: bool | None = None, - cover_app_call_inner_transaction_fees: bool | None = None, - additional_atc_context: AdditionalAtcContext | None = None, -) -> SendAtomicTransactionComposerResults: - """Send an AtomicTransactionComposer transaction group. - - Executes a group of transactions atomically using the AtomicTransactionComposer. - - :param atc: The AtomicTransactionComposer instance containing the transaction group to send - :param algod: The Algod client to use for sending the transactions - :param max_rounds_to_wait: Maximum number of rounds to wait for confirmation, defaults to 5 - :param skip_waiting: If True, don't wait for transaction confirmation, defaults to False - :param suppress_log: If True, suppress logging, defaults to None - :param populate_app_call_resources: If True, populate app call resources, defaults to None - :param cover_app_call_inner_transaction_fees: If True, cover app call inner transaction fees, defaults to None - :param additional_atc_context: Additional context for the AtomicTransactionComposer - :return: Results from sending the transaction group - :raises Exception: If there is an error sending the transactions - :raises error: If there is an error from the Algorand node - """ - from algokit_utils._debugging import simulate_and_persist_response, simulate_response - - try: - # Build transactions - transactions_with_signer = atc.build_group() - - populate_app_call_resources = ( - populate_app_call_resources - if populate_app_call_resources is not None - else config.populate_app_call_resource - ) - - if (populate_app_call_resources or cover_app_call_inner_transaction_fees) and any( - isinstance(t.txn, algosdk.transaction.ApplicationCallTxn) for t in transactions_with_signer - ): - atc = prepare_group_for_sending( - atc, - algod, - populate_app_call_resources, - cover_app_call_inner_transaction_fees, - additional_atc_context, - ) - - # atc.build_group() is needed to ensure that any changes - # made by prepare_group_for_sending are reflected and the group id is set - transactions_to_send = [t.txn for t in atc.build_group()] - - # Get group ID if multiple transactions - group_id = None - if len(transactions_to_send) > 1: - group_id = ( - base64.b64encode(transactions_to_send[0].group).decode("utf-8") if transactions_to_send[0].group else "" ) - - if not suppress_log: - config.logger.info( - f"Sending group of {len(transactions_to_send)} transactions ({group_id})", - extra={"suppress_log": suppress_log or False}, - ) - config.logger.debug( - f"Transaction IDs ({group_id}): {[t.get_txid() for t in transactions_to_send]}", - extra={"suppress_log": suppress_log or False}, - ) - - # Simulate if debug enabled - if config.debug and config.trace_all and config.project_root: - simulate_and_persist_response( - atc, - config.project_root, - algod, - config.trace_buffer_size_mb, - ) - - # Execute transactions - result = atc.execute(algod, wait_rounds=max_rounds_to_wait or 5) - - # Log results - if not suppress_log: - if len(transactions_to_send) > 1: - config.logger.info( - f"Group transaction ({group_id}) sent with {len(transactions_to_send)} transactions", - extra={"suppress_log": suppress_log or False}, - ) - else: - config.logger.info( - f"Sent transaction ID {transactions_to_send[0].get_txid()}", - extra={"suppress_log": suppress_log or False}, - ) - - # Get confirmations if not skipping - confirmations = None - if not skip_waiting: - confirmations = [algod.pending_transaction_info(t.get_txid()) for t in transactions_to_send] - - # Return results - return SendAtomicTransactionComposerResults( - group_id=group_id or "", - confirmations=confirmations or [], - tx_ids=[t.get_txid() for t in transactions_to_send], - transactions=[TransactionWrapper(t) for t in transactions_to_send], - returns=[ABIReturn(r) for r in result.abi_results], - ) - - except Exception as e: - # Handle error with debug info if enabled - if config.debug: - config.logger.error( - "Received error executing Atomic Transaction Composer and debug flag enabled; " - "attempting simulation to get more information ", - extra={"suppress_log": suppress_log or False}, - exc_info=e, - ) - - simulate = None - if config.project_root and not config.trace_all: - # Only simulate if trace_all is disabled and project_root is set - simulate = simulate_and_persist_response(atc, config.project_root, algod, config.trace_buffer_size_mb) - else: - simulate = simulate_response(atc, algod) - - traces = [] - if simulate and simulate.failed_at: - for txn_group in simulate.simulate_response["txn-groups"]: - app_budget = txn_group.get("app-budget-added") - app_budget_consumed = txn_group.get("app-budget-consumed") - failure_message = txn_group.get("failure-message") - txn_result = txn_group.get("txn-results", [{}])[0] - exec_trace = txn_result.get("exec-trace", {}) - - traces.append( - { - "trace": exec_trace, - "app_budget": app_budget, - "app_budget_consumed": app_budget_consumed, - "failure_message": failure_message, - } - ) - - error = Exception(f"Transaction failed: {e}") - error.traces = traces # type: ignore[attr-defined] - raise error from e - - config.logger.error( - "Received error executing Atomic Transaction Composer, for more information enable the debug flag", - extra={"suppress_log": suppress_log or False}, - exc_info=e, ) - raise e - - -class TransactionComposer: - """A class for composing and managing Algorand transactions. - - Provides a high-level interface for building and executing transaction groups using the Algosdk library. - Supports various transaction types including payments, asset operations, application calls, and key registrations. - - :param algod: An instance of AlgodClient used to get suggested params and send transactions - :param get_signer: A function that takes an address and returns a TransactionSigner for that address - :param get_suggested_params: Optional function to get suggested transaction parameters, - defaults to using algod.suggested_params() - :param default_validity_window: Optional default validity window for transactions in rounds, defaults to 10 - :param app_manager: Optional AppManager instance for compiling TEAL programs, defaults to None - :param error_transformers: Optional list of error transformers to use when an error is caught in simulate or send - """ + cloned._queued = [self._clone_entry(entry) for entry in self._queued] + cloned._raw_built_transactions = list(self._raw_built_transactions) if self._raw_built_transactions else None + return cloned - def __init__( - self, - algod: AlgodClient, - get_signer: Callable[[str], TransactionSigner], - get_suggested_params: Callable[[], algosdk.transaction.SuggestedParams] | None = None, - default_validity_window: int | None = None, - app_manager: AppManager | None = None, - error_transformers: list[ErrorTransformer] | None = None, - ): - # Map of transaction index in the atc to a max logical fee. - # This is set using the value of either maxFee or staticFee. - self._txn_max_fees: dict[int, AlgoAmount] = {} - self._txns: list[TransactionWithSigner | TxnParams | AtomicTransactionComposer] = [] - self._atc: AtomicTransactionComposer = AtomicTransactionComposer() - self._algod: AlgodClient = algod - self._default_get_send_params = lambda: self._algod.suggested_params() - self._get_suggested_params = get_suggested_params or self._default_get_send_params - self._get_signer: Callable[[str], TransactionSigner] = get_signer - self._default_validity_window: int = default_validity_window or 10 - self._default_validity_window_is_explicit: bool = default_validity_window is not None - self._app_manager = app_manager or AppManager(algod) - self._error_transformers: list[ErrorTransformer] = error_transformers or [] - - def _transform_error(self, original_error: Exception) -> Exception: - """Transform an error using registered error transformers. - - :param original_error: The original error to transform - :return: The transformed error or the original error if transformation fails - """ - transformed_exception: Exception = original_error - - for transformer in self._error_transformers: - try: - result = transformer(transformed_exception) - if not isinstance(result, Exception): - return InvalidErrorTransformerValueError(original_error, result) - transformed_exception = result - except Exception as error_from_transformer: - return ErrorTransformerError(original_error, error_from_transformer) - - return transformed_exception - - def register_error_transformer(self, transformer: ErrorTransformer) -> TransactionComposer: - """Register a function that will be used to transform an error caught when simulating or sending. - - :param transformer: The error transformer function - :return: The composer so you can chain method calls - """ + def register_error_transformer(self, transformer: ErrorTransformer) -> "TransactionComposer": self._error_transformers.append(transformer) return self - def add_transaction( - self, transaction: algosdk.transaction.Transaction, signer: TransactionSigner | None = None - ) -> TransactionComposer: - """Add a raw transaction to the composer. - - :param transaction: The transaction to add - :param signer: Optional transaction signer, defaults to getting signer from transaction sender - :return: The transaction composer instance for chaining - - :example: - >>> composer.add_transaction(transaction) - """ - self._txns.append(TransactionWithSigner(txn=transaction, signer=signer or self._get_signer(transaction.sender))) + def add_transaction(self, txn: Transaction, signer: TransactionSigner | None = None) -> "TransactionComposer": + validate_transaction(txn) + self._ensure_not_built() + self._queued.append(_QueuedTransaction(txn=self._sanitize_transaction(txn), signer=signer)) return self - def add_payment(self, params: PaymentParams) -> TransactionComposer: - """Add a payment transaction. - - :example: - >>> params = PaymentParams( - ... sender="SENDER_ADDRESS", - ... receiver="RECEIVER_ADDRESS", - ... amount=AlgoAmount.from_algo(1), - ... close_remainder_to="CLOSE_ADDRESS" - ... ... (see PaymentParams for more options) - ... ) - >>> composer.add_payment(params) - - :param params: The payment transaction parameters - :return: The transaction composer instance for chaining - """ - self._txns.append(params) + def add_payment(self, params: PaymentParams) -> "TransactionComposer": + self._ensure_not_built() + self._queued.append(_QueuedTransaction(txn=params, signer=params.signer)) return self - def add_asset_create(self, params: AssetCreateParams) -> TransactionComposer: - """Add an asset creation transaction. - - :example: - >>> params = AssetCreateParams( - ... sender="SENDER_ADDRESS", - ... total=1000, - ... asset_name="MyAsset", - ... unit_name="MA", - ... url="https://example.com", - ... decimals=0, - ... default_frozen=False, - ... manager="MANAGER_ADDRESS", - ... reserve="RESERVE_ADDRESS", - ... freeze="FREEZE_ADDRESS", - ... clawback="CLAWBACK_ADDRESS" - ... ... (see AssetCreateParams for more options) - >>> composer.add_asset_create(params) - - :param params: The asset creation parameters - :return: The transaction composer instance for chaining - """ - self._txns.append(params) + def add_asset_create(self, params: AssetCreateParams) -> "TransactionComposer": + self._ensure_not_built() + self._queued.append(_QueuedTransaction(txn=params, signer=params.signer)) return self - def add_asset_config(self, params: AssetConfigParams) -> TransactionComposer: - """Add an asset configuration transaction. - - :example: - >>> params = AssetConfigParams( - ... sender="SENDER_ADDRESS", - ... asset_id=123456, - ... manager="NEW_MANAGER_ADDRESS", - ... reserve="NEW_RESERVE_ADDRESS", - ... freeze="NEW_FREEZE_ADDRESS", - ... clawback="NEW_CLAWBACK_ADDRESS" - ... ... (see AssetConfigParams for more options) - ... ) - >>> composer.add_asset_config(params) - - :param params: The asset configuration parameters - :return: The transaction composer instance for chaining - """ - self._txns.append(params) + def add_asset_config(self, params: AssetConfigParams) -> "TransactionComposer": + self._ensure_not_built() + self._queued.append(_QueuedTransaction(txn=params, signer=params.signer)) return self - def add_asset_freeze(self, params: AssetFreezeParams) -> TransactionComposer: - """Add an asset freeze transaction. - - :example: - >>> params = AssetFreezeParams( - ... sender="SENDER_ADDRESS", - ... asset_id=123456, - ... account="ACCOUNT_TO_FREEZE", - ... frozen=True - ... ... (see AssetFreezeParams for more options) - ... ) - >>> composer.add_asset_freeze(params) - - :param params: The asset freeze parameters - :return: The transaction composer instance for chaining - """ - self._txns.append(params) + def add_asset_freeze(self, params: AssetFreezeParams) -> "TransactionComposer": + self._ensure_not_built() + self._queued.append(_QueuedTransaction(txn=params, signer=params.signer)) return self - def add_asset_destroy(self, params: AssetDestroyParams) -> TransactionComposer: - """Add an asset destruction transaction. - - :example: - >>> params = AssetDestroyParams( - ... sender="SENDER_ADDRESS", - ... asset_id=123456 - ... ... (see AssetDestroyParams for more options) - >>> composer.add_asset_destroy(params) - - :param params: The asset destruction parameters - :return: The transaction composer instance for chaining - """ - self._txns.append(params) + def add_asset_destroy(self, params: AssetDestroyParams) -> "TransactionComposer": + self._ensure_not_built() + self._queued.append(_QueuedTransaction(txn=params, signer=params.signer)) return self - def add_asset_transfer(self, params: AssetTransferParams) -> TransactionComposer: - """Add an asset transfer transaction. - - :example: - >>> params = AssetTransferParams( - ... sender="SENDER_ADDRESS", - ... asset_id=123456, - ... amount=10, - ... receiver="RECEIVER_ADDRESS", - ... clawback_target="CLAWBACK_TARGET_ADDRESS", - ... close_asset_to="CLOSE_ADDRESS" - ... ... (see AssetTransferParams for more options) - >>> composer.add_asset_transfer(params) - - :param params: The asset transfer parameters - :return: The transaction composer instance for chaining - """ - self._txns.append(params) + def add_asset_transfer(self, params: AssetTransferParams) -> "TransactionComposer": + self._ensure_not_built() + self._queued.append(_QueuedTransaction(txn=params, signer=params.signer)) return self - def add_asset_opt_in(self, params: AssetOptInParams) -> TransactionComposer: - """Add an asset opt-in transaction. - - :example: - >>> params = AssetOptInParams( - ... sender="SENDER_ADDRESS", - ... asset_id=123456 - ... ... (see AssetOptInParams for more options) - ... ) - >>> composer.add_asset_opt_in(params) - - :param params: The asset opt-in parameters - :return: The transaction composer instance for chaining - """ - self._txns.append(params) + def add_asset_opt_in(self, params: AssetOptInParams) -> "TransactionComposer": + self._ensure_not_built() + self._queued.append(_QueuedTransaction(txn=params, signer=params.signer)) return self - def add_asset_opt_out(self, params: AssetOptOutParams) -> TransactionComposer: - """Add an asset opt-out transaction. - - :example: - >>> params = AssetOptOutParams( - ... sender="SENDER_ADDRESS", - ... asset_id=123456, - ... creator="CREATOR_ADDRESS" - ... ... (see AssetOptOutParams for more options) - >>> composer.add_asset_opt_out(params) + def add_asset_opt_out(self, params: AssetOptOutParams) -> "TransactionComposer": + self._ensure_not_built() + self._queued.append(_QueuedTransaction(txn=params, signer=params.signer)) + return self - :param params: The asset opt-out parameters - :return: The transaction composer instance for chaining - """ - self._txns.append(params) + def add_app_create(self, params: AppCreateParams) -> "TransactionComposer": + self._ensure_not_built() + self._queued.append(_QueuedTransaction(txn=params, signer=params.signer)) return self - def add_app_create(self, params: AppCreateParams) -> TransactionComposer: - """Add an application creation transaction. - - :example: - >>> params = AppCreateParams( - ... sender="SENDER_ADDRESS", - ... approval_program="TEAL_APPROVAL_CODE", - ... clear_state_program="TEAL_CLEAR_CODE", - ... schema={'global_ints': 1, 'global_byte_slices': 1, 'local_ints': 1, 'local_byte_slices': 1}, - ... on_complete=OnComplete.NoOpOC, - ... args=[b'arg1'], - ... account_references=["ACCOUNT1"], - ... app_references=[789], - ... asset_references=[123], - ... box_references=[], - ... extra_program_pages=0 - ... ... (see AppCreateParams for more options) - ... ) - >>> composer.add_app_create(params) - - :param params: The application creation parameters - :return: The transaction composer instance for chaining - """ - self._txns.append(params) + def add_app_update(self, params: AppUpdateParams) -> "TransactionComposer": + self._ensure_not_built() + self._queued.append(_QueuedTransaction(txn=params, signer=params.signer)) return self - def add_app_update(self, params: AppUpdateParams) -> TransactionComposer: - """Add an application update transaction. - - :example: - >>> params = AppUpdateParams( - ... sender="SENDER_ADDRESS", - ... app_id=789, - ... approval_program="TEAL_NEW_APPROVAL_CODE", - ... clear_state_program="TEAL_NEW_CLEAR_CODE", - ... args=[b'new_arg1'], - ... account_references=["ACCOUNT1"], - ... app_references=[789], - ... asset_references=[123], - ... box_references=[], - ... on_complete=OnComplete.UpdateApplicationOC - ... ... (see AppUpdateParams for more options) - >>> composer.add_app_update(params) - - :param params: The application update parameters - :return: The transaction composer instance for chaining - """ - self._txns.append(params) + def add_app_delete(self, params: AppDeleteParams) -> "TransactionComposer": + self._ensure_not_built() + self._queued.append(_QueuedTransaction(txn=params, signer=params.signer)) return self - def add_app_delete(self, params: AppDeleteParams) -> TransactionComposer: - """Add an application deletion transaction. - - :example: - >>> params = AppDeleteParams( - ... sender="SENDER_ADDRESS", - ... app_id=789, - ... args=[b'delete_arg'], - ... account_references=["ACCOUNT1"], - ... app_references=[789], - ... asset_references=[123], - ... box_references=[], - ... on_complete=OnComplete.DeleteApplicationOC - ... ... (see AppDeleteParams for more options) - >>> composer.add_app_delete(params) - - :param params: The application deletion parameters - :return: The transaction composer instance for chaining - """ - self._txns.append(params) + def add_app_call(self, params: AppCallParams) -> "TransactionComposer": + self._ensure_not_built() + self._queued.append(_QueuedTransaction(txn=params, signer=params.signer)) return self - def add_app_call(self, params: AppCallParams) -> TransactionComposer: - """Add an application call transaction. - - :example: - >>> params = AppCallParams( - ... sender="SENDER_ADDRESS", - ... on_complete=OnComplete.NoOpOC, - ... app_id=789, - ... approval_program="TEAL_APPROVAL_CODE", - ... clear_state_program="TEAL_CLEAR_CODE", - ... schema={'global_ints': 1, 'global_byte_slices': 1, 'local_ints': 1, 'local_byte_slices': 1}, - ... ... (see AppCallParams for more options) - ... ) - >>> composer.add_app_call(params) - - :param params: The application call parameters - :return: The transaction composer instance for chaining - """ - self._txns.append(params) + def add_app_create_method_call(self, params: AppCreateMethodCallParams) -> "TransactionComposer": + self._ensure_not_built() + self._queued.append(_QueuedTransaction(txn=params, signer=params.signer)) return self - def add_app_create_method_call(self, params: AppCreateMethodCallParams) -> TransactionComposer: - """Add an application creation method call transaction. - - :param params: The application creation method call parameters - :return: The transaction composer instance for chaining - - :example: - >>> # Basic example - >>> method = algosdk.abi.Method( - ... name="method", - ... args=[...], - ... returns="string" - ... ) - >>> composer.add_app_create_method_call( - ... AppCreateMethodCallParams( - ... sender="CREATORADDRESS", - ... approval_program="TEALCODE", - ... clear_state_program="TEALCODE", - ... method=method, - ... args=["arg1_value"] - ... ) - ... ) - >>> - >>> # Advanced example - >>> method = ABIMethod( - ... name="method", - ... args=[{"name": "arg1", "type": "string"}], - ... returns={"type": "string"} - ... ) - >>> composer.add_app_create_method_call( - ... AppCreateMethodCallParams( - ... sender="CREATORADDRESS", - ... method=method, - ... args=["arg1_value"], - ... approval_program="TEALCODE", - ... clear_state_program="TEALCODE", - ... schema={ - ... "global_ints": 1, - ... "global_byte_slices": 2, - ... "local_ints": 3, - ... "local_byte_slices": 4 - ... }, - ... extra_pages=1, - ... on_complete=OnComplete.OptInOC, - ... args=[bytes([1, 2, 3, 4])], - ... account_references=["ACCOUNT_1"], - ... app_references=[123, 1234], - ... asset_references=[12345], - ... box_references=["box1", {"app_id": 1234, "name": "box2"}], - ... lease="lease", - ... note="note", - ... first_valid_round=1000, - ... validity_window=10, - ... extra_fee=AlgoAmount.from_micro_algos(1000), - ... static_fee=AlgoAmount.from_micro_algos(1000), - ... max_fee=AlgoAmount.from_micro_algos(3000) - ... ) - ... ) - """ - self._txns.append(params) + def add_app_update_method_call(self, params: AppUpdateMethodCallParams) -> "TransactionComposer": + self._ensure_not_built() + self._queued.append(_QueuedTransaction(txn=params, signer=params.signer)) return self - def add_app_update_method_call(self, params: AppUpdateMethodCallParams) -> TransactionComposer: - """Add an application update method call transaction. + def add_app_delete_method_call(self, params: AppDeleteMethodCallParams) -> "TransactionComposer": + self._ensure_not_built() + self._queued.append(_QueuedTransaction(txn=params, signer=params.signer)) + return self - :param params: The application update method call parameters - :return: The transaction composer instance for chaining - """ - self._txns.append(params) + def add_app_call_method_call(self, params: AppCallMethodCallParams) -> "TransactionComposer": + self._ensure_not_built() + self._queued.append(_QueuedTransaction(txn=params, signer=params.signer)) return self - def add_app_delete_method_call(self, params: AppDeleteMethodCallParams) -> TransactionComposer: - """Add an application deletion method call transaction. + def add_online_key_registration(self, params: OnlineKeyRegistrationParams) -> "TransactionComposer": + self._ensure_not_built() + self._queued.append(_QueuedTransaction(txn=params, signer=params.signer)) + return self - :param params: The application deletion method call parameters - :return: The transaction composer instance for chaining - """ - self._txns.append(params) + def add_offline_key_registration(self, params: OfflineKeyRegistrationParams) -> "TransactionComposer": + self._ensure_not_built() + self._queued.append(_QueuedTransaction(txn=params, signer=params.signer)) return self - def add_app_call_method_call(self, params: AppCallMethodCallParams) -> TransactionComposer: - """Add an application call method call transaction. + def count(self) -> int: + return len(self._queued) - :param params: The application call method call parameters - :return: The transaction composer instance for chaining - """ - self._txns.append(params) - return self + def rebuild(self) -> BuiltTransactions: + self._transactions_with_signers = None + self._signed_transactions = None + self._raw_built_transactions = None + return self.build() - def add_online_key_registration(self, params: OnlineKeyRegistrationParams) -> TransactionComposer: - """Add an online key registration transaction. + @staticmethod + def arc2_note(note: Arc2TransactionNote) -> bytes: + pattern = r"^[a-zA-Z0-9][a-zA-Z0-9_/@.-]{4,31}$" + if not re.match(pattern, note["dapp_name"]): + raise ValueError( + "dapp_name must be 5-32 chars, start with alphanumeric, and contain only alphanumeric, _, /, @, ., or -" + ) - :param params: The online key registration parameters - :return: The transaction composer instance for chaining - """ - self._txns.append(params) - return self + data = note["data"] + if note["format"] == "j" and isinstance(data, (dict | list)): + data = json.dumps(data) - def add_offline_key_registration(self, params: OfflineKeyRegistrationParams) -> TransactionComposer: - """Add an offline key registration transaction. + arc2_payload = f"{note['dapp_name']}:{note['format']}{data}" + return arc2_payload.encode("utf-8") - :param params: The offline key registration parameters - :return: The transaction composer instance for chaining - """ - self._txns.append(params) + def add_transaction_composer(self, composer: "TransactionComposer") -> "TransactionComposer": + self._ensure_not_built() + current_size = len(self._queued) + composer_size = len(composer._queued) # noqa: SLF001 + new_size = current_size + composer_size + if new_size > MAX_TRANSACTION_GROUP_SIZE: + raise ValueError( + "Adding transactions from composer would exceed the maximum group size. " + f"Current: {current_size}, Adding: {composer_size}, " + f"Maximum: {MAX_TRANSACTION_GROUP_SIZE}" + ) + for entry in composer._queued: # noqa: SLF001 + self._queued.append(self._clone_entry(entry)) return self - def add_atc(self, atc: AtomicTransactionComposer) -> TransactionComposer: - """Add an existing AtomicTransactionComposer's transactions. + def build(self) -> BuiltTransactions: + """Build transactions with grouping, resource population, and fee adjustments applied.""" + self._ensure_built() + assert self._transactions_with_signers is not None + transactions = [entry.txn for entry in self._transactions_with_signers] + signers = {index: entry.signer for index, entry in enumerate(self._transactions_with_signers)} + method_calls = { + index: entry.method for index, entry in enumerate(self._transactions_with_signers) if entry.method + } + return BuiltTransactions(transactions=transactions, method_calls=method_calls, signers=signers) - :param atc: The AtomicTransactionComposer to add - :return: The transaction composer instance for chaining + def build_transactions(self) -> BuiltTransactions: + """Build queued transactions without resource population or grouping. - :example: - >>> atc = AtomicTransactionComposer() - >>> atc.add_transaction(TransactionWithSigner(transaction, signer)) - >>> composer.add_atc(atc) + Returns raw transactions, method call metadata, and any explicit signers. This does not + populate unnamed resources or adjust fees, and it leaves grouping unchanged. """ - self._txns.append(atc) - return self + if not self._queued: + raise ValueError("Cannot build an empty transaction group") - def count(self) -> int: - """Get the total number of transactions. + suggested_params = self._get_suggested_params() + genesis_id = getattr(suggested_params, "genesis_id", None) + if genesis_id is None: + genesis_id = getattr(suggested_params, "gen", "") + is_localnet = ClientManager.genesis_id_is_localnet(genesis_id or "") + + built_entries, method_calls = self._build_txn_specs(suggested_params, is_localnet=is_localnet) + transactions = [entry.txn for entry in built_entries] + self._raw_built_transactions = list(transactions) + signers = {index: entry.signer for index, entry in enumerate(built_entries) if entry.signer is not None} + return BuiltTransactions(transactions=transactions, method_calls=method_calls, signers=signers) - :return: The number of transactions - """ - return len(self.build_transactions().transactions) + def gather_signatures(self) -> list[bytes]: + self._ensure_built() + if self._signed_transactions is None: + self._signed_transactions = self._sign_transactions(self._transactions_with_signers or []) + return self._signed_transactions - def build(self) -> TransactionComposerBuildResult: - """Build the transaction group. + def send(self, params: SendParams | None = None) -> SendTransactionComposerResults: + """Compose the transaction group and send it to the network.""" + params = params or SendParams() - :return: The built transaction group result - """ - if self._atc.get_status() == algosdk.atomic_transaction_composer.AtomicTransactionComposerStatus.BUILDING: - suggested_params = self._get_suggested_params() - txn_with_signers: list[TransactionWithSignerAndContext] = [] - - for txn in self._txns: - txn_with_signers.extend(self._build_txn(txn, suggested_params, include_signer=True)) - - for ts in txn_with_signers: - self._atc.add_transaction(ts) - if ts.context.abi_method: - self._atc.method_dict[len(self._atc.txn_list) - 1] = ts.context.abi_method - if ts.context.max_fee: - self._txn_max_fees[len(self._atc.txn_list) - 1] = ts.context.max_fee - - return TransactionComposerBuildResult( - atc=self._atc, - transactions=self._atc.build_group(), - method_calls=self._atc.method_dict, + # Update config from params if provided, falling back to composer's config + effective_cover = params.get( + "cover_app_call_inner_transaction_fees", self._config.cover_app_call_inner_transaction_fees ) + effective_populate = params.get("populate_app_call_resources", self._config.populate_app_call_resources) - def rebuild(self) -> TransactionComposerBuildResult: - """Rebuild the transaction group from scratch. - - :return: The rebuilt transaction group result - """ - self._atc = AtomicTransactionComposer() - return self.build() - - def build_transactions(self) -> BuiltTransactions: - """Build and return the transactions without executing them. + if ( + effective_cover != self._config.cover_app_call_inner_transaction_fees + or effective_populate != self._config.populate_app_call_resources + ): + self._config = TransactionComposerConfig( + cover_app_call_inner_transaction_fees=effective_cover, + populate_app_call_resources=effective_populate, + ) + # Reset built state to force rebuild with new config + self._transactions_with_signers = None + self._signed_transactions = None + self._raw_built_transactions = None - :return: The built transactions result - """ - suggested_params = self._get_suggested_params() + # Build and sign transactions - let validation errors bubble up as-is + signed_transactions = self.gather_signatures() - transactions: list[algosdk.transaction.Transaction] = [] - method_calls: dict[int, Method] = {} - signers: dict[int, TransactionSigner] = {} + if config.debug and config.trace_all and config.project_root: + try: + self.simulate(result_on_failure=True) + except Exception: + config.logger.debug( + "Failed to simulate and persist trace for debugging", + exc_info=True, + extra={"suppress_log": params.get("suppress_log")}, + ) - idx = 0 + # Send transactions and handle network errors + try: + self._algod.send_raw_transaction(signed_transactions) + + tx_ids = [get_transaction_id(entry.txn) for entry in self._transactions_with_signers or []] + group_id = self._group_id() + if not params.get("suppress_log") and tx_ids: + if len(tx_ids) > 1: + config.logger.info( + "Sent group of %s transactions (%s)", + len(tx_ids), + group_id or "no-group", + extra={"suppress_log": params.get("suppress_log")}, + ) + config.logger.debug( + "Transaction IDs (%s): %s", + group_id or "no-group", + tx_ids, + extra={"suppress_log": params.get("suppress_log")}, + ) + else: + txn = (self._transactions_with_signers or [])[0].txn + config.logger.info( + "Sent transaction ID %s %s from %s", + tx_ids[0], + txn.transaction_type, + txn.sender, + extra={"suppress_log": params.get("suppress_log")}, + ) + confirmations = self._wait_for_confirmations(tx_ids, params) + abi_returns = self._parse_abi_return_values(confirmations) + return SendTransactionComposerResults( + tx_ids=tx_ids, + transactions=[entry.txn for entry in self._transactions_with_signers or []], + confirmations=confirmations, + returns=abi_returns, + group_id=group_id, + ) + except Exception as err: + sent_transactions = self._resolve_error_transactions() + simulate_response: algod_models.SimulateResponse | None = None + traces: list[SimulateTransactionResult] = [] + + if config.debug and sent_transactions: + simulate_response, traces = self._simulate_error_context( + sent_transactions, + suppress_log=params.get("suppress_log"), + ) - for txn in self._txns: - txn_with_signers: list[TransactionWithSigner] = [] + if config.debug and config.project_root and not config.trace_all and simulate_response is None: + from algokit_utils._debugging import simulate_and_persist_response - if isinstance(txn, MethodCallParams): - txn_with_signers.extend(self._build_method_call(txn, suggested_params, include_signer=False)) - else: - txn_with_signers.extend(self._build_txn(txn, suggested_params, include_signer=False)) - - for ts in txn_with_signers: - transactions.append(ts.txn) - if ts.signer and ts.signer != NULL_SIGNER: - signers[idx] = ts.signer - if isinstance(ts, TransactionWithSignerAndContext) and ts.context.abi_method: - method_calls[idx] = ts.context.abi_method - if ts.context.max_fee: - self._txn_max_fees[idx] = ts.context.max_fee - idx += 1 + try: + simulate_and_persist_response( + self, + config.project_root, + self._algod, + buffer_size_mb=config.trace_buffer_size_mb, + ) + except Exception: + config.logger.debug( + "Failed to simulate and persist trace for debugging", + exc_info=True, + extra={"suppress_log": params.get("suppress_log")}, + ) - return BuiltTransactions(transactions=transactions, method_calls=method_calls, signers=signers) + interpreted = self._interpret_error(err) + composer_error = self._create_composer_error(interpreted, sent_transactions, simulate_response, traces) + raise self._transform_error(composer_error) from err - @deprecated("Use send() instead") - def execute( + def simulate( self, *, - max_rounds_to_wait: int | None = None, - ) -> SendAtomicTransactionComposerResults: - return self.send(SendParams(max_rounds_to_wait=max_rounds_to_wait)) - - def send( - self, - params: SendParams | None = None, - ) -> SendAtomicTransactionComposerResults: - """Send the transaction group to the network. - - :param params: Parameters for the send operation - :return: The transaction send results - :raises self._transform_error: If the transaction fails (may be transformed by error transformers) + skip_signatures: bool = False, + result_on_failure: bool = False, + **raw_options: Any, + ) -> SendTransactionComposerResults: + """Compose the transaction group and simulate execution without submitting to the network. + + Args: + skip_signatures: Whether to skip signatures for all built transactions and use an empty signer instead. + This will set `allow_empty_signatures` and `fix_signers` when sending the request to algod. + result_on_failure: Whether to return the result on simulation failure instead of throwing an error. + Defaults to False (throws on failure). + **raw_options: Additional options to pass to the simulate request. + + Returns: + SendTransactionComposerResults containing simulation results. """ - group = self.build().transactions + try: + persist_trace = bool(raw_options.pop("_persist_trace", True)) + txns_with_signers: list[TransactionWithSigner] + if "throw_on_failure" in raw_options: + raw_options.pop("throw_on_failure") + effective_throw_on_failure = not result_on_failure + if skip_signatures: + raw_options.setdefault("allow_empty_signatures", True) + raw_options.setdefault("fix_signers", True) + if "allow_more_logs" in raw_options: + raw_options["allow_more_logging"] = raw_options.pop("allow_more_logs") + if "simulation_round" in raw_options: + raw_options["round_"] = raw_options.pop("simulation_round") + + txns_with_signers = self._build_transactions_for_simulation() + + if config.debug: + raw_options.setdefault("allow_more_logging", True) + raw_options.setdefault( + "exec_trace_config", + algod_models.SimulateTraceConfig( + enable=True, + scratch_change=True, + stack_change=True, + state_change=True, + ), + ) - if not params: - params = SendParams() + empty_signer: TransactionSigner = make_empty_transaction_signer() + signing_entries = [ + TransactionWithSigner( + txn=entry.txn, + signer=empty_signer if skip_signatures else entry.signer, + ) + for entry in txns_with_signers + ] + encoded_signed_transactions = self._sign_transactions(signing_entries) + signed_transactions = decode_signed_transactions(encoded_signed_transactions) + + request = algod_models.SimulateRequest( + txn_groups=[algod_models.SimulateRequestTransactionGroup(txns=signed_transactions)], + **raw_options, + ) + response = self._algod.simulate_transactions(request) + + if response.txn_groups and response.txn_groups[0].failure_message and effective_throw_on_failure: + raise RuntimeError(response.txn_groups[0].failure_message) + + tx_ids = [get_transaction_id(entry.txn) for entry in txns_with_signers] + group = response.txn_groups[0] if response.txn_groups else None + confirmations = [result.txn_result for result in (group.txn_results if group else [])] + method_calls = {index: entry.method for index, entry in enumerate(txns_with_signers) if entry.method} + abi_returns = self._parse_abi_return_values(confirmations, method_calls) + result = SendTransactionComposerResults( + tx_ids=tx_ids, + transactions=[entry.txn for entry in txns_with_signers], + confirmations=confirmations, + returns=abi_returns, + group_id=( + base64.b64encode(txns_with_signers[0].txn.group).decode() + if txns_with_signers and txns_with_signers[0].txn.group + else None + ), + simulate_response=response, + ) - cover_app_call_inner_transaction_fees = params.get("cover_app_call_inner_transaction_fees") - populate_app_call_resources = params.get("populate_app_call_resources") - wait_rounds = params.get("max_rounds_to_wait") - sp = self._get_suggested_params() if not wait_rounds or cover_app_call_inner_transaction_fees else None + if config.debug and config.project_root and config.trace_all and persist_trace: + from algokit_utils._debugging import simulate_and_persist_response - if wait_rounds is None: - last_round = max(txn.txn.last_valid_round for txn in group) - assert sp is not None - first_round = sp.first - wait_rounds = last_round - first_round + 1 + try: + simulate_and_persist_response( + self, + config.project_root, + self._algod, + buffer_size_mb=config.trace_buffer_size_mb, + result=result, + ) + except Exception: + config.logger.debug("Failed to persist simulation trace", exc_info=True) - try: - return send_atomic_transaction_composer( - self._atc, - self._algod, - max_rounds_to_wait=wait_rounds, - suppress_log=params.get("suppress_log"), - populate_app_call_resources=populate_app_call_resources, - cover_app_call_inner_transaction_fees=cover_app_call_inner_transaction_fees, - additional_atc_context=AdditionalAtcContext( - suggested_params=sp, - max_fees=self._txn_max_fees, - ), - ) - except Exception as original_error: - raise self._transform_error(original_error) from original_error - - def _handle_simulate_error(self, simulate_response: SimulateAtomicTransactionResponse) -> None: - # const failedGroup = simulateResponse?.txnGroups[0] - failed_group = simulate_response.simulate_response.get("txn-groups", [{}])[0] - failure_message = failed_group.get("failure-message") - failed_at = [str(x) for x in failed_group.get("failed-at", [])] - if failure_message: - error_message = ( - f"Transaction failed at transaction(s) {', '.join(failed_at) if failed_at else 'N/A'} in the group. " - f"{failure_message}" - ) - original_error = Exception(error_message) - raise self._transform_error(original_error) from original_error + return result + except Exception as err: + interpreted = self._interpret_error(err) + raise self._transform_error(interpreted) from err - def simulate( + def _ensure_not_built(self) -> None: + if self._transactions_with_signers is not None: + raise RuntimeError("Transactions have already been built") + if len(self._queued) >= MAX_TRANSACTION_GROUP_SIZE: + raise ValueError("Transaction group size exceeds maximum limit") + + def _build_txn_specs( self, - allow_more_logs: bool | None = None, - allow_empty_signatures: bool | None = None, - allow_unnamed_resources: bool | None = None, - extra_opcode_budget: int | None = None, - exec_trace_config: SimulateTraceConfig | None = None, - simulation_round: int | None = None, - skip_signatures: bool | None = None, - ) -> SendAtomicTransactionComposerResults: - """Simulate transaction group execution with configurable validation rules. - - :param allow_more_logs: Whether to allow more logs than the standard limit - :param allow_empty_signatures: Whether to allow transactions with empty signatures - :param allow_unnamed_resources: Whether to allow unnamed resources. - :param extra_opcode_budget: Additional opcode budget to allocate - :param exec_trace_config: Configuration for execution tracing - :param simulation_round: Round number to simulate at - :param skip_signatures: Whether to skip signature validation - :return: The simulation results - - :example: - >>> result = composer.simulate(extra_opcode_budget=1000, skip_signatures=True, ...) - """ - from algokit_utils._debugging import simulate_and_persist_response, simulate_response + suggested_params: algod_models.SuggestedParams, + *, + is_localnet: bool, + ) -> tuple[list[_BuiltTxnSpec], dict[int, ABIMethod]]: + if not self._queued: + raise ValueError("Cannot build an empty transaction group") + + built_entries: list[_BuiltTxnSpec] = [] + method_calls: dict[int, ABIMethod] = {} + + for entry in self._queued: + sender = entry.txn.sender if hasattr(entry.txn, "sender") else None + override_signer = self._resolve_param_signer(entry.signer, sender) + if isinstance(entry.txn, Transaction): + txn = self._sanitize_transaction(entry.txn) + built_entries.append( + _BuiltTxnSpec(txn=txn, signer=override_signer, logical_max_fee=entry.max_fee, method=None) + ) + continue - atc = AtomicTransactionComposer() if skip_signatures else self._atc + specs = self._build_txn_from_params(entry.txn, suggested_params, is_localnet=is_localnet) + for spec in specs: + resolved_signer = spec.signer or override_signer + if resolved_signer is None: + raise ValueError("Signer is required for transaction in composer queue") + index = len(built_entries) + built_entries.append( + _BuiltTxnSpec( + txn=self._sanitize_transaction(spec.txn), + signer=resolved_signer, + logical_max_fee=spec.logical_max_fee, + method=spec.method, + ) + ) + if spec.method: + method_calls[index] = spec.method - if skip_signatures: - allow_empty_signatures = True - transactions = self.build_transactions() - for txn in transactions.transactions: - atc.add_transaction(TransactionWithSigner(txn=txn, signer=NULL_SIGNER)) - atc.method_dict = transactions.method_calls - else: - self.build() - - if config.debug and config.project_root and config.trace_all: - response = simulate_and_persist_response( - atc, - config.project_root, - self._algod, - config.trace_buffer_size_mb, - allow_more_logs, - allow_empty_signatures, - allow_unnamed_resources, - extra_opcode_budget, - exec_trace_config, - simulation_round, + return built_entries, method_calls + + def _ensure_built(self) -> None: + if self._transactions_with_signers is not None: + return + + suggested_params = self._get_suggested_params() + genesis_id = getattr(suggested_params, "genesis_id", None) + if genesis_id is None: + genesis_id = getattr(suggested_params, "gen", "") + is_localnet = ClientManager.genesis_id_is_localnet(genesis_id or "") + + built_entries, method_calls = self._build_txn_specs(suggested_params, is_localnet=is_localnet) + transactions = [entry.txn for entry in built_entries] + self._raw_built_transactions = list(transactions) + logical_max_fees = [entry.logical_max_fee for entry in built_entries] + + needs_analysis = ( + self._config.cover_app_call_inner_transaction_fees or self._config.populate_app_call_resources + ) and any(txn.transaction_type == TransactionType.AppCall for txn in transactions) + if needs_analysis: + group_analysis = self._analyze_group_requirements( + transactions, + logical_max_fees, + suggested_params, + self._config, ) - self._handle_simulate_error(response) - return SendAtomicTransactionComposerResults( - confirmations=response.simulate_response.get("txn-groups", [{"txn-results": [{"txn-result": {}}]}])[0][ - "txn-results" - ], - transactions=[TransactionWrapper(txn.txn) for txn in atc.txn_list], - tx_ids=response.tx_ids, - group_id=atc.txn_list[-1].txn.group or "", - simulate_response=response.simulate_response, - returns=[ABIReturn(r) for r in response.abi_results], + self._populate_transaction_and_group_resources(transactions, group_analysis, logical_max_fees) + + grouped = group_transactions(transactions) + self._transactions_with_signers = [ + TransactionWithSigner( + txn=grouped[index], + signer=cast(TransactionSigner, entry.signer), + method=method_calls.get(index), ) - - response = simulate_response( - atc, - self._algod, - allow_more_logs, - allow_empty_signatures, - allow_unnamed_resources, - extra_opcode_budget, - exec_trace_config, - simulation_round, - ) - self._handle_simulate_error(response) - confirmation_results = response.simulate_response.get("txn-groups", [{"txn-results": [{"txn-result": {}}]}])[0][ - "txn-results" + for index, entry in enumerate(built_entries) ] - return SendAtomicTransactionComposerResults( - confirmations=[txn["txn-result"] for txn in confirmation_results], - transactions=[TransactionWrapper(txn.txn) for txn in atc.txn_list], - tx_ids=response.tx_ids, - group_id=atc.txn_list[-1].txn.group or "", - simulate_response=response.simulate_response, - returns=[ABIReturn(r) for r in response.abi_results], - ) - - @staticmethod - def arc2_note(note: Arc2TransactionNote) -> bytes: - """Create an encoded transaction note that follows the ARC-2 spec. + def _build_transactions_for_simulation(self) -> list[TransactionWithSigner]: + if self._transactions_with_signers is None: + suggested_params = self._get_suggested_params() + genesis_id = getattr(suggested_params, "genesis_id", None) + if genesis_id is None: + genesis_id = getattr(suggested_params, "gen", "") + is_localnet = ClientManager.genesis_id_is_localnet(genesis_id or "") + + built_entries, method_calls = self._build_txn_specs(suggested_params, is_localnet=is_localnet) + transactions = [entry.txn for entry in built_entries] + if len(transactions) > 1: + transactions = group_transactions(transactions) + return [ + TransactionWithSigner( + txn=transactions[index], + signer=cast(TransactionSigner, entry.signer), + method=method_calls.get(index), + ) + for index, entry in enumerate(built_entries) + ] - https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0002.md + return self._transactions_with_signers - :param note: The ARC-2 note to encode - :return: The encoded note bytes - :raises ValueError: If the dapp_name is invalid - """ + def _analyze_group_requirements( # noqa: C901, PLR0912, PLR0915 + self, + transactions: list[Transaction], + logical_max_fees: Sequence[AlgoAmount | None], + suggested_params: algod_models.SuggestedParams, + config: TransactionComposerConfig, + ) -> _GroupAnalysis: + app_call_indexes_without_max_fees: list[int] = [] + transactions_to_simulate: list[Transaction] = [] + for index, txn in enumerate(transactions): + txn_to_simulate = replace(txn, group=None) + if config.cover_app_call_inner_transaction_fees and txn.transaction_type == TransactionType.AppCall: + logical_max_fee = logical_max_fees[index] + if logical_max_fee is None: + app_call_indexes_without_max_fees.append(index) + else: + txn_to_simulate = replace(txn_to_simulate, fee=logical_max_fee.micro_algo) + transactions_to_simulate.append(txn_to_simulate) - pattern = r"^[a-zA-Z0-9][a-zA-Z0-9_/@.-]{4,31}$" - if not re.match(pattern, note["dapp_name"]): + if config.cover_app_call_inner_transaction_fees and app_call_indexes_without_max_fees: + indexes = ", ".join(str(index) for index in app_call_indexes_without_max_fees) raise ValueError( - "dapp_name must be 5-32 chars, start with alphanumeric, and contain only alphanumeric, _, /, @, ., or -" + "Please provide a `max_fee` for each app call transaction when " + "cover_app_call_inner_transaction_fees is enabled. " + f"Required for transaction {indexes}" ) - data = note["data"] - if note["format"] == "j" and isinstance(data, (dict | list)): - # Ensure JSON data uses double quotes - data = json.dumps(data) + if len(transactions_to_simulate) > 1: + transactions_to_simulate = group_transactions(transactions_to_simulate) - arc2_payload = f"{note['dapp_name']}:{note['format']}{data}" - return arc2_payload.encode("utf-8") + empty_signer: TransactionSigner = make_empty_transaction_signer() + encoded_signed_transactions = self._sign_transactions( + [TransactionWithSigner(txn=txn, signer=empty_signer) for txn in transactions_to_simulate] + ) + signed_transactions = decode_signed_transactions(encoded_signed_transactions) + + simulate_request = algod_models.SimulateRequest( + txn_groups=[algod_models.SimulateRequestTransactionGroup(txns=signed_transactions)], + allow_unnamed_resources=True, + allow_empty_signatures=True, + fix_signers=True, + allow_more_logging=True, + exec_trace_config=algod_models.SimulateTraceConfig( + enable=True, + scratch_change=True, + stack_change=True, + state_change=True, + ), + ) - def _build_atc(self, atc: AtomicTransactionComposer) -> list[TransactionWithSignerAndContext]: - group = atc.build_group() - - txn_with_signers = [] - for idx, ts in enumerate(group): - ts.txn.group = None - if atc.method_dict.get(idx): - txn_with_signers.append( - TransactionWithSignerAndContext( - txn=ts.txn, - signer=ts.signer, - context=TransactionContext(abi_method=atc.method_dict.get(idx)), - ) + response = self._algod.simulate_transactions(simulate_request) + group_response = response.txn_groups[0] + + if group_response.failure_message: + if config.cover_app_call_inner_transaction_fees and "too small" in group_response.failure_message: + raise ValueError( + "Fees were too small to resolve execution info via simulate. " + "You may need to increase an app call transaction maxFee." ) - else: - txn_with_signers.append( - TransactionWithSignerAndContext( - txn=ts.txn, - signer=ts.signer, - context=TransactionContext(abi_method=None), + raise ValueError( + "Error resolving execution info via simulate in transaction " + f"{group_response.failed_at or []}: {group_response.failure_message}" + ) + + txn_analysis_results: list[_TransactionAnalysis] = [] + for index, simulate_txn_result in enumerate(group_response.txn_results): + txn = transactions[index] + required_fee_delta: FeeDelta | None = None + if config.cover_app_call_inner_transaction_fees: + min_txn_fee = calculate_fee(txn, fee_per_byte=suggested_params.fee, min_fee=suggested_params.min_fee) + txn_fee = txn.fee or 0 + txn_fee_delta = FeeDelta.from_int(min_txn_fee - txn_fee) + if txn.transaction_type == TransactionType.AppCall: + inner_delta = calculate_inner_fee_delta( + simulate_txn_result.txn_result.inner_txns, suggested_params.min_fee ) + required_fee_delta = FeeDelta.add(inner_delta, txn_fee_delta) + else: + required_fee_delta = txn_fee_delta + + unnamed_resources = ( + simulate_txn_result.unnamed_resources_accessed if config.populate_app_call_resources else None + ) + + # Sort transaction-level resources for deterministic ordering + if unnamed_resources: + if unnamed_resources.accounts: + unnamed_resources.accounts = sorted(unnamed_resources.accounts) + if unnamed_resources.assets: + unnamed_resources.assets = sorted(unnamed_resources.assets) + if unnamed_resources.apps: + unnamed_resources.apps = sorted(unnamed_resources.apps) + + txn_analysis_results.append( + _TransactionAnalysis( + required_fee_delta=required_fee_delta, + unnamed_resources_accessed=unnamed_resources, ) + ) - return txn_with_signers + group_resources = group_response.unnamed_resources_accessed if config.populate_app_call_resources else None + if group_resources: + group_resources.accounts = sorted(group_resources.accounts or []) + group_resources.assets = sorted(group_resources.assets or []) + group_resources.apps = sorted(group_resources.apps or []) + group_resources.boxes = sorted( + group_resources.boxes or [], + key=lambda box: (box.app_id, box.name), + ) + group_resources.app_locals = sorted( + group_resources.app_locals or [], + key=lambda entry: (entry.app_id, entry.address), + ) + group_resources.asset_holdings = sorted( + group_resources.asset_holdings or [], + key=lambda entry: (entry.asset_id, entry.address), + ) + + return _GroupAnalysis(transactions=txn_analysis_results, unnamed_resources_accessed=group_resources) - def _common_txn_build_step( # noqa: C901 + def _populate_transaction_and_group_resources( # noqa: C901, PLR0912, PLR0915 self, - build_txn: Callable[[dict], algosdk.transaction.Transaction], - params: _CommonTxnParams, - txn_params: dict, - ) -> TransactionWithContext: - # Clone suggested params - txn_params["sp"] = ( - algosdk.transaction.SuggestedParams(**txn_params["sp"].__dict__) if "sp" in txn_params else None - ) + transactions: list[Transaction], + group_analysis: _GroupAnalysis, + logical_max_fees: Sequence[AlgoAmount | None], + ) -> None: + if not group_analysis: + return + + surplus_group_fees = 0 + transaction_analysis_list: list[dict[str, Any]] = [] + + for group_index, txn_analysis in enumerate(group_analysis.transactions): + fee_delta = txn_analysis.required_fee_delta + if fee_delta and FeeDelta.is_surplus(fee_delta): + surplus_group_fees += FeeDelta.amount(fee_delta) + + txn = transactions[group_index] + max_fee_source = logical_max_fees[group_index] + max_fee_amount: int | None + if max_fee_source is not None: + max_fee_amount = max_fee_source.micro_algo + elif not self._config.cover_app_call_inner_transaction_fees: + txn_fee = txn.fee or 0 + max_fee_amount = txn_fee if txn_fee > 0 else None + else: + max_fee_amount = None + is_immutable_fee = max_fee_amount is not None and max_fee_amount == (txn.fee or 0) + + priority = FeePriority.Covered + if fee_delta and FeeDelta.is_deficit(fee_delta): + deficit_amount = FeeDelta.amount(fee_delta) + if is_immutable_fee or txn.transaction_type != TransactionType.AppCall: + priority = FeePriority.ImmutableDeficit(deficit_amount) + else: + priority = FeePriority.ModifiableDeficit(deficit_amount) + + transaction_analysis_list.append( + { + "group_index": group_index, + "required_fee_delta": fee_delta, + "priority": priority, + "unnamed_resources_accessed": txn_analysis.unnamed_resources_accessed, + "logical_max_fee": max_fee_amount, + } + ) - if params.lease: - txn_params["lease"] = _encode_lease(params.lease) - if params.rekey_to: - txn_params["rekey_to"] = params.rekey_to - if params.note: - txn_params["note"] = params.note + transaction_analysis_list.sort(key=lambda item: item["priority"], reverse=True) + indexes_with_access_references: list[int] = [] - if txn_params["sp"]: - if params.first_valid_round: - txn_params["sp"].first = params.first_valid_round + for item in transaction_analysis_list: + group_index = item["group_index"] + logical_max_fee = item["logical_max_fee"] + required_fee_delta: FeeDelta | None = item["required_fee_delta"] + unnamed_resources_accessed = item["unnamed_resources_accessed"] - if params.last_valid_round: - txn_params["sp"].last = params.last_valid_round - else: - # If the validity window isn't set in this transaction or by default and we are pointing at - # LocalNet set a bigger window to avoid dead transactions - from algokit_utils.clients import ClientManager - - is_localnet = ClientManager.genesis_id_is_localnet(txn_params["sp"].gen) - window = params.validity_window or ( - 1000 - if is_localnet and not self._default_validity_window_is_explicit - else self._default_validity_window - ) - txn_params["sp"].last = txn_params["sp"].first + window + if required_fee_delta and FeeDelta.is_deficit(required_fee_delta): + deficit_amount = FeeDelta.amount(required_fee_delta) + additional_fee_delta: FeeDelta | None - if params.static_fee is not None and txn_params["sp"]: - txn_params["sp"].fee = params.static_fee.micro_algo - txn_params["sp"].flat_fee = True + if surplus_group_fees == 0: + additional_fee_delta = required_fee_delta + elif surplus_group_fees >= deficit_amount: + surplus_group_fees -= deficit_amount + additional_fee_delta = None + else: + additional_fee_delta = FeeDelta.from_int(deficit_amount - surplus_group_fees) + surplus_group_fees = 0 - if isinstance(txn_params.get("method"), Arc56Method): - txn_params["method"] = txn_params["method"].to_abi_method() + if additional_fee_delta and FeeDelta.is_deficit(additional_fee_delta): + additional_deficit_amount = FeeDelta.amount(additional_fee_delta) + txn = transactions[group_index] - txn = build_txn(txn_params) + if txn.transaction_type != TransactionType.AppCall: + raise ValueError( + "An additional fee of " + f"{additional_deficit_amount} µALGO is required for non app call transaction {group_index}", + ) - if params.extra_fee: - txn.fee += params.extra_fee.micro_algo + current_fee = txn.fee or 0 + transaction_fee = current_fee + additional_deficit_amount + if logical_max_fee is not None and transaction_fee > logical_max_fee: + raise ValueError( + "Calculated transaction fee " + f"{transaction_fee} µALGO is greater than max of {logical_max_fee} " + f"for transaction {group_index}" + ) - if params.max_fee and txn.fee > params.max_fee.micro_algo: - raise ValueError(f"Transaction fee {txn.fee} is greater than max_fee {params.max_fee}") - use_max_fee = params.max_fee and params.max_fee.micro_algo > ( - params.static_fee.micro_algo if params.static_fee else 0 - ) - logical_max_fee = params.max_fee if use_max_fee else params.static_fee + transactions[group_index] = replace(txn, fee=transaction_fee) - return TransactionWithContext( - txn=txn, - context=TransactionContext(max_fee=logical_max_fee), - ) + if unnamed_resources_accessed and transactions[group_index].transaction_type == TransactionType.AppCall: + has_access_references = bool(transactions[group_index].application_call.access_references) + if not has_access_references: + transactions[group_index] = populate_transaction_resources( + transactions[group_index], unnamed_resources_accessed, group_index + ) + else: + indexes_with_access_references.append(group_index) + + if indexes_with_access_references: + config.logger.warning( + "Resource population will be skipped for transaction indexes %s as they use access references.", + indexes_with_access_references, + ) - def _build_method_call( # noqa: C901, PLR0912, PLR0915 + if group_analysis.unnamed_resources_accessed: + populate_group_resources(transactions, group_analysis.unnamed_resources_accessed) + + def _build_txn_from_params( # noqa: C901, PLR0911, PLR0912, PLR0915 self, - params: MethodCallParams, - suggested_params: algosdk.transaction.SuggestedParams, + params: TxnParams, + suggested_params: algod_models.SuggestedParams, *, - include_signer: bool, - ) -> list[TransactionWithSignerAndContext]: - method_args: list[ABIValue | TransactionWithSigner] = [] - txns_for_group: list[TransactionWithSignerAndContext] = [] - - if params.args: - for arg in reversed(params.args): - if arg is None and len(txns_for_group) > 0: - # Pull last transaction from group as placeholder - placeholder_transaction = txns_for_group.pop() - method_args.append(placeholder_transaction) - continue - if self._is_abi_value(arg): - method_args.append(arg) - continue - - if isinstance(arg, TransactionWithSigner): - method_args.append(arg) - continue - - if isinstance(arg, algosdk.transaction.Transaction): - # Wrap in TransactionWithSigner - signer = ( - params.signer.signer - if isinstance(params.signer, TransactionSignerAccountProtocol) - else params.signer - ) - method_args.append( - TransactionWithSignerAndContext( - txn=arg, - signer=signer - if signer is not None - else (NULL_SIGNER if not include_signer else self._get_signer(params.sender)), - context=TransactionContext(abi_method=None), - ) - ) - continue - match arg: - case ( - AppCreateMethodCallParams() - | AppCallMethodCallParams() - | AppUpdateMethodCallParams() - | AppDeleteMethodCallParams() - ): - temp_txn_with_signers = self._build_method_call( - arg, suggested_params, include_signer=include_signer - ) - # Add all transactions except the last one in reverse order - txns_for_group.extend(temp_txn_with_signers[:-1]) - # Add the last transaction to method_args - method_args.append(temp_txn_with_signers[-1]) - continue - case AppCallParams(): - txn = self._build_app_call(arg, suggested_params) - case PaymentParams(): - txn = self._build_payment(arg, suggested_params) - case AssetOptInParams(): - txn = self._build_asset_transfer( - AssetTransferParams(**arg.__dict__, receiver=arg.sender, amount=0), suggested_params - ) - case AssetCreateParams(): - txn = self._build_asset_create(arg, suggested_params) - case AssetConfigParams(): - txn = self._build_asset_config(arg, suggested_params) - case AssetDestroyParams(): - txn = self._build_asset_destroy(arg, suggested_params) - case AssetFreezeParams(): - txn = self._build_asset_freeze(arg, suggested_params) - case AssetTransferParams(): - txn = self._build_asset_transfer(arg, suggested_params) - case OnlineKeyRegistrationParams() | OfflineKeyRegistrationParams(): - txn = self._build_key_reg(arg, suggested_params) - case _: - raise ValueError(f"Unsupported method arg transaction type: {arg!s}") - - signer = ( - params.signer.signer - if isinstance(params.signer, TransactionSignerAccountProtocol) - else params.signer + is_localnet: bool, + ) -> list[_BuiltTxnSpec]: + builder_kwargs: _BuilderKwargs = { + "suggested_params": suggested_params, + "default_validity_window": self._default_validity_window, + "default_validity_window_is_explicit": self._default_validity_window_is_explicit, + "is_localnet": is_localnet, + } + + if isinstance(params, PaymentParams): + signer = self._resolve_param_signer(params.signer, params.sender) + built = build_payment_transaction(params, **builder_kwargs) + return [ + _BuiltTxnSpec( + txn=built.txn, + signer=signer, + logical_max_fee=built.logical_max_fee, ) - method_args.append( - TransactionWithSignerAndContext( - txn=txn.txn, - signer=signer or (NULL_SIGNER if not include_signer else self._get_signer(params.sender)), - context=TransactionContext(abi_method=params.method), - ) + ] + elif isinstance(params, AssetCreateParams): + signer = self._resolve_param_signer(params.signer, params.sender) + built = build_asset_create_transaction(params, **builder_kwargs) + return [ + _BuiltTxnSpec( + txn=built.txn, + signer=signer, + logical_max_fee=built.logical_max_fee, ) - - continue - - method_atc = AtomicTransactionComposer() - max_fees: dict[int, AlgoAmount] = {} - - # Process in reverse order - for arg in reversed(txns_for_group): - atc_index = method_atc.get_tx_count() - 1 - - if isinstance(arg, TransactionWithSignerAndContext) and arg.context: - if arg.context.abi_method: - method_atc.method_dict[atc_index] = arg.context.abi_method - - if arg.context.max_fee is not None: - max_fees[atc_index] = arg.context.max_fee - - # Process method args that are transactions with ABI method info - for i, arg in enumerate(reversed([a for a in method_args if isinstance(a, TransactionWithSignerAndContext)])): - atc_index = method_atc.get_tx_count() + i - if arg.context: - if arg.context.abi_method: - method_atc.method_dict[atc_index] = arg.context.abi_method - if arg.context.max_fee is not None: - max_fees[atc_index] = arg.context.max_fee - - app_id = params.app_id or 0 - approval_program = getattr(params, "approval_program", None) - clear_program = getattr(params, "clear_state_program", None) - extra_pages = None - - if app_id == 0: - extra_pages = getattr(params, "extra_program_pages", None) - if extra_pages is None and approval_program is not None: - extra_pages = calculate_extra_program_pages(approval_program, clear_program) - - txn_params = { - "app_id": app_id, - "method": params.method, - "sender": params.sender, - "sp": suggested_params, - "signer": params.signer - if params.signer is not None - else (NULL_SIGNER if not include_signer else self._get_signer(params.sender)) - or algosdk.atomic_transaction_composer.EmptySigner(), - "method_args": list(reversed(method_args)), - "on_complete": params.on_complete or algosdk.transaction.OnComplete.NoOpOC, - "boxes": [AppManager.get_box_reference(ref) for ref in params.box_references] - if params.box_references - else None, - "foreign_apps": params.app_references, - "foreign_assets": params.asset_references, - "accounts": params.account_references, - "global_schema": algosdk.transaction.StateSchema( - num_uints=params.schema.get("global_ints", 0), - num_byte_slices=params.schema.get("global_byte_slices", 0), + ] + elif isinstance(params, AssetConfigParams): + signer = self._resolve_param_signer(params.signer, params.sender) + built = build_asset_config_transaction(params, **builder_kwargs) + return [ + _BuiltTxnSpec( + txn=built.txn, + signer=signer, + logical_max_fee=built.logical_max_fee, + ) + ] + elif isinstance(params, AssetFreezeParams): + signer = self._resolve_param_signer(params.signer, params.sender) + built = build_asset_freeze_transaction(params, **builder_kwargs) + return [ + _BuiltTxnSpec( + txn=built.txn, + signer=signer, + logical_max_fee=built.logical_max_fee, + ) + ] + elif isinstance(params, AssetDestroyParams): + signer = self._resolve_param_signer(params.signer, params.sender) + built = build_asset_destroy_transaction(params, **builder_kwargs) + return [ + _BuiltTxnSpec( + txn=built.txn, + signer=signer, + logical_max_fee=built.logical_max_fee, + ) + ] + elif isinstance(params, AssetTransferParams): + signer = self._resolve_param_signer(params.signer, params.sender) + built = build_asset_transfer_transaction(params, **builder_kwargs) + return [ + _BuiltTxnSpec( + txn=built.txn, + signer=signer, + logical_max_fee=built.logical_max_fee, + ) + ] + elif isinstance(params, AssetOptInParams): + signer = self._resolve_param_signer(params.signer, params.sender) + built = build_asset_opt_in_transaction(params, **builder_kwargs) + return [ + _BuiltTxnSpec( + txn=built.txn, + signer=signer, + logical_max_fee=built.logical_max_fee, + ) + ] + elif isinstance(params, AssetOptOutParams): + signer = self._resolve_param_signer(params.signer, params.sender) + built = build_asset_opt_out_transaction(params, **builder_kwargs) + return [ + _BuiltTxnSpec( + txn=built.txn, + signer=signer, + logical_max_fee=built.logical_max_fee, + ) + ] + elif isinstance(params, AppCreateParams): + signer = self._resolve_param_signer(params.signer, params.sender) + built = build_app_create_transaction(params, app_manager=self._app_manager, **builder_kwargs) + return [ + _BuiltTxnSpec( + txn=built.txn, + signer=signer, + logical_max_fee=built.logical_max_fee, + ) + ] + elif isinstance(params, AppUpdateParams): + signer = self._resolve_param_signer(params.signer, params.sender) + built = build_app_update_transaction(params, app_manager=self._app_manager, **builder_kwargs) + return [ + _BuiltTxnSpec( + txn=built.txn, + signer=signer, + logical_max_fee=built.logical_max_fee, + ) + ] + elif isinstance(params, AppDeleteParams): + signer = self._resolve_param_signer(params.signer, params.sender) + built = build_app_delete_transaction(params, app_manager=self._app_manager, **builder_kwargs) + return [ + _BuiltTxnSpec( + txn=built.txn, + signer=signer, + logical_max_fee=built.logical_max_fee, + ) + ] + elif isinstance(params, AppCallParams): + signer = self._resolve_param_signer(params.signer, params.sender) + built = build_app_call_transaction(params, app_manager=self._app_manager, **builder_kwargs) + return [ + _BuiltTxnSpec( + txn=built.txn, + signer=signer, + logical_max_fee=built.logical_max_fee, + ) + ] + elif isinstance(params, OnlineKeyRegistrationParams): + signer = self._resolve_param_signer(params.signer, params.sender) + built = build_online_key_registration_transaction(params, **builder_kwargs) + return [ + _BuiltTxnSpec( + txn=built.txn, + signer=signer, + logical_max_fee=built.logical_max_fee, + ) + ] + elif isinstance(params, OfflineKeyRegistrationParams): + signer = self._resolve_param_signer(params.signer, params.sender) + built = build_offline_key_registration_transaction(params, **builder_kwargs) + return [ + _BuiltTxnSpec( + txn=built.txn, + signer=signer, + logical_max_fee=built.logical_max_fee, + ) + ] + elif isinstance(params, MethodCallTxnParamTypes): + extra_specs, flattened_params = self._extract_method_call_transactions( + params, suggested_params, is_localnet=is_localnet ) - if params.schema - else None, - "local_schema": algosdk.transaction.StateSchema( - num_uints=params.schema.get("local_ints", 0), - num_byte_slices=params.schema.get("local_byte_slices", 0), + if isinstance(params, AppCreateMethodCallParams): + create_params = cast(AppCreateMethodCallParams, flattened_params) + built = build_app_create_method_call_transaction( + create_params, + suggested_params=suggested_params, + method_args=create_params.args, + app_manager=self._app_manager, + default_validity_window=self._default_validity_window, + default_validity_window_is_explicit=self._default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + return [ + *extra_specs, + _BuiltTxnSpec( + txn=built.txn, + signer=self._resolve_param_signer(create_params.signer, create_params.sender), + logical_max_fee=built.logical_max_fee, + method=create_params.method, + ), + ] + if isinstance(params, AppUpdateMethodCallParams): + update_params = cast(AppUpdateMethodCallParams, flattened_params) + built = build_app_update_method_call_transaction( + update_params, + suggested_params=suggested_params, + method_args=update_params.args, + app_manager=self._app_manager, + default_validity_window=self._default_validity_window, + default_validity_window_is_explicit=self._default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + return [ + *extra_specs, + _BuiltTxnSpec( + txn=built.txn, + signer=self._resolve_param_signer(update_params.signer, update_params.sender), + logical_max_fee=built.logical_max_fee, + method=update_params.method, + ), + ] + if isinstance(params, AppDeleteMethodCallParams): + delete_params = cast(AppDeleteMethodCallParams, flattened_params) + built = build_app_delete_method_call_transaction( + delete_params, + suggested_params=suggested_params, + method_args=delete_params.args, + app_manager=self._app_manager, + default_validity_window=self._default_validity_window, + default_validity_window_is_explicit=self._default_validity_window_is_explicit, + is_localnet=is_localnet, + ) + return [ + *extra_specs, + _BuiltTxnSpec( + txn=built.txn, + signer=self._resolve_param_signer(delete_params.signer, delete_params.sender), + logical_max_fee=built.logical_max_fee, + method=delete_params.method, + ), + ] + + call_params = cast(AppCallMethodCallParams, flattened_params) + built = build_app_call_method_call_transaction( + call_params, + suggested_params=suggested_params, + method_args=call_params.args, + app_manager=self._app_manager, + default_validity_window=self._default_validity_window, + default_validity_window_is_explicit=self._default_validity_window_is_explicit, + is_localnet=is_localnet, ) - if params.schema - else None, - "approval_program": approval_program, - "clear_program": clear_program, - "extra_pages": extra_pages, - } - def _add_method_call_and_return_txn(x: dict) -> algosdk.transaction.Transaction: - method_atc.add_method_call(**x) - return method_atc.build_group()[-1].txn - - result = self._common_txn_build_step(lambda x: _add_method_call_and_return_txn(x), params, txn_params) - - build_atc_resp = self._build_atc(method_atc) - response = [] - for i, v in enumerate(build_atc_resp): - max_fee = result.context.max_fee if i == method_atc.get_tx_count() - 1 else max_fees.get(i) - context = TransactionContext(abi_method=v.context.abi_method, max_fee=max_fee) - response.append(TransactionWithSignerAndContext(txn=v.txn, signer=v.signer, context=context)) - - return response - - def _build_payment( - self, params: PaymentParams, suggested_params: algosdk.transaction.SuggestedParams - ) -> TransactionWithContext: - txn_params = { - "sender": params.sender, - "sp": suggested_params, - "receiver": params.receiver, - "amt": params.amount.micro_algo, - "close_remainder_to": params.close_remainder_to, - } + return [ + *extra_specs, + _BuiltTxnSpec( + txn=built.txn, + signer=self._resolve_param_signer(call_params.signer, call_params.sender), + logical_max_fee=built.logical_max_fee, + method=call_params.method, + ), + ] - return self._common_txn_build_step(lambda x: algosdk.transaction.PaymentTxn(**x), params, txn_params) - - def _build_asset_create( - self, params: AssetCreateParams, suggested_params: algosdk.transaction.SuggestedParams - ) -> TransactionWithContext: - txn_params = { - "sender": params.sender, - "sp": suggested_params, - "total": params.total, - "default_frozen": params.default_frozen or False, - "unit_name": params.unit_name or "", - "asset_name": params.asset_name or "", - "manager": params.manager, - "reserve": params.reserve, - "freeze": params.freeze, - "clawback": params.clawback, - "url": params.url or "", - "metadata_hash": params.metadata_hash, - "decimals": params.decimals or 0, - } + raise ValueError(f"Unsupported transaction params type: {type(params)}") - return self._common_txn_build_step(lambda x: algosdk.transaction.AssetCreateTxn(**x), params, txn_params) + def _clone_entry(self, entry: _QueuedTransaction) -> _QueuedTransaction: + if isinstance(entry.txn, Transaction): + return _QueuedTransaction(txn=self._sanitize_transaction(entry.txn), signer=entry.signer) + # TxnParams are immutable (frozen dataclasses) so we can share them + return _QueuedTransaction(txn=entry.txn, signer=entry.signer) - def _build_app_call( + def _process_method_call_arg( self, - params: AppCallParams | AppUpdateParams | AppCreateParams | AppDeleteParams, - suggested_params: algosdk.transaction.SuggestedParams, - ) -> TransactionWithContext: - app_id = getattr(params, "app_id", 0) - - approval_program = None - clear_program = None - - if isinstance(params, AppUpdateParams | AppCreateParams): - if isinstance(params.approval_program, str): - approval_program = self._app_manager.compile_teal(params.approval_program).compiled_base64_to_bytes - elif isinstance(params.approval_program, bytes): - approval_program = params.approval_program - - if isinstance(params.clear_state_program, str): - clear_program = self._app_manager.compile_teal(params.clear_state_program).compiled_base64_to_bytes - elif isinstance(params.clear_state_program, bytes): - clear_program = params.clear_state_program - - sdk_params = { - "sender": params.sender, - "sp": suggested_params, - "app_args": params.args, - "on_complete": params.on_complete or algosdk.transaction.OnComplete.NoOpOC, - "accounts": params.account_references, - "foreign_apps": params.app_references, - "foreign_assets": params.asset_references, - "boxes": params.box_references, - "approval_program": approval_program, - "clear_program": clear_program, - } - - txn_params = {**sdk_params, "index": app_id} + arg: object | None, + current_signer: TransactionSigner | None, + suggested_params: algod_models.SuggestedParams, + *, + is_localnet: bool, + ) -> tuple[list[_BuiltTxnSpec], object | None]: + if arg is None: + return [], None + + if isinstance(arg, TransactionWithSigner): + return [ + _BuiltTxnSpec( + txn=self._sanitize_transaction(arg.txn), + signer=arg.signer, + logical_max_fee=None, + ) + ], None - if not app_id and isinstance(params, AppCreateParams): - if not sdk_params["approval_program"] or not sdk_params["clear_program"]: - raise ValueError("approval_program and clear_program are required for application creation") + if isinstance(arg, MethodCallTxnParamTypes): + nested_params = arg + if arg.signer is None and current_signer is not None: + nested_params = replace(arg, signer=current_signer) + return ( + self._build_txn_from_params( + nested_params, + suggested_params, + is_localnet=is_localnet, + ), + None, + ) - schema = params.schema - if not schema: - schema = AppCreateSchema( - global_ints=0, - global_byte_slices=0, - local_ints=0, - local_byte_slices=0, + if isinstance(arg, Transaction): + return [ + _BuiltTxnSpec( + txn=self._sanitize_transaction(arg), + signer=current_signer, + logical_max_fee=None, ) + ], None - txn_params = { - **txn_params, - "global_schema": algosdk.transaction.StateSchema( - num_uints=schema["global_ints"], - num_byte_slices=schema["global_byte_slices"], - ), - "local_schema": algosdk.transaction.StateSchema( - num_uints=schema["local_ints"], - num_byte_slices=schema["local_byte_slices"], - ), - "extra_pages": params.extra_program_pages - or calculate_extra_program_pages(approval_program, clear_program), - } - - return self._common_txn_build_step(lambda x: algosdk.transaction.ApplicationCallTxn(**x), params, txn_params) - - def _build_asset_config( - self, params: AssetConfigParams, suggested_params: algosdk.transaction.SuggestedParams - ) -> TransactionWithContext: - txn_params = { - "sender": params.sender, - "sp": suggested_params, - "index": params.asset_id, - "manager": params.manager, - "reserve": params.reserve, - "freeze": params.freeze, - "clawback": params.clawback, - "strict_empty_address_check": False, - } + if isinstance(arg, TxnParamTypes): + return ( + self._build_txn_from_params(arg, suggested_params, is_localnet=is_localnet), + None, + ) - return self._common_txn_build_step(lambda x: algosdk.transaction.AssetConfigTxn(**x), params, txn_params) + return [], arg - def _build_asset_destroy( - self, params: AssetDestroyParams, suggested_params: algosdk.transaction.SuggestedParams - ) -> TransactionWithContext: - txn_params = { - "sender": params.sender, - "sp": suggested_params, - "index": params.asset_id, - } + def _extract_method_call_transactions( + self, + params: MethodCallTxnParamTypes, + suggested_params: algod_models.SuggestedParams, + *, + is_localnet: bool, + ) -> tuple[list[_BuiltTxnSpec], MethodCallTxnParamTypes]: + """Flatten transaction arguments inside ABI method calls into queued specs.""" + if not params.args: + return [], params + + def _to_signer(value: TransactionSigner | AddressWithTransactionSigner | None) -> TransactionSigner | None: + if isinstance(value, AddressWithTransactionSigner): + return value.signer + return value + + current_signer = _to_signer(params.signer) + extra_specs: list[_BuiltTxnSpec] = [] + processed_args: list[Any] = [] + + for arg in params.args: + specs, processed = self._process_method_call_arg( + arg, + current_signer, + suggested_params, + is_localnet=is_localnet, + ) + extra_specs.extend(specs) + processed_args.append(processed) - return self._common_txn_build_step(lambda x: algosdk.transaction.AssetDestroyTxn(**x), params, txn_params) - - def _build_asset_freeze( - self, params: AssetFreezeParams, suggested_params: algosdk.transaction.SuggestedParams - ) -> TransactionWithContext: - txn_params = { - "sender": params.sender, - "sp": suggested_params, - "index": params.asset_id, - "target": params.account, - "new_freeze_state": params.frozen, - } + return extra_specs, replace(params, args=processed_args) - return self._common_txn_build_step(lambda x: algosdk.transaction.AssetFreezeTxn(**x), params, txn_params) - - def _build_asset_transfer( - self, params: AssetTransferParams, suggested_params: algosdk.transaction.SuggestedParams - ) -> TransactionWithContext: - txn_params = { - "sender": params.sender, - "sp": suggested_params, - "receiver": params.receiver, - "amt": params.amount, - "index": params.asset_id, - "close_assets_to": params.close_asset_to, - "revocation_target": params.clawback_target, + def _sanitize_transaction(self, txn: Transaction) -> Transaction: + return replace(txn, group=None) + + def _resolve_param_signer( + self, + signer: TransactionSigner | AddressWithTransactionSigner | None, + sender: str | None = None, + ) -> TransactionSigner: + if isinstance(signer, AddressWithTransactionSigner): + return signer.signer + if signer is None: + if sender is None: + raise ValueError("Sender is required to resolve signer") + resolved = self._get_signer(sender) + if resolved is None: + raise ValueError(f"No signer found for address {sender}") + return resolved + return signer + + def _sign_transactions(self, txns_with_signers: Sequence[TransactionWithSigner]) -> list[bytes]: + if not txns_with_signers: + raise ValueError("No transactions available to sign") + + transactions = [entry.txn for entry in txns_with_signers] + signer_groups: dict[int, tuple[TransactionSigner, list[int]]] = {} + for index, entry in enumerate(txns_with_signers): + key = id(entry.signer) + if key not in signer_groups: + signer_groups[key] = (entry.signer, []) + signer_groups[key][1].append(index) + + signed_blobs: dict[int, list[bytes]] = {} + for key, (signer, indexes) in signer_groups.items(): + blobs = signer(transactions, indexes) + signed_blobs[key] = list(blobs) + + encoded_signed_transactions: list[bytes | None] = [None] * len(transactions) + + for key, (_, indexes) in signer_groups.items(): + blobs = signed_blobs[key] + for blob_index, txn_index in enumerate(indexes): + if blob_index < len(blobs): + encoded_signed_transactions[txn_index] = blobs[blob_index] + + unsigned_indexes = [i for i, item in enumerate(encoded_signed_transactions) if item is None] + if unsigned_indexes: + raise ValueError(f"Transactions at indexes [{', '.join(map(str, unsigned_indexes))}] were not signed") + + return cast(list[bytes], encoded_signed_transactions) # The guard above ensures no None values + + def _group_id(self) -> str | None: + txns = self._transactions_with_signers or [] + if not txns: + return None + group = txns[0].txn.group + if group is None: + return None + return base64.b64encode(group).decode() + + def _wait_for_confirmations( + self, tx_ids: Sequence[str], params: SendParams + ) -> list[algod_models.PendingTransactionResponse]: + confirmations: list[algod_models.PendingTransactionResponse] = [] + max_rounds = params.get("max_rounds_to_wait") + + if max_rounds is None: + suggested = self._get_suggested_params() + first = int(getattr(suggested, "first_valid", getattr(suggested, "first", 0))) + last = max(entry.txn.last_valid for entry in self._transactions_with_signers or []) + max_rounds = int(max(last - first + 1, 0)) + for tx_id in tx_ids: + confirmations.append(_wait_for_confirmation(self._algod, tx_id, max_rounds)) + return confirmations + + def _transform_error(self, err: Exception) -> Exception: + original_error = err + transformed = err + for transformer in self._error_transformers: + try: + transformed = transformer(transformed) + except Exception as transformer_error: + raise ErrorTransformerError("Error transformer raised an exception") from transformer_error + if not isinstance(transformed, Exception): + raise InvalidErrorTransformerValueError(original_error, transformed) + return transformed + + def _parse_abi_return_values( + self, + confirmations: Sequence[algod_models.PendingTransactionResponse], + method_calls: dict[int, ABIMethod] | None = None, + ) -> list[ABIReturn]: + abi_returns: list[ABIReturn] = [] + method_calls = method_calls or { + index: entry.method for index, entry in enumerate(self._transactions_with_signers or []) if entry.method } + for index, confirmation in enumerate(confirmations): + method = method_calls.get(index) + if not method: + continue + abi_return = self._app_manager.get_abi_return(confirmation, method) + if abi_return is not None: + abi_returns.append(abi_return) + return abi_returns + + def _resolve_error_transactions(self) -> list[Transaction] | None: + if self._transactions_with_signers is not None: + return [entry.txn for entry in self._transactions_with_signers] + if self._raw_built_transactions: + transactions = list(self._raw_built_transactions) + return group_transactions(transactions) if len(transactions) > 1 else transactions + return None - return self._common_txn_build_step(lambda x: algosdk.transaction.AssetTransferTxn(**x), params, txn_params) + def _simulate_error_context( + self, + sent_transactions: Sequence[Transaction], + *, + suppress_log: bool | None, + ) -> tuple[algod_models.SimulateResponse | None, list[SimulateTransactionResult]]: + """Simulate transactions to get error context including traces. - def _build_key_reg( + Returns: + A tuple of (simulate_response, traces). + """ + try: + empty_signer: TransactionSigner = make_empty_transaction_signer() + encoded_signed_transactions = self._sign_transactions( + [TransactionWithSigner(txn=txn, signer=empty_signer) for txn in sent_transactions] + ) + signed_transactions = decode_signed_transactions(encoded_signed_transactions) + request = algod_models.SimulateRequest( + txn_groups=[algod_models.SimulateRequestTransactionGroup(txns=signed_transactions)], + allow_empty_signatures=True, + fix_signers=True, + allow_more_logging=True, + exec_trace_config=algod_models.SimulateTraceConfig( + enable=True, + scratch_change=True, + stack_change=True, + state_change=True, + ), + ) + response = self._algod.simulate_transactions(request) + + # Extract traces from the response - use SimulateTransactionResult directly + # aligned with TypeScript which uses algod client types directly + traces: list[SimulateTransactionResult] = [] + if response.txn_groups and response.txn_groups[0].failed_at: + traces = list(response.txn_groups[0].txn_results) + + return response, traces + except Exception: + config.logger.debug( + "Failed to simulate transaction group after send error", + exc_info=True, + extra={"suppress_log": suppress_log}, + ) + return None, [] + + def _create_composer_error( self, - params: OnlineKeyRegistrationParams | OfflineKeyRegistrationParams, - suggested_params: algosdk.transaction.SuggestedParams, - ) -> TransactionWithContext: - if isinstance(params, OnlineKeyRegistrationParams): - txn_params = { - "sender": params.sender, - "sp": suggested_params, - "votekey": params.vote_key, - "selkey": params.selection_key, - "votefst": params.vote_first, - "votelst": params.vote_last, - "votekd": params.vote_key_dilution, - "rekey_to": params.rekey_to, - "nonpart": False, - "sprfkey": params.state_proof_key, - } - - return self._common_txn_build_step(lambda x: algosdk.transaction.KeyregTxn(**x), params, txn_params) - - return self._common_txn_build_step( - lambda x: algosdk.transaction.KeyregTxn(**x), - params, - { - "sender": params.sender, - "sp": suggested_params, - "nonpart": params.prevent_account_from_ever_participating_again, - "votekey": None, - "selkey": None, - "votefst": None, - "votelst": None, - "votekd": None, - }, + err: Exception, + sent_transactions: Sequence[Transaction] | None, + simulate_response: algod_models.SimulateResponse | None, + traces: list[SimulateTransactionResult], + ) -> TransactionComposerError: + """Create a TransactionComposerError with full context.""" + return TransactionComposerError( + str(err), + cause=err, + traces=traces if traces else None, + sent_transactions=list(sent_transactions) if sent_transactions else None, + simulate_response=simulate_response, ) - def _is_abi_value(self, x: bool | float | str | bytes | list | TxnParams) -> bool: - if isinstance(x, list | tuple): - return len(x) == 0 or all(self._is_abi_value(item) for item in x) - - return isinstance(x, bool | int | float | str | bytes) + def set_max_fees(self, max_fees: dict[int, AlgoAmount]) -> "TransactionComposer": + """Override max_fee for queued transactions by index before building.""" + if self._transactions_with_signers is not None: + raise RuntimeError("Transactions have already been built") - def _build_txn( # noqa: C901, PLR0912, PLR0911 - self, - txn: TransactionWithSigner | TxnParams | AtomicTransactionComposer, - suggested_params: algosdk.transaction.SuggestedParams, - *, - include_signer: bool, - ) -> list[TransactionWithSignerAndContext]: - match txn: - case TransactionWithSigner(): - return [ - TransactionWithSignerAndContext(txn=txn.txn, signer=txn.signer, context=TransactionContext.empty()) - ] - case AtomicTransactionComposer(): - return self._build_atc(txn) - case algosdk.transaction.Transaction(): - signer = NULL_SIGNER if not include_signer else self._get_signer(txn.sender) - return [TransactionWithSignerAndContext(txn=txn, signer=signer, context=TransactionContext.empty())] - case ( - AppCreateMethodCallParams() - | AppCallMethodCallParams() - | AppUpdateMethodCallParams() - | AppDeleteMethodCallParams() - ): - return self._build_method_call(txn, suggested_params, include_signer=include_signer) - - signer = txn.signer.signer if isinstance(txn.signer, TransactionSignerAccountProtocol) else txn.signer # type: ignore[assignment] - signer = signer or (NULL_SIGNER if not include_signer else self._get_signer(txn.sender)) - - match txn: - case PaymentParams(): - payment = self._build_payment(txn, suggested_params) - return [TransactionWithSignerAndContext.from_txn_with_context(payment, signer)] - case AssetCreateParams(): - asset_create = self._build_asset_create(txn, suggested_params) - return [TransactionWithSignerAndContext.from_txn_with_context(asset_create, signer)] - case AppCallParams() | AppUpdateParams() | AppCreateParams() | AppDeleteParams(): - app_call = self._build_app_call(txn, suggested_params) - return [TransactionWithSignerAndContext.from_txn_with_context(app_call, signer)] - case AssetConfigParams(): - asset_config = self._build_asset_config(txn, suggested_params) - return [TransactionWithSignerAndContext.from_txn_with_context(asset_config, signer)] - case AssetDestroyParams(): - asset_destroy = self._build_asset_destroy(txn, suggested_params) - return [TransactionWithSignerAndContext.from_txn_with_context(asset_destroy, signer)] - case AssetFreezeParams(): - asset_freeze = self._build_asset_freeze(txn, suggested_params) - return [TransactionWithSignerAndContext.from_txn_with_context(asset_freeze, signer)] - case AssetTransferParams(): - asset_transfer = self._build_asset_transfer(txn, suggested_params) - return [TransactionWithSignerAndContext.from_txn_with_context(asset_transfer, signer)] - case AssetOptInParams(): - asset_transfer = self._build_asset_transfer( - AssetTransferParams(**txn.__dict__, receiver=txn.sender, amount=0), suggested_params - ) - return [TransactionWithSignerAndContext.from_txn_with_context(asset_transfer, signer)] - case AssetOptOutParams(): - txn_dict = txn.__dict__ - creator = txn_dict.pop("creator") - asset_transfer = self._build_asset_transfer( - AssetTransferParams(**txn_dict, receiver=txn.sender, amount=0, close_asset_to=creator), - suggested_params, + for index in max_fees: + if index < 0 or index >= len(self._queued): + raise ValueError( + f"Index {index} is out of range. The composer only contains {len(self._queued)} transactions" ) - return [TransactionWithSignerAndContext.from_txn_with_context(asset_transfer, signer)] - case OnlineKeyRegistrationParams() | OfflineKeyRegistrationParams(): - key_reg = self._build_key_reg(txn, suggested_params) - return [TransactionWithSignerAndContext.from_txn_with_context(key_reg, signer)] - case _: - raise ValueError(f"Unsupported txn: {txn}") + + for index, max_fee in max_fees.items(): + entry = self._queued[index] + if isinstance(entry.txn, Transaction): + self._queued[index] = replace(entry, max_fee=max_fee) + elif hasattr(entry.txn, "max_fee"): + self._queued[index] = replace(entry, txn=replace(entry.txn, max_fee=max_fee)) + else: + raise ValueError(f"Transaction at index {index} does not support max_fee overrides") + + return self + + def _interpret_error(self, err: Exception) -> Exception: + if isinstance(err, UnexpectedStatusError): + payload_message = self._extract_algod_error_message(err.payload) + if payload_message: + return RuntimeError(payload_message) + return err + + @staticmethod + def _extract_algod_error_message(payload: object) -> str | None: # noqa: PLR0911 + if payload is None: + return None + if isinstance(payload, bytes): + text = payload.decode("utf-8", errors="ignore") + else: + text = str(payload) + text = text.strip() + if not text: + return None + try: + decoded = json.loads(text) + except Exception: + return text + if isinstance(decoded, dict): + for key in ("message", "msg", "error", "detail", "description"): + value = decoded.get(key) + if isinstance(value, str) and value.strip(): + return value + return text + if isinstance(decoded, list) and decoded: + first = decoded[0] + if isinstance(first, str) and first.strip(): + return first + return text + + +def _wait_for_confirmation( + algod: AlgodClient, + tx_id: str, + max_rounds: int, +) -> algod_models.PendingTransactionResponse: + remaining = max_rounds + status = algod.status() + current_round = getattr(status, "last_round", 0) + while remaining > 0: + pending = algod.pending_transaction_information(tx_id) + confirmed_round = getattr(pending, "confirmed_round", None) + if confirmed_round is not None and confirmed_round > 0: + return pending + current_round += 1 + algod.status_after_block(current_round) + remaining -= 1 + raise TimeoutError(f"Transaction {tx_id} not confirmed after {max_rounds} rounds") diff --git a/src/algokit_utils/transactions/transaction_creator.py b/src/algokit_utils/transactions/transaction_creator.py index e4081d06..5649ddfd 100644 --- a/src/algokit_utils/transactions/transaction_creator.py +++ b/src/algokit_utils/transactions/transaction_creator.py @@ -1,8 +1,8 @@ from collections.abc import Callable +from dataclasses import replace from typing import TypeVar -from algosdk.transaction import Transaction - +from algokit_transact import Transaction from algokit_utils.transactions.transaction_composer import ( AppCallMethodCallParams, AppCallParams, @@ -55,7 +55,7 @@ def _transaction( ) -> Callable[[TxnParam], Transaction]: def create_transaction(params: TxnParam) -> Transaction: composer = self._new_group() - result = c(composer)(params).build_transactions() + result = _with_group_ids_cleared(c(composer)(params).build_transactions()) return result.transactions[-1] return create_transaction @@ -65,7 +65,7 @@ def _transactions( ) -> Callable[[TxnParam], BuiltTransactions]: def create_transactions(params: TxnParam) -> BuiltTransactions: composer = self._new_group() - return c(composer)(params).build_transactions() + return _with_group_ids_cleared(c(composer)(params).build_transactions()) return create_transactions @@ -336,7 +336,7 @@ def app_create(self) -> Callable[[AppCreateParams], Transaction]: approval_program="TEAL_APPROVAL_CODE", clear_state_program="TEAL_CLEAR_CODE", schema={'global_ints': 1, 'global_byte_slices': 1, 'local_ints': 1, 'local_byte_slices': 1}, - on_complete=OnComplete.NoOpOC, + on_complete=OnApplicationComplete.NoOp, args=[b'arg1', b'arg2'], account_references=["ACCOUNT1"], app_references=[789], @@ -380,7 +380,7 @@ def app_update(self) -> Callable[[AppUpdateParams], Transaction]: app_references=[789], asset_references=[123], box_references=[], - on_complete=OnComplete.UpdateApplicationOC, + on_complete=OnApplicationComplete.UpdateApplication, lease="lease", note=b"note", rekey_to="REKEYTOADDRESS", @@ -413,7 +413,7 @@ def app_delete(self) -> Callable[[AppDeleteParams], Transaction]: app_references=[789], asset_references=[123], box_references=[], - on_complete=OnComplete.DeleteApplicationOC, + on_complete=OnApplicationComplete.DeleteApplication, lease="lease", note=b"note", rekey_to="REKEYTOADDRESS", @@ -435,7 +435,7 @@ def app_call(self) -> Callable[[AppCallParams], Transaction]: >>> creator = AlgorandClientTransactionCreator(lambda: TransactionComposer()) >>> params = AppCallParams( ... sender="SENDER_ADDRESS", - ... on_complete=OnComplete.NoOpOC, + ... on_complete=OnApplicationComplete.NoOp, ... app_id=789, ... approval_program="TEAL_APPROVAL_CODE", ... clear_state_program="TEAL_CLEAR_CODE", @@ -458,7 +458,7 @@ def app_call(self) -> Callable[[AppCallParams], Transaction]: >>> #Advanced example >>> creator.app_call(AppCallParams( sender="SENDER_ADDRESS", - on_complete=OnComplete.NoOpOC, + on_complete=OnApplicationComplete.NoOp, app_id=789, approval_program="TEAL_APPROVAL_CODE", clear_state_program="TEAL_CLEAR_CODE", @@ -505,7 +505,7 @@ def app_create_method_call(self) -> Callable[[AppCreateMethodCallParams], BuiltT schema={'global_ints': 1, 'global_byte_slices': 1, 'local_ints': 1, 'local_byte_slices': 1}, approval_program="TEAL_APPROVAL_CODE", clear_state_program="TEAL_CLEAR_CODE", - on_complete=OnComplete.NoOpOC, + on_complete=OnApplicationComplete.NoOp, extra_program_pages=0, lease="lease", note=b"note", @@ -543,7 +543,7 @@ def app_update_method_call(self) -> Callable[[AppUpdateMethodCallParams], BuiltT schema={'global_ints': 1, 'global_byte_slices': 1, 'local_ints': 1, 'local_byte_slices': 1}, approval_program="TEAL_NEW_APPROVAL_CODE", clear_state_program="TEAL_NEW_CLEAR_CODE", - on_complete=OnComplete.UpdateApplicationOC, + on_complete=OnApplicationComplete.UpdateApplication, lease="lease", note=b"note", rekey_to="REKEYTOADDRESS", @@ -686,3 +686,14 @@ def offline_key_registration(self) -> Callable[[OfflineKeyRegistrationParams], T )) """ return self._transaction(lambda c: c.add_offline_key_registration) + + +def _with_group_ids_cleared(built: BuiltTransactions) -> BuiltTransactions: + """Return a copy of BuiltTransactions with group IDs cleared so callers can regroup or reuse transactions.""" + + stripped_transactions = [replace(txn, group=None) if txn.group is not None else txn for txn in built.transactions] + return BuiltTransactions( + transactions=stripped_transactions, + method_calls=built.method_calls, + signers=built.signers, + ) diff --git a/src/algokit_utils/transactions/transaction_sender.py b/src/algokit_utils/transactions/transaction_sender.py index 0fdab4fe..3749c809 100644 --- a/src/algokit_utils/transactions/transaction_sender.py +++ b/src/algokit_utils/transactions/transaction_sender.py @@ -1,17 +1,20 @@ from collections.abc import Callable from dataclasses import dataclass -from typing import Any, Generic, TypeVar +from typing import Any, Generic, TypeVar, cast -import algosdk -import algosdk.atomic_transaction_composer -from algosdk.transaction import Transaction from typing_extensions import Self +from algokit_abi import arc56 +from algokit_algod_client import AlgodClient +from algokit_algod_client import models as algod_models +from algokit_common import get_application_address +from algokit_transact import Transaction from algokit_utils.applications.abi import ABIReturn from algokit_utils.applications.app_manager import AppManager from algokit_utils.assets.asset_manager import AssetManager from algokit_utils.config import config -from algokit_utils.models.transaction import SendParams, TransactionWrapper +from algokit_utils.models.application import CompiledTeal +from algokit_utils.models.transaction import SendParams from algokit_utils.transactions.transaction_composer import ( AppCallMethodCallParams, AppCallParams, @@ -31,7 +34,7 @@ OfflineKeyRegistrationParams, OnlineKeyRegistrationParams, PaymentParams, - SendAtomicTransactionComposerResults, + SendTransactionComposerResults, TransactionComposer, TxnParams, ) @@ -56,13 +59,13 @@ class SendSingleTransactionResult: Represents the result of sending a single transaction. """ - transaction: TransactionWrapper # Last transaction + transaction: Transaction # Last transaction """The last transaction""" - confirmation: algosdk.v2client.algod.AlgodResponseType # Last confirmation + confirmation: algod_models.PendingTransactionResponse # Last confirmation """The last confirmation""" - # Fields from SendAtomicTransactionComposerResults + # Fields from SendTransactionComposerResults group_id: str """The group ID""" @@ -71,10 +74,10 @@ class SendSingleTransactionResult: tx_ids: list[str] # Full array of transaction IDs """The full array of transaction IDs""" - transactions: list[TransactionWrapper] + transactions: list[Transaction] """The full array of transactions""" - confirmations: list[algosdk.v2client.algod.AlgodResponseType] + confirmations: list[algod_models.PendingTransactionResponse] """The full array of confirmations""" returns: list[ABIReturn] | None = None @@ -82,38 +85,48 @@ class SendSingleTransactionResult: @classmethod def from_composer_result( - cls, result: SendAtomicTransactionComposerResults, *, is_abi: bool = False, index: int = -1 + cls, result: SendTransactionComposerResults, *, is_abi: bool = False, index: int = -1 ) -> Self: + wrapped_transactions = result.transactions + # Get base parameters base_params = { - "transaction": result.transactions[index], + "transaction": wrapped_transactions[index], "confirmation": result.confirmations[index], - "group_id": result.group_id, + "group_id": result.group_id or "", "tx_id": result.tx_ids[index], "tx_ids": result.tx_ids, - "transactions": [result.transactions[index]], + "transactions": [wrapped_transactions[index]], "confirmations": result.confirmations, "returns": result.returns, } # For asset creation, extract asset_id from confirmation if cls is SendSingleAssetCreateTransactionResult: - base_params["asset_id"] = result.confirmations[index]["asset-index"] # type: ignore[call-overload] + confirmation = result.confirmations[index] + asset_id = confirmation.asset_id + if asset_id is None: + raise ValueError("Could not extract asset_id from confirmation") + base_params["asset_id"] = int(asset_id) # For app creation, extract app_id and calculate app_address elif cls is SendAppCreateTransactionResult: - app_id = result.confirmations[index]["application-index"] # type: ignore[call-overload] + confirmation = result.confirmations[index] + app_id_raw = confirmation.app_id + if app_id_raw is None: + raise ValueError("Could not extract app_id from confirmation") + app_id = int(app_id_raw) base_params.update( { "app_id": app_id, - "app_address": algosdk.logic.get_application_address(app_id), - "abi_return": result.returns[index] if result.returns and is_abi else None, # type: ignore[dict-item] + "app_address": get_application_address(app_id), + "abi_return": result.returns[index] if result.returns and is_abi else None, } ) # For regular app transactions, just add abi_return elif cls is SendAppTransactionResult: - base_params["abi_return"] = result.returns[index] if result.returns and is_abi else None # type: ignore[assignment] + base_params["abi_return"] = result.returns[index] if result.returns and is_abi else None - return cls(**base_params) # type: ignore[arg-type] + return cls(**cast(dict[str, Any], base_params)) @dataclass(frozen=True, kw_only=True) @@ -148,10 +161,10 @@ class SendAppUpdateTransactionResult(SendAppTransactionResult[ABIReturnT]): Contains the compiled approval and clear programs. """ - compiled_approval: Any | None = None + compiled_approval: CompiledTeal | bytes | None = None """The compiled approval program""" - compiled_clear: Any | None = None + compiled_clear: CompiledTeal | bytes | None = None """The compiled clear state program""" @@ -181,7 +194,7 @@ def __init__( new_group: Callable[[], TransactionComposer], asset_manager: AssetManager, app_manager: AppManager, - algod_client: algosdk.v2client.algod.AlgodClient, + algod_client: AlgodClient, ) -> None: self._new_group = new_group self._asset_manager = asset_manager @@ -212,21 +225,24 @@ def send_transaction(params: TxnParamsT, send_params: SendParams | None = None) c(composer)(params) if pre_log: - transaction = composer.build().transactions[-1].txn - config.logger.debug(pre_log(params, transaction)) + built = composer.build() + last_txn = built.transactions[-1] + config.logger.debug(pre_log(params, last_txn)) raw_result = composer.send( send_params, ) - raw_result_dict = raw_result.__dict__.copy() - raw_result_dict["transactions"] = raw_result.transactions - del raw_result_dict["simulate_response"] - + transactions = raw_result.transactions + confirmations = list(raw_result.confirmations) result = SendSingleTransactionResult( - **raw_result_dict, - confirmation=raw_result.confirmations[-1], - transaction=raw_result_dict["transactions"][-1], + transaction=transactions[-1], + confirmation=confirmations[-1], + group_id=raw_result.group_id or "", tx_id=raw_result.tx_ids[-1], + tx_ids=raw_result.tx_ids, + transactions=transactions, + confirmations=confirmations, + returns=raw_result.returns, ) if post_log: @@ -298,17 +314,20 @@ def send_app_create_call( params: TxnParamsT, send_params: SendParams | None = None ) -> SendAppCreateTransactionResult[ABIReturn]: result = self._send_app_update_call(c, pre_log, post_log)(params, send_params) - app_id = int(result.confirmation["application-index"]) # type: ignore[call-overload] + app_id_raw = result.confirmation.app_id + if app_id_raw is None: + raise ValueError("Could not extract app_id from confirmation") + app_id = int(app_id_raw) return SendAppCreateTransactionResult[ABIReturn]( **result.__dict__, app_id=app_id, - app_address=algosdk.logic.get_application_address(app_id), + app_address=get_application_address(app_id), ) return send_app_create_call - def _get_method_call_for_log(self, method: algosdk.abi.Method, args: list[Any]) -> str: + def _get_method_call_for_log(self, method: arc56.Method, args: list[Any]) -> str: """Helper function to format method call logs similar to TypeScript version""" args_str = str([str(a) if not isinstance(a, bytes | bytearray) else a.hex() for a in args]) return f"{method.name}({args_str})" @@ -343,7 +362,7 @@ def payment(self, params: PaymentParams, send_params: SendParams | None = None) >>> max_fee=AlgoAmount(micro_algo=3000), >>> signer=transactionSigner >>> ), send_params=SendParams( - >>> max_rounds_to_wait_for_confirmation=5, + >>> max_rounds_to_wait=5, >>> suppress_log=True, >>> )) """ @@ -351,7 +370,7 @@ def payment(self, params: PaymentParams, send_params: SendParams | None = None) lambda c: c.add_payment, pre_log=lambda params, transaction: ( f"Sending {params.amount} from {params.sender} to {params.receiver} " - f"via transaction {transaction.get_txid()}" + f"via transaction {transaction.tx_id()}" ), )(params, send_params) @@ -363,6 +382,7 @@ def asset_create( :param params: Asset creation parameters :param send_params: Send parameters :return: Result containing the new asset ID + :raises ValueError: If the confirmation payload does not include an asset_id :example: >>> result = algorand.send.asset_create(AssetCreateParams( @@ -401,7 +421,7 @@ def asset_create( >>> # against the sender and not need to pass it in >>> signer=transactionSigner >>> ), send_params=SendParams( - >>> max_rounds_to_wait_for_confirmation=5, + >>> max_rounds_to_wait=5, >>> suppress_log=True, >>> )) """ @@ -411,14 +431,17 @@ def asset_create( f"Created asset{f' {params.asset_name}' if hasattr(params, 'asset_name') else ''}" f"{f' ({params.unit_name})' if hasattr(params, 'unit_name') else ''} with " f"{params.total} units and {getattr(params, 'decimals', 0)} decimals created by " - f"{params.sender} with ID {result.confirmation['asset-index']} via transaction " # type: ignore[call-overload] - f"{result.tx_ids[-1]}" + f"{params.sender} with ID {result.confirmation.asset_id} " + f"via transaction {result.tx_ids[-1]}" ), )(params, send_params) + asset_id_raw = result.confirmation.asset_id + if asset_id_raw is None: + raise ValueError("Could not extract asset_id from confirmation") return SendSingleAssetCreateTransactionResult( **result.__dict__, - asset_id=int(result.confirmation["asset-index"]), # type: ignore[call-overload] + asset_id=int(asset_id_raw), ) def asset_config( @@ -453,14 +476,14 @@ def asset_config( >>> # against the sender and not need to pass it in >>> signer=transactionSigner >>> ), send_params=SendParams( - >>> max_rounds_to_wait_for_confirmation=5, + >>> max_rounds_to_wait=5, >>> suppress_log=True, >>> )) """ return self._send( lambda c: c.add_asset_config, pre_log=lambda params, transaction: ( - f"Configuring asset with ID {params.asset_id} via transaction {transaction.get_txid()}" + f"Configuring asset with ID {params.asset_id} via transaction {transaction.tx_id()}" ), )(params, send_params) @@ -502,14 +525,14 @@ def asset_freeze( >>> # against the sender and not need to pass it in >>> signer=transactionSigner >>> ), send_params=SendParams( - >>> max_rounds_to_wait_for_confirmation=5, + >>> max_rounds_to_wait=5, >>> suppress_log=True, >>> )) """ return self._send( lambda c: c.add_asset_freeze, pre_log=lambda params, transaction: ( - f"Freezing asset with ID {params.asset_id} via transaction {transaction.get_txid()}" + f"Freezing asset with ID {params.asset_id} via transaction {transaction.tx_id()}" ), )(params, send_params) @@ -547,14 +570,14 @@ def asset_destroy( >>> # against the sender and not need to pass it in >>> signer=transactionSigner >>> ), send_params=SendParams( - >>> max_rounds_to_wait_for_confirmation=5, + >>> max_rounds_to_wait=5, >>> suppress_log=True, >>> )) """ return self._send( lambda c: c.add_asset_destroy, pre_log=lambda params, transaction: ( - f"Destroying asset with ID {params.asset_id} via transaction {transaction.get_txid()}" + f"Destroying asset with ID {params.asset_id} via transaction {transaction.tx_id()}" ), )(params, send_params) @@ -599,7 +622,7 @@ def asset_transfer( >>> # against the sender and not need to pass it in >>> signer=transactionSigner >>> ), send_params=SendParams( - >>> max_rounds_to_wait_for_confirmation=5, + >>> max_rounds_to_wait=5, >>> suppress_log=True, >>> )) """ @@ -607,7 +630,7 @@ def asset_transfer( lambda c: c.add_asset_transfer, pre_log=lambda params, transaction: ( f"Transferring {params.amount} units of asset with ID {params.asset_id} from " - f"{params.sender} to {params.receiver} via transaction {transaction.get_txid()}" + f"{params.sender} to {params.receiver} via transaction {transaction.tx_id()}" ), )(params, send_params) @@ -645,14 +668,14 @@ def asset_opt_in( >>> # against the sender and not need to pass it in >>> signer=transactionSigner >>> ), send_params=SendParams( - >>> max_rounds_to_wait_for_confirmation=5, + >>> max_rounds_to_wait=5, >>> suppress_log=True, >>> )) """ return self._send( lambda c: c.add_asset_opt_in, pre_log=lambda params, transaction: ( - f"Opting in {params.sender} to asset with ID {params.asset_id} via transaction {transaction.get_txid()}" + f"Opting in {params.sender} to asset with ID {params.asset_id} via transaction {transaction.tx_id()}" ), )(params, send_params) @@ -700,7 +723,7 @@ def asset_opt_out( >>> # against the sender and not need to pass it in >>> signer=transactionSigner >>> ), send_params=SendParams( - >>> max_rounds_to_wait_for_confirmation=5, + >>> max_rounds_to_wait=5, >>> suppress_log=True, >>> )) """ @@ -730,7 +753,7 @@ def asset_opt_out( lambda c: c.add_asset_opt_out, pre_log=lambda params, transaction: ( f"Opting {params.sender} out of asset with ID {params.asset_id} to creator " - f"{creator} via transaction {transaction.get_txid()}" + f"{creator} via transaction {transaction.tx_id()}" ), )(params, send_params) @@ -755,42 +778,37 @@ def app_create( >>> sender="CREATORADDRESS", >>> approval_program="TEALCODE", >>> clear_state_program="TEALCODE", + >>> schema=AppCreateSchema( + >>> global_ints=1, + >>> global_byte_slices=2, + >>> local_ints=3, + >>> local_byte_slices=4, + >>> ), + >>> extra_program_pages=1, + >>> on_complete=OnApplicationComplete.OptIn, + >>> args=[b'some_bytes'], + >>> account_references=["ACCOUNT_1"], + >>> app_references=[123, 1234], + >>> asset_references=[12345], + >>> box_references=[...], + >>> lease=b'lease', + >>> note=b'note', + >>> # You wouldn't normally set this field + >>> first_valid_round=1000, + >>> validity_window=10, + >>> extra_fee=AlgoAmount(micro_algo=1000), + >>> static_fee=AlgoAmount(micro_algo=1000), + >>> # Max fee doesn't make sense with extra_fee AND static_fee + >>> # already specified, but here for completeness + >>> max_fee=AlgoAmount(micro_algo=3000), + >>> # Signer only needed if you want to provide one, + >>> # generally you'd register it with AlgorandClient + >>> # against the sender and not need to pass it in + >>> signer=transaction_signer, + >>> ), send_params=SendParams( + >>> max_rounds_to_wait=5, + >>> suppress_log=True, >>> )) - >>> # algorand.send.appCreate(AppCreateParams( - >>> # sender='CREATORADDRESS', - >>> # approval_program="TEALCODE", - >>> # clear_state_program="TEALCODE", - >>> # schema={ - >>> # "global_ints": 1, - >>> # "global_byte_slices": 2, - >>> # "local_ints": 3, - >>> # "local_byte_slices": 4 - >>> # }, - >>> # extra_program_pages: 1, - >>> # on_complete: algosdk.transaction.OnComplete.OptInOC, - >>> # args: [b'some_bytes'] - >>> # account_references: ["ACCOUNT_1"] - >>> # app_references: [123, 1234] - >>> # asset_references: [12345] - >>> # box_references: ["box1", {app_id: 1234, name: "box2"}] - >>> # lease: 'lease', - >>> # note: 'note', - >>> # # You wouldn't normally set this field - >>> # first_valid_round: 1000, - >>> # validity_window: 10, - >>> # extra_fee: AlgoAmount(micro_algo=1000), - >>> # static_fee: AlgoAmount(micro_algo=1000), - >>> # # Max fee doesn't make sense with extraFee AND staticFee - >>> # # already specified, but here for completeness - >>> # max_fee: AlgoAmount(micro_algo=3000), - >>> # # Signer only needed if you want to provide one, - >>> # # generally you'd register it with AlgorandClient - >>> # # against the sender and not need to pass it in - >>> # signer: transactionSigner - >>> #}, send_params=SendParams( - >>> # max_rounds_to_wait_for_confirmation=5, - >>> # suppress_log=True, - >>> #)) """ return self._send_app_create_call(lambda c: c.add_app_create)(params, send_params) @@ -815,7 +833,7 @@ def app_update( >>> sender="CREATORADDRESS", >>> approval_program="TEALCODE", >>> clear_state_program="TEALCODE", - >>> on_complete=OnComplete.UpdateApplicationOC, + >>> on_complete=OnApplicationComplete.UpdateApplication, >>> args=[b'some_bytes'], >>> account_references=["ACCOUNT_1"], >>> app_references=[123, 1234], @@ -836,7 +854,7 @@ def app_update( >>> # against the sender and not need to pass it in >>> signer=transactionSigner >>> ), send_params=SendParams( - >>> max_rounds_to_wait_for_confirmation=5, + >>> max_rounds_to_wait=5, >>> suppress_log=True, >>> )) """ @@ -860,7 +878,7 @@ def app_delete( >>> # Advanced example >>> algorand.send.app_delete(AppDeleteParams( >>> sender="CREATORADDRESS", - >>> on_complete=OnComplete.DeleteApplicationOC, + >>> on_complete=OnApplicationComplete.DeleteApplication, >>> args=[b'some_bytes'], >>> account_references=["ACCOUNT_1"], >>> app_references=[123, 1234], @@ -881,7 +899,7 @@ def app_delete( >>> # against the sender and not need to pass it in >>> signer=transactionSigner, >>> ), send_params=SendParams( - >>> max_rounds_to_wait_for_confirmation=5, + >>> max_rounds_to_wait=5, >>> suppress_log=True, >>> )) """ @@ -905,7 +923,7 @@ def app_call( >>> # Advanced example >>> algorand.send.app_call(AppCallParams( >>> sender="CREATORADDRESS", - >>> on_complete=OnComplete.OptInOC, + >>> on_complete=OnApplicationComplete.OptIn, >>> args=[b'some_bytes'], >>> account_references=["ACCOUNT_1"], >>> app_references=[123, 1234], @@ -926,7 +944,7 @@ def app_call( >>> # against the sender and not need to pass it in >>> signer=transactionSigner, >>> ), send_params=SendParams( - >>> max_rounds_to_wait_for_confirmation=5, + >>> max_rounds_to_wait=5, >>> suppress_log=True, >>> )) """ @@ -942,63 +960,59 @@ def app_create_method_call( :return: Result containing the new application ID and address :example: - >>> # Note: you may prefer to use `algorand.client` to get an app client for more advanced functionality. - >>> # - >>> # @param params The parameters for the app creation transaction + >>> # Note: you may prefer to use `algorand.client` to get an app client + >>> # for more advanced functionality. + >>> from algokit_abi import arc56 + >>> >>> # Basic example - >>> method = algorand.abi.Method( - >>> name='method', - >>> args=[b'arg1'], - >>> returns='string' - >>> ) - >>> result = algorand.send.app_create_method_call({ sender: 'CREATORADDRESS', - >>> approval_program: 'TEALCODE', - >>> clear_state_program: 'TEALCODE', - >>> method: method, - >>> args: ["arg1_value"] }) + >>> method = arc56.Method.from_signature("method(string)string") + >>> result = algorand.send.app_create_method_call( + >>> AppCreateMethodCallParams( + >>> sender="CREATORADDRESS", + >>> approval_program="TEALCODE", + >>> clear_state_program="TEALCODE", + >>> method=method, + >>> args=["arg1_value"], + >>> )) >>> created_app_id = result.app_id - >>> ... + >>> >>> # Advanced example - >>> method = algorand.abi.Method( - >>> name='method', - >>> args=[b'arg1'], - >>> returns='string' - >>> ) - >>> result = algorand.send.app_create_method_call({ - >>> sender: 'CREATORADDRESS', - >>> method: method, - >>> args: ["arg1_value"], - >>> approval_program: "TEALCODE", - >>> clear_state_program: "TEALCODE", - >>> schema: { - >>> "global_ints": 1, - >>> "global_byte_slices": 2, - >>> "local_ints": 3, - >>> "local_byte_slices": 4 - >>> }, - >>> extra_program_pages: 1, - >>> on_complete: algosdk.transaction.OnComplete.OptInOC, - >>> args: [new Uint8Array(1, 2, 3, 4)], - >>> account_references: ["ACCOUNT_1"], - >>> app_references: [123, 1234], - >>> asset_references: [12345], - >>> box_references: [...], - >>> lease: 'lease', - >>> note: 'note', - >>> # You wouldn't normally set this field - >>> first_valid_round: 1000, - >>> validity_window: 10, - >>> extra_fee: AlgoAmount(micro_algo=1000), - >>> static_fee: AlgoAmount(micro_algo=1000), - >>> # Max fee doesn't make sense with extraFee AND staticFee - >>> # already specified, but here for completeness - >>> max_fee: AlgoAmount(micro_algo=3000), - >>> # Signer only needed if you want to provide one, - >>> # generally you'd register it with AlgorandClient - >>> # against the sender and not need to pass it in - >>> signer: transactionSigner, - >>> }, send_params=SendParams( - >>> max_rounds_to_wait_for_confirmation=5, + >>> method = arc56.Method.from_signature("method(string)string") + >>> result = algorand.send.app_create_method_call( + >>> AppCreateMethodCallParams( + >>> sender="CREATORADDRESS", + >>> method=method, + >>> args=["arg1_value"], + >>> approval_program="TEALCODE", + >>> clear_state_program="TEALCODE", + >>> schema=AppCreateSchema( + >>> global_ints=1, + >>> global_byte_slices=2, + >>> local_ints=3, + >>> local_byte_slices=4, + >>> ), + >>> extra_program_pages=1, + >>> on_complete=OnApplicationComplete.OptIn, + >>> account_references=["ACCOUNT_1"], + >>> app_references=[123, 1234], + >>> asset_references=[12345], + >>> box_references=[...], + >>> lease=b'lease', + >>> note=b'note', + >>> # You wouldn't normally set this field + >>> first_valid_round=1000, + >>> validity_window=10, + >>> extra_fee=AlgoAmount(micro_algo=1000), + >>> static_fee=AlgoAmount(micro_algo=1000), + >>> # Max fee doesn't make sense with extra_fee AND static_fee + >>> # already specified, but here for completeness + >>> max_fee=AlgoAmount(micro_algo=3000), + >>> # Signer only needed if you want to provide one, + >>> # generally you'd register it with AlgorandClient + >>> # against the sender and not need to pass it in + >>> signer=transaction_signer, + >>> ), send_params=SendParams( + >>> max_rounds_to_wait=5, >>> suppress_log=True, >>> )) """ @@ -1014,42 +1028,32 @@ def app_update_method_call( :return: Result containing the compiled programs :example: - # Basic example: - >>> method = algorand.abi.Method( - ... name="updateMethod", - ... args=[{"type": "string", "name": "arg1"}], - ... returns="string" - ... ) - >>> params = AppUpdateMethodCallParams( - ... sender="CREATORADDRESS", - ... app_id=123, - ... method=method, - ... args=["new_value"], - ... approval_program="TEALCODE", - ... clear_state_program="TEALCODE" - ... ) - >>> result = algorand.send.app_update_method_call(params) - >>> print(result.compiled_approval, result.compiled_clear) - - # Advanced example: - >>> method = algorand.abi.Method( - ... name="updateMethod", - ... args=[{"type": "string", "name": "arg1"}, {"type": "uint64", "name": "arg2"}], - ... returns="string" - ... ) - >>> params = AppUpdateMethodCallParams( - ... sender="CREATORADDRESS", - ... app_id=456, - ... method=method, - ... args=["new_value", 42], - ... approval_program="TEALCODE_ADVANCED", - ... clear_state_program="TEALCLEAR_ADVANCED", - ... account_references=["ACCOUNT1", "ACCOUNT2"], - ... app_references=[789], - ... asset_references=[101112] - ... ) - >>> result = algorand.send.app_update_method_call(params) - >>> print(result.compiled_approval, result.compiled_clear) + >>> # Basic example + >>> method = arc56.Method.from_signature("updateMethod(string)string") + >>> result = algorand.send.app_update_method_call( + >>> AppUpdateMethodCallParams( + >>> sender="CREATORADDRESS", + >>> app_id=123, + >>> method=method, + >>> args=["new_value"], + >>> approval_program="TEALCODE", + >>> clear_state_program="TEALCODE", + >>> )) + >>> + >>> # Advanced example + >>> method = arc56.Method.from_signature("updateMethod(string,uint64)string") + >>> result = algorand.send.app_update_method_call( + >>> AppUpdateMethodCallParams( + >>> sender="CREATORADDRESS", + >>> app_id=456, + >>> method=method, + >>> args=["new_value", 42], + >>> approval_program="TEALCODE", + >>> clear_state_program="TEALCODE", + >>> account_references=["ACCOUNT1", "ACCOUNT2"], + >>> app_references=[789], + >>> asset_references=[101112], + >>> )) """ return self._send_app_update_call(lambda c: c.add_app_update_method_call)(params, send_params) @@ -1063,36 +1067,26 @@ def app_delete_method_call( :return: Result of the deletion transaction :example: - # Basic example: - >>> method = algorand.abi.Method( - ... name="deleteMethod", - ... args=[], - ... returns="void" - ... ) - >>> params = AppDeleteMethodCallParams( - ... sender="CREATORADDRESS", - ... app_id=123, - ... method=method - ... ) - >>> result = algorand.send.app_delete_method_call(params) - >>> print(result.tx_id) - - # Advanced example: - >>> method = algorand.abi.Method( - ... name="deleteMethod", - ... args=[{"type": "uint64", "name": "confirmation"}], - ... returns="void" - ... ) - >>> params = AppDeleteMethodCallParams( - ... sender="CREATORADDRESS", - ... app_id=123, - ... method=method, - ... args=[1], - ... account_references=["ACCOUNT1"], - ... app_references=[456] - ... ) - >>> result = algorand.send.app_delete_method_call(params) - >>> print(result.tx_id) + >>> # Basic example + >>> method = arc56.Method.from_signature("deleteMethod()void") + >>> result = algorand.send.app_delete_method_call( + >>> AppDeleteMethodCallParams( + >>> sender="CREATORADDRESS", + >>> app_id=123, + >>> method=method, + >>> )) + >>> + >>> # Advanced example + >>> method = arc56.Method.from_signature("deleteMethod(uint64)void") + >>> result = algorand.send.app_delete_method_call( + >>> AppDeleteMethodCallParams( + >>> sender="CREATORADDRESS", + >>> app_id=123, + >>> method=method, + >>> args=[1], + >>> account_references=["ACCOUNT1"], + >>> app_references=[456], + >>> )) """ return self._send_app_call(lambda c: c.add_app_delete_method_call)(params, send_params) @@ -1106,38 +1100,28 @@ def app_call_method_call( :return: Result containing any ABI return value :example: - # Basic example: - >>> method = algorand.abi.Method( - ... name="callMethod", - ... args=[{"type": "uint64", "name": "arg1"}], - ... returns="uint64" - ... ) - >>> params = AppCallMethodCallParams( - ... sender="CALLERADDRESS", - ... app_id=123, - ... method=method, - ... args=[12345] - ... ) - >>> result = algorand.send.app_call_method_call(params) - >>> print(result.abi_return) - - # Advanced example: - >>> method = algorand.abi.Method( - ... name="callMethod", - ... args=[{"type": "uint64", "name": "arg1"}, {"type": "string", "name": "arg2"}], - ... returns="uint64" - ... ) - >>> params = AppCallMethodCallParams( - ... sender="CALLERADDRESS", - ... app_id=123, - ... method=method, - ... args=[12345, "extra"], - ... account_references=["ACCOUNT1"], - ... asset_references=[101112], - ... app_references=[789] - ... ) - >>> result = algorand.send.app_call_method_call(params) - >>> print(result.abi_return) + >>> # Basic example + >>> method = arc56.Method.from_signature("callMethod(uint64)uint64") + >>> result = algorand.send.app_call_method_call( + >>> AppCallMethodCallParams( + >>> sender="CALLERADDRESS", + >>> app_id=123, + >>> method=method, + >>> args=[12345], + >>> )) + >>> + >>> # Advanced example + >>> method = arc56.Method.from_signature("callMethod(uint64,string)uint64") + >>> result = algorand.send.app_call_method_call( + >>> AppCallMethodCallParams( + >>> sender="CALLERADDRESS", + >>> app_id=123, + >>> method=method, + >>> args=[12345, "extra"], + >>> account_references=["ACCOUNT1"], + >>> asset_references=[101112], + >>> app_references=[789], + >>> )) """ return self._send_app_call(lambda c: c.add_app_call_method_call)(params, send_params) @@ -1179,7 +1163,7 @@ def online_key_registration( return self._send( lambda c: c.add_online_key_registration, pre_log=lambda params, transaction: ( - f"Registering online key for {params.sender} via transaction {transaction.get_txid()}" + f"Registering online key for {params.sender} via transaction {transaction.tx_id()}" ), )(params, send_params) @@ -1213,6 +1197,6 @@ def offline_key_registration( return self._send( lambda c: c.add_offline_key_registration, pre_log=lambda params, transaction: ( - f"Registering offline key for {params.sender} via transaction {transaction.get_txid()}" + f"Registering offline key for {params.sender} via transaction {transaction.tx_id()}" ), )(params, send_params) diff --git a/src/algokit_utils/transactions/types.py b/src/algokit_utils/transactions/types.py new file mode 100644 index 00000000..8bfdbe1f --- /dev/null +++ b/src/algokit_utils/transactions/types.py @@ -0,0 +1,262 @@ +from dataclasses import dataclass +from typing import TypedDict, Union + +from algokit_abi import arc56 +from algokit_transact import OnApplicationComplete +from algokit_transact.signer import AddressWithTransactionSigner, TransactionSigner +from algokit_utils.models.amount import AlgoAmount +from algokit_utils.models.state import BoxIdentifier, BoxReference + +__all__ = [ + "AppCallMethodCallParams", + "AppCallParams", + "AppCreateMethodCallParams", + "AppCreateParams", + "AppCreateSchema", + "AppDeleteMethodCallParams", + "AppDeleteParams", + "AppMethodCallParams", + "AppUpdateMethodCallParams", + "AppUpdateParams", + "AssetConfigParams", + "AssetCreateParams", + "AssetDestroyParams", + "AssetFreezeParams", + "AssetOptInParams", + "AssetOptOutParams", + "AssetTransferParams", + "CommonTxnParams", + "MethodCallParams", + "OfflineKeyRegistrationParams", + "OnlineKeyRegistrationParams", + "PaymentParams", + "TxnParams", +] + + +@dataclass(kw_only=True, frozen=True) +class CommonTxnParams: + sender: str + signer: TransactionSigner | AddressWithTransactionSigner | None = None + rekey_to: str | None = None + note: bytes | None = None + lease: bytes | None = None + static_fee: AlgoAmount | None = None + extra_fee: AlgoAmount | None = None + max_fee: AlgoAmount | None = None + validity_window: int | None = None + first_valid_round: int | None = None + last_valid_round: int | None = None + + +@dataclass(kw_only=True, frozen=True) +class PaymentParams(CommonTxnParams): + receiver: str + amount: AlgoAmount + close_remainder_to: str | None = None + + +@dataclass(kw_only=True, frozen=True) +class AssetCreateParams(CommonTxnParams): + total: int + asset_name: str | None = None + unit_name: str | None = None + url: str | None = None + decimals: int | None = None + default_frozen: bool | None = None + manager: str | None = None + reserve: str | None = None + freeze: str | None = None + clawback: str | None = None + metadata_hash: bytes | None = None + + +@dataclass(kw_only=True, frozen=True) +class AssetConfigParams(CommonTxnParams): + asset_id: int + manager: str | None = None + reserve: str | None = None + freeze: str | None = None + clawback: str | None = None + + +@dataclass(kw_only=True, frozen=True) +class AssetFreezeParams(CommonTxnParams): + asset_id: int + account: str + frozen: bool + + +@dataclass(kw_only=True, frozen=True) +class AssetDestroyParams(CommonTxnParams): + asset_id: int + + +@dataclass(kw_only=True, frozen=True) +class OnlineKeyRegistrationParams(CommonTxnParams): + vote_key: str + selection_key: str + state_proof_key: bytes | None = None + vote_first: int = 0 + vote_last: int = 0 + vote_key_dilution: int = 0 + nonparticipation: bool | None = None + + +@dataclass(kw_only=True, frozen=True) +class OfflineKeyRegistrationParams(CommonTxnParams): + prevent_account_from_ever_participating_again: bool = True + + +@dataclass(kw_only=True, frozen=True) +class AssetTransferParams(CommonTxnParams): + asset_id: int + amount: int + receiver: str + close_asset_to: str | None = None + clawback_target: str | None = None + + +@dataclass(kw_only=True, frozen=True) +class AssetOptInParams(CommonTxnParams): + asset_id: int + + +@dataclass(kw_only=True, frozen=True) +class AssetOptOutParams(CommonTxnParams): + asset_id: int + creator: str + + +@dataclass(kw_only=True, frozen=True) +class AppCallParams(CommonTxnParams): + app_id: int + args: list[bytes] | None = None + account_references: list[str] | None = None + app_references: list[int] | None = None + asset_references: list[int] | None = None + box_references: list[BoxReference | BoxIdentifier] | None = None + on_complete: OnApplicationComplete | None = None + + +class AppCreateSchema(TypedDict): + global_ints: int + global_byte_slices: int + local_ints: int + local_byte_slices: int + + +@dataclass(kw_only=True, frozen=True) +class AppCreateParams(CommonTxnParams): + approval_program: str | bytes + clear_state_program: str | bytes + schema: AppCreateSchema | None = None + on_complete: OnApplicationComplete | None = None + args: list[bytes] | None = None + account_references: list[str] | None = None + app_references: list[int] | None = None + asset_references: list[int] | None = None + box_references: list[BoxReference | BoxIdentifier] | None = None + extra_program_pages: int | None = None + + +@dataclass(kw_only=True, frozen=True) +class AppUpdateParams(CommonTxnParams): + app_id: int + approval_program: str | bytes + clear_state_program: str | bytes + args: list[bytes] | None = None + account_references: list[str] | None = None + app_references: list[int] | None = None + asset_references: list[int] | None = None + box_references: list[BoxReference | BoxIdentifier] | None = None + on_complete: OnApplicationComplete = OnApplicationComplete.UpdateApplication + + +@dataclass(kw_only=True, frozen=True) +class AppDeleteParams(CommonTxnParams): + app_id: int + args: list[bytes] | None = None + account_references: list[str] | None = None + app_references: list[int] | None = None + asset_references: list[int] | None = None + box_references: list[BoxReference | BoxIdentifier] | None = None + on_complete: OnApplicationComplete | None = None + + +@dataclass(kw_only=True, frozen=True) +class _BaseAppMethodCall(CommonTxnParams): + app_id: int | None = None + method: arc56.Method + args: list | None = None + account_references: list[str] | None = None + app_references: list[int] | None = None + asset_references: list[int] | None = None + box_references: list[BoxReference | BoxIdentifier] | None = None + schema: AppCreateSchema | None = None + on_complete: OnApplicationComplete | None = None + extra_program_pages: int | None = None + + +@dataclass(kw_only=True, frozen=True) +class AppMethodCallParams(CommonTxnParams): + app_id: int + method: arc56.Method + args: list[bytes] | None = None + on_complete: OnApplicationComplete | None = None + account_references: list[str] | None = None + app_references: list[int] | None = None + asset_references: list[int] | None = None + box_references: list[BoxReference | BoxIdentifier] | None = None + + +@dataclass(kw_only=True, frozen=True) +class AppCallMethodCallParams(_BaseAppMethodCall): + app_id: int + on_complete: OnApplicationComplete | None = None + + +@dataclass(kw_only=True, frozen=True) +class AppCreateMethodCallParams(_BaseAppMethodCall): + approval_program: str | bytes + clear_state_program: str | bytes + schema: AppCreateSchema | None = None + on_complete: OnApplicationComplete | None = None + + +@dataclass(kw_only=True, frozen=True) +class AppUpdateMethodCallParams(_BaseAppMethodCall): + app_id: int + approval_program: str | bytes + clear_state_program: str | bytes + on_complete: OnApplicationComplete = OnApplicationComplete.UpdateApplication + + +@dataclass(kw_only=True, frozen=True) +class AppDeleteMethodCallParams(_BaseAppMethodCall): + app_id: int + on_complete: OnApplicationComplete = OnApplicationComplete.DeleteApplication + + +MethodCallParams = ( + AppCallMethodCallParams | AppCreateMethodCallParams | AppUpdateMethodCallParams | AppDeleteMethodCallParams +) + + +TxnParams = Union[ # noqa: UP007 + PaymentParams, + AssetCreateParams, + AssetConfigParams, + AssetFreezeParams, + AssetDestroyParams, + OnlineKeyRegistrationParams, + AssetTransferParams, + AssetOptInParams, + AssetOptOutParams, + AppCallParams, + AppCreateParams, + AppUpdateParams, + AppDeleteParams, + MethodCallParams, + OfflineKeyRegistrationParams, +] diff --git a/tests/accounts/test_account_manager.py b/tests/accounts/test_account_manager.py index 9576a510..f271623c 100644 --- a/tests/accounts/test_account_manager.py +++ b/tests/accounts/test_account_manager.py @@ -1,7 +1,14 @@ -import algosdk +import os + +import nacl.signing import pytest -from algokit_utils import SigningAccount +import algokit_algo25 +from algokit_common import address_from_public_key +from algokit_crypto import peikert_hd_wallet_generator +from algokit_transact import LogicSigAccount, MultisigAccount, MultisigMetadata +from algokit_transact.signer import AddressWithSigners +from algokit_utils import PaymentParams from algokit_utils.algorand import AlgorandClient from algokit_utils.models.amount import AlgoAmount from tests.conftest import get_unique_name @@ -13,13 +20,17 @@ def algorand() -> AlgorandClient: @pytest.fixture -def funded_account(algorand: AlgorandClient) -> SigningAccount: +def funded_account(algorand: AlgorandClient) -> AddressWithSigners: + return _fund_new_account(algorand, 100) + + +def _fund_new_account(algorand: AlgorandClient, min_algo: int) -> AddressWithSigners: new_account = algorand.account.random() dispenser = algorand.account.localnet_dispenser() algorand.account.ensure_funded( - new_account, dispenser, AlgoAmount.from_algo(100), min_funding_increment=AlgoAmount.from_algo(1) + new_account, dispenser, AlgoAmount.from_algo(min_algo), min_funding_increment=AlgoAmount.from_algo(1) ) - algorand.set_signer(sender=new_account.address, signer=new_account.signer) + algorand.set_signer(sender=new_account.addr, signer=new_account.signer) return new_account @@ -29,7 +40,7 @@ def test_new_account_is_retrieved_and_funded(algorand: AlgorandClient) -> None: account = algorand.account.from_environment(account_name) # Assert - account_info = algorand.account.get_information(account.address) + account_info = algorand.account.get_information(account.addr) assert account_info.amount > 0 @@ -41,38 +52,52 @@ def test_same_account_is_subsequently_retrieved(algorand: AlgorandClient) -> Non account1 = algorand.account.from_environment(account_name) account2 = algorand.account.from_environment(account_name) - # Assert - accounts should be different objects but with same underlying keys + # Assert - accounts should be different objects but with same underlying address and signers assert account1 is not account2 - assert account1.address == account2.address - assert account1.private_key == account2.private_key + assert account1.addr == account2.addr + # Verify signers are functionally equivalent by checking they sign the same test data identically + assert account1.signer is not None + assert account2.signer is not None def test_environment_is_used_in_preference_to_kmd(algorand: AlgorandClient, monkeypatch: pytest.MonkeyPatch) -> None: - # Arrange - account_name = get_unique_name() - account1 = algorand.account.from_environment(account_name) + # Arrange - create a known account from a mnemonic + # Generate a random mnemonic to create a test account + signing_key = nacl.signing.SigningKey.generate() + secret_key = signing_key.encode() + signing_key.verify_key.encode() + test_mnemonic = algokit_algo25.secret_key_to_mnemonic(secret_key) - # Set up environment variable for second account + # Set up environment variable for the account env_account_name = "TEST_ACCOUNT" - monkeypatch.setenv(f"{env_account_name}_MNEMONIC", algosdk.mnemonic.from_private_key(account1.private_key)) + monkeypatch.setenv(f"{env_account_name}_MNEMONIC", test_mnemonic) - # Act + # Act - get account from environment (should use mnemonic, not KMD) + account1 = algorand.account.from_environment(env_account_name) account2 = algorand.account.from_environment(env_account_name) - # Assert - accounts should be different objects but with same underlying keys - assert account1 is not account2 - assert account1.address == account2.address - assert account1.private_key == account2.private_key + # Assert - both calls should return accounts with the same address (from the mnemonic) + assert account1.addr == account2.addr + # Verify the address matches what we'd expect from the mnemonic + expected_seed = algokit_algo25.seed_from_mnemonic(test_mnemonic) + expected_signing_key = nacl.signing.SigningKey(expected_seed) + expected_address = address_from_public_key(expected_signing_key.verify_key.encode()) + assert account1.addr == expected_address def test_random_account_creation(algorand: AlgorandClient) -> None: # Act account = algorand.account.random() - # Assert - assert account.address - assert account.private_key - assert len(account.public_key) == 32 + # Assert - AddressWithSigners has addr and signer, not private_key/public_key + # This is a secretless signing approach where signers are callable functions + assert account.addr + assert len(account.addr) == 58 # Algorand address length + assert account.signer is not None # Has a transaction signer + assert callable(account.signer) + assert account.bytes_signer is not None # Has a bytes signer + assert account.delegated_lsig_signer is not None # Has a logic sig signer + assert account.program_data_signer is not None # Has a program data signer + assert account.mx_bytes_signer is not None # Has a mx bytes signer def test_ensure_funded_from_environment(algorand: AlgorandClient) -> None: @@ -82,14 +107,14 @@ def test_ensure_funded_from_environment(algorand: AlgorandClient) -> None: # Act result = algorand.account.ensure_funded_from_environment( - account_to_fund=account.address, + account_to_fund=account.addr, min_spending_balance=min_balance, ) # Assert assert result is not None assert result.amount_funded is not None - account_info = algorand.account.get_information(account.address) + account_info = algorand.account.get_information(account.addr) assert account_info.amount_without_pending_rewards >= min_balance.micro_algo @@ -98,10 +123,207 @@ def test_get_account_information(algorand: AlgorandClient) -> None: account = algorand.account.random() # Act - info = algorand.account.get_information(account.address) + info = algorand.account.get_information(account.addr) # Assert assert info.amount is not None assert info.min_balance is not None assert info.address is not None - assert info.address == account.address + assert info.address == account.addr + + +def test_logic_sig_account_msig_signing(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: + account1 = _fund_new_account(algorand, 1) + account2 = _fund_new_account(algorand, 1) + account3 = _fund_new_account(algorand, 1) + + msig_params = MultisigMetadata(version=1, threshold=2, addrs=[account1.addr, account2.addr, account3.addr]) + msig_account1 = MultisigAccount(params=msig_params, sub_signers=[account1]) + msig_account2 = MultisigAccount(params=msig_params, sub_signers=[account2]) + + # Setup the multisig delegated logicsig + lsig_account = LogicSigAccount( + logic=bytes([1, 32, 1, 1, 34]), # int 1 + args=(bytes([1]), bytes([2, 3])), + _address=msig_account1.addr, + ) + + lsig_account.sign_for_delegation(msig_account1) # sign with the first account + lsig_account.sign_for_delegation(msig_account2) # sign with the second account + + algorand.account.ensure_funded( + lsig_account.address, funded_account, AlgoAmount.from_algo(1) + ) # Fund the lsig account + + algorand.set_signer_from_account(lsig_account) + + result = algorand.send.payment( + PaymentParams( + sender=lsig_account.addr, + receiver=funded_account.addr, + amount=AlgoAmount.from_micro_algo(100000), + ) + ) + + lsig = result.confirmation.txn.lsig + assert lsig is not None + assert lsig.msig is None + lmsig = lsig.lmsig + assert lmsig is not None + assert lmsig.threshold == 2 + assert lmsig.version == 1 + assert len(lmsig.subsigs) == 3 + assert lmsig.subsigs[0].sig is not None + assert lmsig.subsigs[1].sig is not None + assert lmsig.subsigs[2].sig is None + + +class TestFromSecret: + """Tests for AccountManager.from_secret method.""" + + def test_from_secret_with_ed25519_seed(self, algorand: AlgorandClient) -> None: + """Test from_secret with Ed25519 seed wrapped secret.""" + # Generate a random seed + seed = os.urandom(32) + + class WrappedSeed: + def unwrap_ed25519_seed(self) -> bytearray: + return bytearray(seed) + + # Act + account = algorand.account.from_secret(secret=WrappedSeed()) + + # Assert + assert account.addr + assert len(account.addr) == 58 # Algorand address length + assert account.signer is not None + + # Verify we can get the signer + signer = algorand.account.get_signer(account.addr) + assert signer is not None + + def test_from_secret_with_hd_extended_private_key(self, algorand: AlgorandClient) -> None: + """Test from_secret with HD extended private key wrapped secret.""" + # Generate an HD wallet and get the extended private key for account 0 + wallet = peikert_hd_wallet_generator() + account_data = wallet["account_generator"](0, 0) + extended_key = bytearray(account_data["extended_private_key"]) + + class WrappedHdKey: + def unwrap_hd_extended_private_key(self) -> bytearray: + return bytearray(extended_key) + + # Act + account = algorand.account.from_secret(secret=WrappedHdKey()) + + # Assert + assert account.addr + assert len(account.addr) == 58 + assert account.signer is not None + + def test_from_secret_with_hd_mnemonic(self, algorand: AlgorandClient) -> None: + """Test from_secret with HD mnemonic wrapped secret.""" + + class WrappedHdMnemonic: + def unwrap_hd_mnemonic(self) -> str: + # Standard BIP39 test mnemonic + return "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about" + + # Act + account = algorand.account.from_secret(secret=WrappedHdMnemonic()) + + # Assert + assert account.addr + assert len(account.addr) == 58 + assert account.signer is not None + + def test_from_secret_with_legacy_mnemonic(self, algorand: AlgorandClient) -> None: + """Test from_secret with legacy Algorand mnemonic wrapped secret.""" + # Generate a random keypair and get its mnemonic + signing_key = nacl.signing.SigningKey.generate() + seed = signing_key.encode() + mnemonic = algokit_algo25.mnemonic_from_seed(seed) + + class WrappedLegacyMnemonic: + def unwrap_legacy_mnemonic(self) -> str: + return mnemonic + + # Act + account = algorand.account.from_secret(secret=WrappedLegacyMnemonic()) + + # Assert + assert account.addr + assert len(account.addr) == 58 + assert account.signer is not None + + # Verify the address matches expected (using the deprecated from_mnemonic for comparison) + expected_seed = algokit_algo25.seed_from_mnemonic(mnemonic) + expected_signing_key = nacl.signing.SigningKey(expected_seed) + expected_address = address_from_public_key(expected_signing_key.verify_key.encode()) + assert account.addr == expected_address + + def test_from_secret_with_sender_rekeyed(self, algorand: AlgorandClient) -> None: + """Test from_secret with sender address for rekeyed accounts.""" + # Generate a random seed + seed = os.urandom(32) + sender = "XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA" + + class WrappedSeed: + def unwrap_ed25519_seed(self) -> bytearray: + return bytearray(seed) + + # Act + account = algorand.account.from_secret(secret=WrappedSeed(), sender=sender) + + # Assert - account address should be the sender (rekeyed) + assert account.addr == sender + assert account.signer is not None + + def test_from_secret_optional_wrap_methods(self, algorand: AlgorandClient) -> None: + """Test that from_secret works with implementations that don't have wrap methods.""" + seed = os.urandom(32) + + class WrappedSeedNoWrap: + def unwrap_ed25519_seed(self) -> bytearray: + return bytearray(seed) + + # Note: no wrap_ed25519_seed method + + # Act - should work without wrap method + account = algorand.account.from_secret(secret=WrappedSeedNoWrap()) + + # Assert + assert account.addr + assert len(account.addr) == 58 + assert account.signer is not None + + def test_from_mnemonic_deprecated(self, algorand: AlgorandClient) -> None: + """Test that from_mnemonic raises deprecation warning.""" + # Generate a random keypair and get its mnemonic + signing_key = nacl.signing.SigningKey.generate() + seed = signing_key.encode() + mnemonic = algokit_algo25.mnemonic_from_seed(seed) + + # Act & Assert + with pytest.warns(DeprecationWarning, match="from_mnemonic is deprecated"): + account = algorand.account.from_mnemonic(mnemonic=mnemonic) + + # Account should still be created correctly + assert account.addr + assert len(account.addr) == 58 + + def test_from_secret_registers_account(self, algorand: AlgorandClient) -> None: + """Test that from_secret properly registers the account for later retrieval.""" + seed = os.urandom(32) + + class WrappedSeed: + def unwrap_ed25519_seed(self) -> bytearray: + return bytearray(seed) + + # Act + account = algorand.account.from_secret(secret=WrappedSeed()) + + # Assert - should be able to retrieve the signer + retrieved_account = algorand.account.get_account(account.addr) + assert retrieved_account is not None + assert retrieved_account.addr == account.addr diff --git a/tests/applications/_snapshots/test_arc56.approvals/test_arc32_state_keys_are_not_normalized.approved.txt b/tests/applications/_snapshots/test_arc56.approvals/test_arc32_state_keys_are_not_normalized.approved.txt index efbacf7a..cef4ba3b 100644 --- a/tests/applications/_snapshots/test_arc56.approvals/test_arc32_state_keys_are_not_normalized.approved.txt +++ b/tests/applications/_snapshots/test_arc56.approvals/test_arc32_state_keys_are_not_normalized.approved.txt @@ -255,8 +255,7 @@ "type": "uint64", "defaultValue": { "data": "aW50MQ==", - "source": "global", - "type": "uint64" + "source": "global" }, "name": "arg_with_default" } @@ -280,8 +279,7 @@ "type": "string", "defaultValue": { "data": "bG9jYWxfYnl0ZXMx", - "source": "local", - "type": "AVMString" + "source": "local" }, "name": "arg_with_default" } diff --git a/tests/applications/test_app_client.py b/tests/applications/test_app_client.py index 24637506..ef293d8a 100644 --- a/tests/applications/test_app_client.py +++ b/tests/applications/test_app_client.py @@ -1,14 +1,16 @@ import base64 import json import random +from collections.abc import Sequence from pathlib import Path from typing import Any -import algosdk import pytest -from algosdk.atomic_transaction_composer import TransactionSigner, TransactionWithSigner -from algokit_utils._legacy_v2.application_specification import ApplicationSpecification +from algokit_abi import arc32, arc32_to_arc56, arc56 +from algokit_common import ProgramSourceMap +from algokit_transact.models.transaction import Transaction +from algokit_transact.signer import AddressWithSigners from algokit_utils.algorand import AlgorandClient from algokit_utils.applications.abi import ABIType from algokit_utils.applications.app_client import ( @@ -19,12 +21,16 @@ ) from algokit_utils.applications.app_factory import AppFactoryCreateMethodCallParams from algokit_utils.applications.app_manager import AppManager -from algokit_utils.applications.app_spec.arc56 import Arc56Contract, Network from algokit_utils.errors.logic_error import LogicError -from algokit_utils.models.account import SigningAccount from algokit_utils.models.amount import AlgoAmount, micro_algo from algokit_utils.models.state import BoxReference -from algokit_utils.transactions.transaction_composer import AppCallMethodCallParams, AppCreateParams, PaymentParams +from algokit_utils.protocols.signer import TransactionSigner +from algokit_utils.transactions.transaction_composer import ( + AppCallMethodCallParams, + AppCreateParams, + PaymentParams, + TransactionWithSigner, +) @pytest.fixture @@ -33,13 +39,13 @@ def algorand() -> AlgorandClient: @pytest.fixture -def funded_account(algorand: AlgorandClient) -> SigningAccount: +def funded_account(algorand: AlgorandClient) -> AddressWithSigners: new_account = algorand.account.random() dispenser = algorand.account.localnet_dispenser() algorand.account.ensure_funded( new_account, dispenser, AlgoAmount.from_algo(100), min_funding_increment=AlgoAmount.from_algo(1) ) - algorand.set_signer(sender=new_account.address, signer=new_account.signer) + algorand.set_signer(sender=new_account.addr, signer=new_account.signer) return new_account @@ -50,27 +56,33 @@ def raw_hello_world_arc32_app_spec() -> str: @pytest.fixture -def hello_world_arc32_app_spec() -> ApplicationSpecification: +def hello_world_arc32_app_spec() -> arc56.Arc56Contract: raw_json_spec = Path(__file__).parent.parent / "artifacts" / "hello_world" / "app_spec.arc32.json" - return ApplicationSpecification.from_json(raw_json_spec.read_text()) + return arc32_to_arc56(raw_json_spec.read_text()) @pytest.fixture def hello_world_arc32_app_id( - algorand: AlgorandClient, funded_account: SigningAccount, hello_world_arc32_app_spec: ApplicationSpecification + algorand: AlgorandClient, funded_account: AddressWithSigners, hello_world_arc32_app_spec: arc56.Arc56Contract ) -> int: - global_schema = hello_world_arc32_app_spec.global_state_schema - local_schema = hello_world_arc32_app_spec.local_state_schema + global_schema = hello_world_arc32_app_spec.state.schema.global_state + local_schema = hello_world_arc32_app_spec.state.schema.local_state + source = hello_world_arc32_app_spec.source + assert source is not None, "App spec is missing source content" + approval = source.get_decoded_approval() + clear = source.get_decoded_clear() + assert approval is not None, "Approval program must be defined in the app spec" + assert clear is not None, "Clear state program must be defined in the app spec" response = algorand.send.app_create( AppCreateParams( - sender=funded_account.address, - approval_program=hello_world_arc32_app_spec.approval_program, - clear_state_program=hello_world_arc32_app_spec.clear_program, + sender=funded_account.addr, + approval_program=approval, + clear_state_program=clear, schema={ - "global_ints": int(global_schema.num_uints) if global_schema.num_uints else 0, - "global_byte_slices": int(global_schema.num_byte_slices) if global_schema.num_byte_slices else 0, - "local_ints": int(local_schema.num_uints) if local_schema.num_uints else 0, - "local_byte_slices": int(local_schema.num_byte_slices) if local_schema.num_byte_slices else 0, + "global_ints": int(global_schema.ints) if global_schema.ints else 0, + "global_byte_slices": int(global_schema.bytes) if global_schema.bytes else 0, + "local_ints": int(local_schema.ints) if local_schema.ints else 0, + "local_byte_slices": int(local_schema.bytes) if local_schema.bytes else 0, }, ) ) @@ -84,14 +96,14 @@ def raw_testing_app_arc32_app_spec() -> str: @pytest.fixture -def testing_app_arc32_app_spec() -> ApplicationSpecification: +def testing_app_arc32_app_spec() -> arc32.Arc32Contract: raw_json_spec = Path(__file__).parent.parent / "artifacts" / "testing_app" / "app_spec.arc32.json" - return ApplicationSpecification.from_json(raw_json_spec.read_text()) + return arc32.Arc32Contract.from_json(raw_json_spec.read_text()) @pytest.fixture def testing_app_arc32_app_id( - algorand: AlgorandClient, funded_account: SigningAccount, testing_app_arc32_app_spec: ApplicationSpecification + algorand: AlgorandClient, funded_account: AddressWithSigners, testing_app_arc32_app_spec: arc32.Arc32Contract ) -> int: global_schema = testing_app_arc32_app_spec.global_state_schema local_schema = testing_app_arc32_app_spec.local_state_schema @@ -105,7 +117,7 @@ def testing_app_arc32_app_id( ) response = algorand.send.app_create( AppCreateParams( - sender=funded_account.address, + sender=funded_account.addr, approval_program=approval, clear_state_program=testing_app_arc32_app_spec.clear_program, schema={ @@ -122,13 +134,13 @@ def testing_app_arc32_app_id( @pytest.fixture def test_app_client( algorand: AlgorandClient, - funded_account: SigningAccount, - testing_app_arc32_app_spec: ApplicationSpecification, + funded_account: AddressWithSigners, + testing_app_arc32_app_spec: arc32.Arc32Contract, testing_app_arc32_app_id: int, ) -> AppClient: return AppClient( AppClientParams( - default_sender=funded_account.address, + default_sender=funded_account.addr, default_signer=funded_account.signer, app_id=testing_app_arc32_app_id, algorand=algorand, @@ -140,8 +152,8 @@ def test_app_client( @pytest.fixture def test_app_client_with_sourcemaps( algorand: AlgorandClient, - funded_account: SigningAccount, - testing_app_arc32_app_spec: ApplicationSpecification, + funded_account: AddressWithSigners, + testing_app_arc32_app_spec: arc32.Arc32Contract, testing_app_arc32_app_id: int, ) -> AppClient: sourcemaps = json.loads( @@ -149,33 +161,33 @@ def test_app_client_with_sourcemaps( ) return AppClient( AppClientParams( - default_sender=funded_account.address, + default_sender=funded_account.addr, default_signer=funded_account.signer, app_id=testing_app_arc32_app_id, algorand=algorand, - approval_source_map=algosdk.source_map.SourceMap(sourcemaps["approvalSourceMap"]), - clear_source_map=algosdk.source_map.SourceMap(sourcemaps["clearSourceMap"]), + approval_source_map=ProgramSourceMap(sourcemaps["approvalSourceMap"]), + clear_source_map=ProgramSourceMap(sourcemaps["clearSourceMap"]), app_spec=testing_app_arc32_app_spec, ) ) @pytest.fixture -def testing_app_puya_arc32_app_spec() -> ApplicationSpecification: +def testing_app_puya_arc32_app_spec() -> arc32.Arc32Contract: raw_json_spec = Path(__file__).parent.parent / "artifacts" / "testing_app_puya" / "app_spec.arc32.json" - return ApplicationSpecification.from_json(raw_json_spec.read_text()) + return arc32.Arc32Contract.from_json(raw_json_spec.read_text()) @pytest.fixture def testing_app_puya_arc32_app_id( - algorand: AlgorandClient, funded_account: SigningAccount, testing_app_puya_arc32_app_spec: ApplicationSpecification + algorand: AlgorandClient, funded_account: AddressWithSigners, testing_app_puya_arc32_app_spec: arc32.Arc32Contract ) -> int: global_schema = testing_app_puya_arc32_app_spec.global_state_schema local_schema = testing_app_puya_arc32_app_spec.local_state_schema response = algorand.send.app_create( AppCreateParams( - sender=funded_account.address, + sender=funded_account.addr, approval_program=testing_app_puya_arc32_app_spec.approval_program, clear_state_program=testing_app_puya_arc32_app_spec.clear_program, schema={ @@ -192,13 +204,13 @@ def testing_app_puya_arc32_app_id( @pytest.fixture def test_app_client_puya( algorand: AlgorandClient, - funded_account: SigningAccount, - testing_app_puya_arc32_app_spec: ApplicationSpecification, + funded_account: AddressWithSigners, + testing_app_puya_arc32_app_spec: arc32.Arc32Contract, testing_app_puya_arc32_app_id: int, ) -> AppClient: return AppClient( AppClientParams( - default_sender=funded_account.address, + default_sender=funded_account.addr, default_signer=funded_account.signer, app_id=testing_app_puya_arc32_app_id, algorand=algorand, @@ -209,13 +221,13 @@ def test_app_client_puya( def test_clone_overriding_default_sender_and_inheriting_app_name( algorand: AlgorandClient, - funded_account: SigningAccount, - hello_world_arc32_app_spec: ApplicationSpecification, + funded_account: AddressWithSigners, + hello_world_arc32_app_spec: arc56.Arc56Contract, hello_world_arc32_app_id: int, ) -> None: app_client = AppClient( AppClientParams( - default_sender=funded_account.address, + default_sender=funded_account.addr, default_signer=funded_account.signer, app_id=hello_world_arc32_app_id, algorand=algorand, @@ -230,18 +242,18 @@ def test_clone_overriding_default_sender_and_inheriting_app_name( assert cloned_app_client.app_id == app_client.app_id assert cloned_app_client.app_name == app_client.app_name assert cloned_app_client._default_sender == cloned_default_sender # noqa: SLF001 - assert app_client._default_sender == funded_account.address # noqa: SLF001 + assert app_client._default_sender == funded_account.addr # noqa: SLF001 def test_clone_overriding_app_name( algorand: AlgorandClient, - funded_account: SigningAccount, - hello_world_arc32_app_spec: ApplicationSpecification, + funded_account: AddressWithSigners, + hello_world_arc32_app_spec: arc56.Arc56Contract, hello_world_arc32_app_id: int, ) -> None: app_client = AppClient( AppClientParams( - default_sender=funded_account.address, + default_sender=funded_account.addr, default_signer=funded_account.signer, app_id=hello_world_arc32_app_id, algorand=algorand, @@ -251,7 +263,7 @@ def test_clone_overriding_app_name( cloned_app_name = "George CLONEy" cloned_app_client = app_client.clone(app_name=cloned_app_name) - assert app_client.app_name == hello_world_arc32_app_spec.contract.name == "HelloWorld" + assert app_client.app_name == hello_world_arc32_app_spec.name == "HelloWorld" assert cloned_app_client.app_name == cloned_app_name # Test for explicit None when closning @@ -261,13 +273,13 @@ def test_clone_overriding_app_name( def test_clone_inheriting_app_name_based_on_default_handling( algorand: AlgorandClient, - funded_account: SigningAccount, - hello_world_arc32_app_spec: ApplicationSpecification, + funded_account: AddressWithSigners, + hello_world_arc32_app_spec: arc56.Arc56Contract, hello_world_arc32_app_id: int, ) -> None: app_client = AppClient( AppClientParams( - default_sender=funded_account.address, + default_sender=funded_account.addr, default_signer=funded_account.signer, app_id=hello_world_arc32_app_id, algorand=algorand, @@ -277,26 +289,24 @@ def test_clone_inheriting_app_name_based_on_default_handling( cloned_app_name = None cloned_app_client = app_client.clone(app_name=cloned_app_name) - assert cloned_app_client.app_name == hello_world_arc32_app_spec.contract.name == app_client.app_name + assert cloned_app_client.app_name == hello_world_arc32_app_spec.name == app_client.app_name def test_group_simulate_matches_send( - funded_account: SigningAccount, + funded_account: AddressWithSigners, test_app_client: AppClient, ) -> None: app_call1_params = AppCallMethodCallParams( - sender=funded_account.address, + sender=funded_account.addr, app_id=test_app_client.app_id, - method=algosdk.abi.Method.from_signature("set_global(uint64,uint64,string,byte[4])void"), + method=arc56.Method.from_signature("set_global(uint64,uint64,string,byte[4])void"), args=[1, 2, "asdf", bytes([1, 2, 3, 4])], ) - payment_params = PaymentParams( - sender=funded_account.address, receiver=funded_account.address, amount=micro_algo(10000) - ) + payment_params = PaymentParams(sender=funded_account.addr, receiver=funded_account.addr, amount=micro_algo(10000)) app_call2_params = AppCallMethodCallParams( - sender=funded_account.address, + sender=funded_account.addr, app_id=test_app_client.app_id, - method=algosdk.abi.Method.from_signature("call_abi(string)string"), + method=arc56.Method.from_signature("call_abi(string)string"), args=["test"], ) @@ -324,22 +334,22 @@ def test_group_simulate_matches_send( def test_normalise_app_spec( raw_hello_world_arc32_app_spec: str, - hello_world_arc32_app_spec: ApplicationSpecification, + hello_world_arc32_app_spec: arc56.Arc56Contract, ) -> None: normalized_app_spec_from_arc32 = AppClient.normalise_app_spec(hello_world_arc32_app_spec) - assert isinstance(normalized_app_spec_from_arc32, Arc56Contract) + assert isinstance(normalized_app_spec_from_arc32, arc56.Arc56Contract) normalize_app_spec_from_raw_arc32 = AppClient.normalise_app_spec(raw_hello_world_arc32_app_spec) - assert isinstance(normalize_app_spec_from_raw_arc32, Arc56Contract) + assert isinstance(normalize_app_spec_from_raw_arc32, arc56.Arc56Contract) def test_resolve_from_network( algorand: AlgorandClient, hello_world_arc32_app_id: int, - hello_world_arc32_app_spec: ApplicationSpecification, + hello_world_arc32_app_spec: arc56.Arc56Contract, ) -> None: - arc56_app_spec = Arc56Contract.from_arc32(hello_world_arc32_app_spec) - arc56_app_spec.networks = {"localnet": Network(app_id=hello_world_arc32_app_id)} + arc56_app_spec = hello_world_arc32_app_spec + arc56_app_spec.networks = {"localnet": arc56.Network(app_id=hello_world_arc32_app_id)} app_client = AppClient.from_network( algorand=algorand, app_spec=arc56_app_spec, @@ -357,8 +367,8 @@ def test_construct_transaction_with_boxes(test_app_client: AppClient) -> None: ) ) - assert isinstance(call.transactions[0], algosdk.transaction.ApplicationCallTxn) - assert call.transactions[0].boxes == [BoxReference(app_id=0, name=b"1")] # type: ignore # noqa: PGH003 + assert call.transactions[0].application_call + assert call.transactions[0].application_call.box_references == [BoxReference(app_id=0, name=b"1")] # Test with string box reference call2 = test_app_client.create_transaction.call( @@ -369,19 +379,19 @@ def test_construct_transaction_with_boxes(test_app_client: AppClient) -> None: ) ) - assert isinstance(call2.transactions[0], algosdk.transaction.ApplicationCallTxn) - assert call2.transactions[0].boxes == [BoxReference(app_id=0, name=b"1")] # type: ignore # noqa: PGH003 + assert call2.transactions[0].application_call + assert call2.transactions[0].application_call.box_references == [BoxReference(app_id=0, name=b"1")] def test_construct_transaction_with_abi_encoding_including_transaction( - algorand: AlgorandClient, funded_account: SigningAccount, test_app_client: AppClient + algorand: AlgorandClient, funded_account: AddressWithSigners, test_app_client: AppClient ) -> None: # Create a payment transaction with random amount amount = AlgoAmount.from_micro_algo(random.randint(1, 10000)) payment_txn = algorand.create_transaction.payment( PaymentParams( - sender=funded_account.address, - receiver=funded_account.address, + sender=funded_account.addr, + receiver=funded_account.addr, amount=amount, ) ) @@ -396,9 +406,7 @@ def test_construct_transaction_with_abi_encoding_including_transaction( assert result.confirmation assert len(result.transactions) == 2 - response = AppManager.get_abi_return( - result.confirmation, test_app_client.app_spec.get_arc56_method("call_abi_txn").to_abi_method() - ) + response = AppManager.get_abi_return(result.confirmation, test_app_client.app_spec.get_abi_method("call_abi_txn")) expected_return = f"Sent {amount.micro_algo}. test" assert result.abi_return == expected_return assert response @@ -406,33 +414,31 @@ def test_construct_transaction_with_abi_encoding_including_transaction( def test_sign_all_transactions_in_group_with_abi_call_with_transaction_arg( - algorand: AlgorandClient, test_app_client: AppClient, funded_account: SigningAccount + algorand: AlgorandClient, test_app_client: AppClient, funded_account: AddressWithSigners ) -> None: # Create a payment transaction with a random amount amount = AlgoAmount.from_micro_algo(random.randint(1, 10000)) txn = algorand.create_transaction.payment( PaymentParams( - sender=funded_account.address, - receiver=funded_account.address, + sender=funded_account.addr, + receiver=funded_account.addr, amount=amount, ) ) - called_indexes = [] - original_signer = algorand.account.get_signer(funded_account.address) + called_indexes: list[int] = [] + original_signer = algorand.account.get_signer(funded_account.addr) class IndexCapturingSigner(TransactionSigner): - def sign_transactions( - self, txn_group: list[algosdk.transaction.Transaction], indexes: list[int] - ) -> list[algosdk.transaction.GenericSignedTransaction]: + def __call__(self, txn_group: Sequence[Transaction], indexes: Sequence[int]) -> Sequence[bytes]: called_indexes.extend(indexes) - return original_signer.sign_transactions(txn_group, indexes) + return original_signer(txn_group, indexes) test_app_client.send.call( AppClientMethodCallParams( method="call_abi_txn", args=[txn, "test"], - sender=funded_account.address, + sender=funded_account.addr, signer=IndexCapturingSigner(), ) ) @@ -441,7 +447,7 @@ def sign_transactions( def test_sign_transaction_in_group_with_different_signer_if_provided( - algorand: AlgorandClient, test_app_client: AppClient, funded_account: SigningAccount + algorand: AlgorandClient, test_app_client: AppClient, funded_account: AddressWithSigners ) -> None: # Generate a new account test_account = algorand.account.random() @@ -455,8 +461,8 @@ def test_sign_transaction_in_group_with_different_signer_if_provided( # Fund the account with 1 Algo txn = algorand.create_transaction.payment( PaymentParams( - sender=test_account.address, - receiver=test_account.address, + sender=test_account.addr, + receiver=test_account.addr, amount=AlgoAmount.from_algo(random.randint(1, 5)), ) ) @@ -471,7 +477,7 @@ def test_sign_transaction_in_group_with_different_signer_if_provided( def test_construct_transaction_with_abi_encoding_including_foreign_references_not_in_signature( - algorand: AlgorandClient, test_app_client: AppClient, funded_account: SigningAccount + algorand: AlgorandClient, test_app_client: AppClient, funded_account: AddressWithSigners ) -> None: test_account = algorand.account.random() algorand.account.ensure_funded( @@ -485,15 +491,14 @@ def test_construct_transaction_with_abi_encoding_including_foreign_references_no AppClientMethodCallParams( method="call_abi_foreign_refs", app_references=[345], - account_references=[test_account.address], + account_references=[test_account.addr], asset_references=[567], ) ) # Assuming the method returns a string matching the format below expected_return = AppManager.get_abi_return( - result.confirmations[0], - test_app_client.app_spec.get_arc56_method("call_abi_foreign_refs").to_abi_method(), + result.confirmations[0], test_app_client.app_spec.get_abi_method("call_abi_foreign_refs") ) assert result.abi_return assert str(result.abi_return).startswith("App: 345, Asset: 567, Account: ") @@ -501,10 +506,15 @@ def test_construct_transaction_with_abi_encoding_including_foreign_references_no assert expected_return.value == result.abi_return -def test_retrieve_state(test_app_client: AppClient, funded_account: SigningAccount) -> None: - # Test global state - test_app_client.send.call(AppClientMethodCallParams(method="set_global", args=[1, 2, "asdf", bytes([1, 2, 3, 4])])) +def test_retrieve_global_state(test_app_client: AppClient) -> None: + set_global_result = test_app_client.send.call( + AppClientMethodCallParams(method="set_global", args=[1, 2, "asdf", bytes([1, 2, 3, 4])]) + ) global_state = test_app_client.get_global_state() + confirmation_global_delta_kvs = { + x.key.decode("utf-8"): (x.value.bytes_ if x.value.action == 1 else x.value.uint) + for x in sorted(set_global_result.confirmation.global_state_delta or [], key=lambda x: x.key) + } assert "int1" in global_state assert "int2" in global_state @@ -516,11 +526,25 @@ def test_retrieve_state(test_app_client: AppClient, funded_account: SigningAccou assert global_state["int2"].value == 2 assert global_state["bytes1"].value == "asdf" assert global_state["bytes2"].value_raw == bytes([1, 2, 3, 4]) + assert confirmation_global_delta_kvs == { + "bytes1": b"asdf", + "bytes2": bytes([1, 2, 3, 4]), + "int1": 1, + "int2": 2, + } + - # Test local state +def test_retrieve_local_state(test_app_client: AppClient, funded_account: AddressWithSigners) -> None: test_app_client.send.opt_in(AppClientMethodCallParams(method="opt_in")) - test_app_client.send.call(AppClientMethodCallParams(method="set_local", args=[1, 2, "asdf", bytes([1, 2, 3, 4])])) - local_state = test_app_client.get_local_state(funded_account.address) + set_local_result = test_app_client.send.call( + AppClientMethodCallParams(method="set_local", args=[1, 2, "asdf", bytes([1, 2, 3, 4])]) + ) + local_state = test_app_client.get_local_state(funded_account.addr) + assert set_local_result.confirmation.local_state_delta is not None + confirmation_local_delta_kvs = { + x.key.decode("utf-8"): (x.value.bytes_ if x.value.action == 1 else x.value.uint) + for x in sorted(set_local_result.confirmation.local_state_delta[0].delta or [], key=lambda x: x.key) + } assert "local_int1" in local_state assert "local_int2" in local_state @@ -531,8 +555,15 @@ def test_retrieve_state(test_app_client: AppClient, funded_account: SigningAccou assert local_state["local_int2"].value == 2 assert local_state["local_bytes1"].value == "asdf" assert local_state["local_bytes2"].value_raw == bytes([1, 2, 3, 4]) + assert confirmation_local_delta_kvs == { + "local_bytes1": b"asdf", + "local_bytes2": bytes([1, 2, 3, 4]), + "local_int1": 1, + "local_int2": 2, + } - # Test box storage + +def test_retrieve_box_state(test_app_client: AppClient) -> None: box_name1 = bytes([0, 0, 0, 1]) box_name1_base64 = base64.b64encode(box_name1).decode() box_name2 = bytes([0, 0, 0, 2]) @@ -596,7 +627,7 @@ def test_retrieve_state(test_app_client: AppClient, funded_account: SigningAccou "name1", b"test_bytes", # Updated to match Bytes type "byte[]", - [116, 101, 115, 116, 95, 98, 121, 116, 101, 115], + b"test_bytes", ), ( "name2", @@ -618,9 +649,9 @@ def test_retrieve_state(test_app_client: AppClient, funded_account: SigningAccou ), ( "name5", # Updated to use string key - [1, 2, 3, 4], + bytes([1, 2, 3, 4]), "byte[4]", - [1, 2, 3, 4], + bytes([1, 2, 3, 4]), ), ], ) @@ -661,7 +692,7 @@ def test_box_methods_with_manually_encoded_abi_args( ("box_str", "set_box_str", "string", "string"), ("box_int", "set_box_int", 123, "uint32"), ("box_int512", "set_box_int512", 2**256, "uint512"), - ("box_static", "set_box_static", [1, 2, 3, 4], "byte[4]"), + ("box_static", "set_box_static", bytes([1, 2, 3, 4]), "byte[4]"), ("", "set_struct", ("box1", 123), "(string,uint64)"), ], ) @@ -711,16 +742,16 @@ def test_box_methods_with_arc4_returns_parametrized( def test_abi_with_default_arg_method( algorand: AlgorandClient, - funded_account: SigningAccount, + funded_account: AddressWithSigners, testing_app_arc32_app_id: int, - testing_app_arc32_app_spec: ApplicationSpecification, + testing_app_arc32_app_spec: arc32.Arc32Contract, ) -> None: - arc56_app_spec = Arc56Contract.from_arc32(testing_app_arc32_app_spec) - arc56_app_spec.networks = {"localnet": Network(app_id=testing_app_arc32_app_id)} + arc56_app_spec = arc32_to_arc56(testing_app_arc32_app_spec) + arc56_app_spec.networks = {"localnet": arc56.Network(app_id=testing_app_arc32_app_id)} app_client = AppClient.from_network( algorand=algorand, app_spec=arc56_app_spec, - default_sender=funded_account.address, + default_sender=funded_account.addr, default_signer=funded_account.signer, ) # app_client.send. @@ -760,16 +791,16 @@ def test_exposing_logic_error(test_app_client_with_sourcemaps: AppClient) -> Non @pytest.fixture -def nested_struct_app_spec() -> Arc56Contract: +def nested_struct_app_spec() -> arc56.Arc56Contract: raw_json_spec = Path(__file__).parent.parent / "artifacts" / "nested_struct" / "nested_struct.arc56.json" - return Arc56Contract.from_json(raw_json_spec.read_text()) + return arc56.Arc56Contract.from_json(raw_json_spec.read_text()) def test_nested_structs_described_by_structure( - algorand: AlgorandClient, funded_account: SigningAccount, nested_struct_app_spec: Arc56Contract + algorand: AlgorandClient, funded_account: AddressWithSigners, nested_struct_app_spec: arc56.Arc56Contract ) -> None: """Test nested struct when described by structure.""" - factory = algorand.client.get_app_factory(app_spec=nested_struct_app_spec, default_sender=funded_account.address) + factory = algorand.client.get_app_factory(app_spec=nested_struct_app_spec, default_sender=funded_account.addr) app_client, _ = factory.send.create(AppFactoryCreateMethodCallParams(method="createApplication", args=[])) app_client.send.call(AppClientMethodCallParams(method="setValue", args=[1, "hello"])) @@ -794,7 +825,7 @@ def test_app_client_error_transformer_logic_error_enhancement(test_app_client_wi def test_nested_structs_referenced_by_name( - algorand: AlgorandClient, funded_account: SigningAccount, nested_struct_app_spec: Arc56Contract + algorand: AlgorandClient, funded_account: AddressWithSigners, nested_struct_app_spec: arc56.Arc56Contract ) -> None: """Test nested struct when referenced by name.""" edited_spec_dict = nested_struct_app_spec.dictify() @@ -812,11 +843,49 @@ def test_nested_structs_referenced_by_name( } ], } - edited_spec = Arc56Contract.from_json(json.dumps(edited_spec_dict)) - factory = algorand.client.get_app_factory(app_spec=edited_spec, default_sender=funded_account.address) + edited_spec = arc56.Arc56Contract.from_json(json.dumps(edited_spec_dict)) + factory = algorand.client.get_app_factory(app_spec=edited_spec, default_sender=funded_account.addr) app_client, _ = factory.send.create(AppFactoryCreateMethodCallParams(method="createApplication", args=[])) app_client.send.call(AppClientMethodCallParams(method="setValue", args=[1, "hello"])) result = app_client.send.call(AppClientMethodCallParams(method="getValue", args=[1])) assert result.abi_return == {"x": {"a": "hello"}} + + +def test_logic_error_includes_simulation_traces( + test_app_client_with_sourcemaps: AppClient, +) -> None: + """Test that LogicError includes simulation traces when errors occur during send phase. + + When debug=True and a transaction fails during send, the composer performs a + post-failure re-simulation to capture execution traces and attach them to the error. + This enables better debugging by showing the exact execution state at failure. + """ + from algokit_utils.config import config + from algokit_utils.transactions.transaction_composer import SendParams + + # Enable debug mode for send-phase trace capture + original_debug = config.debug + try: + config.configure(debug=True) + + with pytest.raises(LogicError) as exc_info: + test_app_client_with_sourcemaps.send.call( + AppClientMethodCallParams(method="error"), + send_params=SendParams(populate_app_call_resources=False), + ) + + error = exc_info.value + # Verify the error contains simulation traces + assert error.traces is not None, "LogicError should include simulation traces" + assert len(error.traces) > 0, "LogicError should have at least one simulation trace" + + # Verify the trace structure - uses SimulateTransactionResult from algod client + trace = error.traces[0] + assert hasattr(trace, "exec_trace"), "SimulateTransactionResult should have exec_trace attribute" + assert hasattr(trace, "app_budget_consumed"), "SimulateTransactionResult should have app_budget_consumed" + assert hasattr(trace, "txn_result"), "SimulateTransactionResult should have txn_result" + finally: + # Restore original debug setting + config.configure(debug=original_debug) diff --git a/tests/applications/test_app_factory.py b/tests/applications/test_app_factory.py index d9b94c71..afa87a60 100644 --- a/tests/applications/test_app_factory.py +++ b/tests/applications/test_app_factory.py @@ -1,10 +1,14 @@ from pathlib import Path -import algosdk import pytest -from algosdk.logic import get_application_address -from algosdk.transaction import OnComplete +import algokit_utils +from algokit_abi import arc56 +from algokit_algod_client import models as algod_models +from algokit_common import get_application_address +from algokit_transact import OnApplicationComplete +from algokit_transact.signer import AddressWithSigners +from algokit_utils import AppClientCompilationParams from algokit_utils.algorand import AlgorandClient from algokit_utils.applications.app_client import ( AppClient, @@ -19,9 +23,7 @@ AppFactoryCreateMethodCallParams, AppFactoryCreateParams, ) -from algokit_utils.applications.app_spec.arc56 import Arc56Contract from algokit_utils.errors import LogicError -from algokit_utils.models.account import SigningAccount from algokit_utils.models.amount import AlgoAmount, micro_algo from algokit_utils.transactions.transaction_composer import PaymentParams @@ -32,13 +34,13 @@ def algorand() -> AlgorandClient: @pytest.fixture -def funded_account(algorand: AlgorandClient) -> SigningAccount: +def funded_account(algorand: AlgorandClient) -> AddressWithSigners: new_account = algorand.account.random() dispenser = algorand.account.localnet_dispenser() algorand.account.ensure_funded( new_account, dispenser, AlgoAmount.from_algo(100), min_funding_increment=AlgoAmount.from_algo(1) ) - algorand.set_signer(sender=new_account.address, signer=new_account.signer) + algorand.set_signer(sender=new_account.addr, signer=new_account.signer) return new_account @@ -53,33 +55,45 @@ def app_spec_bare_create_abi_delete() -> str: @pytest.fixture -def factory(algorand: AlgorandClient, funded_account: SigningAccount, app_spec: str) -> AppFactory: +def legacy_app_client_test_app_spec() -> str: + return (Path(__file__).parent.parent / "artifacts" / "legacy_app_client_test" / "app_client_test.json").read_text() + + +@pytest.fixture +def legacy_app_client_factory( + algorand: AlgorandClient, funded_account: AddressWithSigners, legacy_app_client_test_app_spec: str +) -> AppFactory: + """Create AppFactory fixture""" + app_spec = arc56.Arc56Contract.from_arc32(legacy_app_client_test_app_spec) + return algorand.client.get_app_factory(app_spec=app_spec, default_sender=funded_account.addr) + + +@pytest.fixture +def factory(algorand: AlgorandClient, funded_account: AddressWithSigners, app_spec: str) -> AppFactory: """Create AppFactory fixture""" - return algorand.client.get_app_factory(app_spec=app_spec, default_sender=funded_account.address) + return algorand.client.get_app_factory(app_spec=app_spec, default_sender=funded_account.addr) @pytest.fixture def factory_bare_create_abi_delete( algorand: AlgorandClient, - funded_account: SigningAccount, + funded_account: AddressWithSigners, app_spec_bare_create_abi_delete: str, ) -> AppFactory: """Create AppFactory fixture for bare create with ABI delete""" - return algorand.client.get_app_factory( - app_spec=app_spec_bare_create_abi_delete, default_sender=funded_account.address - ) + return algorand.client.get_app_factory(app_spec=app_spec_bare_create_abi_delete, default_sender=funded_account.addr) @pytest.fixture def arc56_factory( algorand: AlgorandClient, - funded_account: SigningAccount, + funded_account: AddressWithSigners, ) -> AppFactory: """Create AppFactory fixture""" arc56_raw_spec = ( Path(__file__).parent.parent / "artifacts" / "testing_app_arc56" / "app_spec.arc56.json" ).read_text() - return algorand.client.get_app_factory(app_spec=arc56_raw_spec, default_sender=funded_account.address) + return algorand.client.get_app_factory(app_spec=arc56_raw_spec, default_sender=funded_account.addr) def test_create_app(factory: AppFactory) -> None: @@ -98,8 +112,8 @@ def test_create_app(factory: AppFactory) -> None: assert app_client.app_id > 0 assert app_client.app_address == get_application_address(app_client.app_id) - assert isinstance(result.confirmation, dict) - assert result.confirmation.get("application-index", 0) == app_client.app_id + assert isinstance(result.confirmation, algod_models.PendingTransactionResponse) + assert result.confirmation.app_id == app_client.app_id assert result.compiled_approval is not None assert result.compiled_clear is not None @@ -110,14 +124,14 @@ def test_create_app_with_constructor_deploy_time_params(algorand: AlgorandClient dispenser_account = algorand.account.localnet_dispenser() algorand.account.ensure_funded( account_to_fund=random_account, - dispenser_account=dispenser_account.address, + dispenser_account=dispenser_account.addr, min_spending_balance=AlgoAmount.from_algo(10), min_funding_increment=AlgoAmount.from_algo(1), ) factory = algorand.client.get_app_factory( app_spec=app_spec, - default_sender=random_account.address, + default_sender=random_account.addr, compilation_params={ "deploy_time_params": { # It should strip off the TMPL_ @@ -137,7 +151,7 @@ def test_create_app_with_constructor_deploy_time_params(algorand: AlgorandClient def test_create_app_with_oncomplete_overload(factory: AppFactory) -> None: app_client, result = factory.send.bare.create( params=AppFactoryCreateParams( - on_complete=OnComplete.OptInOC, + on_complete=OnApplicationComplete.OptIn, ), compilation_params={ "updatable": True, @@ -149,11 +163,11 @@ def test_create_app_with_oncomplete_overload(factory: AppFactory) -> None: ) assert result.transaction.application_call - assert result.transaction.application_call.on_complete == OnComplete.OptInOC + assert result.transaction.application_call.on_complete == OnApplicationComplete.OptIn assert app_client.app_id > 0 assert app_client.app_address == get_application_address(app_client.app_id) - assert isinstance(result.confirmation, dict) - assert result.confirmation.get("application-index", 0) == app_client.app_id + assert isinstance(result.confirmation, algod_models.PendingTransactionResponse) + assert result.confirmation.app_id == app_client.app_id def test_deploy_when_immutable_and_permanent(factory: AppFactory) -> None: @@ -200,13 +214,14 @@ def test_deploy_app_create_abi(factory: AppFactory) -> None: create_result = deploy_result.create_result assert create_result is not None assert deploy_result.app.app_id > 0 - app_index = create_result.confirmation["application-index"] # type: ignore[call-overload] + assert create_result.confirmation.app_id is not None + app_index = create_result.confirmation.app_id assert app_client.app_id == deploy_result.app.app_id == app_index assert app_client.app_address == get_application_address(app_client.app_id) def test_deploy_app_update(factory: AppFactory) -> None: - app_client, create_deploy_result = factory.deploy( + _app_client, create_deploy_result = factory.deploy( compilation_params={ "deploy_time_params": { "VALUE": 1, @@ -217,7 +232,7 @@ def test_deploy_app_update(factory: AppFactory) -> None: assert create_deploy_result.operation_performed == OperationPerformed.Create assert create_deploy_result.create_result - updated_app_client, update_deploy_result = factory.deploy( + _updated_app_client, update_deploy_result = factory.deploy( compilation_params={ "deploy_time_params": { "VALUE": 2, @@ -236,18 +251,19 @@ def test_deploy_app_update(factory: AppFactory) -> None: assert create_deploy_result.app.updated_round != update_deploy_result.app.updated_round assert create_deploy_result.app.created_round == update_deploy_result.app.created_round assert update_deploy_result.update_result.confirmation - confirmed_round = update_deploy_result.update_result.confirmation["confirmed-round"] # type: ignore[call-overload] + assert update_deploy_result.update_result.confirmation.confirmed_round is not None + confirmed_round = update_deploy_result.update_result.confirmation.confirmed_round assert update_deploy_result.app.updated_round == confirmed_round -def test_deploy_app_update_detects_extra_page_deficit_as_breaking_change( - algorand: AlgorandClient, funded_account: SigningAccount +def test_deploy_app_update_detects_extra_pages_as_breaking_change( + algorand: AlgorandClient, funded_account: AddressWithSigners ) -> None: small_app_spec = (Path(__file__).parent.parent / "artifacts" / "extra_pages_test" / "small.arc56.json").read_text() large_app_spec = (Path(__file__).parent.parent / "artifacts" / "extra_pages_test" / "large.arc56.json").read_text() factory = algorand.client.get_app_factory( app_spec=small_app_spec, - default_sender=funded_account.address, + default_sender=funded_account.addr, ) small_client, create_deploy_result = factory.deploy( compilation_params={ @@ -257,7 +273,7 @@ def test_deploy_app_update_detects_extra_page_deficit_as_breaking_change( assert create_deploy_result.operation_performed == OperationPerformed.Create assert create_deploy_result.create_result - factory._app_spec = Arc56Contract.from_json(large_app_spec) # noqa: SLF001 + factory._app_spec = arc56.Arc56Contract.from_json(large_app_spec) # noqa: SLF001 large_client, update_deploy_result = factory.deploy( compilation_params={ "updatable": True, @@ -272,13 +288,13 @@ def test_deploy_app_update_detects_extra_page_deficit_as_breaking_change( def test_deploy_app_update_detects_extra_page_surplus_as_non_breaking_change( - algorand: AlgorandClient, funded_account: SigningAccount + algorand: AlgorandClient, funded_account: AddressWithSigners ) -> None: small_app_spec = (Path(__file__).parent.parent / "artifacts" / "extra_pages_test" / "small.arc56.json").read_text() large_app_spec = (Path(__file__).parent.parent / "artifacts" / "extra_pages_test" / "large.arc56.json").read_text() factory = algorand.client.get_app_factory( app_spec=small_app_spec, - default_sender=funded_account.address, + default_sender=funded_account.addr, ) small_client, create_deploy_result = factory.deploy( compilation_params={ @@ -289,7 +305,7 @@ def test_deploy_app_update_detects_extra_page_surplus_as_non_breaking_change( assert create_deploy_result.operation_performed == OperationPerformed.Create assert create_deploy_result.create_result - factory._app_spec = Arc56Contract.from_json(large_app_spec) # noqa: SLF001 + factory._app_spec = arc56.Arc56Contract.from_json(large_app_spec) # noqa: SLF001 large_client, update_deploy_result = factory.deploy( compilation_params={ "updatable": True, @@ -331,11 +347,13 @@ def test_deploy_app_update_abi(factory: AppFactory) -> None: assert update_deploy_result.update_result.confirmation is not None assert update_deploy_result.app.created_round == create_deploy_result.app.created_round assert update_deploy_result.app.updated_round != update_deploy_result.app.created_round + assert update_deploy_result.update_result.confirmation.confirmed_round is not None + assert update_deploy_result.app.updated_round == update_deploy_result.update_result.confirmation.confirmed_round + assert update_deploy_result.update_result.transaction.application_call assert ( - update_deploy_result.app.updated_round == update_deploy_result.update_result.confirmation["confirmed-round"] # type: ignore[call-overload] + update_deploy_result.update_result.transaction.application_call.on_complete + == OnApplicationComplete.UpdateApplication ) - assert update_deploy_result.update_result.transaction.application_call - assert update_deploy_result.update_result.transaction.application_call.on_complete == OnComplete.UpdateApplicationOC assert update_deploy_result.update_result.abi_return == "args_io" @@ -362,9 +380,7 @@ def test_deploy_app_replace(factory: AppFactory) -> None: assert replace_deploy_result.operation_performed == OperationPerformed.Replace assert replace_deploy_result.app.app_id > create_deploy_result.app.app_id - assert replace_deploy_result.app.app_address == algosdk.logic.get_application_address( - replace_deploy_result.app.app_id - ) + assert replace_deploy_result.app.app_address == get_application_address(replace_deploy_result.app.app_id) assert replace_deploy_result.create_result is not None assert replace_deploy_result.delete_result is not None assert replace_deploy_result.delete_result.confirmation is not None @@ -373,9 +389,10 @@ def test_deploy_app_replace(factory: AppFactory) -> None: == 2 ) assert replace_deploy_result.delete_result.transaction.application_call - assert replace_deploy_result.delete_result.transaction.application_call.index == create_deploy_result.app.app_id + assert replace_deploy_result.delete_result.transaction.application_call.app_id == create_deploy_result.app.app_id assert ( - replace_deploy_result.delete_result.transaction.application_call.on_complete == OnComplete.DeleteApplicationOC + replace_deploy_result.delete_result.transaction.application_call.on_complete + == OnApplicationComplete.DeleteApplication ) @@ -406,7 +423,7 @@ def test_deploy_app_replace_abi(factory: AppFactory) -> None: assert replace_deploy_result.operation_performed == OperationPerformed.Replace assert replace_deploy_result.app.app_id > create_deploy_result.app.app_id - assert replace_deploy_result.app.app_address == algosdk.logic.get_application_address(replaced_app_client.app_id) + assert replace_deploy_result.app.app_address == get_application_address(replaced_app_client.app_id) assert replace_deploy_result.create_result is not None assert replace_deploy_result.delete_result is not None assert replace_deploy_result.delete_result.confirmation is not None @@ -415,9 +432,10 @@ def test_deploy_app_replace_abi(factory: AppFactory) -> None: == 2 ) assert replace_deploy_result.delete_result.transaction.application_call - assert replace_deploy_result.delete_result.transaction.application_call.index == create_deploy_result.app.app_id + assert replace_deploy_result.delete_result.transaction.application_call.app_id == create_deploy_result.app.app_id assert ( - replace_deploy_result.delete_result.transaction.application_call.on_complete == OnComplete.DeleteApplicationOC + replace_deploy_result.delete_result.transaction.application_call.on_complete + == OnApplicationComplete.DeleteApplication ) assert replace_deploy_result.create_result.abi_return == "arg_io" assert replace_deploy_result.delete_result.abi_return == "arg2_io" @@ -449,11 +467,11 @@ def test_call_app_with_too_many_args(factory: AppFactory) -> None: }, ) - with pytest.raises(Exception, match="Unexpected arg at position 1. call_abi only expects 1 args"): + with pytest.raises(Exception, match=r"Unexpected arg at position 1\. call_abi only expects 1 args"): app_client.send.call(AppClientMethodCallParams(method="call_abi", args=["test", "extra"])) -def test_call_app_with_rekey(funded_account: SigningAccount, algorand: AlgorandClient, factory: AppFactory) -> None: +def test_call_app_with_rekey(funded_account: AddressWithSigners, algorand: AlgorandClient, factory: AppFactory) -> None: rekey_to = algorand.account.random() app_client, _ = factory.send.bare.create( @@ -466,12 +484,12 @@ def test_call_app_with_rekey(funded_account: SigningAccount, algorand: AlgorandC }, ) - app_client.send.opt_in(AppClientMethodCallParams(method="opt_in", rekey_to=rekey_to.address)) + app_client.send.opt_in(AppClientMethodCallParams(method="opt_in", rekey_to=rekey_to.addr)) # If the rekey didn't work this will throw - rekeyed_account = algorand.account.rekeyed(sender=funded_account.address, account=rekey_to) + rekeyed_account = algorand.account.rekeyed(sender=funded_account.addr, account=rekey_to) algorand.send.payment( - PaymentParams(amount=AlgoAmount.from_algo(0), sender=rekeyed_account.address, receiver=funded_account.address) + PaymentParams(amount=AlgoAmount.from_algo(0), sender=rekeyed_account.addr, receiver=funded_account.addr) ) @@ -544,7 +562,7 @@ def test_delete_app_with_abi(factory: AppFactory) -> None: def test_export_import_sourcemaps( factory: AppFactory, algorand: AlgorandClient, - funded_account: SigningAccount, + funded_account: AddressWithSigners, ) -> None: # Export source maps from original client app_client, _ = factory.deploy(compilation_params={"deploy_time_params": {"VALUE": 1}}) @@ -554,7 +572,7 @@ def test_export_import_sourcemaps( new_client = AppClient( AppClientParams( app_id=app_client.app_id, - default_sender=funded_account.address, + default_sender=funded_account.addr, default_signer=funded_account.signer, algorand=algorand, app_spec=app_client.app_spec, @@ -606,7 +624,7 @@ def test_arc56_error_messages_with_dynamic_template_vars_cblock_offset( def test_arc56_undefined_error_message_with_dynamic_template_vars_cblock_offset( arc56_factory: AppFactory, algorand: AlgorandClient, - funded_account: SigningAccount, + funded_account: AddressWithSigners, ) -> None: # Deploy app with template parameters app_client, _ = arc56_factory.deploy( @@ -626,7 +644,7 @@ def test_arc56_undefined_error_message_with_dynamic_template_vars_cblock_offset( app_client = AppClient( AppClientParams( app_id=app_id, - default_sender=funded_account.address, + default_sender=funded_account.addr, default_signer=funded_account.signer, algorand=algorand, app_spec=app_client.app_spec, @@ -649,11 +667,47 @@ def test_arc56_undefined_error_message_with_dynamic_template_vars_cblock_offset( assert "*abi_route_specificLengthTemplateVar:" in actual_trace +def test_bare_create_update_delete(legacy_app_client_factory: AppFactory) -> None: + client, _ = legacy_app_client_factory.send.bare.create( + compilation_params=AppClientCompilationParams( + deploy_time_params={"TMPL_VERSION": 1}, + deletable=False, + updatable=True, + ) + ) + + # should fail to delete + with pytest.raises(algokit_utils.LogicError, match="// is deletable\n\tassert\t\t<-- Error"): + client.send.bare.delete() + + # make deletable but not updatable + client.send.bare.update( + compilation_params=AppClientCompilationParams( + deploy_time_params={"TMPL_VERSION": 2}, + deletable=True, + updatable=False, + ) + ) + + # should fail to update + with pytest.raises(algokit_utils.LogicError, match="// is updatable\n\tassert\t\t<-- Error"): + client.send.bare.update( + compilation_params=AppClientCompilationParams( + deploy_time_params={"TMPL_VERSION": 3}, + deletable=True, + updatable=False, + ) + ) + + # should delete + client.send.bare.delete() + + def test_bare_create_abi_delete( factory_bare_create_abi_delete: AppFactory, ) -> None: factory = factory_bare_create_abi_delete - app_client, _ = factory.send.bare.create( + _app_client, _ = factory.send.bare.create( compilation_params={ "deploy_time_params": { "GREETING": "Hello, World!", diff --git a/tests/applications/test_app_manager.py b/tests/applications/test_app_manager.py index 61084d69..48c6ac03 100644 --- a/tests/applications/test_app_manager.py +++ b/tests/applications/test_app_manager.py @@ -1,8 +1,8 @@ import pytest +from algokit_transact.signer import AddressWithSigners from algokit_utils.algorand import AlgorandClient from algokit_utils.applications.app_manager import AppManager -from algokit_utils.models.account import SigningAccount from algokit_utils.models.amount import AlgoAmount from tests.conftest import check_output_stability @@ -13,13 +13,13 @@ def algorand() -> AlgorandClient: @pytest.fixture -def funded_account(algorand: AlgorandClient) -> SigningAccount: +def funded_account(algorand: AlgorandClient) -> AddressWithSigners: new_account = algorand.account.random() dispenser = algorand.account.localnet_dispenser() algorand.account.ensure_funded( new_account, dispenser, AlgoAmount.from_algo(100), min_funding_increment=AlgoAmount.from_algo(1) ) - algorand.set_signer(sender=new_account.address, signer=new_account.signer) + algorand.set_signer(sender=new_account.addr, signer=new_account.signer) return new_account diff --git a/tests/applications/test_arc56.py b/tests/applications/test_arc56.py index 67be0e21..d9099d6a 100644 --- a/tests/applications/test_arc56.py +++ b/tests/applications/test_arc56.py @@ -1,7 +1,7 @@ import json from pathlib import Path -from algokit_utils.applications.app_spec.arc56 import Arc56Contract +from algokit_abi import arc32_to_arc56, arc56 from tests.conftest import check_output_stability from tests.utils import load_app_spec @@ -12,7 +12,7 @@ def test_arc56_from_arc32_json() -> None: - arc56_app_spec = Arc56Contract.from_arc32(TEST_ARC32_SPEC_FILE_PATH.read_text()) + arc56_app_spec = arc32_to_arc56(TEST_ARC32_SPEC_FILE_PATH.read_text()) assert arc56_app_spec @@ -24,7 +24,7 @@ def test_arc56_from_arc32_instance() -> None: TEST_ARC32_SPEC_FILE_PATH, arc=32, deletable=True, updatable=True, template_values={"VERSION": 1} ) - arc56_app_spec = Arc56Contract.from_arc32(arc32_app_spec) + arc56_app_spec = arc32_to_arc56(arc32_app_spec) assert arc56_app_spec @@ -32,7 +32,7 @@ def test_arc56_from_arc32_instance() -> None: def test_arc56_from_json() -> None: - arc56_app_spec = Arc56Contract.from_json(TEST_ARC56_SPEC_FILE_PATH.read_text()) + arc56_app_spec = arc56.Arc56Contract.from_json(TEST_ARC56_SPEC_FILE_PATH.read_text()) assert arc56_app_spec @@ -40,7 +40,7 @@ def test_arc56_from_json() -> None: def test_arc56_from_dict() -> None: - arc56_app_spec = Arc56Contract.from_dict(json.loads(TEST_ARC56_SPEC_FILE_PATH.read_text())) + arc56_app_spec = arc56.Arc56Contract.from_dict(json.loads(TEST_ARC56_SPEC_FILE_PATH.read_text())) assert arc56_app_spec @@ -48,7 +48,7 @@ def test_arc56_from_dict() -> None: def test_arc32_state_keys_are_not_normalized() -> None: - arc56_auto_converted_app_spec = Arc56Contract.from_arc32(TEST_STATE_ARC32_SPEC_FILE_PATH.read_text()) + arc56_auto_converted_app_spec = arc32_to_arc56(TEST_STATE_ARC32_SPEC_FILE_PATH.read_text()) raw_app_spec = json.loads(TEST_STATE_ARC32_SPEC_FILE_PATH.read_text()) assert "bytesNotInSnakeCase" in raw_app_spec["schema"]["global"]["declared"] assert "localBytesNotInSnakeCase" in raw_app_spec["schema"]["local"]["declared"] @@ -65,7 +65,7 @@ def test_arc32_state_keys_are_not_normalized() -> None: def test_arc56_state_keys_are_not_normalized() -> None: - arc56_app_spec = Arc56Contract.from_json(TEST_STATE_ARC56_SPEC_FILE_PATH.read_text()) + arc56_app_spec = arc56.Arc56Contract.from_json(TEST_STATE_ARC56_SPEC_FILE_PATH.read_text()) raw_app_spec = json.loads(TEST_STATE_ARC56_SPEC_FILE_PATH.read_text()) assert "bytesNotInSnakeCase" in raw_app_spec["state"]["keys"]["global"] assert "localBytesNotInSnakeCase" in raw_app_spec["state"]["keys"]["local"] diff --git a/tests/artifacts/resource-packer-puya/ExternalAppPuya.approval.puya.map b/tests/artifacts/resource-packer-puya/ExternalAppPuya.approval.puya.map new file mode 100644 index 00000000..4af80823 --- /dev/null +++ b/tests/artifacts/resource-packer-puya/ExternalAppPuya.approval.puya.map @@ -0,0 +1,135 @@ +{ + "version": 3, + "sources": [ + "contract.py" + ], + "mappings": ";AAeA;;AAAA;AAAA;AAAA;;AAAA;;;AAAA;;;;;;AAAA;;;AAAA;;;;AAAA;AAOK;;AAAA;AAPL;;;;;;AAAA;;;AAAA;;;;AAAA;AAGK;;AAAA", + "op_pc_offset": 0, + "pc_events": { + "1": { + "subroutine": "algopy.arc4.ARC4Contract.approval_program", + "params": {}, + "block": "main", + "stack_in": [], + "op": "txn OnCompletion", + "defined_out": [ + "tmp%0#1" + ], + "stack_out": [ + "tmp%0#1" + ] + }, + "3": { + "op": "!", + "defined_out": [ + "tmp%1#0" + ], + "stack_out": [ + "tmp%1#0" + ] + }, + "4": { + "op": "assert", + "stack_out": [] + }, + "5": { + "op": "txn ApplicationID", + "defined_out": [ + "tmp%2#0" + ], + "stack_out": [ + "tmp%2#0" + ] + }, + "7": { + "op": "bz main_create_NoOp@5", + "stack_out": [] + }, + "10": { + "op": "pushbytes 0xa30ce7ff // method \"dummy()void\"", + "defined_out": [ + "Method(dummy()void)" + ], + "stack_out": [ + "Method(dummy()void)" + ] + }, + "16": { + "op": "txna ApplicationArgs 0", + "defined_out": [ + "Method(dummy()void)", + "tmp%4#0" + ], + "stack_out": [ + "Method(dummy()void)", + "tmp%4#0" + ] + }, + "19": { + "op": "match main_dummy_route@3", + "stack_out": [] + }, + "23": { + "op": "err" + }, + "24": { + "block": "main_dummy_route@3", + "stack_in": [], + "op": "pushint 1", + "defined_out": [ + "1" + ], + "stack_out": [ + "1" + ] + }, + "26": { + "op": "return", + "stack_out": [] + }, + "27": { + "block": "main_create_NoOp@5", + "stack_in": [], + "op": "pushbytes 0x752c3ac0 // method \"create_application()void\"", + "defined_out": [ + "Method(create_application()void)" + ], + "stack_out": [ + "Method(create_application()void)" + ] + }, + "33": { + "op": "txna ApplicationArgs 0", + "defined_out": [ + "Method(create_application()void)", + "tmp%5#0" + ], + "stack_out": [ + "Method(create_application()void)", + "tmp%5#0" + ] + }, + "36": { + "op": "match main_create_application_route@6", + "stack_out": [] + }, + "40": { + "op": "err" + }, + "41": { + "block": "main_create_application_route@6", + "stack_in": [], + "op": "pushint 1", + "defined_out": [ + "1" + ], + "stack_out": [ + "1" + ] + }, + "43": { + "op": "return", + "stack_out": [] + } + } +} \ No newline at end of file diff --git a/tests/artifacts/resource-packer-puya/ExternalAppPuya.approval.teal b/tests/artifacts/resource-packer-puya/ExternalAppPuya.approval.teal new file mode 100644 index 00000000..98f72093 --- /dev/null +++ b/tests/artifacts/resource-packer-puya/ExternalAppPuya.approval.teal @@ -0,0 +1,36 @@ +#pragma version 11 +#pragma typetrack false + +// algopy.arc4.ARC4Contract.approval_program() -> uint64: +main: + // contract.py:16 + // class ExternalAppPuya(ARC4Contract): + txn OnCompletion + ! + assert + txn ApplicationID + bz main_create_NoOp@5 + pushbytes 0xa30ce7ff // method "dummy()void" + txna ApplicationArgs 0 + match main_dummy_route@3 + err + +main_dummy_route@3: + // contract.py:23 + // @arc4.abimethod + pushint 1 + return + +main_create_NoOp@5: + // contract.py:16 + // class ExternalAppPuya(ARC4Contract): + pushbytes 0x752c3ac0 // method "create_application()void" + txna ApplicationArgs 0 + match main_create_application_route@6 + err + +main_create_application_route@6: + // contract.py:19 + // @arc4.abimethod(create="require") + pushint 1 + return diff --git a/tests/artifacts/resource-packer-puya/ExternalAppPuya.arc56.json b/tests/artifacts/resource-packer-puya/ExternalAppPuya.arc56.json new file mode 100644 index 00000000..2be6805c --- /dev/null +++ b/tests/artifacts/resource-packer-puya/ExternalAppPuya.arc56.json @@ -0,0 +1,99 @@ +{ + "name": "ExternalAppPuya", + "structs": {}, + "methods": [ + { + "name": "create_application", + "args": [], + "returns": { + "type": "void" + }, + "actions": { + "create": [ + "NoOp" + ], + "call": [] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "dummy", + "args": [], + "returns": { + "type": "void" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "desc": "Empty method used to fill transaction groups.", + "events": [], + "recommendations": {} + } + ], + "arcs": [ + 22, + 28 + ], + "desc": "Simple external app for testing - has a dummy method.", + "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": [], + "pcOffsetMethod": "none" + }, + "clear": { + "sourceInfo": [], + "pcOffsetMethod": "none" + } + }, + "source": { + "approval": "I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuYXBwcm92YWxfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIC8vIGNvbnRyYWN0LnB5OjE2CiAgICAvLyBjbGFzcyBFeHRlcm5hbEFwcFB1eWEoQVJDNENvbnRyYWN0KToKICAgIHR4biBPbkNvbXBsZXRpb24KICAgICEKICAgIGFzc2VydAogICAgdHhuIEFwcGxpY2F0aW9uSUQKICAgIGJ6IG1haW5fY3JlYXRlX05vT3BANQogICAgcHVzaGJ5dGVzIDB4YTMwY2U3ZmYgLy8gbWV0aG9kICJkdW1teSgpdm9pZCIKICAgIHR4bmEgQXBwbGljYXRpb25BcmdzIDAKICAgIG1hdGNoIG1haW5fZHVtbXlfcm91dGVAMwogICAgZXJyCgptYWluX2R1bW15X3JvdXRlQDM6CiAgICAvLyBjb250cmFjdC5weToyMwogICAgLy8gQGFyYzQuYWJpbWV0aG9kCiAgICBwdXNoaW50IDEKICAgIHJldHVybgoKbWFpbl9jcmVhdGVfTm9PcEA1OgogICAgLy8gY29udHJhY3QucHk6MTYKICAgIC8vIGNsYXNzIEV4dGVybmFsQXBwUHV5YShBUkM0Q29udHJhY3QpOgogICAgcHVzaGJ5dGVzIDB4NzUyYzNhYzAgLy8gbWV0aG9kICJjcmVhdGVfYXBwbGljYXRpb24oKXZvaWQiCiAgICB0eG5hIEFwcGxpY2F0aW9uQXJncyAwCiAgICBtYXRjaCBtYWluX2NyZWF0ZV9hcHBsaWNhdGlvbl9yb3V0ZUA2CiAgICBlcnIKCm1haW5fY3JlYXRlX2FwcGxpY2F0aW9uX3JvdXRlQDY6CiAgICAvLyBjb250cmFjdC5weToxOQogICAgLy8gQGFyYzQuYWJpbWV0aG9kKGNyZWF0ZT0icmVxdWlyZSIpCiAgICBwdXNoaW50IDEKICAgIHJldHVybgo=", + "clear": "I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg==" + }, + "byteCode": { + "approval": "CzEZFEQxGEEAEYAEowzn/zYaAI4BAAEAgQFDgAR1LDrANhoAjgEAAQCBAUM=", + "clear": "C4EBQw==" + }, + "compilerInfo": { + "compiler": "puya", + "compilerVersion": { + "major": 5, + "minor": 7, + "patch": 1 + } + }, + "events": [], + "templateVariables": {} +} \ No newline at end of file diff --git a/tests/artifacts/resource-packer-puya/ExternalAppPuya.clear.puya.map b/tests/artifacts/resource-packer-puya/ExternalAppPuya.clear.puya.map new file mode 100644 index 00000000..d580b5c4 --- /dev/null +++ b/tests/artifacts/resource-packer-puya/ExternalAppPuya.clear.puya.map @@ -0,0 +1,25 @@ +{ + "version": 3, + "sources": [], + "mappings": ";;;", + "op_pc_offset": 0, + "pc_events": { + "1": { + "subroutine": "algopy.arc4.ARC4Contract.clear_state_program", + "params": {}, + "block": "main", + "stack_in": [], + "op": "pushint 1", + "defined_out": [ + "1" + ], + "stack_out": [ + "1" + ] + }, + "3": { + "op": "return", + "stack_out": [] + } + } +} \ No newline at end of file diff --git a/tests/artifacts/resource-packer-puya/ExternalAppPuya.clear.teal b/tests/artifacts/resource-packer-puya/ExternalAppPuya.clear.teal new file mode 100644 index 00000000..75f539be --- /dev/null +++ b/tests/artifacts/resource-packer-puya/ExternalAppPuya.clear.teal @@ -0,0 +1,7 @@ +#pragma version 11 +#pragma typetrack false + +// algopy.arc4.ARC4Contract.clear_state_program() -> uint64: +main: + pushint 1 + return diff --git a/tests/artifacts/resource-packer-puya/ResourcePackerPuya.approval.puya.map b/tests/artifacts/resource-packer-puya/ResourcePackerPuya.approval.puya.map new file mode 100644 index 00000000..0c2ac003 --- /dev/null +++ b/tests/artifacts/resource-packer-puya/ResourcePackerPuya.approval.puya.map @@ -0,0 +1,3504 @@ +{ + "version": 3, + "sources": [ + "contract.py" + ], + "mappings": ";;;;;;;AA4BA;;AAAA;AAAA;AAAA;;AAAA;;;AAAA;;;;;;;;;;;;AAAA;;;AAAA;;;;;;AAAA;AAcK;AAAA;AAdL;;;;;;AAAA;;;AAAA;;;;AAAA;AAUK;AAAA;;;;;;AASA;;;AAAA;AAAA;AAAA;;;AAAA;AAAA;AAAA;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;AAAA;AAAA;AAAA;AAAA;AAAA;;AAcL;AAAA;AAAA;AAAA;;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;AACmB;AAAA;AAAA;AAAA;AAAA;AACW;;AAAA;;AACX;AAAP;;;;AAGZ;;AAAA;AAAA;AAAA;;;AAAA;;AAAA;AAAA;;AAAA;AAC8B;;AAAA;AAAA;AACS;;AAAA;AAAA;;AAAA;;AAChB;AAAP;;;;;;;;;;;AAGhB;;AAAA;AAAA;AAAA;;;AAAA;;AAAA;AAAA;;AAAA;AACkC;;AAAA;AAAA;AACP;;AAAA;AAAA;AAAJ;AAAP;;;;;;;;;;;;;;;;;;;AAGhB;;AAAA;AAAA;AAAA;;;AAAA;;AAAA;AAAA;;AAAA;AAC0B;;AAAA;AAAA;AACP;;AAAA;AAAP;;;;;;;;;;;AAGZ;;AAAA;AAAA;AAAA;;;AAAA;;AAAA;AAAA;;AAAA;AAC8B;;AAAA;AAAA;AACd;;AAAA;AAAJ;;;;;;;;;;;AAGZ;;AAAA;AAAA;AAAA;;;AAAA;;AAAA;;AAAA;AAAA;;AAAA;AAAA;AACY;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;;AAA2B;;;;;AAA3B;;;;;;;;AA1CP;AAAA", + "op_pc_offset": 0, + "pc_events": { + "1": { + "subroutine": "algopy.arc4.ARC4Contract.approval_program", + "params": {}, + "block": "main", + "stack_in": [], + "op": "intcblock 1 0 4 32" + }, + "7": { + "op": "txn OnCompletion", + "defined_out": [ + "tmp%0#1" + ], + "stack_out": [ + "tmp%0#1" + ] + }, + "9": { + "op": "!", + "defined_out": [ + "tmp%1#1" + ], + "stack_out": [ + "tmp%1#1" + ] + }, + "10": { + "op": "assert", + "stack_out": [] + }, + "11": { + "op": "txn ApplicationID", + "defined_out": [ + "tmp%2#0" + ], + "stack_out": [ + "tmp%2#0" + ] + }, + "13": { + "op": "bz main_create_NoOp@8", + "stack_out": [] + }, + "16": { + "op": "pushbytess 0xa30ce7ff 0x1929655b // method \"dummy()void\", method \"many_resources(address[4],uint64[4],uint64[4],uint8[4])void\"", + "defined_out": [ + "Method(dummy()void)", + "Method(many_resources(address[4],uint64[4],uint64[4],uint8[4])void)" + ], + "stack_out": [ + "Method(dummy()void)", + "Method(many_resources(address[4],uint64[4],uint64[4],uint8[4])void)" + ] + }, + "28": { + "op": "txna ApplicationArgs 0", + "defined_out": [ + "Method(dummy()void)", + "Method(many_resources(address[4],uint64[4],uint64[4],uint8[4])void)", + "tmp%4#0" + ], + "stack_out": [ + "Method(dummy()void)", + "Method(many_resources(address[4],uint64[4],uint64[4],uint8[4])void)", + "tmp%4#0" + ] + }, + "31": { + "op": "match main_dummy_route@5 many_resources", + "stack_out": [] + }, + "37": { + "op": "err" + }, + "38": { + "block": "main_dummy_route@5", + "stack_in": [], + "op": "intc_0 // 1", + "defined_out": [ + "1" + ], + "stack_out": [ + "1" + ] + }, + "39": { + "op": "return", + "stack_out": [] + }, + "40": { + "block": "main_create_NoOp@8", + "stack_in": [], + "op": "pushbytes 0x752c3ac0 // method \"create_application()void\"", + "defined_out": [ + "Method(create_application()void)" + ], + "stack_out": [ + "Method(create_application()void)" + ] + }, + "46": { + "op": "txna ApplicationArgs 0", + "defined_out": [ + "Method(create_application()void)", + "tmp%5#0" + ], + "stack_out": [ + "Method(create_application()void)", + "tmp%5#0" + ] + }, + "49": { + "op": "match main_create_application_route@9", + "stack_out": [] + }, + "53": { + "op": "err" + }, + "54": { + "block": "main_create_application_route@9", + "stack_in": [], + "op": "intc_0 // 1", + "defined_out": [ + "1" + ], + "stack_out": [ + "1" + ] + }, + "55": { + "op": "return", + "stack_out": [] + }, + "56": { + "subroutine": "contract.ResourcePackerPuya.many_resources[routing]", + "params": {}, + "block": "many_resources", + "stack_in": [], + "op": "intc_1 // 0", + "stack_out": [ + "addr_arc4#0" + ] + }, + "57": { + "op": "pushbytes \"\"", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0" + ] + }, + "59": { + "op": "dupn 4", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0" + ] + }, + "61": { + "op": "txna ApplicationArgs 1" + }, + "64": { + "op": "dup", + "defined_out": [ + "accounts#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "accounts#0" + ] + }, + "65": { + "op": "len", + "defined_out": [ + "accounts#0", + "len%0#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "len%0#0" + ] + }, + "66": { + "op": "pushint 128", + "defined_out": [ + "128", + "accounts#0", + "len%0#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "len%0#0", + "128" + ] + }, + "69": { + "op": "==", + "defined_out": [ + "accounts#0", + "eq%0#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "eq%0#0" + ] + }, + "70": { + "error": "invalid number of bytes for arc4.static_array, 4>", + "op": "assert // invalid number of bytes for arc4.static_array, 4>", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0" + ] + }, + "71": { + "op": "txna ApplicationArgs 2" + }, + "74": { + "op": "dup", + "defined_out": [ + "accounts#0", + "assets#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "assets#0" + ] + }, + "75": { + "op": "len", + "defined_out": [ + "accounts#0", + "assets#0", + "len%1#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "len%1#0" + ] + }, + "76": { + "op": "intc_3 // 32", + "defined_out": [ + "32", + "accounts#0", + "assets#0", + "len%1#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "len%1#0", + "32" + ] + }, + "77": { + "op": "==", + "defined_out": [ + "accounts#0", + "assets#0", + "eq%1#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "eq%1#0" + ] + }, + "78": { + "error": "invalid number of bytes for arc4.static_array", + "op": "assert // invalid number of bytes for arc4.static_array", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0" + ] + }, + "79": { + "op": "txna ApplicationArgs 3" + }, + "82": { + "op": "dup", + "defined_out": [ + "accounts#0", + "apps#0", + "assets#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "apps#0" + ] + }, + "83": { + "op": "len", + "defined_out": [ + "accounts#0", + "apps#0", + "assets#0", + "len%2#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "len%2#0" + ] + }, + "84": { + "op": "intc_3 // 32", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "len%2#0", + "32" + ] + }, + "85": { + "op": "==", + "defined_out": [ + "accounts#0", + "apps#0", + "assets#0", + "eq%2#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "eq%2#0" + ] + }, + "86": { + "error": "invalid number of bytes for arc4.static_array", + "op": "assert // invalid number of bytes for arc4.static_array", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0" + ] + }, + "87": { + "op": "txna ApplicationArgs 4" + }, + "90": { + "op": "dup", + "defined_out": [ + "accounts#0", + "apps#0", + "assets#0", + "boxes#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "boxes#0" + ] + }, + "91": { + "op": "len", + "defined_out": [ + "accounts#0", + "apps#0", + "assets#0", + "boxes#0", + "len%3#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "len%3#0" + ] + }, + "92": { + "op": "intc_2 // 4", + "defined_out": [ + "4", + "accounts#0", + "apps#0", + "assets#0", + "boxes#0", + "len%3#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "len%3#0", + "4" + ] + }, + "93": { + "op": "==", + "defined_out": [ + "accounts#0", + "apps#0", + "assets#0", + "boxes#0", + "eq%3#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "eq%3#0" + ] + }, + "94": { + "error": "invalid number of bytes for arc4.static_array", + "op": "assert // invalid number of bytes for arc4.static_array", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0" + ] + }, + "95": { + "op": "intc_1 // 0", + "defined_out": [ + "accounts#0", + "apps#0", + "assets#0", + "boxes#0", + "item_index_internal%0#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ] + }, + "96": { + "block": "many_resources_for_header@2", + "stack_in": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ], + "op": "dup", + "defined_out": [ + "item_index_internal%0#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%0#0" + ] + }, + "97": { + "op": "intc_2 // 4", + "defined_out": [ + "4", + "item_index_internal%0#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%0#0", + "4" + ] + }, + "98": { + "op": "<", + "defined_out": [ + "continue_looping%0#0", + "item_index_internal%0#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "continue_looping%0#0" + ] + }, + "99": { + "op": "bz many_resources_after_for@13", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ] + }, + "102": { + "op": "dup", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%0#0" + ] + }, + "103": { + "op": "intc_3 // 32", + "defined_out": [ + "32", + "item_index_internal%0#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%0#0", + "32" + ] + }, + "104": { + "op": "*", + "defined_out": [ + "aggregate%bytes_offset%0#0", + "item_index_internal%0#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "aggregate%bytes_offset%0#0" + ] + }, + "105": { + "op": "dig 5", + "defined_out": [ + "accounts#0", + "aggregate%bytes_offset%0#0", + "item_index_internal%0#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "aggregate%bytes_offset%0#0", + "accounts#0" + ] + }, + "107": { + "op": "swap", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "accounts#0", + "aggregate%bytes_offset%0#0" + ] + }, + "108": { + "op": "intc_3 // 32", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "accounts#0", + "aggregate%bytes_offset%0#0", + "32" + ] + }, + "109": { + "error": "index access is out of bounds", + "op": "extract3 // on error: index access is out of bounds", + "defined_out": [ + "accounts#0", + "addr_arc4#0", + "item_index_internal%0#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "addr_arc4#0" + ] + }, + "110": { + "op": "dup", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "addr_arc4#0", + "addr_arc4#0" + ] + }, + "111": { + "op": "bury 12", + "defined_out": [ + "accounts#0", + "addr_arc4#0", + "item_index_internal%0#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "addr_arc4#0" + ] + }, + "113": { + "op": "dup", + "defined_out": [ + "accounts#0", + "addr_arc4#0", + "addr_arc4#0 (copy)", + "item_index_internal%0#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "addr_arc4#0", + "addr_arc4#0 (copy)" + ] + }, + "114": { + "op": "len", + "defined_out": [ + "accounts#0", + "addr_arc4#0", + "item_index_internal%0#0", + "tmp%0#1" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "addr_arc4#0", + "tmp%0#1" + ] + }, + "115": { + "op": "intc_3 // 32", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "addr_arc4#0", + "tmp%0#1", + "32" + ] + }, + "116": { + "op": "==", + "defined_out": [ + "accounts#0", + "addr_arc4#0", + "item_index_internal%0#0", + "tmp%1#1" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "addr_arc4#0", + "tmp%1#1" + ] + }, + "117": { + "error": "Address length is 32 bytes", + "op": "assert // Address length is 32 bytes", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "addr_arc4#0" + ] + }, + "118": { + "op": "acct_params_get AcctMinBalance", + "defined_out": [ + "accounts#0", + "addr_arc4#0", + "exists#0", + "item_index_internal%0#0", + "min_bal#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "min_bal#0", + "exists#0" + ] + }, + "120": { + "op": "bury 1", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "exists#0" + ] + }, + "122": { + "op": "!", + "defined_out": [ + "accounts#0", + "addr_arc4#0", + "item_index_internal%0#0", + "tmp%4#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "tmp%4#0" + ] + }, + "123": { + "error": "account should not be in ledger", + "op": "assert // account should not be in ledger", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ] + }, + "124": { + "op": "intc_1 // 0", + "defined_out": [ + "accounts#0", + "addr_arc4#0", + "item_index_internal%0#0", + "item_index_internal%1#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%1#0" + ] + }, + "125": { + "op": "bury 10", + "defined_out": [ + "accounts#0", + "addr_arc4#0", + "item_index_internal%0#0", + "item_index_internal%1#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ] + }, + "127": { + "block": "many_resources_for_header@4", + "stack_in": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ], + "op": "dig 9", + "defined_out": [ + "item_index_internal%1#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%1#0" + ] + }, + "129": { + "op": "intc_2 // 4", + "defined_out": [ + "4", + "item_index_internal%1#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%1#0", + "4" + ] + }, + "130": { + "op": "<", + "defined_out": [ + "continue_looping%1#0", + "item_index_internal%1#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "continue_looping%1#0" + ] + }, + "131": { + "op": "bz many_resources_after_for@7", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ] + }, + "134": { + "op": "dig 9", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%1#0" + ] + }, + "136": { + "op": "dup", + "defined_out": [ + "item_index_internal%1#0", + "item_index_internal%1#0 (copy)" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%1#0", + "item_index_internal%1#0 (copy)" + ] + }, + "137": { + "op": "pushint 8", + "defined_out": [ + "8", + "item_index_internal%1#0", + "item_index_internal%1#0 (copy)" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%1#0", + "item_index_internal%1#0 (copy)", + "8" + ] + }, + "139": { + "op": "*", + "defined_out": [ + "aggregate%bytes_offset%1#0", + "item_index_internal%1#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%1#0", + "aggregate%bytes_offset%1#0" + ] + }, + "140": { + "op": "dig 5", + "defined_out": [ + "aggregate%bytes_offset%1#0", + "assets#0", + "item_index_internal%1#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%1#0", + "aggregate%bytes_offset%1#0", + "assets#0" + ] + }, + "142": { + "op": "swap", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%1#0", + "assets#0", + "aggregate%bytes_offset%1#0" + ] + }, + "143": { + "op": "extract_uint64", + "defined_out": [ + "asset#0", + "assets#0", + "item_index_internal%1#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%1#0", + "asset#0" + ] + }, + "144": { + "op": "dig 12", + "defined_out": [ + "addr_arc4#0", + "asset#0", + "assets#0", + "item_index_internal%1#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%1#0", + "asset#0", + "addr_arc4#0" + ] + }, + "146": { + "op": "swap", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%1#0", + "addr_arc4#0", + "asset#0" + ] + }, + "147": { + "op": "asset_holding_get AssetBalance", + "defined_out": [ + "addr_arc4#0", + "assets#0", + "balance#0", + "is_opted_in#0", + "item_index_internal%1#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%1#0", + "balance#0", + "is_opted_in#0" + ] + }, + "149": { + "op": "bury 1", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%1#0", + "is_opted_in#0" + ] + }, + "151": { + "op": "!", + "defined_out": [ + "addr_arc4#0", + "assets#0", + "item_index_internal%1#0", + "tmp%8#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%1#0", + "tmp%8#0" + ] + }, + "152": { + "error": "account should not hold asset", + "op": "assert // account should not hold asset", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%1#0" + ] + }, + "153": { + "op": "intc_0 // 1", + "defined_out": [ + "1", + "addr_arc4#0", + "assets#0", + "item_index_internal%1#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%1#0", + "1" + ] + }, + "154": { + "op": "+", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%1#0" + ] + }, + "155": { + "op": "bury 10", + "defined_out": [ + "addr_arc4#0", + "assets#0", + "item_index_internal%1#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ] + }, + "157": { + "op": "b many_resources_for_header@4" + }, + "160": { + "block": "many_resources_after_for@7", + "stack_in": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ], + "op": "intc_1 // 0", + "defined_out": [ + "item_index_internal%2#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%2#0" + ] + }, + "161": { + "op": "bury 9", + "defined_out": [ + "item_index_internal%2#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ] + }, + "163": { + "block": "many_resources_for_header@8", + "stack_in": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ], + "op": "dig 8", + "defined_out": [ + "item_index_internal%2#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%2#0" + ] + }, + "165": { + "op": "intc_2 // 4", + "defined_out": [ + "4", + "item_index_internal%2#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%2#0", + "4" + ] + }, + "166": { + "op": "<", + "defined_out": [ + "continue_looping%2#0", + "item_index_internal%2#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "continue_looping%2#0" + ] + }, + "167": { + "op": "bz many_resources_after_for@11", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ] + }, + "170": { + "op": "dig 8", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%2#0" + ] + }, + "172": { + "op": "dup", + "defined_out": [ + "item_index_internal%2#0", + "item_index_internal%2#0 (copy)" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%2#0", + "item_index_internal%2#0 (copy)" + ] + }, + "173": { + "op": "pushint 8", + "defined_out": [ + "8", + "item_index_internal%2#0", + "item_index_internal%2#0 (copy)" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%2#0", + "item_index_internal%2#0 (copy)", + "8" + ] + }, + "175": { + "op": "*", + "defined_out": [ + "aggregate%bytes_offset%2#0", + "item_index_internal%2#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%2#0", + "aggregate%bytes_offset%2#0" + ] + }, + "176": { + "op": "dig 4", + "defined_out": [ + "aggregate%bytes_offset%2#0", + "apps#0", + "item_index_internal%2#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%2#0", + "aggregate%bytes_offset%2#0", + "apps#0" + ] + }, + "178": { + "op": "swap", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%2#0", + "apps#0", + "aggregate%bytes_offset%2#0" + ] + }, + "179": { + "op": "extract_uint64", + "defined_out": [ + "app#0", + "apps#0", + "item_index_internal%2#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%2#0", + "app#0" + ] + }, + "180": { + "op": "dig 12", + "defined_out": [ + "addr_arc4#0", + "app#0", + "apps#0", + "item_index_internal%2#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%2#0", + "app#0", + "addr_arc4#0" + ] + }, + "182": { + "op": "swap", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%2#0", + "addr_arc4#0", + "app#0" + ] + }, + "183": { + "op": "app_opted_in", + "defined_out": [ + "addr_arc4#0", + "apps#0", + "item_index_internal%2#0", + "tmp%10#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%2#0", + "tmp%10#0" + ] + }, + "184": { + "op": "!", + "defined_out": [ + "addr_arc4#0", + "apps#0", + "item_index_internal%2#0", + "tmp%11#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%2#0", + "tmp%11#0" + ] + }, + "185": { + "error": "account should not be opted into app", + "op": "assert // account should not be opted into app", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%2#0" + ] + }, + "186": { + "op": "intc_0 // 1", + "defined_out": [ + "1", + "addr_arc4#0", + "apps#0", + "item_index_internal%2#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%2#0", + "1" + ] + }, + "187": { + "op": "+", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%2#0" + ] + }, + "188": { + "op": "bury 9", + "defined_out": [ + "addr_arc4#0", + "apps#0", + "item_index_internal%2#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ] + }, + "190": { + "op": "b many_resources_for_header@8" + }, + "193": { + "block": "many_resources_after_for@11", + "stack_in": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ], + "op": "dup", + "defined_out": [ + "item_index_internal%0#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%0#0" + ] + }, + "194": { + "op": "intc_0 // 1", + "defined_out": [ + "1", + "item_index_internal%0#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%0#0", + "1" + ] + }, + "195": { + "op": "+", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%0#0" + ] + }, + "196": { + "op": "bury 1", + "defined_out": [ + "item_index_internal%0#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ] + }, + "198": { + "op": "b many_resources_for_header@2" + }, + "201": { + "block": "many_resources_after_for@13", + "stack_in": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ], + "op": "intc_1 // 0", + "defined_out": [ + "item_index_internal%3#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%3#0" + ] + }, + "202": { + "op": "bury 8", + "defined_out": [ + "item_index_internal%3#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ] + }, + "204": { + "block": "many_resources_for_header@14", + "stack_in": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ], + "op": "dig 7", + "defined_out": [ + "item_index_internal%3#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%3#0" + ] + }, + "206": { + "op": "intc_2 // 4", + "defined_out": [ + "4", + "item_index_internal%3#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%3#0", + "4" + ] + }, + "207": { + "op": "<", + "defined_out": [ + "continue_looping%3#0", + "item_index_internal%3#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "continue_looping%3#0" + ] + }, + "208": { + "op": "bz many_resources_after_for@17", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ] + }, + "211": { + "op": "dig 7", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%3#0" + ] + }, + "213": { + "op": "dup", + "defined_out": [ + "item_index_internal%3#0", + "item_index_internal%3#0 (copy)" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%3#0", + "item_index_internal%3#0 (copy)" + ] + }, + "214": { + "op": "pushint 8", + "defined_out": [ + "8", + "item_index_internal%3#0", + "item_index_internal%3#0 (copy)" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%3#0", + "item_index_internal%3#0 (copy)", + "8" + ] + }, + "216": { + "op": "*", + "defined_out": [ + "aggregate%bytes_offset%3#0", + "item_index_internal%3#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%3#0", + "aggregate%bytes_offset%3#0" + ] + }, + "217": { + "op": "dig 5", + "defined_out": [ + "aggregate%bytes_offset%3#0", + "assets#0", + "item_index_internal%3#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%3#0", + "aggregate%bytes_offset%3#0", + "assets#0" + ] + }, + "219": { + "op": "swap", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%3#0", + "assets#0", + "aggregate%bytes_offset%3#0" + ] + }, + "220": { + "op": "extract_uint64", + "defined_out": [ + "asset#0", + "assets#0", + "item_index_internal%3#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%3#0", + "asset#0" + ] + }, + "221": { + "op": "asset_params_get AssetTotal", + "defined_out": [ + "assets#0", + "check%0#0", + "item_index_internal%3#0", + "value%0#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%3#0", + "value%0#0", + "check%0#0" + ] + }, + "223": { + "error": "asset exists", + "op": "assert // asset exists", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%3#0", + "value%0#0" + ] + }, + "224": { + "error": "asset must have total > 0", + "op": "assert // asset must have total > 0", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%3#0" + ] + }, + "225": { + "op": "intc_0 // 1", + "defined_out": [ + "1", + "assets#0", + "item_index_internal%3#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%3#0", + "1" + ] + }, + "226": { + "op": "+", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%3#0" + ] + }, + "227": { + "op": "bury 8", + "defined_out": [ + "assets#0", + "item_index_internal%3#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ] + }, + "229": { + "op": "b many_resources_for_header@14" + }, + "232": { + "block": "many_resources_after_for@17", + "stack_in": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ], + "op": "intc_1 // 0", + "defined_out": [ + "item_index_internal%4#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%4#0" + ] + }, + "233": { + "op": "bury 7", + "defined_out": [ + "item_index_internal%4#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ] + }, + "235": { + "block": "many_resources_for_header@18", + "stack_in": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ], + "op": "dig 6", + "defined_out": [ + "item_index_internal%4#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%4#0" + ] + }, + "237": { + "op": "intc_2 // 4", + "defined_out": [ + "4", + "item_index_internal%4#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%4#0", + "4" + ] + }, + "238": { + "op": "<", + "defined_out": [ + "continue_looping%4#0", + "item_index_internal%4#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "continue_looping%4#0" + ] + }, + "239": { + "op": "bz many_resources_after_for@21", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ] + }, + "242": { + "op": "dig 6", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%4#0" + ] + }, + "244": { + "op": "dup", + "defined_out": [ + "item_index_internal%4#0", + "item_index_internal%4#0 (copy)" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%4#0", + "item_index_internal%4#0 (copy)" + ] + }, + "245": { + "op": "pushint 8", + "defined_out": [ + "8", + "item_index_internal%4#0", + "item_index_internal%4#0 (copy)" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%4#0", + "item_index_internal%4#0 (copy)", + "8" + ] + }, + "247": { + "op": "*", + "defined_out": [ + "aggregate%bytes_offset%4#0", + "item_index_internal%4#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%4#0", + "aggregate%bytes_offset%4#0" + ] + }, + "248": { + "op": "dig 4", + "defined_out": [ + "aggregate%bytes_offset%4#0", + "apps#0", + "item_index_internal%4#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%4#0", + "aggregate%bytes_offset%4#0", + "apps#0" + ] + }, + "250": { + "op": "swap", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%4#0", + "apps#0", + "aggregate%bytes_offset%4#0" + ] + }, + "251": { + "op": "extract_uint64", + "defined_out": [ + "app#0", + "apps#0", + "item_index_internal%4#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%4#0", + "app#0" + ] + }, + "252": { + "op": "app_params_get AppCreator", + "defined_out": [ + "apps#0", + "check%1#0", + "item_index_internal%4#0", + "value%1#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%4#0", + "value%1#0", + "check%1#0" + ] + }, + "254": { + "error": "application exists", + "op": "assert // application exists", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%4#0", + "value%1#0" + ] + }, + "255": { + "op": "log", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%4#0" + ] + }, + "256": { + "op": "intc_0 // 1", + "defined_out": [ + "1", + "apps#0", + "item_index_internal%4#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%4#0", + "1" + ] + }, + "257": { + "op": "+", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%4#0" + ] + }, + "258": { + "op": "bury 7", + "defined_out": [ + "apps#0", + "item_index_internal%4#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ] + }, + "260": { + "op": "b many_resources_for_header@18" + }, + "263": { + "block": "many_resources_after_for@21", + "stack_in": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ], + "op": "intc_1 // 0", + "defined_out": [ + "item_index_internal%5#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%5#0" + ] + }, + "264": { + "op": "bury 6", + "defined_out": [ + "item_index_internal%5#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ] + }, + "266": { + "block": "many_resources_for_header@22", + "stack_in": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ], + "op": "dig 5", + "defined_out": [ + "item_index_internal%5#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%5#0" + ] + }, + "268": { + "op": "intc_2 // 4", + "defined_out": [ + "4", + "item_index_internal%5#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%5#0", + "4" + ] + }, + "269": { + "op": "<", + "defined_out": [ + "continue_looping%5#0", + "item_index_internal%5#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "continue_looping%5#0" + ] + }, + "270": { + "op": "bz many_resources_after_for@25", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ] + }, + "273": { + "op": "dig 1", + "defined_out": [ + "boxes#0", + "item_index_internal%5#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "boxes#0" + ] + }, + "275": { + "op": "dig 6", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "boxes#0", + "item_index_internal%5#0" + ] + }, + "277": { + "op": "dup", + "defined_out": [ + "boxes#0", + "item_index_internal%5#0", + "item_index_internal%5#0 (copy)" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "boxes#0", + "item_index_internal%5#0 (copy)", + "item_index_internal%5#0 (copy)" + ] + }, + "278": { + "op": "cover 2", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%5#0", + "boxes#0", + "item_index_internal%5#0 (copy)" + ] + }, + "280": { + "op": "intc_0 // 1", + "defined_out": [ + "1", + "boxes#0", + "item_index_internal%5#0", + "item_index_internal%5#0 (copy)" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%5#0", + "boxes#0", + "item_index_internal%5#0 (copy)", + "1" + ] + }, + "281": { + "error": "index access is out of bounds", + "op": "extract3 // on error: index access is out of bounds", + "defined_out": [ + "box_key#0", + "boxes#0", + "item_index_internal%5#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%5#0", + "box_key#0" + ] + }, + "282": { + "op": "pushbytes \"byte_boxes\"", + "defined_out": [ + "\"byte_boxes\"", + "box_key#0", + "boxes#0", + "item_index_internal%5#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%5#0", + "box_key#0", + "\"byte_boxes\"" + ] + }, + "294": { + "op": "swap", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%5#0", + "\"byte_boxes\"", + "box_key#0" + ] + }, + "295": { + "op": "concat", + "defined_out": [ + "box_prefixed_key%0#0", + "boxes#0", + "item_index_internal%5#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%5#0", + "box_prefixed_key%0#0" + ] + }, + "296": { + "op": "dup", + "defined_out": [ + "box_prefixed_key%0#0", + "box_prefixed_key%0#0 (copy)", + "boxes#0", + "item_index_internal%5#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%5#0", + "box_prefixed_key%0#0", + "box_prefixed_key%0#0 (copy)" + ] + }, + "297": { + "op": "box_del", + "defined_out": [ + "box_prefixed_key%0#0", + "boxes#0", + "item_index_internal%5#0", + "{box_del}" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%5#0", + "box_prefixed_key%0#0", + "{box_del}" + ] + }, + "298": { + "op": "pop", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%5#0", + "box_prefixed_key%0#0" + ] + }, + "299": { + "op": "pushbytes 0x666f6f", + "defined_out": [ + "0x666f6f", + "box_prefixed_key%0#0", + "boxes#0", + "item_index_internal%5#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%5#0", + "box_prefixed_key%0#0", + "0x666f6f" + ] + }, + "304": { + "op": "box_put", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%5#0" + ] + }, + "305": { + "op": "intc_0 // 1", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%5#0", + "1" + ] + }, + "306": { + "op": "+", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "item_index_internal%5#0" + ] + }, + "307": { + "op": "bury 6", + "defined_out": [ + "boxes#0", + "item_index_internal%5#0" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ] + }, + "309": { + "op": "b many_resources_for_header@22" + }, + "312": { + "block": "many_resources_after_for@25", + "stack_in": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ], + "op": "intc_0 // 1", + "defined_out": [ + "1" + ], + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0", + "1" + ] + }, + "313": { + "op": "return", + "stack_out": [ + "addr_arc4#0", + "item_index_internal%1#0", + "item_index_internal%2#0", + "item_index_internal%3#0", + "item_index_internal%4#0", + "item_index_internal%5#0", + "accounts#0", + "assets#0", + "apps#0", + "boxes#0", + "item_index_internal%0#0" + ] + } + } +} \ No newline at end of file diff --git a/tests/artifacts/resource-packer-puya/ResourcePackerPuya.approval.teal b/tests/artifacts/resource-packer-puya/ResourcePackerPuya.approval.teal new file mode 100644 index 00000000..b64e7c9c --- /dev/null +++ b/tests/artifacts/resource-packer-puya/ResourcePackerPuya.approval.teal @@ -0,0 +1,279 @@ +#pragma version 11 +#pragma typetrack false + +// algopy.arc4.ARC4Contract.approval_program() -> uint64: +main: + intcblock 1 0 4 32 + // contract.py:29 + // class ResourcePackerPuya(ARC4Contract): + txn OnCompletion + ! + assert + txn ApplicationID + bz main_create_NoOp@8 + pushbytess 0xa30ce7ff 0x1929655b // method "dummy()void", method "many_resources(address[4],uint64[4],uint64[4],uint8[4])void" + txna ApplicationArgs 0 + match main_dummy_route@5 many_resources + err + +main_dummy_route@5: + // contract.py:43 + // @arc4.abimethod + intc_0 // 1 + return + +main_create_NoOp@8: + // contract.py:29 + // class ResourcePackerPuya(ARC4Contract): + pushbytes 0x752c3ac0 // method "create_application()void" + txna ApplicationArgs 0 + match main_create_application_route@9 + err + +main_create_application_route@9: + // contract.py:39 + // @arc4.abimethod(create="require") + intc_0 // 1 + return + + +// contract.ResourcePackerPuya.many_resources[routing]() -> void: +many_resources: + intc_1 // 0 + pushbytes "" + dupn 4 + // contract.py:48 + // @arc4.abimethod + txna ApplicationArgs 1 + dup + len + pushint 128 + == + assert // invalid number of bytes for arc4.static_array, 4> + txna ApplicationArgs 2 + dup + len + intc_3 // 32 + == + assert // invalid number of bytes for arc4.static_array + txna ApplicationArgs 3 + dup + len + intc_3 // 32 + == + assert // invalid number of bytes for arc4.static_array + txna ApplicationArgs 4 + dup + len + intc_2 // 4 + == + assert // invalid number of bytes for arc4.static_array + intc_1 // 0 + +many_resources_for_header@2: + // contract.py:61-62 + // # Reference all accounts by checking they are NOT in the ledger + // for addr_arc4 in accounts: + dup + intc_2 // 4 + < + bz many_resources_after_for@13 + dup + intc_3 // 32 + * + dig 5 + swap + intc_3 // 32 + extract3 // on error: index access is out of bounds + dup + bury 12 + // contract.py:63 + // addr = Account(addr_arc4.bytes) + dup + len + intc_3 // 32 + == + assert // Address length is 32 bytes + // contract.py:64 + // min_bal, exists = op.AcctParamsGet.acct_min_balance(addr) + acct_params_get AcctMinBalance + bury 1 + // contract.py:65 + // assert not exists, "account should not be in ledger" + ! + assert // account should not be in ledger + intc_1 // 0 + bury 10 + +many_resources_for_header@4: + // contract.py:67-68 + // # Check account is not opted into any of the assets + // for asset_arc4 in assets: + dig 9 + intc_2 // 4 + < + bz many_resources_after_for@7 + dig 9 + dup + pushint 8 + * + // contract.py:69 + // asset = Asset(asset_arc4.native) + dig 5 + swap + extract_uint64 + // contract.py:70 + // balance, is_opted_in = op.AssetHoldingGet.asset_balance(addr, asset) + dig 12 + swap + asset_holding_get AssetBalance + bury 1 + // contract.py:71 + // assert not is_opted_in, "account should not hold asset" + ! + assert // account should not hold asset + intc_0 // 1 + + + bury 10 + b many_resources_for_header@4 + +many_resources_after_for@7: + intc_1 // 0 + bury 9 + +many_resources_for_header@8: + // contract.py:73-74 + // # Check account is not opted into any of the apps + // for app_arc4 in apps: + dig 8 + intc_2 // 4 + < + bz many_resources_after_for@11 + dig 8 + dup + pushint 8 + * + // contract.py:75 + // app = Application(app_arc4.native) + dig 4 + swap + extract_uint64 + // contract.py:76 + // assert not addr.is_opted_in(app), "account should not be opted into app" + dig 12 + swap + app_opted_in + ! + assert // account should not be opted into app + intc_0 // 1 + + + bury 9 + b many_resources_for_header@8 + +many_resources_after_for@11: + dup + intc_0 // 1 + + + bury 1 + b many_resources_for_header@2 + +many_resources_after_for@13: + intc_1 // 0 + bury 8 + +many_resources_for_header@14: + // contract.py:78-79 + // # Reference all assets by checking their total supply + // for asset_arc4 in assets: + dig 7 + intc_2 // 4 + < + bz many_resources_after_for@17 + dig 7 + dup + pushint 8 + * + // contract.py:80 + // asset = Asset(asset_arc4.native) + dig 5 + swap + extract_uint64 + // contract.py:81 + // assert asset.total > 0, "asset must have total > 0" + asset_params_get AssetTotal + assert // asset exists + assert // asset must have total > 0 + intc_0 // 1 + + + bury 8 + b many_resources_for_header@14 + +many_resources_after_for@17: + intc_1 // 0 + bury 7 + +many_resources_for_header@18: + // contract.py:83-84 + // # Reference all apps by logging their creator + // for app_arc4 in apps: + dig 6 + intc_2 // 4 + < + bz many_resources_after_for@21 + dig 6 + dup + pushint 8 + * + // contract.py:85 + // app = Application(app_arc4.native) + dig 4 + swap + extract_uint64 + // contract.py:86 + // log(app.creator) + app_params_get AppCreator + assert // application exists + log + intc_0 // 1 + + + bury 7 + b many_resources_for_header@18 + +many_resources_after_for@21: + intc_1 // 0 + bury 6 + +many_resources_for_header@22: + // contract.py:88-89 + // # Reference boxes by writing to them + // for box_key in boxes: + dig 5 + intc_2 // 4 + < + bz many_resources_after_for@25 + dig 1 + dig 6 + dup + cover 2 + intc_0 // 1 + extract3 // on error: index access is out of bounds + // contract.py:90 + // self.byte_boxes[box_key] = Bytes(b"foo") + pushbytes "byte_boxes" + swap + concat + dup + box_del + pop + pushbytes 0x666f6f + box_put + intc_0 // 1 + + + bury 6 + b many_resources_for_header@22 + +many_resources_after_for@25: + // contract.py:48 + // @arc4.abimethod + intc_0 // 1 + return diff --git a/tests/artifacts/resource-packer-puya/ResourcePackerPuya.arc56.json b/tests/artifacts/resource-packer-puya/ResourcePackerPuya.arc56.json new file mode 100644 index 00000000..a3025bc0 --- /dev/null +++ b/tests/artifacts/resource-packer-puya/ResourcePackerPuya.arc56.json @@ -0,0 +1,208 @@ +{ + "name": "ResourcePackerPuya", + "structs": {}, + "methods": [ + { + "name": "create_application", + "args": [], + "returns": { + "type": "void" + }, + "actions": { + "create": [ + "NoOp" + ], + "call": [] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "dummy", + "args": [], + "returns": { + "type": "void" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "desc": "Empty method used to fill transaction groups.", + "events": [], + "recommendations": {} + }, + { + "name": "many_resources", + "args": [ + { + "type": "address[4]", + "name": "accounts" + }, + { + "type": "uint64[4]", + "name": "assets" + }, + { + "type": "uint64[4]", + "name": "apps" + }, + { + "type": "uint8[4]", + "name": "boxes" + } + ], + "returns": { + "type": "void" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "desc": "Method that references many external resources.\nUsed to test that resource population order is deterministic. Mirrors the TEALScript manyResources method.", + "events": [], + "recommendations": {} + } + ], + "arcs": [ + 22, + 28 + ], + "desc": "\n Contract for testing resource population determinism.\n References multiple accounts, assets, apps, and boxes.\n ", + "networks": {}, + "state": { + "schema": { + "global": { + "ints": 0, + "bytes": 0 + }, + "local": { + "ints": 0, + "bytes": 0 + } + }, + "keys": { + "global": {}, + "local": {}, + "box": {} + }, + "maps": { + "global": {}, + "local": {}, + "box": { + "byte_boxes": { + "keyType": "uint8", + "valueType": "AVMBytes", + "prefix": "Ynl0ZV9ib3hlcw==" + } + } + } + }, + "bareActions": { + "create": [], + "call": [] + }, + "sourceInfo": { + "approval": { + "sourceInfo": [ + { + "pc": [ + 117 + ], + "errorMessage": "Address length is 32 bytes" + }, + { + "pc": [ + 123 + ], + "errorMessage": "account should not be in ledger" + }, + { + "pc": [ + 185 + ], + "errorMessage": "account should not be opted into app" + }, + { + "pc": [ + 152 + ], + "errorMessage": "account should not hold asset" + }, + { + "pc": [ + 254 + ], + "errorMessage": "application exists" + }, + { + "pc": [ + 223 + ], + "errorMessage": "asset exists" + }, + { + "pc": [ + 224 + ], + "errorMessage": "asset must have total > 0" + }, + { + "pc": [ + 109, + 281 + ], + "errorMessage": "index access is out of bounds" + }, + { + "pc": [ + 70 + ], + "errorMessage": "invalid number of bytes for arc4.static_array, 4>" + }, + { + "pc": [ + 78, + 86 + ], + "errorMessage": "invalid number of bytes for arc4.static_array" + }, + { + "pc": [ + 94 + ], + "errorMessage": "invalid number of bytes for arc4.static_array" + } + ], + "pcOffsetMethod": "none" + }, + "clear": { + "sourceInfo": [], + "pcOffsetMethod": "none" + } + }, + "source": { + "approval": "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", + "clear": "I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg==" + }, + "byteCode": { + "approval": "CyAEAQAEIDEZFEQxGEEAGIICBKMM5/8EGSllWzYaAI4CAAEAEwAiQ4AEdSw6wDYaAI4BAAEAIkMjgABHBDYaAUkVgYABEkQ2GgJJFSUSRDYaA0kVJRJENhoESRUkEkQjSSQMQQBjSSULSwVMJVhJRQxJFSUSRHMBRQEURCNFCksJJAxBABpLCUmBCAtLBUxbSwxMcABFARREIghFCkL/3yNFCUsIJAxBABdLCEmBCAtLBExbSwxMYRREIghFCUL/4kkiCEUBQv+XI0UISwckDEEAFUsHSYEIC0sFTFtxAEREIghFCEL/5CNFB0sGJAxBABVLBkmBCAtLBExbcgdEsCIIRQdC/+QjRQZLBSQMQQAnSwFLBklOAiJYgApieXRlX2JveGVzTFBJvEiAA2Zvb78iCEUGQv/SIkM=", + "clear": "C4EBQw==" + }, + "compilerInfo": { + "compiler": "puya", + "compilerVersion": { + "major": 5, + "minor": 7, + "patch": 1 + } + }, + "events": [], + "templateVariables": {} +} \ No newline at end of file diff --git a/tests/artifacts/resource-packer-puya/ResourcePackerPuya.clear.puya.map b/tests/artifacts/resource-packer-puya/ResourcePackerPuya.clear.puya.map new file mode 100644 index 00000000..d580b5c4 --- /dev/null +++ b/tests/artifacts/resource-packer-puya/ResourcePackerPuya.clear.puya.map @@ -0,0 +1,25 @@ +{ + "version": 3, + "sources": [], + "mappings": ";;;", + "op_pc_offset": 0, + "pc_events": { + "1": { + "subroutine": "algopy.arc4.ARC4Contract.clear_state_program", + "params": {}, + "block": "main", + "stack_in": [], + "op": "pushint 1", + "defined_out": [ + "1" + ], + "stack_out": [ + "1" + ] + }, + "3": { + "op": "return", + "stack_out": [] + } + } +} \ No newline at end of file diff --git a/tests/artifacts/resource-packer-puya/ResourcePackerPuya.clear.teal b/tests/artifacts/resource-packer-puya/ResourcePackerPuya.clear.teal new file mode 100644 index 00000000..75f539be --- /dev/null +++ b/tests/artifacts/resource-packer-puya/ResourcePackerPuya.clear.teal @@ -0,0 +1,7 @@ +#pragma version 11 +#pragma typetrack false + +// algopy.arc4.ARC4Contract.clear_state_program() -> uint64: +main: + pushint 1 + return diff --git a/tests/artifacts/resource-packer-puya/contract.py b/tests/artifacts/resource-packer-puya/contract.py new file mode 100644 index 00000000..a6846b74 --- /dev/null +++ b/tests/artifacts/resource-packer-puya/contract.py @@ -0,0 +1,89 @@ +from typing import Literal + +from algopy import ( + ARC4Contract, + Account, + Application, + Asset, + BoxMap, + Bytes, + arc4, + log, + op, +) + + +class ExternalAppPuya(ARC4Contract): + """Simple external app for testing - has a dummy method.""" + + @arc4.abimethod(create="require") + def create_application(self) -> None: + pass + + @arc4.abimethod + def dummy(self) -> None: + """Empty method used to fill transaction groups.""" + pass + + +class ResourcePackerPuya(ARC4Contract): + """ + Contract for testing resource population determinism. + References multiple accounts, assets, apps, and boxes. + """ + + def __init__(self) -> None: + # Box storage for testing + self.byte_boxes = BoxMap(arc4.UInt8, Bytes) + + @arc4.abimethod(create="require") + def create_application(self) -> None: + pass + + @arc4.abimethod + def dummy(self) -> None: + """Empty method used to fill transaction groups.""" + pass + + @arc4.abimethod + def many_resources( + self, + accounts: arc4.StaticArray[arc4.Address, Literal[4]], + assets: arc4.StaticArray[arc4.UInt64, Literal[4]], + apps: arc4.StaticArray[arc4.UInt64, Literal[4]], + boxes: arc4.StaticArray[arc4.UInt8, Literal[4]], + ) -> None: + """ + Method that references many external resources. + Used to test that resource population order is deterministic. + """ + # Reference all accounts by checking they are NOT in the ledger + for addr_arc4 in accounts: + addr = Account(addr_arc4.bytes) + min_bal, exists = op.AcctParamsGet.acct_min_balance(addr) + assert not exists, "account should not be in ledger" + + # Check account is not opted into any of the assets + for asset_arc4 in assets: + asset = Asset(asset_arc4.native) + balance, is_opted_in = op.AssetHoldingGet.asset_balance(addr, asset) + assert not is_opted_in, "account should not hold asset" + + # Check account is not opted into any of the apps + for app_arc4 in apps: + app = Application(app_arc4.native) + assert not addr.is_opted_in(app), "account should not be opted into app" + + # Reference all assets by checking their total supply + for asset_arc4 in assets: + asset = Asset(asset_arc4.native) + assert asset.total > 0, "asset must have total > 0" + + # Reference all apps by logging their creator + for app_arc4 in apps: + app = Application(app_arc4.native) + log(app.creator) + + # Reference boxes by writing to them + for box_key in boxes: + self.byte_boxes[box_key] = Bytes(b"foo") diff --git a/tests/assets/test_asset_manager.py b/tests/assets/test_asset_manager.py index 71ff08d4..b4e4639a 100644 --- a/tests/assets/test_asset_manager.py +++ b/tests/assets/test_asset_manager.py @@ -1,7 +1,6 @@ import pytest -from algosdk.atomic_transaction_composer import AccountTransactionSigner -from algokit_utils import SigningAccount +from algokit_transact.signer import AddressWithSigners from algokit_utils.algorand import AlgorandClient from algokit_utils.assets.asset_manager import ( AccountAssetInformation, @@ -21,18 +20,18 @@ def algorand() -> AlgorandClient: @pytest.fixture -def sender(algorand: AlgorandClient) -> SigningAccount: +def sender(algorand: AlgorandClient) -> AddressWithSigners: new_account = algorand.account.random() dispenser = algorand.account.localnet_dispenser() algorand.account.ensure_funded( new_account, dispenser, AlgoAmount.from_algo(100), min_funding_increment=AlgoAmount.from_algo(1) ) - algorand.set_signer(sender=new_account.address, signer=new_account.signer) + algorand.set_signer(sender=new_account.addr, signer=new_account.signer) return new_account @pytest.fixture -def receiver(algorand: AlgorandClient) -> SigningAccount: +def receiver(algorand: AlgorandClient) -> AddressWithSigners: new_account = algorand.account.random() dispenser = algorand.account.localnet_dispenser() algorand.account.ensure_funded( @@ -41,12 +40,12 @@ def receiver(algorand: AlgorandClient) -> SigningAccount: return new_account -def test_get_by_id(algorand: AlgorandClient, sender: SigningAccount) -> None: +def test_get_by_id(algorand: AlgorandClient, sender: AddressWithSigners) -> None: # First create an asset total = 1000 create_result = algorand.send.asset_create( AssetCreateParams( - sender=sender.address, + sender=sender.addr, total=total, decimals=0, default_frozen=False, @@ -55,7 +54,8 @@ def test_get_by_id(algorand: AlgorandClient, sender: SigningAccount) -> None: url="https://example.com", ) ) - asset_id = int(create_result.confirmation["asset-index"]) # type: ignore[call-overload] + assert create_result.confirmation.asset_id is not None + asset_id = create_result.confirmation.asset_id # Then get its info asset_info = algorand.asset.get_by_id(asset_id) @@ -68,15 +68,15 @@ def test_get_by_id(algorand: AlgorandClient, sender: SigningAccount) -> None: assert asset_info.unit_name == "TEST" assert asset_info.asset_name == "Test Asset" assert asset_info.url == "https://example.com" - assert asset_info.creator == sender.address + assert asset_info.creator == sender.addr -def test_get_account_information_with_address(algorand: AlgorandClient, sender: SigningAccount) -> None: +def test_get_account_information_with_address(algorand: AlgorandClient, sender: AddressWithSigners) -> None: # First create an asset total = 1000 create_result = algorand.send.asset_create( AssetCreateParams( - sender=sender.address, + sender=sender.addr, total=total, decimals=0, default_frozen=False, @@ -85,10 +85,11 @@ def test_get_account_information_with_address(algorand: AlgorandClient, sender: url="https://example.com", ) ) - asset_id = int(create_result.confirmation["asset-index"]) # type: ignore[call-overload] + assert create_result.confirmation.asset_id is not None + asset_id = create_result.confirmation.asset_id # Then get account info - account_info = algorand.asset.get_account_information(sender.address, asset_id) + account_info = algorand.asset.get_account_information(sender.addr, asset_id) assert isinstance(account_info, AccountAssetInformation) assert account_info.asset_id == asset_id @@ -96,12 +97,12 @@ def test_get_account_information_with_address(algorand: AlgorandClient, sender: assert account_info.frozen is False -def test_get_account_information_with_account(algorand: AlgorandClient, sender: SigningAccount) -> None: +def test_get_account_information_with_account(algorand: AlgorandClient, sender: AddressWithSigners) -> None: # First create an asset total = 1000 create_result = algorand.send.asset_create( AssetCreateParams( - sender=sender.address, + sender=sender.addr, total=total, decimals=0, default_frozen=False, @@ -110,7 +111,8 @@ def test_get_account_information_with_account(algorand: AlgorandClient, sender: url="https://example.com", ) ) - asset_id = int(create_result.confirmation["asset-index"]) # type: ignore[call-overload] + assert create_result.confirmation.asset_id is not None + asset_id = create_result.confirmation.asset_id # Then get account info account_info = algorand.asset.get_account_information(sender, asset_id) @@ -121,12 +123,12 @@ def test_get_account_information_with_account(algorand: AlgorandClient, sender: assert account_info.frozen is False -def test_get_account_information_with_transaction_signer(algorand: AlgorandClient, sender: SigningAccount) -> None: +def test_get_account_information_with_transaction_signer(algorand: AlgorandClient, sender: AddressWithSigners) -> None: # First create an asset total = 1000 create_result = algorand.send.asset_create( AssetCreateParams( - sender=sender.address, + sender=sender.addr, total=total, decimals=0, default_frozen=False, @@ -135,11 +137,11 @@ def test_get_account_information_with_transaction_signer(algorand: AlgorandClien url="https://example.com", ) ) - asset_id = int(create_result.confirmation["asset-index"]) # type: ignore[call-overload] + asset_id = create_result.confirmation.asset_id + assert asset_id # Then get account info using transaction signer - signer = AccountTransactionSigner(sender.private_key) - account_info = algorand.asset.get_account_information(signer, asset_id) + account_info = algorand.asset.get_account_information(sender, asset_id) assert isinstance(account_info, AccountAssetInformation) assert account_info.asset_id == asset_id @@ -147,13 +149,15 @@ def test_get_account_information_with_transaction_signer(algorand: AlgorandClien assert account_info.frozen is False -def test_bulk_opt_in_with_address(algorand: AlgorandClient, sender: SigningAccount, receiver: SigningAccount) -> None: +def test_bulk_opt_in_with_address( + algorand: AlgorandClient, sender: AddressWithSigners, receiver: AddressWithSigners +) -> None: # First create some assets - asset_ids = [] + asset_ids: list[int] = [] for i in range(3): create_result = algorand.send.asset_create( AssetCreateParams( - sender=sender.address, + sender=sender.addr, total=1000, decimals=0, default_frozen=False, @@ -163,20 +167,20 @@ def test_bulk_opt_in_with_address(algorand: AlgorandClient, sender: SigningAccou signer=sender.signer, ) ) - asset_id = int(create_result.confirmation["asset-index"]) # type: ignore[call-overload] - asset_ids.append(asset_id) + assert create_result.confirmation.asset_id is not None + asset_ids.append(create_result.confirmation.asset_id) # Fund receiver algorand.send.payment( PaymentParams( - sender=sender.address, - receiver=receiver.address, + sender=sender.addr, + receiver=receiver.addr, amount=AlgoAmount.from_algo(1), ) ) # Then bulk opt-in - results = algorand.asset.bulk_opt_in(receiver.address, asset_ids, signer=receiver.signer) + results = algorand.asset.bulk_opt_in(receiver.addr, asset_ids, signer=receiver.signer) assert len(results) == len(asset_ids) for result in results: @@ -186,12 +190,12 @@ def test_bulk_opt_in_with_address(algorand: AlgorandClient, sender: SigningAccou def test_bulk_opt_out_not_opted_in_fails( - algorand: AlgorandClient, sender: SigningAccount, receiver: SigningAccount + algorand: AlgorandClient, sender: AddressWithSigners, receiver: AddressWithSigners ) -> None: # First create an asset create_result = algorand.send.asset_create( AssetCreateParams( - sender=sender.address, + sender=sender.addr, total=1000, decimals=0, default_frozen=False, @@ -200,17 +204,18 @@ def test_bulk_opt_out_not_opted_in_fails( url="https://example.com", ) ) - asset_id = int(create_result.confirmation["asset-index"]) # type: ignore[call-overload] + assert create_result.confirmation.asset_id is not None + asset_id = create_result.confirmation.asset_id # Fund receiver but don't opt-in algorand.send.payment( PaymentParams( - sender=sender.address, - receiver=receiver.address, + sender=sender.addr, + receiver=receiver.addr, amount=AlgoAmount.from_algo(1), ) ) # Then attempt to opt-out with pytest.raises(ValueError, match="is not opted-in"): - algorand.asset.bulk_opt_out(account=receiver.address, asset_ids=[asset_id]) + algorand.asset.bulk_opt_out(account=receiver.addr, asset_ids=[asset_id]) diff --git a/tests/clients/algorand_client/test_transfer.py b/tests/clients/algorand_client/test_transfer.py index 285cc9e1..50de7fc2 100644 --- a/tests/clients/algorand_client/test_transfer.py +++ b/tests/clients/algorand_client/test_transfer.py @@ -2,9 +2,10 @@ import pytest from pytest_httpx._httpx_mock import HTTPXMock +from algokit_transact.signer import AddressWithSigners +from algokit_utils.accounts.account_manager import AccountInformation from algokit_utils.algorand import AlgorandClient from algokit_utils.clients.dispenser_api_client import DispenserApiConfig, TestNetDispenserApiClient -from algokit_utils.models.account import SigningAccount from algokit_utils.models.amount import AlgoAmount from algokit_utils.transactions.transaction_composer import ( AssetOptInParams, @@ -20,23 +21,23 @@ def algorand() -> AlgorandClient: @pytest.fixture -def funded_account(algorand: AlgorandClient) -> SigningAccount: +def funded_account(algorand: AlgorandClient) -> AddressWithSigners: new_account = algorand.account.random() dispenser = algorand.account.localnet_dispenser() algorand.account.ensure_funded( new_account, dispenser, AlgoAmount.from_algo(100), min_funding_increment=AlgoAmount.from_algo(1) ) - algorand.set_signer(sender=new_account.address, signer=new_account.signer) + algorand.set_signer(sender=new_account.addr, signer=new_account.signer) return new_account -def test_transfer_algo_is_sent_and_waited_for(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_transfer_algo_is_sent_and_waited_for(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: second_account = algorand.account.random() result = algorand.send.payment( PaymentParams( - sender=funded_account.address, - receiver=second_account.address, + sender=funded_account.addr, + receiver=second_account.addr, amount=AlgoAmount.from_algo(5), note=b"Transfer 5 Algos", ) @@ -45,19 +46,19 @@ def test_transfer_algo_is_sent_and_waited_for(algorand: AlgorandClient, funded_a account_info = algorand.account.get_information(second_account) assert result.transaction.payment - assert result.transaction.payment.amt == 5_000_000 + assert result.transaction.payment.amount == 5_000_000 - assert result.transaction.payment.sender == funded_account.address == result.confirmation["txn"]["txn"]["snd"] # type: ignore # noqa: PGH003 + assert result.transaction.sender == funded_account.addr == result.confirmation.txn.txn.sender assert account_info.amount == 5_000_000 -def test_transfer_algo_respects_string_lease(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_transfer_algo_respects_string_lease(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: second_account = algorand.account.random() algorand.send.payment( PaymentParams( - sender=funded_account.address, - receiver=second_account.address, + sender=funded_account.addr, + receiver=second_account.addr, amount=AlgoAmount.from_algo(1), lease=b"test", ) @@ -66,21 +67,21 @@ def test_transfer_algo_respects_string_lease(algorand: AlgorandClient, funded_ac with pytest.raises(Exception, match="overlapping lease"): algorand.send.payment( PaymentParams( - sender=funded_account.address, - receiver=second_account.address, + sender=funded_account.addr, + receiver=second_account.addr, amount=AlgoAmount.from_algo(2), lease=b"test", ) ) -def test_transfer_algo_respects_byte_array_lease(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_transfer_algo_respects_byte_array_lease(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: second_account = algorand.account.random() algorand.send.payment( PaymentParams( - sender=funded_account.address, - receiver=second_account.address, + sender=funded_account.addr, + receiver=second_account.addr, amount=AlgoAmount.from_algo(1), lease=b"\x01\x02\x03\x04", ) @@ -89,15 +90,15 @@ def test_transfer_algo_respects_byte_array_lease(algorand: AlgorandClient, funde with pytest.raises(Exception, match="overlapping lease"): algorand.send.payment( PaymentParams( - sender=funded_account.address, - receiver=second_account.address, + sender=funded_account.addr, + receiver=second_account.addr, amount=AlgoAmount.from_algo(2), lease=b"\x01\x02\x03\x04", ) ) -def test_transfer_asa_respects_lease(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_transfer_asa_respects_lease(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: test_asset_id = generate_test_asset(algorand, funded_account, 100) second_account = algorand.account.random() @@ -110,15 +111,15 @@ def test_transfer_asa_respects_lease(algorand: AlgorandClient, funded_account: S algorand.send.asset_opt_in( AssetOptInParams( - sender=second_account.address, + sender=second_account.addr, asset_id=test_asset_id, ) ) algorand.send.asset_transfer( AssetTransferParams( - sender=funded_account.address, - receiver=second_account.address, + sender=funded_account.addr, + receiver=second_account.addr, asset_id=test_asset_id, amount=1, lease=b"test", @@ -128,8 +129,8 @@ def test_transfer_asa_respects_lease(algorand: AlgorandClient, funded_account: S with pytest.raises(Exception, match="overlapping lease"): algorand.send.asset_transfer( AssetTransferParams( - sender=funded_account.address, - receiver=second_account.address, + sender=funded_account.addr, + receiver=second_account.addr, asset_id=test_asset_id, amount=2, lease=b"test", @@ -139,7 +140,7 @@ def test_transfer_asa_respects_lease(algorand: AlgorandClient, funded_account: S def test_transfer_asa_receiver_not_opted_in( algorand: AlgorandClient, - funded_account: SigningAccount, + funded_account: AddressWithSigners, ) -> None: test_asset_id = generate_test_asset(algorand, funded_account, 100) second_account = algorand.account.random() @@ -147,8 +148,8 @@ def test_transfer_asa_receiver_not_opted_in( with pytest.raises(Exception, match="receiver error: must optin"): algorand.send.asset_transfer( AssetTransferParams( - sender=funded_account.address, - receiver=second_account.address, + sender=funded_account.addr, + receiver=second_account.addr, asset_id=test_asset_id, amount=1, note=b"Transfer 5 assets with id %d" % test_asset_id, @@ -156,7 +157,7 @@ def test_transfer_asa_receiver_not_opted_in( ) -def test_transfer_asa_sender_not_opted_in(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_transfer_asa_sender_not_opted_in(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: test_asset_id = generate_test_asset(algorand, funded_account, 100) second_account = algorand.account.random() algorand.account.ensure_funded( @@ -166,11 +167,11 @@ def test_transfer_asa_sender_not_opted_in(algorand: AlgorandClient, funded_accou min_funding_increment=AlgoAmount.from_algo(1), ) - with pytest.raises(Exception, match=f"asset {test_asset_id} missing from {second_account.address}"): + with pytest.raises(Exception, match=f"asset {test_asset_id} missing from {second_account.addr}"): algorand.send.asset_transfer( AssetTransferParams( - sender=second_account.address, - receiver=funded_account.address, + sender=second_account.addr, + receiver=funded_account.addr, asset_id=test_asset_id, amount=1, note=b"Transfer 5 assets with id %d" % test_asset_id, @@ -178,7 +179,7 @@ def test_transfer_asa_sender_not_opted_in(algorand: AlgorandClient, funded_accou ) -def test_transfer_asa_asset_doesnt_exist(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_transfer_asa_asset_doesnt_exist(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: second_account = algorand.account.random() algorand.account.ensure_funded( account_to_fund=second_account, @@ -187,11 +188,11 @@ def test_transfer_asa_asset_doesnt_exist(algorand: AlgorandClient, funded_accoun min_funding_increment=AlgoAmount.from_algo(1), ) - with pytest.raises(Exception, match=f"asset 123123 missing from {funded_account.address}"): + with pytest.raises(Exception, match=f"asset 123123 missing from {funded_account.addr}"): algorand.send.asset_transfer( AssetTransferParams( - sender=funded_account.address, - receiver=second_account.address, + sender=funded_account.addr, + receiver=second_account.addr, asset_id=123123, amount=5, note=b"Transfer asset with wrong id", @@ -199,7 +200,7 @@ def test_transfer_asa_asset_doesnt_exist(algorand: AlgorandClient, funded_accoun ) -def test_transfer_asa_to_another_account(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_transfer_asa_to_another_account(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: test_asset_id = generate_test_asset(algorand, funded_account, 100) second_account = algorand.account.random() algorand.account.ensure_funded( @@ -214,15 +215,15 @@ def test_transfer_asa_to_another_account(algorand: AlgorandClient, funded_accoun algorand.send.asset_opt_in( AssetOptInParams( - sender=second_account.address, + sender=second_account.addr, asset_id=test_asset_id, ) ) algorand.send.asset_transfer( AssetTransferParams( - sender=funded_account.address, - receiver=second_account.address, + sender=funded_account.addr, + receiver=second_account.addr, asset_id=test_asset_id, amount=5, note=b"Transfer 5 assets with id %d" % test_asset_id, @@ -236,7 +237,7 @@ def test_transfer_asa_to_another_account(algorand: AlgorandClient, funded_accoun assert test_account_info.balance == 95 -def test_transfer_asa_from_revocation_target(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_transfer_asa_from_revocation_target(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: test_asset_id = generate_test_asset(algorand, funded_account, 100) second_account = algorand.account.random() clawback_account = algorand.account.random() @@ -256,22 +257,22 @@ def test_transfer_asa_from_revocation_target(algorand: AlgorandClient, funded_ac algorand.send.asset_opt_in( AssetOptInParams( - sender=second_account.address, + sender=second_account.addr, asset_id=test_asset_id, ) ) algorand.send.asset_opt_in( AssetOptInParams( - sender=clawback_account.address, + sender=clawback_account.addr, asset_id=test_asset_id, ) ) algorand.send.asset_transfer( AssetTransferParams( - sender=funded_account.address, - receiver=clawback_account.address, + sender=funded_account.addr, + receiver=clawback_account.addr, asset_id=test_asset_id, amount=5, note=b"Transfer 5 assets with id %d" % test_asset_id, @@ -283,12 +284,12 @@ def test_transfer_asa_from_revocation_target(algorand: AlgorandClient, funded_ac algorand.send.asset_transfer( AssetTransferParams( - sender=funded_account.address, - receiver=second_account.address, + sender=funded_account.addr, + receiver=second_account.addr, asset_id=test_asset_id, amount=5, note=b"Transfer 5 assets with id %d" % test_asset_id, - clawback_target=clawback_account.address, + clawback_target=clawback_account.addr, ) ) @@ -307,7 +308,7 @@ def test_transfer_asa_from_revocation_target(algorand: AlgorandClient, funded_ac ) # see https://dev.algorand.co/concepts/smart-contracts/costs-constraints#mbr -def test_ensure_funded(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_ensure_funded(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: test_account = algorand.account.random() response = algorand.account.ensure_funded( account_to_fund=test_account, @@ -317,7 +318,8 @@ def test_ensure_funded(algorand: AlgorandClient, funded_account: SigningAccount) assert response is not None to_account_info = algorand.account.get_information(test_account) - assert to_account_info.amount == MINIMUM_BALANCE + AlgoAmount.from_algo(1) + expected_balance = MINIMUM_BALANCE + AlgoAmount.from_algo(1) + assert to_account_info.amount == expected_balance.micro_algo def test_ensure_funded_uses_dispenser_by_default( @@ -334,14 +336,15 @@ def test_ensure_funded_uses_dispenser_by_default( assert result is not None assert result.transaction.payment is not None - assert result.transaction.payment.sender == dispenser.address + assert result.transaction.sender == dispenser.addr account_info = algorand.account.get_information(second_account) - assert account_info.amount == MINIMUM_BALANCE + AlgoAmount.from_algo(1) + expected_balance = MINIMUM_BALANCE + AlgoAmount.from_algo(1) + assert account_info.amount == expected_balance.micro_algo def test_ensure_funded_respects_minimum_funding_increment( - algorand: AlgorandClient, funded_account: SigningAccount + algorand: AlgorandClient, funded_account: AddressWithSigners ) -> None: test_account = algorand.account.random() response = algorand.account.ensure_funded( @@ -353,7 +356,7 @@ def test_ensure_funded_respects_minimum_funding_increment( assert response is not None to_account_info = algorand.account.get_information(test_account) - assert to_account_info.amount == AlgoAmount.from_algo(1) + assert to_account_info.amount == AlgoAmount.from_algo(1).micro_algo def test_ensure_funded_testnet_api_success(monkeypatch: pytest.MonkeyPatch, httpx_mock: HTTPXMock) -> None: @@ -369,6 +372,19 @@ def test_ensure_funded_testnet_api_success(monkeypatch: pytest.MonkeyPatch, http json={"amount": 1, "txID": "dummy_tx_id"}, ) + fake_account_info = AccountInformation( + address=account_to_fund.addr, + amount=AlgoAmount.from_micro_algo(0), + amount_without_pending_rewards=AlgoAmount.from_micro_algo(0), + min_balance=AlgoAmount.from_micro_algo(100_000), + pending_rewards=AlgoAmount.from_micro_algo(0), + rewards=AlgoAmount.from_micro_algo(0), + round=1, + status="Offline", + ) + monkeypatch.setattr(algorand.account, "get_information", lambda _: fake_account_info) + monkeypatch.setattr(algorand.account._client_manager, "is_testnet", lambda: True) # noqa: SLF001 + result = algorand.account.ensure_funded_from_testnet_dispenser_api( account_to_fund=account_to_fund, dispenser_client=TestNetDispenserApiClient(), @@ -404,6 +420,19 @@ def test_ensure_funded_testnet_api_bad_response(monkeypatch: pytest.MonkeyPatch, method="POST", ) + fake_account_info = AccountInformation( + address=account_to_fund.addr, + amount=AlgoAmount.from_micro_algo(0), + amount_without_pending_rewards=AlgoAmount.from_micro_algo(0), + min_balance=AlgoAmount.from_micro_algo(100_000), + pending_rewards=AlgoAmount.from_micro_algo(0), + rewards=AlgoAmount.from_micro_algo(0), + round=1, + status="Offline", + ) + monkeypatch.setattr(algorand.account, "get_information", lambda _: fake_account_info) + monkeypatch.setattr(algorand.account._client_manager, "is_testnet", lambda: True) # noqa: SLF001 + with pytest.raises(Exception, match="fund_limit_exceeded"): algorand.account.ensure_funded_from_testnet_dispenser_api( account_to_fund=account_to_fund, @@ -412,16 +441,16 @@ def test_ensure_funded_testnet_api_bad_response(monkeypatch: pytest.MonkeyPatch, ) -def test_rekey_works(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_rekey_works(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: second_account = algorand.account.random() - algorand.account.rekey_account(funded_account.address, second_account, note=b"rekey") + algorand.account.rekey_account(funded_account.addr, second_account, note=b"rekey") # This will throw if the rekey wasn't successful algorand.send.payment( PaymentParams( - sender=funded_account.address, - receiver=funded_account.address, + sender=funded_account.addr, + receiver=funded_account.addr, amount=AlgoAmount.from_micro_algo(1), signer=second_account.signer, ) diff --git a/tests/conftest.py b/tests/conftest.py index fab07acf..0dbd1752 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -9,14 +9,14 @@ import pytest from dotenv import load_dotenv -from algokit_utils import ( - ApplicationClient, - ApplicationSpecification, - SigningAccount, - replace_template_variables, -) +from algokit_transact.signer import AddressWithSigners from algokit_utils.algorand import AlgorandClient -from algokit_utils.applications.app_manager import DELETABLE_TEMPLATE_NAME, UPDATABLE_TEMPLATE_NAME +from algokit_utils.applications import Arc32Contract +from algokit_utils.applications.app_manager import ( + DELETABLE_TEMPLATE_NAME, + UPDATABLE_TEMPLATE_NAME, + AppManager, +) from algokit_utils.transactions.transaction_composer import AssetCreateParams if TYPE_CHECKING: @@ -74,9 +74,9 @@ def read_spec( updatable: bool | None = None, deletable: bool | None = None, template_values: dict | None = None, -) -> ApplicationSpecification: +) -> Arc32Contract: path = Path(__file__).parent / file_name - spec = ApplicationSpecification.from_json(Path(path).read_text(encoding="utf-8")) + spec = Arc32Contract.from_json(Path(path).read_text(encoding="utf-8")) template_variables = template_values or {} if updatable is not None: @@ -86,7 +86,7 @@ def read_spec( template_variables["DELETABLE"] = int(deletable) spec.approval_program = ( - replace_template_variables(spec.approval_program, template_variables) + AppManager.replace_template_variables(spec.approval_program, template_variables) .replace(f"// {UPDATABLE_TEMPLATE_NAME}", "// updatable") .replace(f"// {DELETABLE_TEMPLATE_NAME}", "// deletable") ) @@ -96,7 +96,7 @@ def read_spec( def get_specs( updatable: bool | None = None, deletable: bool | None = None, -) -> tuple[ApplicationSpecification, ApplicationSpecification, ApplicationSpecification]: +) -> tuple[Arc32Contract, Arc32Contract, Arc32Contract]: return ( read_spec("app_v1.json", updatable=updatable, deletable=deletable), read_spec("app_v2.json", updatable=updatable, deletable=deletable), @@ -110,15 +110,7 @@ def get_unique_name() -> str: return name -def is_opted_in(client_fixture: ApplicationClient) -> bool: - _, sender = client_fixture.resolve_signer_sender() - account_info = client_fixture.algod_client.account_info(sender) - assert isinstance(account_info, dict) - apps_local_state = account_info["apps-local-state"] - return any(x for x in apps_local_state if x["id"] == client_fixture.app_id) - - -def generate_test_asset(algorand: AlgorandClient, sender: SigningAccount, total: int | None) -> int: +def generate_test_asset(algorand: AlgorandClient, sender: AddressWithSigners, total: int | None) -> int: if total is None: total = math.floor(random.random() * 100) + 20 @@ -127,18 +119,19 @@ def generate_test_asset(algorand: AlgorandClient, sender: SigningAccount, total: create_result = algorand.send.asset_create( AssetCreateParams( - sender=sender.address, + sender=sender.addr, total=total, decimals=decimals, default_frozen=False, unit_name="CFG", asset_name=asset_name, url="https://example.com", - manager=sender.address, - reserve=sender.address, - freeze=sender.address, - clawback=sender.address, + manager=sender.addr, + reserve=sender.addr, + freeze=sender.addr, + clawback=sender.addr, ) ) - return int(create_result.confirmation["asset-index"]) # type: ignore[call-overload] + assert create_result.confirmation.asset_id is not None + return int(create_result.confirmation.asset_id) diff --git a/tests/crypto/test_wrapped_secrets.py b/tests/crypto/test_wrapped_secrets.py new file mode 100644 index 00000000..c0383257 --- /dev/null +++ b/tests/crypto/test_wrapped_secrets.py @@ -0,0 +1,309 @@ +"""Tests for wrapped secret protocols and AccountManager.from_secret.""" + +import os + +import pytest + +from algokit_algo25 import mnemonic_from_seed +from algokit_crypto import ( + WrappedHdMnemonic, + WrappedLegacyMnemonic, + ed25519_signing_key_from_wrapped_secret, + ed25519_verifier, + hd_root_key_from_mnemonic, + hd_seed_from_mnemonic, + pynacl_ed25519_generator, +) +from algokit_utils.algorand import AlgorandClient + + +class TestWrappedHdMnemonicSigning: + """Tests for wrapped HD mnemonic signing.""" + + def test_wrapped_hd_mnemonic_signing(self) -> None: + """Create a wrapped HD mnemonic, get signing key, sign, and verify.""" + # Generate a random seed and convert to mnemonic + seed = os.urandom(64) + # For testing, we'll use a class that wraps the seed derived HD mnemonic + + class WrappedHdMnemonicImpl: + def __init__(self, mnemonic: str) -> None: + self._mnemonic = mnemonic + + def unwrap_hd_mnemonic(self) -> str: + return self._mnemonic + + def wrap_hd_mnemonic(self) -> None: + pass + + # Generate an HD wallet from a seed and get account 0 + from algokit_crypto import peikert_hd_wallet_generator + + seed_bytes = bytearray(seed) + wallet = peikert_hd_wallet_generator(seed_bytes) + _ = wallet["account_generator"](0, 0) # Verify wallet works + + # Create a wrapped HD mnemonic using the same seed + # (Note: xhd-wallet-api doesn't expose mnemonic generation, so we test with seed directly) + # For this test, we'll use a known BIP39 mnemonic + test_mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about" + + wrapped = WrappedHdMnemonicImpl(test_mnemonic) + + # Verify it's recognized as a WrappedHdMnemonic + assert isinstance(wrapped, WrappedHdMnemonic) + + # Get signing key + signing_key = ed25519_signing_key_from_wrapped_secret(wrapped) + message = b"wrapped HD mnemonic test" + signature = signing_key["raw_ed25519_signer"](message) + + # Verify + assert ed25519_verifier(signature, message, signing_key["ed25519_pubkey"]) is True + + def test_wrapped_hd_mnemonic_without_wrap_method(self) -> None: + """HD mnemonic without wrap method should still work.""" + + class WrappedHdMnemonicNoWrap: + def __init__(self, mnemonic: str) -> None: + self._mnemonic = mnemonic + + def unwrap_hd_mnemonic(self) -> str: + return self._mnemonic + + # Note: no wrap_hd_mnemonic method + + test_mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about" + wrapped = WrappedHdMnemonicNoWrap(test_mnemonic) + + # Should work without wrap method + signing_key = ed25519_signing_key_from_wrapped_secret(wrapped) + message = b"test without wrap" + signature = signing_key["raw_ed25519_signer"](message) + + assert ed25519_verifier(signature, message, signing_key["ed25519_pubkey"]) is True + + +class TestWrappedLegacyMnemonicSigning: + """Tests for wrapped legacy mnemonic signing.""" + + def test_wrapped_legacy_mnemonic_signing(self) -> None: + """Create a wrapped legacy mnemonic, get signing key, sign, and verify.""" + # Generate a random keypair and get its mnemonic + keypair = pynacl_ed25519_generator() + seed = keypair["ed25519_secret_key"][:32] + mnemonic = mnemonic_from_seed(seed) + + class WrappedLegacyMnemonicImpl: + def __init__(self, mnemonic: str) -> None: + self._mnemonic = mnemonic + + def unwrap_legacy_mnemonic(self) -> str: + return self._mnemonic + + def wrap_legacy_mnemonic(self) -> None: + pass + + wrapped = WrappedLegacyMnemonicImpl(mnemonic) + + # Verify it's recognized as a WrappedLegacyMnemonic + assert isinstance(wrapped, WrappedLegacyMnemonic) + + # Get signing key + signing_key = ed25519_signing_key_from_wrapped_secret(wrapped) + message = b"wrapped legacy mnemonic test" + signature = signing_key["raw_ed25519_signer"](message) + + # Verify signature + assert ed25519_verifier(signature, message, signing_key["ed25519_pubkey"]) is True + + # Verify the public key matches the original + assert signing_key["ed25519_pubkey"] == keypair["ed25519_pubkey"] + + def test_wrapped_legacy_mnemonic_without_wrap_method(self) -> None: + """Legacy mnemonic without wrap method should still work.""" + # Generate a random keypair and get its mnemonic + keypair = pynacl_ed25519_generator() + seed = keypair["ed25519_secret_key"][:32] + mnemonic = mnemonic_from_seed(seed) + + class WrappedLegacyMnemonicNoWrap: + def __init__(self, mnemonic: str) -> None: + self._mnemonic = mnemonic + + def unwrap_legacy_mnemonic(self) -> str: + return self._mnemonic + + # Note: no wrap_legacy_mnemonic method + + wrapped = WrappedLegacyMnemonicNoWrap(mnemonic) + + # Should work without wrap method + signing_key = ed25519_signing_key_from_wrapped_secret(wrapped) + message = b"test without wrap" + signature = signing_key["raw_ed25519_signer"](message) + + assert ed25519_verifier(signature, message, signing_key["ed25519_pubkey"]) is True + + +class TestHdHelperFunctions: + """Tests for HD wallet helper functions.""" + + def test_hd_seed_from_mnemonic(self) -> None: + """Test converting mnemonic to seed.""" + mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about" + seed = hd_seed_from_mnemonic(mnemonic) + + # Should be 64 bytes + assert len(seed) == 64 + + def test_hd_root_key_from_mnemonic(self) -> None: + """Test converting mnemonic directly to root key.""" + mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about" + root_key = hd_root_key_from_mnemonic(mnemonic) + + # Should be 96 bytes + assert len(root_key) == 96 + + def test_hd_seed_from_mnemonic_invalid_length(self) -> None: + """Test that invalid seed length raises ValueError.""" + from algokit_crypto.hd import hd_root_key_from_seed + + short_seed = bytearray(32) + with pytest.raises(ValueError, match="Seed must be 64 bytes"): + hd_root_key_from_seed(short_seed) + + +class TestAccountManagerFromSecret: + """Tests for AccountManager.from_secret method.""" + + @pytest.fixture + def algorand(self) -> AlgorandClient: + return AlgorandClient.default_localnet() + + def test_from_secret_with_ed25519_seed(self, algorand: AlgorandClient) -> None: + """Test from_secret with Ed25519 seed.""" + # Generate a random seed + seed = os.urandom(32) + + class WrappedSeed: + def unwrap_ed25519_seed(self) -> bytearray: + return bytearray(seed) + + account = algorand.account.from_secret(secret=WrappedSeed()) + + # Verify account was created + assert account.addr + assert len(account.addr) == 58 # Algorand address length + assert account.signer is not None + + # Verify we can get the signer + signer = algorand.account.get_signer(account.addr) + assert signer is not None + + def test_from_secret_with_hd_mnemonic(self, algorand: AlgorandClient) -> None: + """Test from_secret with HD mnemonic.""" + + class WrappedHdMnemonicImpl: + def unwrap_hd_mnemonic(self) -> str: + return "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about" + + account = algorand.account.from_secret(secret=WrappedHdMnemonicImpl()) + + # Verify account was created + assert account.addr + assert len(account.addr) == 58 + assert account.signer is not None + + def test_from_secret_with_legacy_mnemonic(self, algorand: AlgorandClient) -> None: + """Test from_secret with legacy mnemonic.""" + # Generate a random keypair and get its mnemonic + keypair = pynacl_ed25519_generator() + seed = keypair["ed25519_secret_key"][:32] + mnemonic = mnemonic_from_seed(seed) + + class WrappedLegacyMnemonicImpl: + def unwrap_legacy_mnemonic(self) -> str: + return mnemonic + + account = algorand.account.from_secret(secret=WrappedLegacyMnemonicImpl()) + + # Verify account was created + assert account.addr + assert len(account.addr) == 58 + assert account.signer is not None + + # Verify the address matches expected + expected_address = algorand.account.from_mnemonic(mnemonic=mnemonic).addr + assert account.addr == expected_address + + def test_from_secret_with_sender(self, algorand: AlgorandClient) -> None: + """Test from_secret with sender address for rekeyed accounts.""" + # Generate a random seed + seed = os.urandom(32) + sender = "XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA" + + class WrappedSeed: + def unwrap_ed25519_seed(self) -> bytearray: + return bytearray(seed) + + account = algorand.account.from_secret(secret=WrappedSeed(), sender=sender) + + # Verify account was created with the sender address + assert account.addr == sender + assert account.signer is not None + + def test_from_mnemonic_deprecated(self, algorand: AlgorandClient) -> None: + """Test that from_mnemonic raises deprecation warning.""" + # Generate a random keypair and get its mnemonic + keypair = pynacl_ed25519_generator() + seed = keypair["ed25519_secret_key"][:32] + mnemonic = mnemonic_from_seed(seed) + + with pytest.warns(DeprecationWarning, match="from_mnemonic is deprecated"): + account = algorand.account.from_mnemonic(mnemonic=mnemonic) + + # Account should still be created + assert account.addr + + +class TestOptionalWrapMethods: + """Tests that wrap methods are truly optional.""" + + def test_ed25519_seed_without_wrap(self) -> None: + """Ed25519 seed without wrap method should work.""" + seed = os.urandom(32) + + class WrappedSeedNoWrap: + def unwrap_ed25519_seed(self) -> bytearray: + return bytearray(seed) + + # Note: no wrap_ed25519_seed method + + wrapped = WrappedSeedNoWrap() + signing_key = ed25519_signing_key_from_wrapped_secret(wrapped) + + message = b"test" + signature = signing_key["raw_ed25519_signer"](message) + assert ed25519_verifier(signature, message, signing_key["ed25519_pubkey"]) is True + + def test_hd_extended_key_without_wrap(self) -> None: + """HD extended key without wrap method should work.""" + from algokit_crypto import peikert_hd_wallet_generator + + wallet = peikert_hd_wallet_generator() + account = wallet["account_generator"](0, 0) + extended_key = bytearray(account["extended_private_key"]) + + class WrappedHdKeyNoWrap: + def unwrap_hd_extended_private_key(self) -> bytearray: + return bytearray(extended_key) + + # Note: no wrap_hd_extended_private_key method + + wrapped = WrappedHdKeyNoWrap() + signing_key = ed25519_signing_key_from_wrapped_secret(wrapped) + + message = b"test" + signature = signing_key["raw_ed25519_signer"](message) + assert ed25519_verifier(signature, message, signing_key["ed25519_pubkey"]) is True diff --git a/tests/fixtures/__init__.py b/tests/fixtures/__init__.py new file mode 100644 index 00000000..f0ca41c5 --- /dev/null +++ b/tests/fixtures/__init__.py @@ -0,0 +1 @@ +"""Test fixtures for algokit-utils tests.""" diff --git a/tests/fixtures/schemas/__init__.py b/tests/fixtures/schemas/__init__.py new file mode 100644 index 00000000..dc056f72 --- /dev/null +++ b/tests/fixtures/schemas/__init__.py @@ -0,0 +1 @@ +"""Pydantic validation schemas for testing API clients.""" diff --git a/tests/fixtures/schemas/algod.py b/tests/fixtures/schemas/algod.py new file mode 100644 index 00000000..cd0222bb --- /dev/null +++ b/tests/fixtures/schemas/algod.py @@ -0,0 +1,886 @@ +"""Generated Pydantic validation schemas from OpenAPI spec.""" + +from __future__ import annotations + +from typing import Any + +from pydantic import BaseModel, ConfigDict, Field, RootModel + + +class AccountParticipationSchema(BaseModel): + """AccountParticipation describes the parameters used by this account in consensus protocol.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + selection_participation_key: str = Field(alias="selection-participation-key") + vote_first_valid: int = Field(alias="vote-first-valid") + vote_key_dilution: int = Field(alias="vote-key-dilution") + vote_last_valid: int = Field(alias="vote-last-valid") + vote_participation_key: str = Field(alias="vote-participation-key") + state_proof_key: str | None = Field(default=None, alias="state-proof-key") + + +class ApplicationStateSchemaSchema(BaseModel): + """Specifies maximums on the number of each type that may be stored.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + num_uints: int = Field(ge=0, le=64, alias="num-uint") + num_byte_slices: int = Field(ge=0, le=64, alias="num-byte-slice") + + +class TealValueSchema(BaseModel): + """Represents a TEAL value.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + type_: int = Field(alias="type") + bytes_: str = Field(alias="bytes") + uint: int = Field(ge=0, le=18446744073709551615, alias="uint") + + +class TealKeyValueSchema(BaseModel): + """Represents a key-value pair in an application store.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + key: str = Field(alias="key") + value: TealValueSchema = Field(alias="value") + + +class TealKeyValueStoreSchema(RootModel[list[TealKeyValueSchema]]): + """Represents a key-value store for use in an application.""" + + +class ApplicationParamsSchema(BaseModel): + """Stores the global information associated with an application.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + creator: str = Field(alias="creator") + approval_program: str = Field(alias="approval-program") + clear_state_program: str = Field(alias="clear-state-program") + extra_program_pages: int | None = Field(default=None, ge=0, le=3, alias="extra-program-pages") + local_state_schema: ApplicationStateSchemaSchema | None = Field(default=None, alias="local-state-schema") + global_state_schema: ApplicationStateSchemaSchema | None = Field(default=None, alias="global-state-schema") + global_state: TealKeyValueStoreSchema | None = Field(default=None, alias="global-state") + version: int | None = Field(default=None, alias="version") + + +class ApplicationSchema(BaseModel): + """Application index and its parameters""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + id_: int = Field(alias="id") + params: ApplicationParamsSchema = Field(alias="params") + + +class ApplicationLocalStateSchema(BaseModel): + """Stores local state associated with an application.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + id_: int = Field(alias="id") + schema_: ApplicationStateSchemaSchema = Field(alias="schema") + key_value: TealKeyValueStoreSchema | None = Field(default=None, alias="key-value") + + +class AssetParamsSchema(BaseModel): + """AssetParams specifies the parameters for an asset. + + \\[apar\\] when part of an AssetConfig transaction. + + De...""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + clawback: str | None = Field(default=None, alias="clawback") + creator: str = Field(alias="creator") + decimals: int = Field(ge=0, le=19, alias="decimals") + default_frozen: bool | None = Field(default=None, alias="default-frozen") + freeze: str | None = Field(default=None, alias="freeze") + manager: str | None = Field(default=None, alias="manager") + metadata_hash: str | None = Field(default=None, alias="metadata-hash") + name: str | None = Field(default=None, alias="name") + name_b64: str | None = Field(default=None, alias="name-b64") + reserve: str | None = Field(default=None, alias="reserve") + total: int = Field(ge=0, le=18446744073709551615, alias="total") + unit_name: str | None = Field(default=None, alias="unit-name") + unit_name_b64: str | None = Field(default=None, alias="unit-name-b64") + url: str | None = Field(default=None, alias="url") + url_b64: str | None = Field(default=None, alias="url-b64") + + +class AssetSchema(BaseModel): + """Specifies both the unique identifier and the parameters for an asset""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + id_: int = Field(alias="index") + params: AssetParamsSchema = Field(alias="params") + + +class AssetHoldingSchema(BaseModel): + """Describes an asset held by an account. + + Definition: + data/basics/userBalance.go : AssetHolding""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + amount: int = Field(ge=0, le=18446744073709551615, alias="amount") + asset_id: int = Field(alias="asset-id") + is_frozen: bool = Field(alias="is-frozen") + + +class AccountSchema(BaseModel): + """Account information at a given round. + + Definition: + data/basics/userBalance.go : AccountData + """ + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + address: str = Field(alias="address") + amount: int = Field(ge=0, le=18446744073709551615, alias="amount") + min_balance: int = Field(ge=0, le=18446744073709551615, alias="min-balance") + amount_without_pending_rewards: int = Field(ge=0, le=18446744073709551615, alias="amount-without-pending-rewards") + apps_local_state: list[ApplicationLocalStateSchema] | None = Field(default=None, alias="apps-local-state") + total_apps_opted_in: int = Field(alias="total-apps-opted-in") + apps_total_schema: ApplicationStateSchemaSchema | None = Field(default=None, alias="apps-total-schema") + apps_total_extra_pages: int | None = Field(default=None, alias="apps-total-extra-pages") + assets: list[AssetHoldingSchema] | None = Field(default=None, alias="assets") + total_assets_opted_in: int = Field(alias="total-assets-opted-in") + created_apps: list[ApplicationSchema] | None = Field(default=None, alias="created-apps") + total_created_apps: int = Field(alias="total-created-apps") + created_assets: list[AssetSchema] | None = Field(default=None, alias="created-assets") + total_created_assets: int = Field(alias="total-created-assets") + total_boxes: int | None = Field(default=None, alias="total-boxes") + total_box_bytes: int | None = Field(default=None, alias="total-box-bytes") + participation: AccountParticipationSchema | None = Field(default=None, alias="participation") + incentive_eligible: bool | None = Field(default=None, alias="incentive-eligible") + pending_rewards: int = Field(ge=0, le=18446744073709551615, alias="pending-rewards") + reward_base: int | None = Field(default=None, ge=0, le=18446744073709551615, alias="reward-base") + rewards: int = Field(ge=0, le=18446744073709551615, alias="rewards") + round_: int = Field(alias="round") + status: str = Field(alias="status") + sig_type: str | None = Field(default=None, alias="sig-type") + auth_addr: str | None = Field(default=None, alias="auth-addr") + last_proposed: int | None = Field(default=None, alias="last-proposed") + last_heartbeat: int | None = Field(default=None, alias="last-heartbeat") + + +class AccountApplicationResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + round_: int = Field(alias="round") + app_local_state: ApplicationLocalStateSchema | None = Field(default=None, alias="app-local-state") + created_app: ApplicationParamsSchema | None = Field(default=None, alias="created-app") + + +class AccountAssetHoldingSchema(BaseModel): + """AccountAssetHolding describes the account's asset holding and asset parameters (if either exist) for a spec...""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + asset_holding: AssetHoldingSchema = Field(alias="asset-holding") + asset_params: AssetParamsSchema | None = Field(default=None, alias="asset-params") + + +class AccountAssetResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + round_: int = Field(alias="round") + asset_holding: AssetHoldingSchema | None = Field(default=None, alias="asset-holding") + created_asset: AssetParamsSchema | None = Field(default=None, alias="created-asset") + + +class AccountAssetsInformationResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + round_: int = Field(alias="round") + next_token: str | None = Field(default=None, alias="next-token") + asset_holdings: list[AccountAssetHoldingSchema] | None = Field(default=None, alias="asset-holdings") + + +class EvalDeltaSchema(BaseModel): + """Represents a TEAL value delta.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + action: int = Field(alias="action") + bytes_: str | None = Field(default=None, alias="bytes") + uint: int | None = Field(default=None, ge=0, le=18446744073709551615, alias="uint") + + +class EvalDeltaKeyValueSchema(BaseModel): + """Key-value pairs for StateDelta.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + key: str = Field(alias="key") + value: EvalDeltaSchema = Field(alias="value") + + +class StateDeltaSchema(RootModel[list[EvalDeltaKeyValueSchema]]): + """Application state delta.""" + + +class AccountStateDeltaSchema(BaseModel): + """Application state delta.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + address: str = Field(alias="address") + delta: StateDeltaSchema = Field(alias="delta") + + +class AppCallLogsSchema(BaseModel): + """The logged messages from an app call along with the app ID and outer transaction ID. Logs appear in the sam...""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + logs: list[str] = Field(alias="logs") + app_id: int = Field(alias="application-index") + tx_id: str = Field(alias="txId") + + +class AvmValueSchema(BaseModel): + """Represents an AVM value.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + type_: int = Field(alias="type") + bytes_: str | None = Field(default=None, alias="bytes") + uint: int | None = Field(default=None, ge=0, le=18446744073709551615, alias="uint") + + +class AvmKeyValueSchema(BaseModel): + """Represents an AVM key-value pair in an application store.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + key: str = Field(alias="key") + value: AvmValueSchema = Field(alias="value") + + +class ApplicationKVStorageSchema(BaseModel): + """An application's global/local/box state.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + kvs: list[AvmKeyValueSchema] = Field(alias="kvs") + account: str | None = Field(default=None, alias="account") + + +class ApplicationInitialStatesSchema(BaseModel): + """An application's initial global/local/box states that were accessed during simulation.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + id_: int = Field(alias="id") + app_locals: list[ApplicationKVStorageSchema] | None = Field(default=None, alias="app-locals") + app_globals: ApplicationKVStorageSchema | None = Field(default=None, alias="app-globals") + app_boxes: ApplicationKVStorageSchema | None = Field(default=None, alias="app-boxes") + + +class ApplicationLocalReferenceSchema(BaseModel): + """References an account's local state for an application.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + account: str = Field(alias="account") + app: int = Field(alias="app") + + +class ApplicationStateOperationSchema(BaseModel): + """An operation against an application's global/local/box state.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + operation: str = Field(alias="operation") + app_state_type: str = Field(alias="app-state-type") + key: str = Field(alias="key") + new_value: AvmValueSchema | None = Field(default=None, alias="new-value") + account: str | None = Field(default=None, alias="account") + + +class AssetHoldingReferenceSchema(BaseModel): + """References an asset held by an account.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + account: str = Field(alias="account") + asset: int = Field(alias="asset") + + +class BlockHashResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + block_hash: str = Field(alias="blockHash") + + +class BlockLogsResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + logs: list[AppCallLogsSchema] = Field(alias="logs") + + +class BlockResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + block: dict[str, Any] = Field(alias="block") + cert: dict[str, Any] | None = Field(default=None, alias="cert") + + +class BlockTxidsResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + block_tx_ids: list[str] = Field(alias="blockTxids") + + +class BoxSchema(BaseModel): + """Box name and its content.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + round_: int = Field(alias="round") + name: str = Field(alias="name") + value: str = Field(alias="value") + + +class BoxDescriptorSchema(BaseModel): + """Box descriptor describes a Box.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + name: str = Field(alias="name") + + +class BoxReferenceSchema(BaseModel): + """References a box of an application.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + app: int = Field(alias="app") + name: str = Field(alias="name") + + +class BoxesResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + boxes: list[BoxDescriptorSchema] = Field(alias="boxes") + + +class BuildVersionSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + branch: str = Field(alias="branch") + build_number: int = Field(alias="build_number") + channel: str = Field(alias="channel") + commit_hash: str = Field(alias="commit_hash") + major: int = Field(alias="major") + minor: int = Field(alias="minor") + + +class CatchpointAbortResponseSchema(BaseModel): + """An catchpoint abort response.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + catchup_message: str = Field(alias="catchup-message") + + +class CatchpointStartResponseSchema(BaseModel): + """An catchpoint start response.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + catchup_message: str = Field(alias="catchup-message") + + +class SourceMapSchema(BaseModel): + """Source map for the program""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + version: int = Field(alias="version") + sources: list[str] = Field(alias="sources") + names: list[str] = Field(alias="names") + mappings: str = Field(alias="mappings") + + +class CompileResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + hash_: str = Field(alias="hash") + result: str = Field(alias="result") + sourcemap: SourceMapSchema | None = Field(default=None, alias="sourcemap") + + +class DebugSettingsProfSchema(BaseModel): + """algod mutex and blocking profiling state.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + block_rate: int | None = Field(default=None, ge=0, le=18446744073709551615, alias="block-rate") + mutex_rate: int | None = Field(default=None, ge=0, le=18446744073709551615, alias="mutex-rate") + + +class DisassembleResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + result: str = Field(alias="result") + + +class DryrunSourceSchema(BaseModel): + """DryrunSource is TEAL source text that gets uploaded, compiled, and inserted into transactions or applicatio...""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + field_name: str = Field(alias="field-name") + source: str = Field(alias="source") + txn_index: int = Field(alias="txn-index") + app_id: int = Field(alias="app-index") + + +class DryrunRequestSchema(BaseModel): + """Request data type for dryrun endpoint. Given the Transactions and simulated ledger state upload, run TEAL s...""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + txns: list[str] = Field(alias="txns") + accounts: list[AccountSchema] = Field(alias="accounts") + apps: list[ApplicationSchema] = Field(alias="apps") + protocol_version: str = Field(alias="protocol-version") + round_: int = Field(alias="round") + latest_timestamp: int = Field(ge=0, alias="latest-timestamp") + sources: list[DryrunSourceSchema] = Field(alias="sources") + + +class DryrunStateSchema(BaseModel): + """Stores the TEAL eval step data""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + line: int = Field(alias="line") + pc: int = Field(alias="pc") + stack: list[TealValueSchema] = Field(alias="stack") + scratch: list[TealValueSchema] | None = Field(default=None, alias="scratch") + error: str | None = Field(default=None, alias="error") + + +class DryrunTxnResultSchema(BaseModel): + """DryrunTxnResult contains any LogicSig or ApplicationCall program debug information and state updates from a...""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + disassembly: list[str] = Field(alias="disassembly") + logic_sig_disassembly: list[str] | None = Field(default=None, alias="logic-sig-disassembly") + logic_sig_trace: list[DryrunStateSchema] | None = Field(default=None, alias="logic-sig-trace") + logic_sig_messages: list[str] | None = Field(default=None, alias="logic-sig-messages") + app_call_trace: list[DryrunStateSchema] | None = Field(default=None, alias="app-call-trace") + app_call_messages: list[str] | None = Field(default=None, alias="app-call-messages") + global_delta: StateDeltaSchema | None = Field(default=None, alias="global-delta") + local_deltas: list[AccountStateDeltaSchema] | None = Field(default=None, alias="local-deltas") + logs: list[str] | None = Field(default=None, alias="logs") + budget_added: int | None = Field(default=None, alias="budget-added") + budget_consumed: int | None = Field(default=None, alias="budget-consumed") + + +class DryrunResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + txns: list[DryrunTxnResultSchema] = Field(alias="txns") + error: str = Field(alias="error") + protocol_version: str = Field(alias="protocol-version") + + +class ErrorResponseSchema(BaseModel): + """An error response with optional data field.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + data: dict[str, Any] | None = Field(default=None, alias="data") + message: str = Field(alias="message") + + +class GenesisAllocationSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + addr: str = Field(alias="addr") + comment: str = Field(alias="comment") + state: dict[str, Any] = Field(alias="state") + + +class GenesisSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + alloc: list[GenesisAllocationSchema] = Field(alias="alloc") + comment: str | None = Field(default=None, alias="comment") + devmode: bool | None = Field(default=None, alias="devmode") + fees: str = Field(alias="fees") + id_: str = Field(alias="id") + network: str = Field(alias="network") + proto: str = Field(alias="proto") + rwd: str = Field(alias="rwd") + timestamp: int | None = Field(default=None, alias="timestamp") + + +class GetBlockTimeStampOffsetResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + offset: int = Field(alias="offset") + + +class GetSyncRoundResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + round_: int = Field(alias="round") + + +class LedgerStateDeltaSchema(BaseModel): + """Ledger StateDelta object""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True, extra="allow") + + +class LedgerStateDeltaForTransactionGroupSchema(BaseModel): + """Contains a ledger delta for a single transaction group""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + delta: LedgerStateDeltaSchema = Field(alias="Delta") + ids: list[str] = Field(alias="Ids") + + +class LightBlockHeaderProofSchema(BaseModel): + """Proof of membership and position of a light block header.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + index: int = Field(alias="index") + treedepth: int = Field(alias="treedepth") + proof: str = Field(alias="proof") + + +class NodeStatusResponseSchema(BaseModel): + """NodeStatus contains the information about a node status""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + catchup_time: int = Field(alias="catchup-time") + last_round: int = Field(alias="last-round") + last_version: str = Field(alias="last-version") + next_version: str = Field(alias="next-version") + next_version_round: int = Field(alias="next-version-round") + next_version_supported: bool = Field(alias="next-version-supported") + stopped_at_unsupported_round: bool = Field(alias="stopped-at-unsupported-round") + time_since_last_round: int = Field(alias="time-since-last-round") + last_catchpoint: str | None = Field(default=None, alias="last-catchpoint") + catchpoint: str | None = Field(default=None, alias="catchpoint") + catchpoint_total_accounts: int | None = Field(default=None, alias="catchpoint-total-accounts") + catchpoint_processed_accounts: int | None = Field(default=None, alias="catchpoint-processed-accounts") + catchpoint_verified_accounts: int | None = Field(default=None, alias="catchpoint-verified-accounts") + catchpoint_total_kvs: int | None = Field(default=None, alias="catchpoint-total-kvs") + catchpoint_processed_kvs: int | None = Field(default=None, alias="catchpoint-processed-kvs") + catchpoint_verified_kvs: int | None = Field(default=None, alias="catchpoint-verified-kvs") + catchpoint_total_blocks: int | None = Field(default=None, alias="catchpoint-total-blocks") + catchpoint_acquired_blocks: int | None = Field(default=None, alias="catchpoint-acquired-blocks") + upgrade_delay: int | None = Field(default=None, alias="upgrade-delay") + upgrade_node_vote: bool | None = Field(default=None, alias="upgrade-node-vote") + upgrade_votes_required: int | None = Field(default=None, alias="upgrade-votes-required") + upgrade_votes: int | None = Field(default=None, alias="upgrade-votes") + upgrade_yes_votes: int | None = Field(default=None, alias="upgrade-yes-votes") + upgrade_no_votes: int | None = Field(default=None, alias="upgrade-no-votes") + upgrade_next_protocol_vote_before: int | None = Field(default=None, alias="upgrade-next-protocol-vote-before") + upgrade_vote_rounds: int | None = Field(default=None, alias="upgrade-vote-rounds") + + +class ParticipationKeySchema(BaseModel): + """Represents a participation key used by the node.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + id_: str = Field(alias="id") + address: str = Field(alias="address") + effective_first_valid: int | None = Field(default=None, alias="effective-first-valid") + effective_last_valid: int | None = Field(default=None, alias="effective-last-valid") + last_vote: int | None = Field(default=None, alias="last-vote") + last_block_proposal: int | None = Field(default=None, alias="last-block-proposal") + last_state_proof: int | None = Field(default=None, alias="last-state-proof") + key: AccountParticipationSchema = Field(alias="key") + + +class ParticipationKeysResponseSchema(RootModel[list[ParticipationKeySchema]]): + pass + + +class PendingTransactionResponseSchema(BaseModel): + """Details about a pending transaction. If the transaction was recently confirmed, includes confirmation detai...""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + asset_id: int | None = Field(default=None, alias="asset-index") + app_id: int | None = Field(default=None, alias="application-index") + close_rewards: int | None = Field(default=None, alias="close-rewards") + closing_amount: int | None = Field(default=None, alias="closing-amount") + asset_closing_amount: int | None = Field(default=None, alias="asset-closing-amount") + confirmed_round: int | None = Field(default=None, alias="confirmed-round") + pool_error: str = Field(alias="pool-error") + receiver_rewards: int | None = Field(default=None, alias="receiver-rewards") + sender_rewards: int | None = Field(default=None, alias="sender-rewards") + local_state_delta: list[AccountStateDeltaSchema] | None = Field(default=None, alias="local-state-delta") + global_state_delta: StateDeltaSchema | None = Field(default=None, alias="global-state-delta") + logs: list[str] | None = Field(default=None, alias="logs") + inner_txns: list[PendingTransactionResponseSchema] | None = Field(default=None, alias="inner-txns") + txn: dict[str, Any] = Field(alias="txn") + + +class PendingTransactionsResponseSchema(BaseModel): + """PendingTransactions is an array of signed transactions exactly as they were submitted.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + top_transactions: list[dict[str, Any]] = Field(alias="top-transactions") + total_transactions: int = Field(alias="total-transactions") + + +class PostParticipationResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + part_id: str = Field(alias="partId") + + +class PostTransactionsResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + tx_id: str = Field(alias="txId") + + +class ScratchChangeSchema(BaseModel): + """A write operation into a scratch slot.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + slot: int = Field(alias="slot") + new_value: AvmValueSchema = Field(alias="new-value") + + +class SimulateInitialStatesSchema(BaseModel): + """Initial states of resources that were accessed during simulation.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + app_initial_states: list[ApplicationInitialStatesSchema] | None = Field(default=None, alias="app-initial-states") + + +class SimulateRequestTransactionGroupSchema(BaseModel): + """A transaction group to simulate.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + txns: list[str] = Field(alias="txns") + + +class SimulateTraceConfigSchema(BaseModel): + """An object that configures simulation execution trace.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + enable: bool | None = Field(default=None, alias="enable") + stack_change: bool | None = Field(default=None, alias="stack-change") + scratch_change: bool | None = Field(default=None, alias="scratch-change") + state_change: bool | None = Field(default=None, alias="state-change") + + +class SimulateRequestSchema(BaseModel): + """Request type for simulation endpoint.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + txn_groups: list[SimulateRequestTransactionGroupSchema] = Field(alias="txn-groups") + round_: int | None = Field(default=None, alias="round") + allow_empty_signatures: bool | None = Field(default=None, alias="allow-empty-signatures") + allow_more_logging: bool | None = Field(default=None, alias="allow-more-logging") + allow_unnamed_resources: bool | None = Field(default=None, alias="allow-unnamed-resources") + extra_opcode_budget: int | None = Field(default=None, alias="extra-opcode-budget") + exec_trace_config: SimulateTraceConfigSchema | None = Field(default=None, alias="exec-trace-config") + fix_signers: bool | None = Field(default=None, alias="fix-signers") + + +class SimulateUnnamedResourcesAccessedSchema(BaseModel): + """These are resources that were accessed by this group that would normally have caused failure, but were allo...""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + accounts: list[str] | None = Field(default=None, alias="accounts") + assets: list[int] | None = Field(default=None, alias="assets") + apps: list[int] | None = Field(default=None, alias="apps") + boxes: list[BoxReferenceSchema] | None = Field(default=None, alias="boxes") + extra_box_refs: int | None = Field(default=None, alias="extra-box-refs") + asset_holdings: list[AssetHoldingReferenceSchema] | None = Field(default=None, alias="asset-holdings") + app_locals: list[ApplicationLocalReferenceSchema] | None = Field(default=None, alias="app-locals") + + +class SimulationOpcodeTraceUnitSchema(BaseModel): + """The set of trace information and effect from evaluating a single opcode.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + pc: int = Field(alias="pc") + scratch_changes: list[ScratchChangeSchema] | None = Field(default=None, alias="scratch-changes") + state_changes: list[ApplicationStateOperationSchema] | None = Field(default=None, alias="state-changes") + spawned_inners: list[int] | None = Field(default=None, alias="spawned-inners") + stack_pop_count: int | None = Field(default=None, alias="stack-pop-count") + stack_additions: list[AvmValueSchema] | None = Field(default=None, alias="stack-additions") + + +class SimulationTransactionExecTraceSchema(BaseModel): + """The execution trace of calling an app or a logic sig, containing the inner app call trace in a recursive wa...""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + approval_program_trace: list[SimulationOpcodeTraceUnitSchema] | None = Field( + default=None, alias="approval-program-trace" + ) + approval_program_hash: str | None = Field(default=None, alias="approval-program-hash") + clear_state_program_trace: list[SimulationOpcodeTraceUnitSchema] | None = Field( + default=None, alias="clear-state-program-trace" + ) + clear_state_program_hash: str | None = Field(default=None, alias="clear-state-program-hash") + clear_state_rollback: bool | None = Field(default=None, alias="clear-state-rollback") + clear_state_rollback_error: str | None = Field(default=None, alias="clear-state-rollback-error") + logic_sig_trace: list[SimulationOpcodeTraceUnitSchema] | None = Field(default=None, alias="logic-sig-trace") + logic_sig_hash: str | None = Field(default=None, alias="logic-sig-hash") + inner_trace: list[SimulationTransactionExecTraceSchema] | None = Field(default=None, alias="inner-trace") + + +class SimulateTransactionResultSchema(BaseModel): + """Simulation result for an individual transaction""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + txn_result: PendingTransactionResponseSchema = Field(alias="txn-result") + app_budget_consumed: int | None = Field(default=None, alias="app-budget-consumed") + logic_sig_budget_consumed: int | None = Field(default=None, alias="logic-sig-budget-consumed") + exec_trace: SimulationTransactionExecTraceSchema | None = Field(default=None, alias="exec-trace") + unnamed_resources_accessed: SimulateUnnamedResourcesAccessedSchema | None = Field( + default=None, alias="unnamed-resources-accessed" + ) + fixed_signer: str | None = Field(default=None, alias="fixed-signer") + + +class SimulateTransactionGroupResultSchema(BaseModel): + """Simulation result for an atomic transaction group""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + txn_results: list[SimulateTransactionResultSchema] = Field(alias="txn-results") + failure_message: str | None = Field(default=None, alias="failure-message") + failed_at: list[int] | None = Field(default=None, alias="failed-at") + app_budget_added: int | None = Field(default=None, alias="app-budget-added") + app_budget_consumed: int | None = Field(default=None, alias="app-budget-consumed") + unnamed_resources_accessed: SimulateUnnamedResourcesAccessedSchema | None = Field( + default=None, alias="unnamed-resources-accessed" + ) + + +class SimulationEvalOverridesSchema(BaseModel): + """The set of parameters and limits override during simulation. If this set of parameters is present, then eva...""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + allow_empty_signatures: bool | None = Field(default=None, alias="allow-empty-signatures") + allow_unnamed_resources: bool | None = Field(default=None, alias="allow-unnamed-resources") + max_log_calls: int | None = Field(default=None, alias="max-log-calls") + max_log_size: int | None = Field(default=None, alias="max-log-size") + extra_opcode_budget: int | None = Field(default=None, alias="extra-opcode-budget") + fix_signers: bool | None = Field(default=None, alias="fix-signers") + + +class SimulateResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + version: int = Field(alias="version") + last_round: int = Field(alias="last-round") + txn_groups: list[SimulateTransactionGroupResultSchema] = Field(alias="txn-groups") + eval_overrides: SimulationEvalOverridesSchema | None = Field(default=None, alias="eval-overrides") + exec_trace_config: SimulateTraceConfigSchema | None = Field(default=None, alias="exec-trace-config") + initial_states: SimulateInitialStatesSchema | None = Field(default=None, alias="initial-states") + + +class StateProofMessageSchema(BaseModel): + """Represents the message that the state proofs are attesting to.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + block_headers_commitment: str = Field(alias="BlockHeadersCommitment") + voters_commitment: str = Field(alias="VotersCommitment") + ln_proven_weight: int = Field(ge=0, le=18446744073709551615, alias="LnProvenWeight") + first_attested_round: int = Field(alias="FirstAttestedRound") + last_attested_round: int = Field(alias="LastAttestedRound") + + +class StateProofSchema(BaseModel): + """Represents a state proof and its corresponding message""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + message: StateProofMessageSchema = Field(alias="Message") + state_proof: str = Field(alias="StateProof") + + +class SupplyResponseSchema(BaseModel): + """Supply represents the current supply of MicroAlgos in the system""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + current_round: int = Field(alias="current_round") + online_money: int = Field(alias="online-money") + total_money: int = Field(alias="total-money") + + +class TransactionGroupLedgerStateDeltasForRoundResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + deltas: list[LedgerStateDeltaForTransactionGroupSchema] = Field(alias="Deltas") + + +class TransactionParametersResponseSchema(BaseModel): + """TransactionParams contains the parameters that help a client construct + a new transaction.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + consensus_version: str = Field(alias="consensus-version") + fee: int = Field(alias="fee") + genesis_hash: str = Field(alias="genesis-hash") + genesis_id: str = Field(alias="genesis-id") + last_round: int = Field(alias="last-round") + min_fee: int = Field(alias="min-fee") + + +class TransactionProofSchema(BaseModel): + """Proof of transaction in a block.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + proof: str = Field(alias="proof") + stibhash: str = Field(alias="stibhash") + treedepth: int = Field(alias="treedepth") + idx: int = Field(alias="idx") + hashtype: str = Field(alias="hashtype") + + +class VersionSchema(BaseModel): + """algod version information.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + build: BuildVersionSchema = Field(alias="build") + genesis_hash_b64: str = Field(alias="genesis_hash_b64") + genesis_id: str = Field(alias="genesis_id") + versions: list[str] = Field(alias="versions") diff --git a/tests/fixtures/schemas/indexer.py b/tests/fixtures/schemas/indexer.py new file mode 100644 index 00000000..b58b750e --- /dev/null +++ b/tests/fixtures/schemas/indexer.py @@ -0,0 +1,849 @@ +"""Generated Pydantic validation schemas from OpenAPI spec.""" + +from __future__ import annotations + +from typing import Any + +from pydantic import BaseModel, ConfigDict, Field, RootModel + + +class AccountParticipationSchema(BaseModel): + """AccountParticipation describes the parameters used by this account in consensus protocol.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + selection_participation_key: str = Field(alias="selection-participation-key") + vote_first_valid: int = Field(alias="vote-first-valid") + vote_key_dilution: int = Field(alias="vote-key-dilution") + vote_last_valid: int = Field(alias="vote-last-valid") + vote_participation_key: str = Field(alias="vote-participation-key") + state_proof_key: str | None = Field(default=None, alias="state-proof-key") + + +class ApplicationStateSchemaSchema(BaseModel): + """Specifies maximums on the number of each type that may be stored.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + num_uints: int = Field(ge=0, le=64, alias="num-uint") + num_byte_slices: int = Field(ge=0, le=64, alias="num-byte-slice") + + +class TealValueSchema(BaseModel): + """Represents a TEAL value.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + type_: int = Field(alias="type") + bytes_: str = Field(alias="bytes") + uint: int = Field(alias="uint") + + +class TealKeyValueSchema(BaseModel): + """Represents a key-value pair in an application store.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + key: str = Field(alias="key") + value: TealValueSchema = Field(alias="value") + + +class TealKeyValueStoreSchema(RootModel[list[TealKeyValueSchema]]): + """Represents a key-value store for use in an application.""" + + +class ApplicationParamsSchema(BaseModel): + """Stores the global information associated with an application.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + creator: str | None = Field(default=None, alias="creator") + approval_program: str | None = Field(default=None, alias="approval-program") + clear_state_program: str | None = Field(default=None, alias="clear-state-program") + extra_program_pages: int | None = Field(default=None, ge=0, le=3, alias="extra-program-pages") + local_state_schema: ApplicationStateSchemaSchema | None = Field(default=None, alias="local-state-schema") + global_state_schema: ApplicationStateSchemaSchema | None = Field(default=None, alias="global-state-schema") + global_state: TealKeyValueStoreSchema | None = Field(default=None, alias="global-state") + version: int | None = Field(default=None, alias="version") + + +class ApplicationSchema(BaseModel): + """Application index and its parameters""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + id_: int = Field(alias="id") + deleted: bool | None = Field(default=None, alias="deleted") + created_at_round: int | None = Field(default=None, alias="created-at-round") + deleted_at_round: int | None = Field(default=None, alias="deleted-at-round") + params: ApplicationParamsSchema = Field(alias="params") + + +class ApplicationLocalStateSchema(BaseModel): + """Stores local state associated with an application.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + id_: int = Field(alias="id") + deleted: bool | None = Field(default=None, alias="deleted") + opted_in_at_round: int | None = Field(default=None, alias="opted-in-at-round") + closed_out_at_round: int | None = Field(default=None, alias="closed-out-at-round") + schema_: ApplicationStateSchemaSchema = Field(alias="schema") + key_value: TealKeyValueStoreSchema | None = Field(default=None, alias="key-value") + + +class AssetParamsSchema(BaseModel): + """AssetParams specifies the parameters for an asset. + + \\[apar\\] when part of an AssetConfig transaction. + + De...""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + clawback: str | None = Field(default=None, alias="clawback") + creator: str = Field(alias="creator") + decimals: int = Field(ge=0, le=19, alias="decimals") + default_frozen: bool | None = Field(default=None, alias="default-frozen") + freeze: str | None = Field(default=None, alias="freeze") + manager: str | None = Field(default=None, alias="manager") + metadata_hash: str | None = Field(default=None, alias="metadata-hash") + name: str | None = Field(default=None, alias="name") + name_b64: str | None = Field(default=None, alias="name-b64") + reserve: str | None = Field(default=None, alias="reserve") + total: int = Field(alias="total") + unit_name: str | None = Field(default=None, alias="unit-name") + unit_name_b64: str | None = Field(default=None, alias="unit-name-b64") + url: str | None = Field(default=None, alias="url") + url_b64: str | None = Field(default=None, alias="url-b64") + + +class AssetSchema(BaseModel): + """Specifies both the unique identifier and the parameters for an asset""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + id_: int = Field(alias="index") + deleted: bool | None = Field(default=None, alias="deleted") + created_at_round: int | None = Field(default=None, alias="created-at-round") + destroyed_at_round: int | None = Field(default=None, alias="destroyed-at-round") + params: AssetParamsSchema = Field(alias="params") + + +class AssetHoldingSchema(BaseModel): + """Describes an asset held by an account. + + Definition: + data/basics/userBalance.go : AssetHolding""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + amount: int = Field(alias="amount") + asset_id: int = Field(alias="asset-id") + is_frozen: bool = Field(alias="is-frozen") + deleted: bool | None = Field(default=None, alias="deleted") + opted_in_at_round: int | None = Field(default=None, alias="opted-in-at-round") + opted_out_at_round: int | None = Field(default=None, alias="opted-out-at-round") + + +class AccountSchema(BaseModel): + """Account information at a given round. + + Definition: + data/basics/userBalance.go : AccountData + """ + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + address: str = Field(alias="address") + amount: int = Field(alias="amount") + min_balance: int = Field(alias="min-balance") + amount_without_pending_rewards: int = Field(alias="amount-without-pending-rewards") + apps_local_state: list[ApplicationLocalStateSchema] | None = Field(default=None, alias="apps-local-state") + apps_total_schema: ApplicationStateSchemaSchema | None = Field(default=None, alias="apps-total-schema") + apps_total_extra_pages: int | None = Field(default=None, alias="apps-total-extra-pages") + assets: list[AssetHoldingSchema] | None = Field(default=None, alias="assets") + created_apps: list[ApplicationSchema] | None = Field(default=None, alias="created-apps") + created_assets: list[AssetSchema] | None = Field(default=None, alias="created-assets") + participation: AccountParticipationSchema | None = Field(default=None, alias="participation") + incentive_eligible: bool | None = Field(default=None, alias="incentive-eligible") + pending_rewards: int = Field(alias="pending-rewards") + reward_base: int | None = Field(default=None, alias="reward-base") + rewards: int = Field(alias="rewards") + round_: int = Field(alias="round") + status: str = Field(alias="status") + sig_type: str | None = Field(default=None, alias="sig-type") + total_apps_opted_in: int = Field(alias="total-apps-opted-in") + total_assets_opted_in: int = Field(alias="total-assets-opted-in") + total_box_bytes: int = Field(alias="total-box-bytes") + total_boxes: int = Field(alias="total-boxes") + total_created_apps: int = Field(alias="total-created-apps") + total_created_assets: int = Field(alias="total-created-assets") + auth_addr: str | None = Field(default=None, alias="auth-addr") + last_proposed: int | None = Field(default=None, alias="last-proposed") + last_heartbeat: int | None = Field(default=None, alias="last-heartbeat") + deleted: bool | None = Field(default=None, alias="deleted") + created_at_round: int | None = Field(default=None, alias="created-at-round") + closed_at_round: int | None = Field(default=None, alias="closed-at-round") + + +class AccountResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + account: AccountSchema = Field(alias="account") + current_round: int = Field(alias="current-round") + + +class EvalDeltaSchema(BaseModel): + """Represents a TEAL value delta.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + action: int = Field(alias="action") + bytes_: str | None = Field(default=None, alias="bytes") + uint: int | None = Field(default=None, alias="uint") + + +class EvalDeltaKeyValueSchema(BaseModel): + """Key-value pairs for StateDelta.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + key: str = Field(alias="key") + value: EvalDeltaSchema = Field(alias="value") + + +class StateDeltaSchema(RootModel[list[EvalDeltaKeyValueSchema]]): + """Application state delta.""" + + +class AccountStateDeltaSchema(BaseModel): + """Application state delta.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + address: str = Field(alias="address") + delta: StateDeltaSchema = Field(alias="delta") + + +class AccountsResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + accounts: list[AccountSchema] = Field(alias="accounts") + current_round: int = Field(alias="current-round") + next_token: str | None = Field(default=None, alias="next-token") + + +class ApplicationLocalStatesResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + apps_local_states: list[ApplicationLocalStateSchema] = Field(alias="apps-local-states") + current_round: int = Field(alias="current-round") + next_token: str | None = Field(default=None, alias="next-token") + + +class ApplicationLogDataSchema(BaseModel): + """Stores the global information associated with an application.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + tx_id: str = Field(alias="txid") + logs: list[str] = Field(alias="logs") + + +class ApplicationLogsResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + application_id: int = Field(alias="application-id") + current_round: int = Field(alias="current-round") + next_token: str | None = Field(default=None, alias="next-token") + log_data: list[ApplicationLogDataSchema] | None = Field(default=None, alias="log-data") + + +class ApplicationResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + application: ApplicationSchema | None = Field(default=None, alias="application") + current_round: int = Field(alias="current-round") + + +class ApplicationsResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + applications: list[ApplicationSchema] = Field(alias="applications") + current_round: int = Field(alias="current-round") + next_token: str | None = Field(default=None, alias="next-token") + + +class MiniAssetHoldingSchema(BaseModel): + """A simplified version of AssetHolding""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + address: str = Field(alias="address") + amount: int = Field(alias="amount") + is_frozen: bool = Field(alias="is-frozen") + deleted: bool | None = Field(default=None, alias="deleted") + opted_in_at_round: int | None = Field(default=None, alias="opted-in-at-round") + opted_out_at_round: int | None = Field(default=None, alias="opted-out-at-round") + + +class AssetBalancesResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + balances: list[MiniAssetHoldingSchema] = Field(alias="balances") + current_round: int = Field(alias="current-round") + next_token: str | None = Field(default=None, alias="next-token") + + +class AssetHoldingsResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + current_round: int = Field(alias="current-round") + next_token: str | None = Field(default=None, alias="next-token") + assets: list[AssetHoldingSchema] = Field(alias="assets") + + +class AssetResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + asset: AssetSchema = Field(alias="asset") + current_round: int = Field(alias="current-round") + + +class AssetsResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + assets: list[AssetSchema] = Field(alias="assets") + current_round: int = Field(alias="current-round") + next_token: str | None = Field(default=None, alias="next-token") + + +class BlockRewardsSchema(BaseModel): + """Fields relating to rewards,""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + fee_sink: str = Field(alias="fee-sink") + rewards_calculation_round: int = Field(alias="rewards-calculation-round") + rewards_level: int = Field(alias="rewards-level") + rewards_pool: str = Field(alias="rewards-pool") + rewards_rate: int = Field(alias="rewards-rate") + rewards_residue: int = Field(alias="rewards-residue") + + +class BlockUpgradeStateSchema(BaseModel): + """Fields relating to a protocol upgrade.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + current_protocol: str = Field(alias="current-protocol") + next_protocol: str | None = Field(default=None, alias="next-protocol") + next_protocol_approvals: int | None = Field(default=None, alias="next-protocol-approvals") + next_protocol_switch_on: int | None = Field(default=None, alias="next-protocol-switch-on") + next_protocol_vote_before: int | None = Field(default=None, alias="next-protocol-vote-before") + + +class BlockUpgradeVoteSchema(BaseModel): + """Fields relating to voting for a protocol upgrade.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + upgrade_approve: bool | None = Field(default=None, alias="upgrade-approve") + upgrade_delay: int | None = Field(default=None, alias="upgrade-delay") + upgrade_propose: str | None = Field(default=None, alias="upgrade-propose") + + +class ParticipationUpdatesSchema(BaseModel): + """Participation account data that needs to be checked/acted on by the network.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + expired_participation_accounts: list[str] = Field(alias="expired-participation-accounts") + absent_participation_accounts: list[str] = Field(alias="absent-participation-accounts") + + +class StateProofTrackingSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + type_: int | None = Field(default=None, alias="type") + voters_commitment: str | None = Field(default=None, alias="voters-commitment") + online_total_weight: int | None = Field(default=None, alias="online-total-weight") + next_round: int | None = Field(default=None, alias="next-round") + + +class BoxReferenceSchema(BaseModel): + """BoxReference names a box by its name and the application ID it belongs to.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + app: int = Field(alias="app") + name: str = Field(alias="name") + + +class OnCompletionSchema(RootModel[str]): + """\\[apan\\] defines the what additional actions occur with the transaction. + + Valid types: + * noop + * optin + * c...""" + + +class HoldingRefSchema(BaseModel): + """HoldingRef names a holding by referring to an Address and Asset it belongs to.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + address: str = Field(alias="address") + asset: int = Field(alias="asset") + + +class LocalsRefSchema(BaseModel): + """LocalsRef names a local state by referring to an Address and App it belongs to.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + address: str = Field(alias="address") + app: int = Field(alias="app") + + +class ResourceRefSchema(BaseModel): + """ResourceRef names a single resource. Only one of the fields should be set.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + address: str | None = Field(default=None, alias="address") + application_id: int | None = Field(default=None, alias="application-id") + asset_id: int | None = Field(default=None, alias="asset-id") + box: BoxReferenceSchema | None = Field(default=None, alias="box") + holding: HoldingRefSchema | None = Field(default=None, alias="holding") + local: LocalsRefSchema | None = Field(default=None, alias="local") + + +class StateSchemaSchema(BaseModel): + """Represents a \\[apls\\] local-state or \\[apgs\\] global-state schema. These schemas determine how much sto...""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + num_uints: int = Field(ge=0, le=64, alias="num-uint") + num_byte_slices: int = Field(ge=0, le=64, alias="num-byte-slice") + + +class TransactionApplicationSchema(BaseModel): + """Fields for application transactions. + + Definition: + data/transactions/application.go : ApplicationCallTxnFiel...""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + application_id: int = Field(alias="application-id") + on_completion: OnCompletionSchema = Field(alias="on-completion") + application_args: list[str] | None = Field(default=None, alias="application-args") + access: list[ResourceRefSchema] | None = Field(default=None, alias="access") + accounts: list[str] | None = Field(default=None, alias="accounts") + box_references: list[BoxReferenceSchema] | None = Field(default=None, alias="box-references") + foreign_apps: list[int] | None = Field(default=None, alias="foreign-apps") + foreign_assets: list[int] | None = Field(default=None, alias="foreign-assets") + local_state_schema: StateSchemaSchema | None = Field(default=None, alias="local-state-schema") + global_state_schema: StateSchemaSchema | None = Field(default=None, alias="global-state-schema") + approval_program: str | None = Field(default=None, alias="approval-program") + clear_state_program: str | None = Field(default=None, alias="clear-state-program") + extra_program_pages: int | None = Field(default=None, ge=0, le=3, alias="extra-program-pages") + reject_version: int | None = Field(default=None, alias="reject-version") + + +class TransactionAssetConfigSchema(BaseModel): + """Fields for asset allocation, re-configuration, and destruction. + + + A zero value for asset-id indicates asset...""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + asset_id: int | None = Field(default=None, alias="asset-id") + params: AssetParamsSchema | None = Field(default=None, alias="params") + + +class TransactionAssetFreezeSchema(BaseModel): + """Fields for an asset freeze transaction. + + Definition: + data/transactions/asset.go : AssetFreezeTxnFields""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + address: str = Field(alias="address") + asset_id: int = Field(alias="asset-id") + new_freeze_status: bool = Field(alias="new-freeze-status") + + +class TransactionAssetTransferSchema(BaseModel): + """Fields for an asset transfer transaction. + + Definition: + data/transactions/asset.go : AssetTransferTxnFields""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + amount: int = Field(alias="amount") + asset_id: int = Field(alias="asset-id") + close_amount: int | None = Field(default=None, alias="close-amount") + close_to: str | None = Field(default=None, alias="close-to") + receiver: str = Field(alias="receiver") + sender: str | None = Field(default=None, alias="sender") + + +class HbProofFieldsSchema(BaseModel): + """\\[hbprf\\] HbProof is a signature using HeartbeatAddress's partkey, thereby showing it is online.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + hb_sig: str | None = Field(default=None, alias="hb-sig") + hb_pk: str | None = Field(default=None, alias="hb-pk") + hb_pk2: str | None = Field(default=None, alias="hb-pk2") + hb_pk1sig: str | None = Field(default=None, alias="hb-pk1sig") + hb_pk2sig: str | None = Field(default=None, alias="hb-pk2sig") + + +class TransactionHeartbeatSchema(BaseModel): + """Fields for a heartbeat transaction. + + Definition: + data/transactions/heartbeat.go : HeartbeatTxnFields""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + hb_address: str = Field(alias="hb-address") + hb_proof: HbProofFieldsSchema = Field(alias="hb-proof") + hb_seed: str = Field(alias="hb-seed") + hb_vote_id: str = Field(alias="hb-vote-id") + hb_key_dilution: int = Field(alias="hb-key-dilution") + + +class TransactionKeyregSchema(BaseModel): + """Fields for a keyreg transaction. + + Definition: + data/transactions/keyreg.go : KeyregTxnFields""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + non_participation: bool | None = Field(default=None, alias="non-participation") + selection_participation_key: str | None = Field(default=None, alias="selection-participation-key") + vote_first_valid: int | None = Field(default=None, alias="vote-first-valid") + vote_key_dilution: int | None = Field(default=None, alias="vote-key-dilution") + vote_last_valid: int | None = Field(default=None, alias="vote-last-valid") + vote_participation_key: str | None = Field(default=None, alias="vote-participation-key") + state_proof_key: str | None = Field(default=None, alias="state-proof-key") + + +class TransactionPaymentSchema(BaseModel): + """Fields for a payment transaction. + + Definition: + data/transactions/payment.go : PaymentTxnFields""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + amount: int = Field(alias="amount") + close_amount: int | None = Field(default=None, alias="close-amount") + close_remainder_to: str | None = Field(default=None, alias="close-remainder-to") + receiver: str = Field(alias="receiver") + + +class TransactionSignatureMultisigSubsignatureSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + public_key: str | None = Field(default=None, alias="public-key") + signature: str | None = Field(default=None, alias="signature") + + +class TransactionSignatureMultisigSchema(BaseModel): + """structure holding multiple subsignatures. + + Definition: + crypto/multisig.go : MultisigSig""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + subsignature: list[TransactionSignatureMultisigSubsignatureSchema] | None = Field( + default=None, alias="subsignature" + ) + threshold: int | None = Field(default=None, alias="threshold") + version: int | None = Field(default=None, alias="version") + + +class TransactionSignatureLogicsigSchema(BaseModel): + """\\[lsig\\] Programatic transaction signature. + + Definition: + data/transactions/logicsig.go""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + args: list[str] | None = Field(default=None, alias="args") + logic: str = Field(alias="logic") + multisig_signature: TransactionSignatureMultisigSchema | None = Field(default=None, alias="multisig-signature") + logic_multisig_signature: TransactionSignatureMultisigSchema | None = Field( + default=None, alias="logic-multisig-signature" + ) + signature: str | None = Field(default=None, alias="signature") + + +class TransactionSignatureSchema(BaseModel): + """Validation signature associated with some data. Only one of the signatures should be provided.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + logicsig: TransactionSignatureLogicsigSchema | None = Field(default=None, alias="logicsig") + multisig: TransactionSignatureMultisigSchema | None = Field(default=None, alias="multisig") + sig: str | None = Field(default=None, alias="sig") + + +class IndexerStateProofMessageSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + block_headers_commitment: str | None = Field(default=None, alias="block-headers-commitment") + voters_commitment: str | None = Field(default=None, alias="voters-commitment") + ln_proven_weight: int | None = Field(default=None, alias="ln-proven-weight") + first_attested_round: int | None = Field(default=None, alias="first-attested-round") + latest_attested_round: int | None = Field(default=None, alias="latest-attested-round") + + +class HashFactorySchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + hash_type: int | None = Field(default=None, alias="hash-type") + + +class MerkleArrayProofSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + path: list[str] | None = Field(default=None, alias="path") + hash_factory: HashFactorySchema | None = Field(default=None, alias="hash-factory") + tree_depth: int | None = Field(default=None, alias="tree-depth") + + +class StateProofVerifierSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + commitment: str | None = Field(default=None, alias="commitment") + key_lifetime: int | None = Field(default=None, alias="key-lifetime") + + +class StateProofParticipantSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + verifier: StateProofVerifierSchema | None = Field(default=None, alias="verifier") + weight: int | None = Field(default=None, alias="weight") + + +class StateProofSignatureSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + falcon_signature: str | None = Field(default=None, alias="falcon-signature") + merkle_array_index: int | None = Field(default=None, alias="merkle-array-index") + proof: MerkleArrayProofSchema | None = Field(default=None, alias="proof") + verifying_key: str | None = Field(default=None, alias="verifying-key") + + +class StateProofSigSlotSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + signature: StateProofSignatureSchema | None = Field(default=None, alias="signature") + lower_sig_weight: int | None = Field(default=None, alias="lower-sig-weight") + + +class StateProofRevealSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + position: int | None = Field(default=None, alias="position") + sig_slot: StateProofSigSlotSchema | None = Field(default=None, alias="sig-slot") + participant: StateProofParticipantSchema | None = Field(default=None, alias="participant") + + +class StateProofFieldsSchema(BaseModel): + """\\[sp\\] represents a state proof. + + Definition: + crypto/stateproof/structs.go : StateProof""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + sig_commit: str | None = Field(default=None, alias="sig-commit") + signed_weight: int | None = Field(default=None, alias="signed-weight") + sig_proofs: MerkleArrayProofSchema | None = Field(default=None, alias="sig-proofs") + part_proofs: MerkleArrayProofSchema | None = Field(default=None, alias="part-proofs") + salt_version: int | None = Field(default=None, alias="salt-version") + reveals: list[StateProofRevealSchema] | None = Field(default=None, alias="reveals") + positions_to_reveal: list[int] | None = Field(default=None, alias="positions-to-reveal") + + +class TransactionStateProofSchema(BaseModel): + """Fields for a state proof transaction. + + Definition: + data/transactions/stateproof.go : StateProofTxnFields""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + state_proof_type: int | None = Field(default=None, alias="state-proof-type") + state_proof: StateProofFieldsSchema | None = Field(default=None, alias="state-proof") + message: IndexerStateProofMessageSchema | None = Field(default=None, alias="message") + + +class TransactionSchema(BaseModel): + """Contains all fields common to all transactions and serves as an envelope to all transactions type. Represen...""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + application_transaction: TransactionApplicationSchema | None = Field(default=None, alias="application-transaction") + asset_config_transaction: TransactionAssetConfigSchema | None = Field( + default=None, alias="asset-config-transaction" + ) + asset_freeze_transaction: TransactionAssetFreezeSchema | None = Field( + default=None, alias="asset-freeze-transaction" + ) + asset_transfer_transaction: TransactionAssetTransferSchema | None = Field( + default=None, alias="asset-transfer-transaction" + ) + state_proof_transaction: TransactionStateProofSchema | None = Field(default=None, alias="state-proof-transaction") + heartbeat_transaction: TransactionHeartbeatSchema | None = Field(default=None, alias="heartbeat-transaction") + auth_addr: str | None = Field(default=None, alias="auth-addr") + close_rewards: int | None = Field(default=None, alias="close-rewards") + closing_amount: int | None = Field(default=None, alias="closing-amount") + confirmed_round: int | None = Field(default=None, alias="confirmed-round") + created_app_id: int | None = Field(default=None, alias="created-application-index") + created_asset_id: int | None = Field(default=None, alias="created-asset-index") + fee: int = Field(alias="fee") + first_valid: int = Field(alias="first-valid") + genesis_hash: str | None = Field(default=None, alias="genesis-hash") + genesis_id: str | None = Field(default=None, alias="genesis-id") + group: str | None = Field(default=None, alias="group") + id_: str | None = Field(default=None, alias="id") + intra_round_offset: int | None = Field(default=None, alias="intra-round-offset") + keyreg_transaction: TransactionKeyregSchema | None = Field(default=None, alias="keyreg-transaction") + last_valid: int = Field(alias="last-valid") + lease: str | None = Field(default=None, alias="lease") + note: str | None = Field(default=None, alias="note") + payment_transaction: TransactionPaymentSchema | None = Field(default=None, alias="payment-transaction") + receiver_rewards: int | None = Field(default=None, alias="receiver-rewards") + rekey_to: str | None = Field(default=None, alias="rekey-to") + round_time: int | None = Field(default=None, alias="round-time") + sender: str = Field(alias="sender") + sender_rewards: int | None = Field(default=None, alias="sender-rewards") + signature: TransactionSignatureSchema | None = Field(default=None, alias="signature") + tx_type: str = Field(alias="tx-type") + local_state_delta: list[AccountStateDeltaSchema] | None = Field(default=None, alias="local-state-delta") + global_state_delta: StateDeltaSchema | None = Field(default=None, alias="global-state-delta") + logs: list[str] | None = Field(default=None, alias="logs") + inner_txns: list[TransactionSchema] | None = Field(default=None, alias="inner-txns") + + +class BlockSchema(BaseModel): + """Block information. + + Definition: + data/bookkeeping/block.go : Block""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + proposer: str | None = Field(default=None, alias="proposer") + fees_collected: int | None = Field(default=None, alias="fees-collected") + bonus: int | None = Field(default=None, alias="bonus") + proposer_payout: int | None = Field(default=None, alias="proposer-payout") + genesis_hash: str = Field(alias="genesis-hash") + genesis_id: str = Field(alias="genesis-id") + previous_block_hash: str = Field(alias="previous-block-hash") + previous_block_hash_512: str | None = Field(default=None, alias="previous-block-hash-512") + rewards: BlockRewardsSchema = Field(alias="rewards") + round_: int = Field(alias="round") + seed: str = Field(alias="seed") + state_proof_tracking: list[StateProofTrackingSchema] | None = Field(default=None, alias="state-proof-tracking") + timestamp: int = Field(alias="timestamp") + transactions: list[TransactionSchema] = Field(alias="transactions") + transactions_root: str = Field(alias="transactions-root") + transactions_root_sha256: str | None = Field(default=None, alias="transactions-root-sha256") + transactions_root_sha512: str | None = Field(default=None, alias="transactions-root-sha512") + txn_counter: int | None = Field(default=None, alias="txn-counter") + upgrade_state: BlockUpgradeStateSchema = Field(alias="upgrade-state") + upgrade_vote: BlockUpgradeVoteSchema | None = Field(default=None, alias="upgrade-vote") + participation_updates: ParticipationUpdatesSchema = Field(alias="participation-updates") + + +class BlockHeadersResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + current_round: int = Field(alias="current-round") + next_token: str | None = Field(default=None, alias="next-token") + blocks: list[BlockSchema] = Field(alias="blocks") + + +class BoxSchema(BaseModel): + """Box name and its content.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + round_: int = Field(alias="round") + name: str = Field(alias="name") + value: str = Field(alias="value") + + +class BoxDescriptorSchema(BaseModel): + """Box descriptor describes an app box without a value.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + name: str = Field(alias="name") + + +class BoxesResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + application_id: int = Field(alias="application-id") + boxes: list[BoxDescriptorSchema] = Field(alias="boxes") + next_token: str | None = Field(default=None, alias="next-token") + + +class ErrorResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + data: dict[str, Any] | None = Field(default=None, alias="data") + message: str = Field(alias="message") + + +class HashtypeSchema(RootModel[str]): + """The type of hash function used to create the proof, must be one of: + * sha512_256 + * sha256""" + + +class HealthCheckSchema(BaseModel): + """A health check response.""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + version: str = Field(alias="version") + data: dict[str, Any] | None = Field(default=None, alias="data") + round_: int = Field(alias="round") + is_migrating: bool = Field(alias="is-migrating") + db_available: bool = Field(alias="db-available") + message: str = Field(alias="message") + errors: list[str] | None = Field(default=None, alias="errors") + + +class TransactionResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + transaction: TransactionSchema = Field(alias="transaction") + current_round: int = Field(alias="current-round") + + +class TransactionsResponseSchema(BaseModel): + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + current_round: int = Field(alias="current-round") + next_token: str | None = Field(default=None, alias="next-token") + transactions: list[TransactionSchema] = Field(alias="transactions") diff --git a/tests/fixtures/schemas/kmd.py b/tests/fixtures/schemas/kmd.py new file mode 100644 index 00000000..47b7121e --- /dev/null +++ b/tests/fixtures/schemas/kmd.py @@ -0,0 +1,446 @@ +"""Generated Pydantic validation schemas from OpenAPI spec.""" + +from __future__ import annotations + +from pydantic import BaseModel, ConfigDict, Field, RootModel + + +class MasterDerivationKeySchema(RootModel[str]): + """MasterDerivationKey is used to derive ed25519 keys for use in wallets""" + + +class CreateWalletRequestSchema(BaseModel): + """The request for `POST /v1/wallet`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + master_derivation_key: MasterDerivationKeySchema | None = Field(default=None, alias="master_derivation_key") + wallet_driver_name: str | None = Field(default=None, alias="wallet_driver_name") + wallet_name: str = Field(alias="wallet_name") + wallet_password: str = Field(alias="wallet_password") + + +class TxTypeSchema(RootModel[str]): + """TxType is the type of the transaction written to the ledger""" + + +class WalletSchema(BaseModel): + """Wallet is the API's representation of a wallet""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + driver_name: str = Field(alias="driver_name") + driver_version: int = Field(alias="driver_version") + id_: str = Field(alias="id") + mnemonic_ux: bool = Field(alias="mnemonic_ux") + name: str = Field(alias="name") + supported_txs: list[TxTypeSchema] = Field(alias="supported_txs") + + +class CreateWalletResponseSchema(BaseModel): + """CreateWalletResponse is the response to `POST /v1/wallet`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + wallet: WalletSchema = Field(alias="wallet") + + +class DeleteKeyRequestSchema(BaseModel): + """The request for `DELETE /v1/key`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + address: str = Field(alias="address") + wallet_handle_token: str = Field(alias="wallet_handle_token") + wallet_password: str | None = Field(default=None, alias="wallet_password") + + +class DeleteMultisigRequestSchema(BaseModel): + """The request for `DELETE /v1/multisig`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + address: str = Field(alias="address") + wallet_handle_token: str = Field(alias="wallet_handle_token") + wallet_password: str | None = Field(default=None, alias="wallet_password") + + +class DigestSchema(RootModel[str]): + pass + + +class ExportKeyRequestSchema(BaseModel): + """The request for `POST /v1/key/export`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + address: str = Field(alias="address") + wallet_handle_token: str = Field(alias="wallet_handle_token") + wallet_password: str | None = Field(default=None, alias="wallet_password") + + +class ExportKeyResponseSchema(BaseModel): + """ExportKeyResponse is the response to `POST /v1/key/export`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + private_key: str = Field(alias="private_key") + + +class ExportMasterKeyRequestSchema(BaseModel): + """The request for `POST /v1/master-key/export`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + wallet_handle_token: str = Field(alias="wallet_handle_token") + wallet_password: str | None = Field(default=None, alias="wallet_password") + + +class ExportMasterKeyResponseSchema(BaseModel): + """ExportMasterKeyResponse is the response to `POST /v1/master-key/export`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + master_derivation_key: MasterDerivationKeySchema = Field(alias="master_derivation_key") + + +class ExportMultisigRequestSchema(BaseModel): + """The request for `POST /v1/multisig/export`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + address: str = Field(alias="address") + wallet_handle_token: str = Field(alias="wallet_handle_token") + + +class Ed25519PublicKeySchema(RootModel[str]): + pass + + +class PublicKeySchema(RootModel[str]): + pass + + +class ExportMultisigResponseSchema(BaseModel): + """ExportMultisigResponse is the response to `POST /v1/multisig/export`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + multisig_version: int = Field(alias="multisig_version") + public_keys: list[PublicKeySchema] = Field(alias="pks") + threshold: int = Field(alias="threshold") + + +class GenerateKeyRequestSchema(BaseModel): + """The request for `POST /v1/key`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + wallet_handle_token: str = Field(alias="wallet_handle_token") + + +class GenerateKeyResponseSchema(BaseModel): + """GenerateKeyResponse is the response to `POST /v1/key`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + address: str = Field(alias="address") + + +class ImportKeyRequestSchema(BaseModel): + """The request for `POST /v1/key/import`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + private_key: str = Field(alias="private_key") + wallet_handle_token: str = Field(alias="wallet_handle_token") + + +class ImportKeyResponseSchema(BaseModel): + """ImportKeyResponse is the response to `POST /v1/key/import`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + address: str = Field(alias="address") + + +class ImportMultisigRequestSchema(BaseModel): + """The request for `POST /v1/multisig/import`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + multisig_version: int = Field(alias="multisig_version") + public_keys: list[PublicKeySchema] = Field(alias="pks") + threshold: int = Field(alias="threshold") + wallet_handle_token: str = Field(alias="wallet_handle_token") + + +class ImportMultisigResponseSchema(BaseModel): + """ImportMultisigResponse is the response to `POST /v1/multisig/import`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + address: str = Field(alias="address") + + +class InitWalletHandleTokenRequestSchema(BaseModel): + """The request for `POST /v1/wallet/init`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + wallet_id: str = Field(alias="wallet_id") + wallet_password: str = Field(alias="wallet_password") + + +class InitWalletHandleTokenResponseSchema(BaseModel): + """InitWalletHandleTokenResponse is the response to `POST /v1/wallet/init`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + wallet_handle_token: str = Field(alias="wallet_handle_token") + + +class ListKeysRequestSchema(BaseModel): + """The request for `POST /v1/key/list`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + wallet_handle_token: str = Field(alias="wallet_handle_token") + + +class ListKeysResponseSchema(BaseModel): + """ListKeysResponse is the response to `POST /v1/key/list`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + addresses: list[str] = Field(alias="addresses") + + +class ListMultisigRequestSchema(BaseModel): + """The request for `POST /v1/multisig/list`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + wallet_handle_token: str = Field(alias="wallet_handle_token") + + +class ListMultisigResponseSchema(BaseModel): + """ListMultisigResponse is the response to `POST /v1/multisig/list`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + addresses: list[str] = Field(alias="addresses") + + +class ListWalletsRequestSchema(BaseModel): + """APIV1GETWalletsRequest is the request for `GET /v1/wallets`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True, extra="allow") + + +class ListWalletsResponseSchema(BaseModel): + """ListWalletsResponse is the response to `GET /v1/wallets`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + wallets: list[WalletSchema] = Field(alias="wallets") + + +class Ed25519SignatureSchema(RootModel[str]): + pass + + +class SignatureSchema(RootModel[str]): + pass + + +class MultisigSubsigSchema(BaseModel): + """MultisigSubsig is a struct that holds a pair of public key and signatures + signatures may be empty""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + public_key: PublicKeySchema = Field(alias="pk") + signature: SignatureSchema | None = Field(default=None, alias="s") + + +class MultisigSigSchema(BaseModel): + """MultisigSig is the structure that holds multiple Subsigs""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + subsignatures: list[MultisigSubsigSchema] = Field(alias="subsig") + threshold: int = Field(alias="thr") + version: int = Field(alias="v") + + +class Ed25519PrivateKeySchema(RootModel[str]): + pass + + +class PrivateKeySchema(RootModel[str]): + pass + + +class ReleaseWalletHandleTokenRequestSchema(BaseModel): + """The request for `POST /v1/wallet/release`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + wallet_handle_token: str = Field(alias="wallet_handle_token") + + +class RenameWalletRequestSchema(BaseModel): + """The request for `POST /v1/wallet/rename`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + wallet_id: str = Field(alias="wallet_id") + wallet_name: str = Field(alias="wallet_name") + wallet_password: str = Field(alias="wallet_password") + + +class RenameWalletResponseSchema(BaseModel): + """RenameWalletResponse is the response to `POST /v1/wallet/rename`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + wallet: WalletSchema = Field(alias="wallet") + + +class RenewWalletHandleTokenRequestSchema(BaseModel): + """The request for `POST /v1/wallet/renew`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + wallet_handle_token: str = Field(alias="wallet_handle_token") + + +class WalletHandleSchema(BaseModel): + """WalletHandle includes the wallet the handle corresponds to + and the number of number of seconds to expiratio...""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + expires_seconds: int = Field(alias="expires_seconds") + wallet: WalletSchema = Field(alias="wallet") + + +class RenewWalletHandleTokenResponseSchema(BaseModel): + """RenewWalletHandleTokenResponse is the response to `POST /v1/wallet/renew`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + wallet_handle: WalletHandleSchema = Field(alias="wallet_handle") + + +class SignMultisigResponseSchema(BaseModel): + """SignMultisigResponse is the response to `POST /v1/multisig/sign`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + multisig: str = Field(alias="multisig") + + +class SignMultisigTxnRequestSchema(BaseModel): + """The request for `POST /v1/multisig/sign`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + partial_multisig: MultisigSigSchema | None = Field(default=None, alias="partial_multisig") + public_key: PublicKeySchema = Field(alias="public_key") + signer: DigestSchema | None = Field(default=None, alias="signer") + transaction: str = Field(alias="transaction") + wallet_handle_token: str = Field(alias="wallet_handle_token") + wallet_password: str | None = Field(default=None, alias="wallet_password") + + +class SignProgramMultisigRequestSchema(BaseModel): + """The request for `POST /v1/multisig/signprogram`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + address: str = Field(alias="address") + program: str = Field(alias="data") + partial_multisig: MultisigSigSchema | None = Field(default=None, alias="partial_multisig") + public_key: PublicKeySchema = Field(alias="public_key") + use_legacy_msig: bool | None = Field(default=None, alias="use_legacy_msig") + wallet_handle_token: str = Field(alias="wallet_handle_token") + wallet_password: str | None = Field(default=None, alias="wallet_password") + + +class SignProgramMultisigResponseSchema(BaseModel): + """SignProgramMultisigResponse is the response to `POST /v1/multisig/signdata`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + multisig: str = Field(alias="multisig") + + +class SignProgramRequestSchema(BaseModel): + """The request for `POST /v1/program/sign`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + address: str = Field(alias="address") + program: str = Field(alias="data") + wallet_handle_token: str = Field(alias="wallet_handle_token") + wallet_password: str | None = Field(default=None, alias="wallet_password") + + +class SignProgramResponseSchema(BaseModel): + """SignProgramResponse is the response to `POST /v1/data/sign`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + sig: str = Field(alias="sig") + + +class SignTransactionResponseSchema(BaseModel): + """SignTransactionResponse is the response to `POST /v1/transaction/sign`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + signed_transaction: str = Field(alias="signed_transaction") + + +class SignTxnRequestSchema(BaseModel): + """The request for `POST /v1/transaction/sign`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + public_key: PublicKeySchema | None = Field(default=None, alias="public_key") + transaction: str = Field(alias="transaction") + wallet_handle_token: str = Field(alias="wallet_handle_token") + wallet_password: str | None = Field(default=None, alias="wallet_password") + + +class VersionsRequestSchema(BaseModel): + """VersionsRequest is the request for `GET /versions`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True, extra="allow") + + +class VersionsResponseSchema(BaseModel): + """VersionsResponse is the response to `GET /versions` + friendly:VersionsResponse""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + versions: list[str] = Field(alias="versions") + + +class WalletInfoRequestSchema(BaseModel): + """The request for `POST /v1/wallet/info`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + wallet_handle_token: str = Field(alias="wallet_handle_token") + + +class WalletInfoResponseSchema(BaseModel): + """WalletInfoResponse is the response to `POST /v1/wallet/info`""" + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + wallet_handle: WalletHandleSchema = Field(alias="wallet_handle") diff --git a/tests/models/test_algo_amount.py b/tests/models/test_algo_amount.py index 51bcdd0f..d7cf4943 100644 --- a/tests/models/test_algo_amount.py +++ b/tests/models/test_algo_amount.py @@ -35,11 +35,15 @@ def test_arithmetic_operations() -> None: # Addition assert (a + b).micro_algo == 8_000_000 + assert (a + 1_000_000).micro_algo == 6_000_000 + assert (1_000_000 + a).micro_algo == 6_000_000 a += b assert a.micro_algo == 8_000_000 # Subtraction assert (a - b).micro_algo == 5_000_000 + assert (a - 1_000_000).micro_algo == 7_000_000 + assert (10_000_000 - a).micro_algo == 2_000_000 a -= b assert a.micro_algo == 5_000_000 @@ -47,6 +51,14 @@ def test_arithmetic_operations() -> None: assert (AlgoAmount.from_micro_algo(1000) + a).micro_algo == 5_001_000 assert (AlgoAmount.from_algo(10) - a).micro_algo == 5_000_000 + # Multiplication + assert (AlgoAmount.from_micro_algo(2_000_000) * 3).micro_algo == 6_000_000 + assert (3 * AlgoAmount.from_micro_algo(2_000_000)).micro_algo == 6_000_000 + + # Division + assert (AlgoAmount.from_micro_algo(9_000_000) / 3).micro_algo == 3_000_000 + assert (9 // AlgoAmount.from_micro_algo(3)).quantize(Decimal("1")) == Decimal("3") + def test_comparison_operators() -> None: base = AlgoAmount.from_algo(5) @@ -88,11 +100,19 @@ def test_string_representation() -> None: def test_type_safety() -> None: with pytest.raises(TypeError, match="Unsupported operand type"): - # int is not AlgoAmount - AlgoAmount.from_algo(5) + 1000 # type: ignore # noqa: PGH003 + AlgoAmount.from_algo(5) - "invalid" # type: ignore # noqa: PGH003 with pytest.raises(TypeError, match="Unsupported operand type"): - AlgoAmount.from_algo(5) - "invalid" # type: ignore # noqa: PGH003 + AlgoAmount.from_algo(5) * "invalid" # type: ignore # noqa: PGH003 + + with pytest.raises(TypeError, match="Unsupported operand type"): + AlgoAmount.from_algo(5) / "invalid" # type: ignore # noqa: PGH003 + + with pytest.raises(ZeroDivisionError): + AlgoAmount.from_micro_algo(1_000) / 0 + + with pytest.raises(ZeroDivisionError): + 1 // AlgoAmount.from_micro_algo(0) def test_helper_functions() -> None: diff --git a/tests/modules/_mock_server.py b/tests/modules/_mock_server.py new file mode 100644 index 00000000..35bf3cb1 --- /dev/null +++ b/tests/modules/_mock_server.py @@ -0,0 +1,129 @@ +"""Mock server infrastructure for algod/indexer/kmd client testing. + +This module provides connectivity to externally-managed mock servers that replay +pre-recorded HAR files for deterministic API testing. Only used by algod_client, +indexer_client, and kmd_client test modules. + +The mock server lifecycle is managed externally: + - CI: Started via GitHub Action (see .github/workflows/) + - Local development: Started manually via bun (see algokit-polytest repo) + +Tests connect to the mock server via environment variables specifying the server URLs. + +Environment Variables: + MOCK_ALGOD_URL: External algod mock server URL (e.g., http://localhost:8000) + MOCK_INDEXER_URL: External indexer mock server URL (e.g., http://localhost:8002) + MOCK_KMD_URL: External KMD mock server URL (e.g., http://localhost:8001) + +For mock server setup instructions, see: + https://github.com/algorandfoundation/algokit-polytest +""" + +from __future__ import annotations + +import os +import urllib.error +import urllib.parse +import urllib.request +from dataclasses import dataclass + +# Environment variable names for external server URLs +EXTERNAL_URL_ENV_VARS = { + "algod": "MOCK_ALGOD_URL", + "indexer": "MOCK_INDEXER_URL", + "kmd": "MOCK_KMD_URL", +} + +DEFAULT_TOKEN = "a" * 64 + + +@dataclass +class MockServer: + """Connection info for an externally-managed mock server. + + The server lifecycle is managed externally (GitHub Action or manual bun process), + so this class only holds connection information. + + Attributes: + base_url: The base URL of the mock server (e.g., http://localhost:8000) + client_type: The type of client this server mocks (algod, indexer, or kmd) + """ + + base_url: str + client_type: str + + +def _check_server_health(url: str, timeout: float = 5.0) -> bool: + """Check if the mock server is reachable and responding. + + The mock server uses Fastify with a catch-all route, so any request + should work. We use the /health path by convention, but any path would + respond (possibly with a 404/500 from HAR replay, which still indicates readiness). + + Args: + url: Base URL of the server to check + timeout: Maximum time to wait for health check (seconds) + + Returns: + True if server is healthy, False otherwise + """ + import time + + health_url = f"{url.rstrip('/')}/health" + start = time.time() + + while time.time() - start < timeout: + try: + req = urllib.request.Request(health_url, method="GET") + with urllib.request.urlopen(req, timeout=2): + return True + except urllib.error.HTTPError: + # HTTP error responses (4xx, 5xx) still indicate server is ready + return True + except (urllib.error.URLError, TimeoutError, OSError): + time.sleep(0.2) + + return False + + +def get_mock_server(client_type: str) -> MockServer: + """Get connection to an externally-managed mock server. + + Reads the appropriate environment variable for the server URL, + validates the server is reachable, and returns connection info. + + Args: + client_type: Type of mock server to connect to (algod, indexer, or kmd) + + Returns: + MockServer instance with connection info + + Raises: + ValueError: If client_type is not recognized + RuntimeError: If environment variable is not set or server is not reachable + """ + if client_type not in EXTERNAL_URL_ENV_VARS: + raise ValueError( + f"Unknown client_type: {client_type}. Must be one of: {', '.join(EXTERNAL_URL_ENV_VARS.keys())}" + ) + + env_var = EXTERNAL_URL_ENV_VARS[client_type] + server_url = os.environ.get(env_var) + + if not server_url: + raise RuntimeError( + f"Environment variable {env_var} is not set. " + f"The mock server must be started externally before running tests. " + f"For local development, run the mock server via bun. " + f"See https://github.com/algorandfoundation/algokit-polytest for setup instructions." + ) + + if not _check_server_health(server_url): + raise RuntimeError( + f"Mock server at {server_url} (from {env_var}) is not reachable. " + f"Ensure the mock server is running and accessible. " + f"For local development, run the mock server via bun. " + f"See https://github.com/algorandfoundation/algokit-polytest for setup instructions." + ) + + return MockServer(base_url=server_url.rstrip("/"), client_type=client_type) diff --git a/tests/modules/abi/__init__.py b/tests/modules/abi/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/modules/abi/test_abi_type.py b/tests/modules/abi/test_abi_type.py new file mode 100644 index 00000000..6a963127 --- /dev/null +++ b/tests/modules/abi/test_abi_type.py @@ -0,0 +1,666 @@ +import dataclasses +import decimal +import re + +import pytest + +from algokit_abi import abi +from algokit_common.constants import ZERO_ADDRESS + +_32K = 32 * 1024 +_MAX_U16 = 2**16 - 1 +_MAX_U32 = 2**32 - 1 +_MAX_U64 = 2**64 - 1 + + +@pytest.mark.parametrize( + ("abi_type_str", "expected_len"), + [ + ("bool", 1), + ("bool[2]", 1), + ("bool[8]", 1), + ("bool[9]", 2), + ("uint8", 1), + ("uint64", 8), + ("uint512", 64), + ("uint64[]", None), + ("ufixed64x2", 8), + ("byte", 1), + ("byte[7]", 7), + ("address", 32), + ("(uint64,bool,byte)", 10), + ], +) +def test_byte_len(abi_type_str: str, expected_len: int | None) -> None: + abi_type = abi.ABIType.from_string(abi_type_str) + assert abi_type.byte_len() == expected_len + + +@pytest.mark.parametrize("bit_size", [i * 8 for i in range(1, 65)]) +def test_uint_bit_sizes(bit_size: int) -> None: + abi_type = abi.UintType(bit_size) + assert abi_type.bit_size == bit_size + + +@pytest.mark.parametrize( + ("bit_size", "value", "expected_hex"), + [ + (8, 0, "00"), + (8, 1, "01"), + (8, 15, "0F"), + (8, 16, "10"), + (8, 254, "FE"), + (8, 255, "FF"), + (16, 0, "0000"), + (16, 1, "0001"), + (16, 3, "0003"), + (16, _MAX_U16, "FFFF"), + (32, 0, "00000000"), + (32, 1, "00000001"), + (32, _MAX_U32, "FFFFFFFF"), + (64, 0, "0000000000000000"), + (64, 1, "0000000000000001"), + (64, 256, "0000000000000100"), + (64, _MAX_U64, "FFFFFFFFFFFFFFFF"), + (128, 0, "00" * 16), + (128, 1, "00" * 15 + "01"), + (128, 2**128 - 1, "FF" * 16), + (256, 0, "00" * 32), + (256, 1, "00" * 31 + "01"), + (256, 2**256 - 1, "FF" * 32), + (512, 0, "00" * 64), + (512, 1, "00" * 63 + "01"), + (512, 2**512 - 1, "FF" * 64), + ], +) +def test_uint(bit_size: int, value: int, expected_hex: str) -> None: + abi_type = abi.UintType(bit_size=bit_size) + encoded = abi_type.encode(value) + expected = bytes.fromhex(expected_hex) + assert encoded == expected, f"expected {value} encoded as {abi_type} to be 0x{expected_hex}" + + +@pytest.mark.parametrize( + "bit_size", + [ + -512, + -8, + -1, + 0, + 1, + 7, + 9, + 15, + 23, + 25, + 520, + ], +) +def test_uint_invalid_size(bit_size: int) -> None: + with pytest.raises(ValueError, match="bit_size must be between 8 and 512"): + abi.UintType(bit_size=bit_size) + + +@pytest.mark.parametrize( + "bit_size", + [ + 8, + 64, + 512, + ], +) +def test_uint_value_too_big(bit_size: int) -> None: + abi_type = abi.UintType(bit_size=bit_size) + with pytest.raises(OverflowError): + abi_type.encode(2**bit_size) + + +@pytest.mark.parametrize( + "bit_size", + [ + 8, + 64, + 512, + ], +) +def test_uint_value_negative(bit_size: int) -> None: + abi_type = abi.UintType(bit_size=bit_size) + with pytest.raises(OverflowError): + abi_type.encode(-1) + + +@pytest.mark.parametrize("value", ["not an int", 1.23, decimal.Decimal("0.00"), b"\x00" * 8]) +def test_uint_invalid_value_type(value: object) -> None: + abi_type: abi.ABIType = abi.UintType(bit_size=64) + with pytest.raises(TypeError): + abi_type.encode(value) + + +@pytest.mark.parametrize( + ("bit_size", "precision", "value_str", "expected_hex"), + [ + (8, 1, "0.0", "00"), + (8, 1, "0.1", "01"), + (8, 1, "25.5", "FF"), + (8, 2, ".01", "01"), + (8, 2, "0.01", "01"), + (8, 2, ".1", "0A"), + (8, 2, "0.1", "0A"), + (8, 2, "1.000", "64"), + (8, 2, "0.00", "00"), + (8, 2, "0.00000", "00"), + (8, 2, "2.55", "FF"), + (16, 1, "0.0", "0000"), + (16, 1, "0.1", "0001"), + (16, 1, "6553.5", "FFFF"), + (512, 160, "0." + "0" * 160, "00" * 64), + (512, 160, "0." + "0" * 159 + "1", "00" * 63 + "01"), + ], +) +def test_ufixed_decimal(bit_size: int, precision: int, value_str: str, expected_hex: str) -> None: + value = decimal.Decimal(value_str) + abi_type = abi.UfixedType(bit_size=bit_size, precision=precision) + encoded = abi_type.encode(value) + expected = bytes.fromhex(expected_hex) + assert encoded == expected, f"expected {value} encoded as {abi_type} to be 0x{expected_hex}" + + +@pytest.mark.parametrize( + ("bit_size", "precision", "value", "expected_hex"), + [ + (8, 2, 0, "00"), + (8, 2, 1, "01"), + (8, 30, 255, "FF"), + (32, 10, 33, "00000021"), + ], +) +def test_ufixed_int(bit_size: int, precision: int, value: int, expected_hex: str) -> None: + abi_type = abi.UfixedType(bit_size=bit_size, precision=precision) + encoded = abi_type.encode(value) + expected = bytes.fromhex(expected_hex) + assert encoded == expected, f"expected {value} encoded as {abi_type} to be 0x{expected_hex}" + + +@pytest.mark.parametrize( + "bit_size", + [ + -512, + -8, + -1, + 0, + 1, + 7, + 9, + 15, + 23, + 25, + 520, + ], +) +def test_ufixed_invalid_size(bit_size: int) -> None: + with pytest.raises(ValueError, match="bit_size must be between 8 and 512"): + abi.UfixedType(bit_size=bit_size, precision=1) + + +@pytest.mark.parametrize( + "precision", + [ + -1, + 0, + 161, + ], +) +def test_ufixed_invalid_precision(precision: int) -> None: + with pytest.raises(ValueError, match="precision must be between 0 and 160"): + abi.UfixedType(bit_size=512, precision=precision) + + +@pytest.mark.parametrize("value", ["not a decimal", 1.23, b"\x00" * 8]) +def test_ufixed_invalid_value_type(value: object) -> None: + abi_type: abi.ABIType = abi.UfixedType(64, 1) + with pytest.raises(TypeError): + abi_type.encode(value) + + +@pytest.mark.parametrize( + "bit_size", + [8, 64, 512], +) +def test_ufixed_value_too_big(bit_size: int) -> None: + abi_type = abi.UfixedType(bit_size, 1) + with pytest.raises(OverflowError): + abi_type.encode(2**bit_size) + + +@pytest.mark.parametrize( + "bit_size", + [8, 64, 512], +) +def test_ufixed_value_negative(bit_size: int) -> None: + abi_type = abi.UfixedType(bit_size, 1) + with pytest.raises(OverflowError): + abi_type.encode(-1) + + +def test_ufixed_value_too_precise() -> None: + abi_type = abi.UfixedType(8, 1) + with pytest.raises(ValueError, match="precision exceeds 1"): + abi_type.encode(decimal.Decimal("1.001")) + + +@pytest.mark.parametrize( + ("value", "expected_hex"), + [ + (0, "00"), + (1, "01"), + (10, "0A"), + (254, "FE"), + (255, "FF"), + ], +) +def test_byte_int(value: int, expected_hex: str) -> None: + abi_type = abi.ByteType() + encoded = abi_type.encode(value) + expected = bytes.fromhex(expected_hex) + assert encoded == expected, f"expected {value} encoded as {abi_type} to be 0x{expected_hex}" + decoded = abi_type.decode(encoded) + assert decoded == bytes.fromhex(expected_hex) + + +@pytest.mark.parametrize( + "expected_hex", + [ + "00", + "01", + "0A", + "80", + "FE", + "FF", + ], +) +def test_byte_byte(expected_hex: str) -> None: + abi_type = abi.ByteType() + expected = bytes.fromhex(expected_hex) + encoded = abi_type.encode(expected) + assert encoded == expected, f"expected 0x{expected_hex} encoded as {abi_type} to be 0x{expected_hex}" + decoded = abi_type.decode(encoded) + assert decoded == expected, f"expected decoded value {decoded} to equal original value {expected}" + + +@pytest.mark.parametrize( + ("value", "expected_hex"), + [ + (False, "00"), + (True, "80"), + ], +) +def test_bool(*, value: bool, expected_hex: str) -> None: + abi_type = abi.BoolType() + encoded = abi_type.encode(value) + expected = bytes.fromhex(expected_hex) + assert encoded == expected, f"expected {value} encoded as {abi_type} to be 0x{expected_hex}" + decoded = abi_type.decode(encoded) + assert decoded == value, f"expected decoded value {decoded} to equal original value {value}" + + +_ADDRESS = "MO2H6ZU47Q36GJ6GVHUKGEBEQINN7ZWVACMWZQGIYUOE3RBSRVYHV4ACJI" +_ADDRESS_BYTES = bytes.fromhex("63B47F669CFC37E327C6A9E8A31024821ADFE6D500996CC0C8C51C4DC4328D70") + + +@pytest.mark.parametrize( + ("value", "expected"), + [(_ADDRESS, _ADDRESS_BYTES), (_ADDRESS_BYTES, _ADDRESS_BYTES), (ZERO_ADDRESS, b"\x00" * 32)], +) +def test_address(value: str | bytes, expected: bytes) -> None: + abi_type = abi.AddressType() + encoded = abi_type.encode(value) + assert encoded == expected, f"expected {value} encoded as {abi_type} to be 0x{expected.hex()}" + + +@pytest.mark.parametrize( + ("value", "expected"), + [ + ("What's new", b"\x00\x0aWhat's new"), + ( + "😅🔨", + bytes([0, 8, 240, 159, 152, 133, 240, 159, 148, 168]), + ), + ("asdf", b"\x00\x04asdf"), + ], +) +def test_string(value: str, expected: bytes) -> None: + abi_type = abi.StringType() + encoded = abi_type.encode(value) + assert encoded == expected, f"expected {value} encoded as {abi_type} to be {expected!r}" + decoded = abi_type.decode(encoded) + assert decoded == value, f"expected decoded value {decoded} to equal original value {value}" + + +@pytest.mark.parametrize( + ("value", "expected_hex"), + [ + ([True], "80"), + ([False], "00"), + ([True, True, False], "C0"), + ([False, True, False, False, False, False, False, False], "40"), + ([True] * 8, "FF"), + ([True, False, False, True, False, False, True, False, True], "9280"), + ([True] * (_32K * 8), "FF" * _32K), # biggest bool static array that can be stored in a box + ], +) +def test_bool_static_array(value: list[bool], expected_hex: str) -> None: + abi_type = abi.StaticArrayType(element=abi.BoolType(), size=len(value)) + encoded = abi_type.encode(value) + expected = bytes.fromhex(expected_hex) + assert encoded == expected, f"expected {value} encoded as {abi_type} to be 0x{expected_hex}" + decoded = abi_type.decode(encoded) + assert decoded == value, f"expected decoded value {decoded} to equal original value {value}" + + +@pytest.mark.parametrize( + ("value", "expected_hex"), + [ + ([1, 2, 3], f"{1:016}{2:016}{3:016}"), + ([_MAX_U64], "FF" * 8), + ([_MAX_U64] * (_32K // 8), "FF" * _32K), + ], +) +def test_uint64_static_array(value: list[int], expected_hex: str) -> None: + abi_type = abi.StaticArrayType(element=abi.UintType(64), size=len(value)) + encoded = abi_type.encode(value) + expected = bytes.fromhex(expected_hex) + assert encoded == expected, f"expected {value} encoded as {abi_type} to be 0x{expected_hex}" + decoded = abi_type.decode(encoded) + assert decoded == value, f"expected decoded value {decoded} to equal original value {value}" + + +@pytest.mark.parametrize( + "element", + [ + abi.UintType(64), + abi.UfixedType(64, 2), + abi.ByteType(), + abi.BoolType(), + abi.AddressType(), + ], +) +def test_empty_array(element: abi.ABIType) -> None: + abi_type = abi.DynamicArrayType(element) + encoded = abi_type.encode([]) + assert encoded == b"\x00\x00", f"expected empty array of {element} to be 0x0000" + decoded = abi_type.decode(encoded) + assert not decoded, "expected decoded empty array to be empty" + + +@pytest.mark.parametrize( + ("value", "expected_hex"), + [ + ([True, True, False], "0003C0"), + ([True] * 8, "0008FF"), + ([True, False, False, True, False, False, True, False, True], "00099280"), + ([False] * _MAX_U16, "FFFF" + "00" * 8192), + ([True] * _MAX_U16, "FF" * 8193 + "FE"), + ], +) +def test_bool_dynamic_array(value: list[bool], expected_hex: str) -> None: + abi_type = abi.DynamicArrayType(abi.BoolType()) + encoded = abi_type.encode(value) + expected = bytes.fromhex(expected_hex) + assert encoded == expected, f"expected bool array to be 0x{expected_hex}" + decoded = abi_type.decode(encoded) + assert decoded == value, f"expected decoded value {decoded} to equal original value {value}" + + +@pytest.mark.parametrize( + ("value", "expected_hex"), + [ + ([1, 2, 3], f"{3:04}{1:016}{2:016}{3:016}"), + ([_MAX_U64], "0001" + "FF" * 8), + ([_MAX_U64] * 2046, "07FE" + "FF" * (2046 * 8)), + ], +) +def test_uint64_dynamic_array(value: list[int], expected_hex: str) -> None: + abi_type = abi.DynamicArrayType(element=abi.UintType(64)) + encoded = abi_type.encode(value) + expected = bytes.fromhex(expected_hex) + assert encoded == expected, f"expected {value} encoded as {abi_type} to be 0x{expected_hex}" + decoded = abi_type.decode(encoded) + assert decoded == value, f"expected decoded value {decoded} to equal original value {value}" + + +def test_array_encode_length_too_big() -> None: + abi_type = abi.ABIType.from_string("uint8[]") + with pytest.raises(ValueError, match="array length exceeds 65535"): + abi_type.encode([0] * (2**16)) + + +def test_array_encode_too_many_bytes() -> None: + abi_type = abi.ABIType.from_string("(byte[],byte[])") + large_bytes = b"\x00" * (2**16 - 1) + with pytest.raises(ValueError, match="encoded bytes length exceeds 65535"): + abi_type.encode((large_bytes, large_bytes)) + + +@pytest.mark.parametrize( + "abi_element_type", + [ + "byte", + "uint8", + "uint64", + "()", + "(uint64,address)", + "byte[]", + ], +) +def test_array_decode_too_many_bytes(abi_element_type: str) -> None: + abi_type = abi.ABIType.from_string(f"{abi_element_type}[]") + large_bytes = b"\x00" * 10 + with pytest.raises(ValueError, match=re.escape(f"expected 0 bytes for {abi_element_type}[0]")): + abi_type.decode(large_bytes) + + +@pytest.mark.parametrize( + "abi_element_type", + [ + "byte", + "uint8", + "uint64", + ], +) +def test_decode_too_many_bytes(abi_element_type: str) -> None: + abi_type = abi.ABIType.from_string(abi_element_type) + valid_bytes = abi_type.encode(0) + invalid_bytes = valid_bytes + b"\x00" + with pytest.raises(ValueError, match=re.escape(f"expected {abi_type.byte_len()} bytes")): + abi_type.decode(invalid_bytes) + + +def test_decode_tuple_too_many_bytes() -> None: + abi_type = abi.ABIType.from_string("(uint64,address)") + valid_bytes = abi_type.encode((0, b"\x00" * 32)) + invalid_bytes = valid_bytes + b"\x00" + with pytest.raises(ValueError, match=re.escape(f"expected {abi_type.byte_len()} bytes")): + abi_type.decode(invalid_bytes) + + +def test_tuple_decode_wrong_offset() -> None: + abi_type = abi.ABIType.from_string("(byte,byte[])") + large_bytes = b"\x00\x00\x04\x00\x00\x00" + with pytest.raises(ValueError, match="expected tail offset of 3"): + abi_type.decode(large_bytes) + + +def test_tuple_decode_wrong_offset2() -> None: + abi_type = abi.ABIType.from_string("(byte[],byte[])") + large_bytes = b"\x00\x04\x00\x08\x00\x01\x00\x00\x00\x00" + # note: the wrong offset causes a decode failure of the second array before + # the offset can be checked + with pytest.raises(ValueError, match=re.escape("expected 1 bytes for byte[1]")): + abi_type.decode(large_bytes) + + +@pytest.mark.parametrize( + ("abi_type_name", "value", "expected_hex"), + [ + ("(uint8,uint16)", (1, 2), "010002"), + ("(uint32,uint32)", (1, 2), f"{1:08}{2:08}"), + ("(uint32,string)", (42, "hello"), f"0000002A{6:04}" + b"\x00\x05hello".hex()), + ("(uint16,bool)", (1234, False), "04D200"), + ("(uint32,string,bool)", (42, "test", False), f"0000002A{7:04}00" + b"\x00\x04test".hex()), + ("()", (), ""), + ("(bool,bool,bool)", (False, True, True), "60"), + ("(bool[3])", ([False, True, True],), "60"), + ("(bool[])", ([False, True, True],), "0002000360"), + ("(bool[2],bool[])", ([True, True], [True, True]), "C000030002C0"), + ("(bool[],bool[])", ([], []), "0004000600000000"), + ("(bool[],bool[])", ([True], [False]), "00040007000180000100"), + ("(string,bool,bool,bool,bool,string)", ("AB", True, False, True, False, "DE"), "0005A000090002414200024445"), + ("(uint16,(byte,address))", (42, (b"\xea", _ADDRESS)), "002AEA" + _ADDRESS_BYTES.hex()), + ("(string,uint32)", ("test", 7), f"0006{7:08}" + b"\x00\x04test".hex()), + ], +) +def test_tuples(abi_type_name: str, value: tuple, expected_hex: str) -> None: + abi_type = abi.ABIType.from_string(abi_type_name) + encoded = abi_type.encode(value) + expected = bytes.fromhex(expected_hex) + assert encoded == expected, f"expected {value} encoded as {abi_type} to be 0x{expected_hex}" + decoded = abi_type.decode(encoded) + assert decoded == value, f"expected decoded value {decoded} to equal original value {value}" + + +def _abi_meta(abi_type_or_name: str | abi.ABIType) -> dict[str, object]: + abi_type = abi.ABIType.from_string(abi_type_or_name) if isinstance(abi_type_or_name, str) else abi_type_or_name + return {"abi": abi_type} + + +def _dataclass_to_abi_type(typ: type) -> abi.ABIType: + fields = {f.name: _get_abi_type(f) for f in dataclasses.fields(typ)} + return abi.StructType(struct_name=typ.__name__, fields=fields, decode_type=typ) + + +_TYPE_TO_DEFAULT_ABI = { + int: "uint64", + bool: "bool", + bytes: "byte[]", + str: "string", +} + + +def _get_abi_type(field: dataclasses.Field) -> abi.ABIType: + if abi_type := field.metadata.get("abi"): + return abi_type + elif dataclasses.is_dataclass(field.type): + return _dataclass_to_abi_type(field.type) + else: + abi_name = _TYPE_TO_DEFAULT_ABI.get(field.type) + + if abi_name is None: + raise TypeError("could not determine abi type, use _abi_metadata") + return abi.ABIType.from_string(abi_name) + + +@dataclasses.dataclass +class Foo: + a: int = dataclasses.field(metadata=_abi_meta("uint16")) + b: str + c: bytes + + +@dataclasses.dataclass +class Baz: + a: int = dataclasses.field(metadata=_abi_meta("uint8")) + b: int = dataclasses.field(metadata=_abi_meta("uint16")) + + +_BAZ_ABI_TYPE = _dataclass_to_abi_type(Baz) + + +@dataclasses.dataclass +class Bar: + a: bytes = dataclasses.field(metadata=_abi_meta("byte")) + b: list[Baz] = dataclasses.field(metadata=_abi_meta(abi.StaticArrayType(_dataclass_to_abi_type(Baz), 3))) + + +@dataclasses.dataclass +class Large: + many_bar: list[Bar] = dataclasses.field(metadata=_abi_meta(abi.DynamicArrayType(_dataclass_to_abi_type(Bar)))) + large_bytes: bytes = dataclasses.field(metadata=_abi_meta("byte[1024]")) + + +@pytest.mark.parametrize( + ("value", "expected_hex"), + [ + ( + Foo(7, "hello", b"world"), + ("00070006000D" + b"\x00\x05hello\x00\x05world".hex()), + ), + ( + Bar(b"\x00", [Baz(1, 2), Baz(3, 4), Baz(5, 6)]), + "00010002030004050006", + ), + ( + Large( + many_bar=[ + Bar(b"\x00", [Baz(1, 2), Baz(3, 4), Baz(5, 6)]), + Bar(b"\x07", [Baz(8, 9), Baz(10, 11), Baz(12, 13)]), + ], + large_bytes=b"A" * 1024, + ), + "0402" + b"A".hex() * 1024 + "000200010002030004050006070800090A000B0C000D", + ), + ], +) +def test_struct(value: object, expected_hex: str) -> None: + abi_type = _dataclass_to_abi_type(type(value)) + encoded = abi_type.encode(value) + expected = bytes.fromhex(expected_hex) + assert encoded == expected, f"expected {value} encoded as {abi_type} to be 0x{expected_hex}" + decoded = abi_type.decode(encoded) + assert decoded == value, f"expected decoded value {decoded} to equal original value {value}" + + +def test_struct_equality() -> None: + fields = {"foo": abi.ByteType(), "bar": abi.BoolType()} + struct = abi.StructType(struct_name="A", fields=fields) + + same_name_and_field = abi.StructType(struct_name="A", fields=fields) + assert struct == same_name_and_field, "structs with the same name and fields should be equal" + + same_fields_different_name = abi.StructType(struct_name="B", fields=fields) + assert struct != same_fields_different_name, "structs with different name and same fields should not be equal" + + same_name_different_fields = abi.StructType(struct_name="A", fields={"foo": abi.ByteType()}) + assert struct != same_name_different_fields, "structs with same name and different fields should not be equal" + + +@pytest.mark.parametrize( + "abi_type_str", + [ + "byte[", + "(byte", + "bad", + "(byte))", + "uintbad", + "ufixedbad", + "ufixedbadx2", + "ufixed2xbad", + "uint64[bad]", + "ufixedbadx2x3", + "ufixed2x3x4", + "ufixedbad2x3[]", + "(uint64,bad)", + ], +) +def test_from_string_errors(abi_type_str: str) -> None: + with pytest.raises(ValueError, match="unknown abi type"): + abi.ABIType.from_string(abi_type_str) + + +def test_missing_tup_element() -> None: + with pytest.raises(ValueError, match="commas must follow a tuple element"): + abi.ABIType.from_string("(byte,,byte)") + + +def test_trailing_comma() -> None: + with pytest.raises(ValueError, match="cannot have leading or trailing commas"): + abi.ABIType.from_string("(byte,)") diff --git a/tests/modules/algo25/__init__.py b/tests/modules/algo25/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/modules/algo25/test_mnemonic.py b/tests/modules/algo25/test_mnemonic.py new file mode 100644 index 00000000..e4f215a8 --- /dev/null +++ b/tests/modules/algo25/test_mnemonic.py @@ -0,0 +1,106 @@ +"""Tests for algokit_algo25 mnemonic functions.""" + +import os + +import pytest + +from algokit_algo25 import ( + FAIL_TO_DECODE_MNEMONIC_ERROR_MSG, + NOT_IN_WORDS_LIST_ERROR_MSG, + InvalidMnemonicError, + InvalidSeedLengthError, + WordNotFoundError, + master_derivation_key_to_mnemonic, + mnemonic_from_seed, + mnemonic_to_master_derivation_key, + secret_key_to_mnemonic, + seed_from_mnemonic, +) + + +# Test vector: zero seed produces specific mnemonic +ZERO_SEED = bytes(32) +ZERO_SEED_MNEMONIC = ( + "abandon abandon abandon abandon abandon abandon abandon abandon " + "abandon abandon abandon abandon abandon abandon abandon abandon " + "abandon abandon abandon abandon abandon abandon abandon abandon invest" +) + + +class TestMnemonicFromSeed: + def test_zero_seed(self) -> None: + mnemonic = mnemonic_from_seed(ZERO_SEED) + assert mnemonic == ZERO_SEED_MNEMONIC + + def test_returns_25_words(self) -> None: + seed = os.urandom(32) + mnemonic = mnemonic_from_seed(seed) + words = mnemonic.split() + assert len(words) == 25 + + def test_invalid_seed_too_short(self) -> None: + with pytest.raises(InvalidSeedLengthError): + mnemonic_from_seed(bytes(31)) + + def test_invalid_seed_too_long(self) -> None: + with pytest.raises(InvalidSeedLengthError): + mnemonic_from_seed(bytes(33)) + + +class TestSeedFromMnemonic: + def test_zero_seed_mnemonic(self) -> None: + seed = seed_from_mnemonic(ZERO_SEED_MNEMONIC) + assert seed == ZERO_SEED + + def test_case_insensitive(self) -> None: + seed = seed_from_mnemonic(ZERO_SEED_MNEMONIC.upper()) + assert seed == ZERO_SEED + + def test_wrong_word_count(self) -> None: + with pytest.raises(InvalidMnemonicError) as exc_info: + seed_from_mnemonic("abandon abandon abandon") + assert FAIL_TO_DECODE_MNEMONIC_ERROR_MSG in str(exc_info.value) + + def test_invalid_word(self) -> None: + mnemonic = "invalidword " + " ".join(["abandon"] * 24) + with pytest.raises(WordNotFoundError) as exc_info: + seed_from_mnemonic(mnemonic) + assert NOT_IN_WORDS_LIST_ERROR_MSG in str(exc_info.value) + + def test_wrong_checksum(self) -> None: + # Replace checksum word with wrong word + mnemonic = " ".join(["abandon"] * 25) # wrong checksum + with pytest.raises(InvalidMnemonicError) as exc_info: + seed_from_mnemonic(mnemonic) + assert FAIL_TO_DECODE_MNEMONIC_ERROR_MSG in str(exc_info.value) + + +class TestRoundtrip: + def test_roundtrip_zero_seed(self) -> None: + mnemonic = mnemonic_from_seed(ZERO_SEED) + recovered = seed_from_mnemonic(mnemonic) + assert recovered == ZERO_SEED + + def test_roundtrip_random_seeds(self) -> None: + for _ in range(10): + seed = os.urandom(32) + mnemonic = mnemonic_from_seed(seed) + recovered = seed_from_mnemonic(mnemonic) + assert recovered == seed + + +class TestSecretKeyToMnemonic: + def test_64_byte_key_uses_first_32_bytes(self) -> None: + secret_key = ZERO_SEED + bytes(32) # seed + dummy public key + mnemonic = secret_key_to_mnemonic(secret_key) + assert mnemonic == ZERO_SEED_MNEMONIC + + +class TestMasterDerivationKey: + def test_to_mnemonic(self) -> None: + mnemonic = master_derivation_key_to_mnemonic(ZERO_SEED) + assert mnemonic == ZERO_SEED_MNEMONIC + + def test_from_mnemonic(self) -> None: + key = mnemonic_to_master_derivation_key(ZERO_SEED_MNEMONIC) + assert key == ZERO_SEED diff --git a/tests/modules/algod_client/__init__.py b/tests/modules/algod_client/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/modules/algod_client/__snapshots__/test_get_genesis/test_basic_request_and_response_validation.json b/tests/modules/algod_client/__snapshots__/test_get_genesis/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..9b2e68c8 --- /dev/null +++ b/tests/modules/algod_client/__snapshots__/test_get_genesis/test_basic_request_and_response_validation.json @@ -0,0 +1,2056 @@ +{ + "alloc": [ + { + "addr": "7777777777777777777777777777777777777777777777777774MSJUVU", + "comment": "RewardsPool", + "state": { + "algo": 125000000000000, + "onl": 2, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "A7NMWS3NT3IUDMLVO26ULGXGIIOUQ3ND2TXSER6EBGRZNOBOUIQXHIBGDE", + "comment": "FeeSink", + "state": { + "algo": 100000, + "onl": 2, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "LHHQJ6UMXRGEPXBVFKT7SY26BQOIK64VVPCLVRL3RNQLX5ZMBYG6ZHZMBE", + "comment": "Wallet1", + "state": { + "algo": 320000000000000, + "onl": 1, + "sel": "h7Ml/mY/PDCPSj33u72quxaMX99n+/VE+wD94/hMdzY=", + "stprf": null, + "vote": "R9kxsHbji4DlxPOAyLehy8vaiWyLjWdLGWBLnQ5jjY8=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "CQW2QBBUW5AGFDXMURQBRJN2AM3OHHQWXXI4PEJXRCVTEJ3E5VBTNRTEAE", + "comment": "Wallet10", + "state": { + "algo": 320000000000000, + "onl": 1, + "sel": "p2tiuQ2kqJGG049hHOKNIjid4/u1MqlvgXfbxK4tuEY=", + "stprf": null, + "vote": "E73cc+KB/LGdDHO1o84440WKCmqvbM4EgROMRyHfjDc=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "HXPCXKQZF4LDL3CE5ERWC5V2BQZTKXUUT3JE6AXXNKLF3OJL4XUAW5WYXM", + "comment": "Wallet11", + "state": { + "algo": 320000000000000, + "onl": 1, + "sel": "ex32mzy8E94GkHGy+cmkRP5JNqFBKGfHtgyUGNxTiW8=", + "stprf": null, + "vote": "BtYvtmeEBY2JovHUfePTjo3OtOMrhKp3QMeOYl3JFYM=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "Y3FSHQ43JWDSJG7LL5FBRTXHEGTPSWEQBO4CO2RO7KS2Z4ZGBUI7LSEDHQ", + "comment": "Wallet12", + "state": { + "algo": 320000000000000, + "onl": 1, + "sel": "+AtsgunCR8dzO9UGUJ6sFtAaX/E+ssK6JNmvAljQG2E=", + "stprf": null, + "vote": "Rx21vGt6pnixU2g6NS/TknVtAGbf8hWMJiEtNuV5lb4=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "KXILJUKZJEOS4OCPGENS72JWIZOXGZSK4R235EQPGQ3JLG6R2BBT3ODXEI", + "comment": "Wallet13", + "state": { + "algo": 320000000000000, + "onl": 1, + "sel": "6s09aJVaGfPdbWy5zUSyBJEX/EGVvsn2moUOvakQdBQ=", + "stprf": null, + "vote": "1oTW6ZpIHhQP6xeNCSqHOZZJYrKiP5D52OHXGzbVz4k=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "R4DCCBODM4L7C6CKVOV5NYDPEYS2G5L7KC7LUYPLUCKBCOIZMYJPFUDTKE", + "comment": "Wallet14", + "state": { + "algo": 320000000000000, + "onl": 1, + "sel": "XsqeQcLz5nPP316ntIp0X9OfJi5ZSfUNrlRSitWXJRg=", + "stprf": null, + "vote": "r+e0lAD9FnNqOKoWdYdFko13pm9fk/zCJkxVVCqzjaU=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "VKM6KSCTDHEM6KGEAMSYCNEGIPFJMHDSEMIRAQLK76CJDIRMMDHKAIRMFQ", + "comment": "Wallet15", + "state": { + "algo": 320000000000000, + "onl": 1, + "sel": "64Xkj7z3rHZT7syihd0OmgNExHfnOLdLojDJZgtB1d8=", + "stprf": null, + "vote": "um2RrGFmZ5Coned2WSbo/htYMKjW7XFE5h25M2IFsDs=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "YTOO52XR6UWNM6OUUDOGWVTNJYBWR5NJ3VCJTZUSR42JERFJFAG3NFD47U", + "comment": "Wallet16", + "state": { + "algo": 320000000000000, + "onl": 1, + "sel": "9f9aNsmJxXgMZke5sRYFbfnH5fIFclSosqSl1mK4Vd8=", + "stprf": null, + "vote": "h8ybeZLDhNG/53oJGAzZ2TFAXDXaslXMzNBOR3Pd+i4=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "EQ5XMOLC2JY5RNFXM725LRVKSTOHWBOQE344ZC6O2K4NW2S3G4XQIJNKAA", + "comment": "Wallet17", + "state": { + "algo": 320000000000000, + "onl": 1, + "sel": "R2LzBwBOEoMEcN6j2Pq9F1RKgrLrqnTyW/iT/tlIRZg=", + "stprf": null, + "vote": "FnP52cIaWwqpJ6dE3KuM3WSGaz+TNlb/iM7EO0j7EZQ=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "3PUAOGK2PIEH6K5JTQ55SCV3E52KSLDPUAWDURMUNST6IIFCH347X5SNAI", + "comment": "Wallet18", + "state": { + "algo": 320000000000000, + "onl": 1, + "sel": "HfTcCIGCoAgUMCHalBv2dSC2L7XCPqPmCmWmxO26Vqo=", + "stprf": null, + "vote": "knBY5MY9DkIguN41/ZoKvSGAg92/fhw64BLHUw0o1BU=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "DUQR2JOFHCTNRRI546OZDYLCVBIVRYOSWKNR7A43YKVH437QS3XGJWTQ6I", + "comment": "Wallet19", + "state": { + "algo": 320000000000000, + "onl": 1, + "sel": "DRSm3BAHOXLJLPHwrkKILG/cvHLXuDQYIceHgNPnQds=", + "stprf": null, + "vote": "9G4AtYrLO26Jc3BsUfNl+0+3IjeHdOOSM+8ASj9x7Tg=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "NWBZBIROXZQEETCDKX6IZVVBV4EY637KCIX56LE5EHIQERCTSDYGXWG6PU", + "comment": "Wallet2", + "state": { + "algo": 320000000000000, + "onl": 1, + "sel": "0eG0edle+ejWcS4Q8DNlITgqaKqNvOtCxNQs+4AncGo=", + "stprf": null, + "vote": "V4YUoGYXrgDjCluBBbBx2Kq9kkbCZudsuSwmSlCUnK0=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "U2573KTKRCC7I47FJUTW6DBEUN2VZQ63ZVYISQMIUEJTWDNOGSUTL67HBE", + "comment": "Wallet20", + "state": { + "algo": 320000000000000, + "onl": 1, + "sel": "cDT+xkHQJ13RgfkAUoNMfGk890z2C1V4HSmkxbm6gRk=", + "stprf": null, + "vote": "r66g4ULatIt179X+2embK0RgwoLdPEq3R3uTTMfP9Hk=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "DBGTTXBPXGKL4TBBISC73RMB3NNZIZBSH2EICWZTQRA42QKNA4S2W4SP7U", + "comment": "Wallet3", + "state": { + "algo": 320000000000000, + "onl": 1, + "sel": "DmlAnKrkD8lgUB1ahLsy/FIjbZ0fypaowyDc8GKwWZA=", + "stprf": null, + "vote": "ROBSmA9EfZitGyubHMTfmw8kSiohADB3n4McvTR8g88=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "XKZWM4PWPLZZWIANNT4S7LU26SPVIKMCDVQAAYRD4G3QJIOJL2X6RZOKK4", + "comment": "Wallet4", + "state": { + "algo": 320000000000000, + "onl": 1, + "sel": "74a0jcs/Y/uCh24vej1rb6CHu64yvW2nYrM0ZUVEhMo=", + "stprf": null, + "vote": "rwkur9iwJbzNECWvELxzFeJpbZl7dpiThgPJOHnRykg=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "LPBKDDUNKPXE7GAICEDXGTNCAJNC6IFJUSD4IK2H2IIB3OAFXLM3RLLIVQ", + "comment": "Wallet5", + "state": { + "algo": 320000000000000, + "onl": 1, + "sel": "V4ldV+IY068YK/h7Wb6aNRIo8pr2bYQg8KDgFd25xVw=", + "stprf": null, + "vote": "d2KdyajjKvpukuGmM2MxEC9XDEgjjF/Spsevjd877RI=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "MZZS43WEFY56LV3WXEVLROT3LYFLEBZ536UY3Z3J56S7EI3SYYOJVO6YRM", + "comment": "Wallet6", + "state": { + "algo": 320000000000000, + "onl": 1, + "sel": "BoBmrNpHTxySZ8DIlg5ZlINKwTPd/K75CCdhNzs9alo=", + "stprf": null, + "vote": "N6v+PVEUn9fLZb+9sQDu5lpCpsXLHY0skx/8bWDqk7Q=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "RP7BOFGBCPNHWPRJEGPNNQRNC3WXJUUAVSBTHMGUXLF36IEHSBGJOHOYZ4", + "comment": "Wallet7", + "state": { + "algo": 320000000000000, + "onl": 1, + "sel": "n0LW+MxrO2S8/AmPClPaGdTDC5PM/MENdEwrm21KmgU=", + "stprf": null, + "vote": "/e1z3LMbc8C4m9DZ6NCILpv7bZ/yVdmZUp/M32OSUN4=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "RDHKWTWXOE5AOWUWTROSR4WFLAHMUCRDZIA7OFBXXMMRBXGQ4BYQRPOXXU", + "comment": "Wallet8", + "state": { + "algo": 320000000000000, + "onl": 1, + "sel": "AGJ4v2nOA62A8rGm4H56VEo/6QdhVVJUuEASUybDPNI=", + "stprf": null, + "vote": "eL2GxfrIoG2kuknlGa8I6vPtMbpygYflrye0u/hE4Lg=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "UXPVVSG7EYC7YR7PRVOZKWYYYZPKEXWGYR6XHBMSAV6BHKQEVFYVYJBVQI", + "comment": "Wallet9", + "state": { + "algo": 320000000000000, + "onl": 1, + "sel": "P4tRdjhyJ9dSNItTY+r2+tQmPfHa6oBAzIh4X3df4gM=", + "stprf": null, + "vote": "VHITXAytk0804xXBLBVKGlRAcAcDSZKcR2fiz4HtWBU=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "GD64YIY3TWGDMCNPP553DZPPR6LDUSFQOIJVFDPPXWEG3FVOJCCDBBHU5A", + "comment": "bank-testnet", + "state": { + "algo": 200000000000000, + "onl": 1, + "sel": "r6aMJIPeqUPB8u4IvOU/wihF+sgqJVsjibvsYHVqj1s=", + "stprf": null, + "vote": "mPB1VDBFOPSIEFhXo7VJRLxn45ylDSRnO8J1nXQf4f0=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "GFICEF3GYRENRQHINLRPG7TS7TUIOARUIN7KWXWFROSG55BWFFRCRX5DAA", + "comment": "n1-testnet", + "state": { + "algo": 150000000000000, + "onl": 1, + "sel": "38qDzZjLPfernXNx7leElHsl39WLXMSgLHbEACeNgn4=", + "stprf": null, + "vote": "8ITl30j5PTSDjmR26G3/rZL7IQM3cSfqqxnJSZf3X0w=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "GFY7ND6YSM5OGNSMAJDYCO6O75SWQRCYOJHCWOPYHUYCWQFWML52TWREBQ", + "comment": "n10-testnet", + "state": { + "algo": 150000000000000, + "onl": 1, + "sel": "iwwKBjoUUUePkoG0ldxc0v6i1fIhVySn2l2kWwekn2A=", + "stprf": null, + "vote": "DaZFFz72XkcUIuPXcEz6VxWj4SVjzMpOwpTfO2k308g=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "VQFEAD2SXHMLJ3BNSGYUHRZZWBOI7HUQZGFFJEKYD3SGNS667FTMPRDC4Y", + "comment": "n11-testnet", + "state": { + "algo": 50000000000000, + "onl": 1, + "sel": "ckpVY6EaDInNeU1WLHQQXNsAaQnh+bpFhzNWzw0ZirI=", + "stprf": null, + "vote": "4N1HJ9R2TrTEzLOyO1vUWPYi6sUcdAwQWoHQNBR/CME=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "6J7K7FIYKWTT3LSOZKYWAMSZC5RDID4CJ24C2S5DBQ5V7YUIHOBHPAO4KY", + "comment": "n12-testnet", + "state": { + "algo": 50000000000000, + "onl": 1, + "sel": "n16osH+x1UIrzDNa7PCZHn/UtheRoLcTBwGRnx0fTa8=", + "stprf": null, + "vote": "Tj0inLse0V3sQRPw+5rVQTIWOqTxn7/URDzUaWGHftg=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "G5KCM3LSFV4GHRYQBXGWTNMR5XESE3PIRODD7ZLASPIGOHPV7CO7UKLZFM", + "comment": "n13-testnet", + "state": { + "algo": 50000000000000, + "onl": 1, + "sel": "tveXF/sDXqBXQY52IEMuvTeVguKzPfN8GLdKgtv3gRg=", + "stprf": null, + "vote": "uwQJnVuqEtdGnWbbfu+TTLe++56z8wQCzv22IDioALE=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "XNQAMZMMLQV3TGYGJYYLYZUHP4YNEKAJM6RAMJ5SBXFLS3XDBIUVGCZPH4", + "comment": "n14-testnet", + "state": { + "algo": 50000000000000, + "onl": 1, + "sel": "8xotecjUoo1YVzWME3ib9uh+kPUNnzsFcuHrjxxhjZM=", + "stprf": null, + "vote": "oQ/iakoP5B6gTTm0+xfHHGFS4Ink30I6FWUGkxRNfo8=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "WXCLU5C6QH6KPVNAHNBGFUMC5JAOQCZP3HF76OT2TH3IAI3XTSPCLVILSU", + "comment": "n15-testnet", + "state": { + "algo": 200000000000000, + "onl": 1, + "sel": "NRxs0rM5dov2oZrf6XrFSmG9CRlS3Bmzt0be7uF/nHw=", + "stprf": null, + "vote": "R8xKtpYYNuTuTqMui/qzxYpc1m8KpbaK/eizYxVQDaY=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "7NRVO2ABPGFRX3374TIJZ46BR72CCSHKTR6PG5VVYNLUPWUVXGOU3O5YQA", + "comment": "n16-testnet", + "state": { + "algo": 200000000000000, + "onl": 1, + "sel": "IQG+jgm2daCxMLxm/f9tTVrDk/hD0ZhB5dxDQn47BSE=", + "stprf": null, + "vote": "CGwAHrq3QFFlsP7NmHed+Xx4BwFsE2f6dB30Os75KxY=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "537URFEXANB7M6UVND6WDM75DPRRORDXWFLSOG7EGILSKDIU4T32N4KAN4", + "comment": "n17-testnet", + "state": { + "algo": 200000000000000, + "onl": 1, + "sel": "SdLlaWBe8B1JanMq0Y7T1Z9C8dKhI36MQiSffXQt7Lo=", + "stprf": null, + "vote": "k4Xr6Bg6VpcY0GKwfr6kI89KqOihmCOToLLuIgFjv9c=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "ZNQXW7V5MISZFOZGVLAHKXS7GLWLXCLRPZTTIAZSTFRZPYTC54NWDZ6XZY", + "comment": "n18-testnet", + "state": { + "algo": 200000000000000, + "onl": 1, + "sel": "TNMELlR1C+r4OmGVp9vc9XlehgD3a0EwfrepuMiDe+c=", + "stprf": null, + "vote": "060veVAG/L2r2IAjqs2TcYy2cthocqrhgrCCoP5lzZ4=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "G3WQEPSGZOQVVJ2H3F6ICMHRIE2JL6U3X3JDABWJRN4HNDUJIAT4YTOGXA", + "comment": "n19-testnet", + "state": { + "algo": 300000000000000, + "onl": 1, + "sel": "ktbtHTm1mUU5u/VMrOuMujMgemUf496zilQsGBynsxQ=", + "stprf": null, + "vote": "XHXYdLvxKIIjtlmwHVqxvtAyRDE+SQR1tpzgXoNo5FA=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "2YNZ5XDUHYXL2COTVLZBRYV2A7VETFKQZQCPYMQRBOKTAANHP37DUH5BOI", + "comment": "n2-testnet", + "state": { + "algo": 150000000000000, + "onl": 1, + "sel": "u7lR9NcWfssuMvFYuqCi5/nX0Fj9qBKbE0B2OpRhmMg=", + "stprf": null, + "vote": "/UGQ/1dcp7OTmguYALryqQYRj0oMWhs/ahAbQTL/mRA=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "IH5Z5UZCZKNAH5OICUGHFEYM2JDMJRUSIUV4TZEQYHRNS3T2ROOV32CDIA", + "comment": "n20-testnet", + "state": { + "algo": 300000000000000, + "onl": 1, + "sel": "Jbcg+BVB6EOTe42U0dq1psQfoFZItb6Phst22z33j60=", + "stprf": null, + "vote": "8Y1QY+WJIziffLecmnr0ZRGJFKtA3oVALQoD3nVKlt8=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "FFJZOPQCYSRZISSJF33MBQJGGTIB2JFUEGBJIY6GXRWEU23ONC65GUZXHM", + "comment": "n3-testnet", + "state": { + "algo": 150000000000000, + "onl": 1, + "sel": "+K8AsLfvuTEuHMANNp2LxGuotgEjFtqOjuR/o4KR6LA=", + "stprf": null, + "vote": "SerMKyY37A1jFkE0BdrP+vuTdVn9oOJc5QjC5f98Dz8=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "ZWYIEI37V6HI62ZQCPJ5I6AIVKZP6JVCBQJKZEQQCWF4A4G2QGFENKS5XU", + "comment": "n4-testnet", + "state": { + "algo": 150000000000000, + "onl": 1, + "sel": "SmhBpQdh23++6xC01unged2JU1Wgm2zZ8v5LQiG/VqA=", + "stprf": null, + "vote": "U2lZo9ahjkKBvcS3qSWsmSx+PGI/m6OtnQrQOH1iuII=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "V32YQ6LMMT7X6MML35KOX4MKY7LXWEH4JETZYKAXQ5RX4ZQQ6FAJJ6EGJQ", + "comment": "n5-testnet", + "state": { + "algo": 150000000000000, + "onl": 1, + "sel": "0yRtE7WSj32D5e/ov4o22ZgipQvqJZ6nx9NX1LdxFJI=", + "stprf": null, + "vote": "scoN8x6Eq0bV4tBLT5R59jU+8gmHgh/6FX6mfV2tIKY=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "OEFWPZHFT25CSDHFRFW62JANGQLB5WD25GJBCGYTTPHFUMAYYD7SEAIVDI", + "comment": "n6-testnet", + "state": { + "algo": 150000000000000, + "onl": 1, + "sel": "dWChUcA1ONX3iNEvHu9GST67XRePhAv6jd3XWt5clvI=", + "stprf": null, + "vote": "rTfQ/l3lEfGQtzwjFii5ir2nCLSU+RT+0xI5af/XDEU=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "KCQLDL4GCVDLDYW5PYK7GJTUGHYRJ6CZ4QSRIZTXVRUIUAMDKYDFNUIFHU", + "comment": "n7-testnet", + "state": { + "algo": 150000000000000, + "onl": 1, + "sel": "gNXMo6XiZvuQs2mtomJZtra7XiZHySIOWLuWivu4iso=", + "stprf": null, + "vote": "okgQcI/L7YDAMOyqrLKs6CUB91k+mMFfMTaEb+ixvyY=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "UMMQNIYQXSI4VBGBXJUQ64ABURY6TPR7F4M5CMCOHYMB7GPVIZETZRNRBM", + "comment": "n8-testnet", + "state": { + "algo": 150000000000000, + "onl": 1, + "sel": "ukzMIkE2U33xKq6LGX19NBLirZNANQAf3oiZtlkn5ls=", + "stprf": null, + "vote": "HYHBaeVeN0DXYBNjRBuGtZqrBr3bSBC1YDQrv93dNrc=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "2INEY2MWIWIUNQS24YVXKT4M3RIKMEZGTVAOJG47N7EOJE7MKXOC6GJSMU", + "comment": "n9-testnet", + "state": { + "algo": 150000000000000, + "onl": 1, + "sel": "7aUtPCawOYpPYjVd6oZOnZ+1CZXApr8QR4q1cOkVyWo=", + "stprf": null, + "vote": "kcq1XWHnMrjbv/fvMmzIfGZzDtJtdL7i70lpWZ0kGi0=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "IE4C3BNWT4EYKPUZXGWDOOKBTJFVOYAZKBCWFYRC37U7BJKBIUH6NEB7SQ", + "comment": "pp1-testnet", + "state": { + "algo": 50000000000000, + "onl": 1, + "sel": "C3PdYqoDjrjyaGvZ6M/W0E56Mv5BXdtRwj7+4unpxDM=", + "stprf": null, + "vote": "8fdNikU3nMNyZb3AZlNTnsfsytvrd8bK2b/dYQgJj30=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "7WCI7XPEMWY6XNWHG2VXGYGDLHPTJ333CZ2WBGGUHCSYPTXPBWYCHZYTSE", + "comment": "pp2-testnet", + "state": { + "algo": 25000000000000, + "onl": 1, + "sel": "l3K4aA15T42mTM+QE7GpOzbOcth6hMljBxna7gSR8IA=", + "stprf": null, + "vote": "NsjSVQJj4XxK5Tt0R7pvU6wQB0MRKHDwC9F2bfUX/vM=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "WYX5JGDYM7TBTMBBEE2OI4GC4KVCTLB2P67B3PUQQS4OMUERE7NIIZDWO4", + "comment": "pp3-testnet", + "state": { + "algo": 25000000000000, + "onl": 1, + "sel": "YmLs97jSdlbYU1H0PwZdzo6hlp0eyBwJ+ydM9ggEENI=", + "stprf": null, + "vote": "GeDnbm9KKEu2dZ1FACwI0NsVWgoU0udpZef06IiTdfQ=", + "vote_fst": null, + "vote_kd": 10000, + "vote_lst": 3000000 + } + }, + { + "addr": "2GJF4FEEPNCFKNYSOP6EOQGDQQCGDXPQHWE474DCKP5QO3HFBO73IBLBBY", + "comment": "u1-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "NHZ3VOL34MVWENM72QB6ZBRDMFJTU6R57HAJALSBERH4BNAGR4QDYYBT7A", + "comment": "u10-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "PTLGEQAIGTDWHPKA3IC5BL5UQE52XDZHQH7FUXRV4S6ZBRR5HGZENQ7LTQ", + "comment": "u100-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "3IE2GDYYSI56U53AQ6UUWRGAIGG5D4RHWLMCXJOPWQJA2ABF2X2OLFXGJE", + "comment": "u11-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "IAMUOCM2SEISQZYZZYTLHKSAALDJIXS2IQRU2GPZUOZWB2NLMFZPJSQ7VQ", + "comment": "u12-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "54GKXNGS7HNFHZGO7OIWK3H2KPKZYWSARW7PV4ITVTNCA65K6ESRKI6N3U", + "comment": "u13-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "5ZSFGF66FIJMMRORTYD2PLDAN67FA2J7LF3IYF4ZKD4DJHLEBYJ76DXGVU", + "comment": "u14-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "DY7K3FLRZTW2ZTYVOC4TCGK4JBL7NSJ4GR4BU252QNAVOCVTGEBCPCSJME", + "comment": "u15-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "JG4JQZNYP2524UDVRPPIMSFCIVQPVXLB5AKHM76VXIIRFNMIN3ROIYW65E", + "comment": "u16-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "7J4QX5DVIXSWBC2NJB44LPPUJXOAJQFMBCOS4EDI3XOE5WS76IY7WFTBQI", + "comment": "u17-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "6SA2WG5XM5Q6SSMBRK3TOHY552A75RVANBQQMKTT67PLUN44T3CJZAQOPM", + "comment": "u18-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "64DCC5CMTM4SMMO3QRTY3EDCHS73KDSNNH2XZL262DBK2LR4GJRETWUWIE", + "comment": "u19-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "TQ2B4MTCC6TARNEP4QPPMCKNBBNXKFTQKPVLAFC5XXRR2SWV5DICZELJOY", + "comment": "u2-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "ATNCIRLQLVZ7I4QBGW54DI6CY4AJVBQBPECVNS645RBMYDTK6VV55HXFUU", + "comment": "u20-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "4LP77VEVJ7QNESED4GICPRBZUNP7ZLKKLEVBRDSKX5NZSUFXPSEA575K5E", + "comment": "u21-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "7D34RBEHVI3A7YTQWOUTCSKNQYS5BDBN4E647DOC6WDVOLHPDPSSBY4MWI", + "comment": "u22-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "UMMKTTPNHIURGX24K7UYJ7T3WBB5J7OYBOQJ5WLPRG3BDYWJAEJLVBNHME", + "comment": "u23-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "EOPSQC3QTL7QJ4AQ2J4OJIJMKQLTMIEETJI7OFWYADIMHDWMHQ6MWCTUMQ", + "comment": "u24-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "XT3AVLURALOWTIMGZKB37J2M22NUQCRXTL4DJZHSTPCGLNQKVL7MR3MKFM", + "comment": "u25-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "WS63FDTLLYHC2NS7NXTEO7RPLNMAFM2D2BPJLTMAQJWPR2JCNYTTRMSOAE", + "comment": "u26-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "P5S5GGUHOMVOKWOZPJO74MBYVRXQWDBW6AOTHQZVKJKFGM7VBU6CNR4ATI", + "comment": "u27-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "PXVAI3MUYH4WWJXEQP7XNH3YIMO5ZBAFJWYUL7DOGPAHALE4K6GZBF4THU", + "comment": "u28-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "VGTKWLFANSULZAFDGBONHF55VVKE4V4F63JRDB66XM4K6KCQX6CL22WPRE", + "comment": "u29-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "QB2OTQ6DKUEJFP66A37ASIT4O3UZUOX24DAMWU2D3GCBDIYIXSIDHSXO4E", + "comment": "u3-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "4F6LA64ZLFN33ATWJ74UPAX56OLTXPL74SS5ATXUL7RGX7NKEFKMAWUQYE", + "comment": "u30-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "3JBNL7BZECXKYWZRPWETNL65XEYMAHLC6G3MZN2YMPFL3V7XSDXZEMBHVQ", + "comment": "u31-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "4M2QSKTXKPPZMNUAQ4UDS7ASMQCEUE4WTWGV6AM326425IJ64UNZBCIRGA", + "comment": "u32-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "J37V3LXHPRRKBODXNMNYNUJQIICCFFC4O4XB4YJCPVUAVZNOUG5DWDCEIA", + "comment": "u33-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "I75JBQHNYEYM3J742RBVW4W6RR3YY3BLG2PKO4PXYLVNEX5L646ASDJOOY", + "comment": "u34-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "ZHEIOZ7E2BEBCCKK5QM7DCZAOPTTONMQWHNJ6FOLKBHY466VON6DCZERD4", + "comment": "u35-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "4QMGP4C6OMSCNJI25H7UQGBFHRHL7KXAEQI57JNAXEO2EW3VT6D6LODT5Y", + "comment": "u36-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "KRED3JOLOJE3SLL5NGHAWSUGEMHCYJLD6PX43SIJYN2GC6MS6HPUPPO2LY", + "comment": "u37-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "SVFLDISKS4PDMJKOB6DVVVN6NQ776FHZMGWCOUQVQCH6GXTKCXIHTLYRRQ", + "comment": "u38-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "7IWGAPZ4VWRZLP2IHFSAC3JYOKNAZP6ONBNGGWUWHAUT7F23YFT3XKGNVU", + "comment": "u39-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "O2QVZMKATOIEU2OD4X42MLXAYVRXLRDKJTDXKBFCN3PCKN2Z3PUS5HKIVA", + "comment": "u4-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "H2YN73YPRWKY4GT744RRD65CXSQZO7MK72MV4RDHTIBV6YQUB2G56TVF2Y", + "comment": "u40-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "WGUAFWHRRX7VXPO3XXYCJL5ELO6REUGD57HRMBKTALT2TTXOLSHNOUEQCE", + "comment": "u41-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "RYHCD7GPAEBRV657FJJAG2ZZUDVPR66IU7CA5Y7UDMYSEEIWR4QDNSPLYQ", + "comment": "u42-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "BKTO5TKB4L57YWTZKQBOQ37EWH2HVXGJPXP3L6YSYOAWP3CYYBWLZ2PHTQ", + "comment": "u43-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "FL7LZ57VQQNW5NDJK2IKEAHIXRTB7VFBJEA2MIAEK3QVZPIBGLYW7XSZDY", + "comment": "u44-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "MXXQXZS2TAMIULLXXLX6MM6AHJAOQLHEIB2U3LR4KYKK7ZKRVUSHTU62QA", + "comment": "u45-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "UGOPPKTJQ2KPHU5I56733IMT3B7ECT5O44GW2FYX5SNDVIEDG72Z5GC5IA", + "comment": "u46-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "Y7MGWPRBHQN2PF3I2A3RWCQMVA42VR6FJONJ3W26WGKE4KMCGCVJIDLHEY", + "comment": "u47-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "NNFIWU43AUEZIUIQQECDXM3HRPUEJMPPZLXTM4ZFJKHWSZ2FEGCVMMJUBQ", + "comment": "u48-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "RN3HTSJKSUO6OECM3OPDFQQ2FYZWEY2OWAQGSMQSGY4DI7JJ4HBV2OIJJU", + "comment": "u49-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "OLYQUMZKLYDX2FVHECURBX4SRQSLMIIWN7D7VRJG7B6DS3IU6M5WYVNAAY", + "comment": "u5-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "PIG4P6JA2WDG7HBBR4FFDMVUCUD5Y5CTQ3K3KY34Y4AMT3CWEMVIKQLZZI", + "comment": "u50-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "QIDX47JRS37LRIYVY744SV7KTFGYXY5ABEK2VALNZCMN2H4FBLO7WWKYRM", + "comment": "u51-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "VQZCPUMOYIGCXOK2AK4XYYLWJNRBLS457IL4OSBKGVBHFZ5QPLTCUOTW4A", + "comment": "u52-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "WE2AIYHXI2LHABITCPTZRBTLFT54HPL4MKIR4HTASARNGCCZLXXDE67H3M", + "comment": "u53-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "HAIGM3LXXVKDCGCNQELNOBFZKP6C4A2ZY464F4TB7GWSVDN6I4SI7EOZUE", + "comment": "u54-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "MVZLGPXT6DZQIORE4PIO7NZD7QMJOZZZCOEVPZ3EQX2V4WG3PFU3BXUGDI", + "comment": "u55-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "MB5XJGVVKQU7NSEWWP65QW6H4JVEQYPA5626J4NGQP2E4BUMXRTEGW5X5Y", + "comment": "u56-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "EODZLNWFSRYZKLLF2YAOST2CYQCBRQGXPFQJLDW4CCMYFTYKBSWMF6QUAU", + "comment": "u57-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "LPAMNP7GJC5CNOMWRDII47WWYPF3TOVEIBDSSJA6PKOCPZ5AKRUWMIU2OM", + "comment": "u58-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "THRYS4MAIMEKG7BSAZ4EOKCVUJ7HA6AOCTK2UOKDGZ4TF7Q4BRVTBOUSYU", + "comment": "u59-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "7V7YITMPBTJ3IHHS2D35PVWRZGNFYWWQVRMTI4QP2CBPSKNDRGG66W2HFQ", + "comment": "u6-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "FHA2V46TK5CW66HQPOMLTH5PSKX2JX2IWLWZIYJUZ2RI7SK6HSSBTJBNHM", + "comment": "u60-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "7EJAXCVH7XLWDCWSXID4FNZ6T2SZRA4S7XIZOWA74ITAB272ZF2T5LSWSE", + "comment": "u61-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "K5L3YNZPU6SVNJOWAOKULCWBPIBNMR2VBCASVI4NWDM2APZ6GL36DFDR5Y", + "comment": "u62-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "5BY6RFBNUYHBYH4E4AWVMEOMI7YFKX7X3IPB5GRGAHH4BSXHIL34P3H43A", + "comment": "u63-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "BX2UBG5VCT2ASTGXHVG5NS6VVCYVB6GLKBN4NAAN7ABSTP7BMYCX2T2WEY", + "comment": "u64-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "37JPBYKXMWF6DO3FFWW53LBQCG636MTC7WG6DTRAPDFVXUIATFOMFR5ZLQ", + "comment": "u65-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "ODSPT3NISYMGEE3TJ6U6JCVC44L7DUCPHIV2QMPPRKBWJDALALGVCAPMRE", + "comment": "u66-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "CQA775B5TCU72Y2BNL6VCURBVJE45QV77RXHQ5KYRMMP6NCQ5BR7XJRYRA", + "comment": "u67-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "3Q4SYOBDOAVXUUTKBXEFFSK3BQMUQX5ORZPDA4PHB56KJJONPFFJ7YZ6HU", + "comment": "u68-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "K23ME4QVDHSJWMGUHPGCL2OODAGBHIBW2KGYLLIR3UAEFD5ZW2KFB4WJ34", + "comment": "u69-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "UD2OLL24RFDFMAKK7CCHKFIABPAP7ET4CYQUEYCJVGEIEJUAMDOGJZT26Y", + "comment": "u7-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "KYXWZODLYDHTDMRUBOGOEV42G6H6KJ2JSBFZBP6XNWT42A6QEMEW23JWAM", + "comment": "u70-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "V464X6D3XJVVJ372FFC2NBBDZLBNQA6H55J57WJMMSNOLHOJQ5UF3EUGNY", + "comment": "u71-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "K27ODRPQARZM3236D2XC27QIV27GO2MUR65RGAJKO7UACIFYHG5QKPOCFU", + "comment": "u72-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "FT3JD6TXUZOLOMN4O5CFZYSIHR4T5XJIF2YNV6WGEORNO2X65QW3VUP77I", + "comment": "u73-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "WOTGZ4WOQ4S7YWVAOQ52GGOQPYQI2M7EPZENR27AOZLYFIEJDI3RYFB7OU", + "comment": "u74-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "46MGTGNCTAC62NVNAVXAGP7PUJJIW5GXYYTSUDURCBSRZEDLGME7ICGE4E", + "comment": "u75-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "MBTXWM5M5XQNUEKLBTW7GPU4LFPUETQQPVUBRCOA7FQ47H4J727NFRKKQE", + "comment": "u76-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "4MCTFKPQCY25X6QARHGVD75OYUMQAAU5QLWCE2EM37NWOS7IFJSABMGKBI", + "comment": "u77-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "PY6K3OGCXZVYQYZVA7W3MVZCAU5AFAWQ5J5THILXYIBYCKCGH4ELFU6TNU", + "comment": "u78-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "4ABEMED4I7UYU6CJSLWYQXQHOK2XCQ443BSHR3SL7QJGXNYJ5QCYILSSNU", + "comment": "u79-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "AXBINC5KA3I6IF3JAMKYQU3JLYTA5P2U4PUW3M4L53NEBNCRLHDHHOT2HY", + "comment": "u8-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "5SXA2C6CGZ63OYDY5G4NFLIPJLKCZAMQWLMD2CBNSHUEXVS3ZYHAQCI5TI", + "comment": "u80-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "EVP6MJIZWN6EE64TKEI4ANETP25MHYVXFWESU626TFA5VDVC75KSBGAA54", + "comment": "u81-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "QAUV22GPBAOCO2JGAJF7U474S5SKXVWSZ7KG6P22P4MH3GNBGEJXAVDQLM", + "comment": "u82-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "4FOOFGIWV4H7AXTEJXV2C4ONZ5NXAMUDKJSZDLSKACZ4JA4SWIU6UTLZAU", + "comment": "u83-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "ARUMRBUW3HBQXE4QAL25PPVWAJSKGORTNUIOW3VA5GAMDECOVNYC7GJJS4", + "comment": "u84-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "EJGCYTFUZPJDL2JBZJFQXKZIYJUDB7IBF3E2BH6GXWYWXUHSBCKYFJUKSU", + "comment": "u85-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "FJMEFROCSGQ7C7IXMAPUST37QTQ2Y4A7RMLGK6YTUGHOCLOEL5BDE4AM2M", + "comment": "u86-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "4V635E2WOGIKKWZ6QMYXDWQLYTUKRN7YAYADBQPETS75MKCR66ZC5IEG5M", + "comment": "u87-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "AFJB4HWJLTMMA45VZAJJSUOFF7NROAEEMGT4Z3FQI5APWY472SJ6RNBWU4", + "comment": "u88-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "BYO56YQOSRBUTNPXYO4XDMG7FU7SIP3QGVKAYQIJVJ4UIIMBRG3E4JMVD4", + "comment": "u89-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "FQJO4LDTXEVQ2ZBFYDEAOYPQQZCZTMASMSXJ6V7LBYKOTFSCBUKKIU3DXA", + "comment": "u9-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "WUCEVFNJGUNLMNG2AJMVYJRGQUFXRAFVX2ZRT7AC47WS6IRHPXHSUZ4NUA", + "comment": "u90-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "5J5Q72IHCVAK5NE54ZI2RUZUF3HN2EAQEYQ674H3VX4UUHBMRYAZFRQDIY", + "comment": "u91-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "2LK2SZ3L4PWUXXM4XYFFSCFIV7V5VQJUDFVK7QXK6HJL4OUQKQLWG77EUI", + "comment": "u92-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "QUWHMJLFQAIIG5LV7NK5VNESUUW23RINBSHKKKQDIV4AP56RSTYSNZHDRQ", + "comment": "u93-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "YJEGUEJ2UW2ABLO6XI5QIHQID5ZKUDUDQPHQEN7MH5SS2FLZ573CHRHCZM", + "comment": "u94-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "XOUVBGEZMDVYPES4MGTAEBYU5O6LOCOH27ZJ3ML7ATWEU63N6IWW6F4BLM", + "comment": "u95-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "6CFS2YVK2IMVVFBGGHSPUQBIKMNWRRB44EIUUB4EFXAL7IOJXAHRGXKAGA", + "comment": "u96-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "W5ITKFRKK265A4WKF7IRCZ4MCC7HM3INCJGKPPH3AEKDFYMOJJ4FDLQWYI", + "comment": "u97-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "MBMU3IODI6OFX34MBDMNTD6WSVA6B3XLDVB3IHZJQY3TZUYBPKRNFTUQSM", + "comment": "u98-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + }, + { + "addr": "CKNVTB7DPRZO3MB64RQFPZIHCHCC4GBSTAAJKVQ2SLYNKVYPK4EJFBCQKM", + "comment": "u99-testnet", + "state": { + "algo": 2000000000000, + "onl": 0, + "sel": null, + "stprf": null, + "vote": null, + "vote_fst": null, + "vote_kd": null, + "vote_lst": null + } + } + ], + "comment": null, + "devmode": null, + "fees": "A7NMWS3NT3IUDMLVO26ULGXGIIOUQ3ND2TXSER6EBGRZNOBOUIQXHIBGDE", + "id_": "v1.0", + "network": "testnet", + "proto": "https://github.com/algorand/spec/tree/a26ed78ed8f834e2b9ccb6eb7d3ee9f629a6e622", + "rwd": "7777777777777777777777777777777777777777777777777774MSJUVU", + "timestamp": 1560210455 +} diff --git a/tests/modules/algod_client/__snapshots__/test_get_v2_accounts_address/test_basic_request_and_response_validation.json b/tests/modules/algod_client/__snapshots__/test_get_v2_accounts_address/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..4206225e --- /dev/null +++ b/tests/modules/algod_client/__snapshots__/test_get_v2_accounts_address/test_basic_request_and_response_validation.json @@ -0,0 +1,682 @@ +{ + "address": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "amount": 13852000, + "amount_without_pending_rewards": 13852000, + "apps_local_state": null, + "apps_total_extra_pages": null, + "apps_total_schema": { + "num_byte_slices": 8, + "num_uints": 23 + }, + "assets": [ + { + "amount": 0, + "asset_id": 705457144, + "is_frozen": false + } + ], + "auth_addr": null, + "created_apps": [ + { + "id_": 705408386, + "params": { + "approval_program": "CiADAAEEJgYLYXVjdGlvbl9lbmQMcHJldmlvdXNfYmlkD3ByZXZpb3VzX2JpZGRlcgNhc2EKYXNhX2Ftb3VudAVjbGFpbTEYQAADiAGjMRtBAKaABCgmsgKABPCqcCOABDDG1YqABNt/6EOABOZUYluABB7BK+82GgCOBgABABMAMQA9AFMAXwAxGRREMRhENhoBF8AwiABqI0MxGRREMRhENhoBFzYaAhcxFiMJSTgQJBJEiABwI0MxGRREMRhEiACQI0MxGRREMRhEMRYjCUk4ECMSRIgAfiNDMRkURDEYRIgAoiNDMRkURDEYRDYaARfAMIgAzyNDMRkURDEYFEQjQ4oBADEAMgkSRCIrZUQURCuL/2exMgqL/7IRshQkshAisgGziYoDADEAMgkSRCIoZUQURIv/OBQyChJEi/84EicETGcyB4v+CChMZymL/WeJigAAiYoBADIHIihlRAxEi/84AEkxABJEi/84CCIpZURLAQxEKUsBZypPAmcxACcFTwJmiYoAADEAIicFY0xJTwJEMQAiKmVEEkEACiIpZUSLAEwJjAGxMQCyB4sBSbIII7IQIrIBszEAiwBPAgknBUxmiYoBADIHIihlRA1EsSIqZUQiKmVEIicEZUSyErIUshWL/7IRJLIQIrIBs4mKAAAoImcpImcnBCJnKyJnKjIDZ4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "YXNhX2Ftb3VudA==", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlk", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "YXNh", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlkZGVy", + "value": { + "bytes_": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", + "type_": 1, + "uint": 0 + } + } + ], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 4 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "version": null + } + }, + { + "id_": 705410358, + "params": { + "approval_program": "CCADAAEEJgYLaGlnaGVzdF9iaWQDYXNhDmhpZ2hlc3RfYmlkZGVyC2F1Y3Rpb25fZW5kB2FzYV9hbXQAMRsiEkAA+DYaAIAEKCayAhJAANc2GgCABPCqcCMSQACcNhoAgAQ5BCruEkAAaDYaAIAEtYkGhhJAAEw2GgCABMkBKDESQAAeNhoAgAQkN408EkAAAQAxGYEFEjEYIhMQRIgBmCNDMRkiEjEYIhMQRDYaASJVNQU2GgIiVTUGNAU0BogBWCNDMRkiEjEYIhMQRIgBPiNDMRkiEjEYIhMQRDYaASJVNQQxFiMJNQM0AzgQIxJENAM0BIgA2iNDMRkiEjEYIhMQRDYaARc1ADYaAhc1ATEWIwk1AjQCOBAkEkQ0ADQBNAKIAGcjQzEZIhIxGCITEEQ2GgEiVYgAKSNDMRkiEkAAAQAxGCISRIgAAiNDigAAKSJnJwQiZysiZygiZyonBWeJigEAMQAyCRJEKWQiEkQpi//AMGexJLIQIrIBMgqyFIv/wDCyESKyErOJigMAMQAyCRJEK2QiEkSL/zgUMgoSRIv/OBEpZBJEJwSL/zgSZysyB4v+CGcoi/1niYoCALEjshCL/rIHi/+yCCKyAbOJigIAMgcrZAxEi/44CChkDUSL/jgAMQASRIv+OAcyChJEKmQnBRNBAAcqZChkiP+8KIv+OAhnKov+OABniYoAADIJKGSI/6WJigIAsSSyECKyASlkshEnBGSyEipkshSL/8AcshWziYoAALEjshAisgEyCbIHMgmyCSKyCLOJ", + "clear_state_program": "CIEAQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "aGlnaGVzdF9iaWQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 10000 + } + }, + { + "key": "YXNh", + "value": { + "bytes_": "", + "type_": 2, + "uint": 705457144 + } + }, + { + "key": "aGlnaGVzdF9iaWRkZXI=", + "value": { + "bytes_": "", + "type_": 1, + "uint": 0 + } + }, + { + "key": "YXNhX2FtdA==", + "value": { + "bytes_": "", + "type_": 2, + "uint": 1 + } + }, + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 1721928880 + } + } + ], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 4 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "id_": 708093293, + "params": { + "approval_program": "CiACAQgmAQQVH3x1MRtBAJ6ABP5r32mABHPAS02ABOAER0WABHjNzgWABIMeel82GgCOBQABABcANQBIAF4AMRkURDEYRDYaATYaAogAaihMULAiQzEZFEQxGEQ2GgFXAgCIAGBJFRZXBgJMUChMULAiQzEZFEQxGEQ2GgGIAEsoTFCwIkMxGRREMRhENhoBNhoCiAA7KExQsCJDMRkURDEYRDYaAYgANihMULAiQzEZFEQxGBREIkOKAgGL/heL/xcIFomKAQGL/4mKAQGL/4mKAgGL/xcjC4v+TCNYiYoBAYv/iQ==", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "id_": 709373991, + "params": { + "approval_program": "CiABASYBBBUffHUxG0EAfoAEV3/iSYAEFW7njDYaAI4CAAEAUwAxGRREMRhENhoBNhoCNhoDNhoENhoFNhoGNhoHNhoINhoJNhoKNhoLNhoMNhoNNhoONhoPVwAINhoPVwgINhoPVxAINhoPVxgIiAAmKExQsCJDMRkURDEYRDYaATYaAogATyhMULAiQzEZFEQxGBREIkOKEgGL7ovvUIvwUIvxUIvyUIvzUIv0UIv1UIv2UIv3UIv4UIv5UIv6UIv7UIv8UIv9UIv+UIv/UIACABJMUImKAgGL/ov/UIk=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "id_": 709806536, + "params": { + "approval_program": "CiABATEbQQCKgATAPy4cNhoAjgEAAQAxGRREMRhENhoBNhoCNhoDNhoENhoFNhoGNhoHNhoINhoJNhoKNhoLNhoMNhoNNhoONhoPVwAINhoPVwgINhoPVxAINhoPVxgBF8AwNhoPVxkINhoPVyEBF8AyMRYiCUk4ECISRDYaD1ciARfAHIgAFYAEFR98dUxQsCJDMRkURDEYFEQiQ4oWAYvqi+tQi+xQi+1Qi+5Qi+9Qi/BQi/FQi/JQi/NQi/RQi/VQi/ZQi/dQi/hQi/lQi/pQi/xQsIv7Fov9Fov/cwBEFov+OBdJFRZXBgJMUE8DTwNQTwJQgAIAGlBMUIk=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "id_": 709982020, + "params": { + "approval_program": "CiACAQQmAQIABDEbQQApgASOp1DSNhoAjgEAAQAxGRREMRhENhoBNhoCiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigIBi/+BAFmL/4ECWYv/TwJLAlJMi/8Vi/9OAlJMSRUjCBZXBgIoTFBMUExQi/4VIwgWVwYCKExQi/5QTFCJ", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "id_": 713725461, + "params": { + "approval_program": "CiABASYBBBUffHUxG0EAPIAEryCdjIAEcT1y5DYaAI4CAAEAFAAxGRREMRhENhoBiAAjKExQsCJDMRkURDEYRDYaAYgAFihMULAiQzEZFEQxGBREIkOKAQGL/4mKAQGL/4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "id_": 716754254, + "params": { + "approval_program": "CiACAQQmAQIABDEbQQApgASOp1DSNhoAjgEAAQAxGRREMRhENhoBNhoCiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigIBi/+BAFmL/4ECWYv/TwJLAlJMi/8Vi/9OAlJMSRUjCBZXBgIoTFBMUExQi/4VIwgWVwYCKExQi/5QTFCJ", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "id_": 717891588, + "params": { + "approval_program": "CiADAAEEJgYLYXVjdGlvbl9lbmQMcHJldmlvdXNfYmlkD3ByZXZpb3VzX2JpZGRlcgNhc2EKYXNhX2Ftb3VudAVjbGFpbTEYQAADiAGjMRtBAKaABCgmsgKABPCqcCOABDDG1YqABNt/6EOABOZUYluABB7BK+82GgCOBgABABMAMQA9AFMAXwAxGRREMRhENhoBF8AwiABqI0MxGRREMRhENhoBFzYaAhcxFiMJSTgQJBJEiABwI0MxGRREMRhEiACQI0MxGRREMRhEMRYjCUk4ECMSRIgAfiNDMRkURDEYRIgAoiNDMRkURDEYRDYaARfAMIgAzyNDMRkURDEYFEQjQ4oBADEAMgkSRCIrZUQURCuL/2exMgqL/7IRshQkshAisgGziYoDADEAMgkSRCIoZUQURIv/OBQyChJEi/84EicETGcyB4v+CChMZymL/WeJigAAiYoBADIHIihlRAxEi/84AEkxABJEi/84CCIpZURLAQxEKUsBZypPAmcxACcFTwJmiYoAADEAIicFY0xJTwJEMQAiKmVEEkEACiIpZUSLAEwJjAGxMQCyB4sBSbIII7IQIrIBszEAiwBPAgknBUxmiYoBADIHIihlRA1EsSIqZUQiKmVEIicEZUSyErIUshWL/7IRJLIQIrIBs4mKAAAoImcpImcnBCJnKyJnKjIDZ4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlk", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "YXNh", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlkZGVy", + "value": { + "bytes_": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", + "type_": 1, + "uint": 0 + } + }, + { + "key": "YXNhX2Ftb3VudA==", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + } + ], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 4 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "version": null + } + }, + { + "id_": 717893078, + "params": { + "approval_program": "CiADAAEEJgYLYXVjdGlvbl9lbmQMcHJldmlvdXNfYmlkD3ByZXZpb3VzX2JpZGRlcgNhc2EKYXNhX2Ftb3VudAVjbGFpbTEYQAADiAGjMRtBAKaABCgmsgKABPCqcCOABDDG1YqABNt/6EOABOZUYluABB7BK+82GgCOBgABABMAMQA9AFMAXwAxGRREMRhENhoBF8AwiABqI0MxGRREMRhENhoBFzYaAhcxFiMJSTgQJBJEiABwI0MxGRREMRhEiACQI0MxGRREMRhEMRYjCUk4ECMSRIgAfiNDMRkURDEYRIgAoiNDMRkURDEYRDYaARfAMIgAzyNDMRkURDEYFEQjQ4oBADEAMgkSRCIrZUQURCuL/2exMgqL/7IRshQkshAisgGziYoDADEAMgkSRCIoZUQURIv/OBQyChJEi/84EicETGcyB4v+CChMZymL/WeJigAAiYoBADIHIihlRAxEi/84AEkxABJEi/84CCIpZURLAQxEKUsBZypPAmcxACcFTwJmiYoAADEAIicFY0xJTwJEMQAiKmVEEkEACiIpZUSLAEwJjAGxMQCyB4sBSbIII7IQIrIBszEAiwBPAgknBUxmiYoBADIHIihlRA1EsSIqZUQiKmVEIicEZUSyErIUshWL/7IRJLIQIrIBs4mKAAAoImcpImcnBCJnKyJnKjIDZ4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "YXNh", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "YXNhX2Ftb3VudA==", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlk", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlkZGVy", + "value": { + "bytes_": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", + "type_": 1, + "uint": 0 + } + } + ], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 4 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "version": null + } + }, + { + "id_": 718129252, + "params": { + "approval_program": "CiADAAEEJgYLYXVjdGlvbl9lbmQMcHJldmlvdXNfYmlkD3ByZXZpb3VzX2JpZGRlcgNhc2EKYXNhX2Ftb3VudAVjbGFpbTEYQAADiAGjMRtBAKaABCgmsgKABPCqcCOABDDG1YqABNt/6EOABOZUYluABB7BK+82GgCOBgABABMAMQA9AFMAXwAxGRREMRhENhoBF8AwiABqI0MxGRREMRhENhoBFzYaAhcxFiMJSTgQJBJEiABwI0MxGRREMRhEiACQI0MxGRREMRhEMRYjCUk4ECMSRIgAfiNDMRkURDEYRIgAoiNDMRkURDEYRDYaARfAMIgAzyNDMRkURDEYFEQjQ4oBADEAMgkSRCIrZUQURCuL/2exMgqL/7IRshQkshAisgGziYoDADEAMgkSRCIoZUQURIv/OBQyChJEi/84EicETGcyB4v+CChMZymL/WeJigAAiYoBADIHIihlRAxEi/84AEkxABJEi/84CCIpZURLAQxEKUsBZypPAmcxACcFTwJmiYoAADEAIicFY0xJTwJEMQAiKmVEEkEACiIpZUSLAEwJjAGxMQCyB4sBSbIII7IQIrIBszEAiwBPAgknBUxmiYoBADIHIihlRA1EsSIqZUQiKmVEIicEZUSyErIUshWL/7IRJLIQIrIBs4mKAAAoImcpImcnBCJnKyJnKjIDZ4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "YXNh", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "YXNhX2Ftb3VudA==", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlk", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlkZGVy", + "value": { + "bytes_": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", + "type_": 1, + "uint": 0 + } + } + ], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 4 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "version": null + } + }, + { + "id_": 718348254, + "params": { + "approval_program": "CiABATEbQQAmgASlPlpBNhoAjgEAAQAxGRREMRhENhoBiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigEBi/+J", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "id_": 719046155, + "params": { + "approval_program": "CiABASYBBBUffHUxGEAAA4gA0jEbQQCMgAQx4uVggASPjC9xgATfX6OPgATxp30WgASsnZwXNhoAjgUAAQARACQANwBMADEZFEQxGESIAF4oTFCwIkMxGRREMRhENhoBiABZKExQsCJDMRkURDEYRDYaAYgATChMULAiQzEZFEQxGEQ2GgEXwBw2GgKIADkiQzEZFEQxGEQ2GgGIAEEoTFCwIkMxGRREMRgURCJDigABgAgAAAAAAAAAA4mKAQGL/4mKAQGL/4mKAgCL/xeL/oAJbG9jYWxfaW50TwJmiYoBAYv/iYoAAIAKZ2xvYmFsX2ludIEqZ4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "Z2xvYmFsX2ludA==", + "value": { + "bytes_": "", + "type_": 2, + "uint": 42 + } + } + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "version": null + } + }, + { + "id_": 719241638, + "params": { + "approval_program": "CiABATEbQQAjgARv4y6HNhoAjgEAAQAxGRREMRhEiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigABgAMxMjNJFRZXBgJMUIk=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "id_": 719253364, + "params": { + "approval_program": "CiABASYBBBUffHUxG0EAX4AEQdnf4YAEL8rd9oAEnL09PTYaAI4DAAEAGQAxADEZFEQxGESIAEFJFRZXBgJMUChMULAiQzEZFEQxGESIADJJFRZXBgJMUChMULAiQzEZFEQxGESIACQWKExQsCJDMRkURDEYFEQiQ4oAAYADYXNkiYoAAYAEQUJDRImKAAEiiQ==", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "id_": 719254146, + "params": { + "approval_program": "CiABASYBBBUffHUxG0EAX4AEQdnf4YAEL8rd9oAEnL09PTYaAI4DAAEAGQAxADEZFEQxGESIAEFJFRZXBgJMUChMULAiQzEZFEQxGESIADNJFRZXBgJMUChMULAiQzEZFEQxGESIACkWKExQsCJDMRkURDEYFEQiQ4oAAYAEdGVzdImKAAGACEFRSURCQT09iYoAAYEziQ==", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "id_": 720689424, + "params": { + "approval_program": "CiABATEbQQAmgARBbn/KNhoAjgEAAQAxGRREMRhENhoBiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigEBi/+BAFmL/4EKWYv/TgJSiQ==", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "id_": 721104877, + "params": { + "approval_program": "CiABATEbQQA1gAQjqAI8NhoAjgEAAQAxGRREMRhENhoBF8AwNhoCF8AyNhoDF8AciAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigMBi/0Wi/4WUIk=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "id_": 729762198, + "params": { + "approval_program": "CiAEAQAKeyYEBBUffHUHAAP/AAJIaQVIZWxsbwH/iAABQ4oAATEbQQDSggcETFxhugSX6OSnBHbE3hEEwcp3CQRt52LCBFn8UoIEnZ7ssDYaAI4HAAIADAAjADYARQBRAGIjiSIxGZCBAxpEIokxGRREMRhENhoBNhoCiACaFihMULAiiTEZFEQxGEQ2GgGIAJwoTFCwIokxGRREMRhENhoBiACpIokxGRREMRhEiACrIokxGRREMRhENhoBI1OIANMiiTEZFEQxGESIAPdPAhZLAhUWVwYCTwNQSwMVgQ0IgAIADU8DUEwWVwYCUE8CUE8CUExQKExQsCKJMRmNBgACAAIACgAKAAoABCOJIokxGBREIokjiYoCAYv+JFmL/hWL/k4CUov/EkSBKomKAQGL/yRZi/8Vi/9OAlJJiAAGSEsBEkSJigECi/9JiYoBAIv/VwAIgAEAEkSJigAAggIE2T83TgsAAyoABmhlbGxvMVCwggIEHnKvThYABAALAAVoZWxsbwADKgAGaGVsbG8yULCJigEAi/9BACeCAgQRxUe6HQAAAAAAAAAqAAAAAAAAACsAEgADKgAGaGVsbG8zULCJigAEKSUqK4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 2, + "num_uints": 1 + }, + "local_state_schema": { + "num_byte_slices": 2, + "num_uints": 1 + }, + "version": null + } + }, + { + "id_": 732773208, + "params": { + "approval_program": "CiADAQIEJgIEFR98dQIABDEbQQFVgAT+a99pgASf2DX4gATqRRPTgATvNGO8gAQWiv26gASOp1DSgARxPXLkgAQOGJh9gAT6J+dBgAT+85NWgARfH5cTNhoAjgsAAQAXADEATwBiAHUAiwCeAK0A0gDlADEZFEQxGEQ2GgE2GgKIAPEoTFCwIkMxGRREMRhEMRYiCUk4ECISRIgA4yhMULAiQzEZFEQxGEQ2GgFXAgCIANZJFRZXBgJMUChMULAiQzEZFEQxGEQ2GgGIAMEoTFCwIkMxGRREMRhENhoBiAC0KExQsCJDMRkURDEYRDYaATYaAogApChMULAiQzEZFEQxGEQ2GgGIAM8oTFCwIkMxGRREMRhENhoBiADCIkMxGRREMRhEMRYjCUk4ECISRDEWIglJOBCBBhJEiAC8KExQsCJDMRkURDEYRDYaAYgAuShMULAiQzEZFEQxGEQ2GgGIAKwoTFCwIkMxGRREMRgURCJDigIBi/4Xi/8XCBaJigEBi/84CBaJigEBi/+JigEBi/+JigEBi/+JigIBi/+BAFmL/yNZi/9PAksCUkyL/xWL/04CUkxJFSQIFlcGAilMUExQTFCL/hUkCBZXBgIpTFCL/lBMUImKAQGL/4mKAQCAEmdsb2JhbF9zdGF0aWNfaW50c4v/Z4mKAgGL/zgXSRUWVwYCTFCJigEBi/+JigEBi/9XABBJVwAIF0xXCAgXCBaL/1cQEElXAAgXTFcICBcJFlCJ", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "id_": 733078310, + "params": { + "approval_program": "CiADAQAEJgMEFR98dQSf2DX4AgAEMRhAACCAFGdsb2JhbF9zdGF0ZV9iaWdfaW50gc2YoKfWoao7ZzEbQQDfgAT+a99pKYIGBOpFE9ME7zRjvAQWiv26BI6nUNIEcT1y5AQLkZhONhoAjggAjQBzAFgASQA6ACQAFQACI0MxGRREMRhENhoBiAD0KExQsCJDMRkURDEYRCg2GgFQsCJDMRkURDEYRDYaATYaAogAjyhMULAiQzEZFEQxGEQoNhoBULAiQzEZFEQxGEQoNhoBULAiQzEZFEQxGEQ2GgFXAgBJFRZXBgJMUChMULAiQzEZFEQxGEQxFiIJSTgQIhJEiAAzKExQsCJDMRkURDEYRDYaATYaAogAEShMULAiQzEZQP9YMRgURCJDigIBi/4Xi/8XCBaJigEBi/84CBaJigIBi/8jWYv/gQJZi/9PAksCUov/FYv/TwNPAlJLARUkCBZXBgIqTFBPAlBMUIv+FSQIFlcGAipMUIv+UExQiYoBATEAsYGgjQayCLIHIrIQI7IBtov/F7IYKbIagQayECOyAbO3AT5JVwQATFcABCgSRIk=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "Z2xvYmFsX3N0YXRlX2JpZ19pbnQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 33399922244455501 + } + } + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + } + ], + "created_assets": [ + { + "id_": 705457144, + "params": { + "clawback": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "decimals": 0, + "default_frozen": false, + "freeze": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "manager": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "metadata_hash": null, + "name": "gold nugget", + "name_b64": "Z29sZCBudWdnZXQ=", + "reserve": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "total": 1, + "unit_name": "piece", + "unit_name_b64": "cGllY2U=", + "url": "https://path/to/my/asset/details", + "url_b64": "aHR0cHM6Ly9wYXRoL3RvL215L2Fzc2V0L2RldGFpbHM=" + } + } + ], + "incentive_eligible": null, + "last_heartbeat": null, + "last_proposed": null, + "min_balance": 3355500, + "participation": null, + "pending_rewards": 0, + "reward_base": 27521, + "rewards": 0, + "round_": 58979813, + "sig_type": null, + "status": "Offline", + "total_apps_opted_in": 0, + "total_assets_opted_in": 1, + "total_box_bytes": null, + "total_boxes": null, + "total_created_apps": 21, + "total_created_assets": 1 +} diff --git a/tests/modules/algod_client/__snapshots__/test_get_v2_accounts_address_applications_application_id/test_basic_request_and_response_validation.json b/tests/modules/algod_client/__snapshots__/test_get_v2_accounts_address_applications_application_id/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..9d0d0abd --- /dev/null +++ b/tests/modules/algod_client/__snapshots__/test_get_v2_accounts_address_applications_application_id/test_basic_request_and_response_validation.json @@ -0,0 +1,20 @@ +{ + "app_local_state": null, + "created_app": { + "approval_program": "CiABATEbQQAmgASlPlpBNhoAjgEAAQAxGRREMRhENhoBiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigEBi/+J", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + }, + "round_": 58979813 +} diff --git a/tests/modules/algod_client/__snapshots__/test_get_v2_accounts_address_assets_asset_id/test_basic_request_and_response_validation.json b/tests/modules/algod_client/__snapshots__/test_get_v2_accounts_address_assets_asset_id/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..7983db7f --- /dev/null +++ b/tests/modules/algod_client/__snapshots__/test_get_v2_accounts_address_assets_asset_id/test_basic_request_and_response_validation.json @@ -0,0 +1,25 @@ +{ + "asset_holding": { + "amount": 0, + "asset_id": 705457144, + "is_frozen": false + }, + "created_asset": { + "clawback": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "decimals": 0, + "default_frozen": false, + "freeze": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "manager": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "metadata_hash": null, + "name": "gold nugget", + "name_b64": "Z29sZCBudWdnZXQ=", + "reserve": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "total": 1, + "unit_name": "piece", + "unit_name_b64": "cGllY2U=", + "url": "https://path/to/my/asset/details", + "url_b64": "aHR0cHM6Ly9wYXRoL3RvL215L2Fzc2V0L2RldGFpbHM=" + }, + "round_": 58979813 +} diff --git a/tests/modules/algod_client/__snapshots__/test_get_v2_applications_application_id/test_basic_request_and_response_validation.json b/tests/modules/algod_client/__snapshots__/test_get_v2_applications_application_id/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..d8218500 --- /dev/null +++ b/tests/modules/algod_client/__snapshots__/test_get_v2_applications_application_id/test_basic_request_and_response_validation.json @@ -0,0 +1,19 @@ +{ + "id_": 718348254, + "params": { + "approval_program": "CiABATEbQQAmgASlPlpBNhoAjgEAAQAxGRREMRhENhoBiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigEBi/+J", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } +} diff --git a/tests/modules/algod_client/__snapshots__/test_get_v2_assets_asset_id/test_basic_request_and_response_validation.json b/tests/modules/algod_client/__snapshots__/test_get_v2_assets_asset_id/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..2c28caaf --- /dev/null +++ b/tests/modules/algod_client/__snapshots__/test_get_v2_assets_asset_id/test_basic_request_and_response_validation.json @@ -0,0 +1,20 @@ +{ + "id_": 705457144, + "params": { + "clawback": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "decimals": 0, + "default_frozen": false, + "freeze": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "manager": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "metadata_hash": null, + "name": "gold nugget", + "name_b64": "Z29sZCBudWdnZXQ=", + "reserve": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "total": 1, + "unit_name": "piece", + "unit_name_b64": "cGllY2U=", + "url": "https://path/to/my/asset/details", + "url_b64": "aHR0cHM6Ly9wYXRoL3RvL215L2Fzc2V0L2RldGFpbHM=" + } +} diff --git a/tests/modules/algod_client/__snapshots__/test_get_v2_blocks_round_hash/test_basic_request_and_response_validation.json b/tests/modules/algod_client/__snapshots__/test_get_v2_blocks_round_hash/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..f8e00379 --- /dev/null +++ b/tests/modules/algod_client/__snapshots__/test_get_v2_blocks_round_hash/test_basic_request_and_response_validation.json @@ -0,0 +1,3 @@ +{ + "block_hash": "PKZ7LQO6KNISFUVXN3HFZQKF4GJV7XKFHFZNNKC6DAHUEZZM3IQQ" +} diff --git a/tests/modules/algod_client/__snapshots__/test_get_v2_blocks_round_lightheader_proof/test_basic_request_and_response_validation.json b/tests/modules/algod_client/__snapshots__/test_get_v2_blocks_round_lightheader_proof/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..b46c8051 --- /dev/null +++ b/tests/modules/algod_client/__snapshots__/test_get_v2_blocks_round_lightheader_proof/test_basic_request_and_response_validation.json @@ -0,0 +1,5 @@ +{ + "index": 118, + "proof": "u/kX3uH7n/GJCIYmDje+voS1GglFZb3GIy1ysRxesJNKe5k9dkSKt2rlGYPdCpv1gl2ANcw9CQi8plGAFYYy6js/c+n1R/8bQ8atQdJCNmwXzp9kfKJsrJweMw3gNlLQDxsLnZ3V0Dpbzve0FFKkRo6wfLY+s55iVnoLS/e8EyzJ7zmQZzLVFp81MniFJrOcmkjmME39l5J39IlHDR5ZnRqQG/RnKdq6GFJOs6GfsZ9P0kFzZWwvsiVSBq7GpP11qHbU5l+YUxaZ+qH2/Wi4GW6KxslhSgMGSUfqoaEQ2KoUKolnmEi/+qymfwE5d0CtVlEEfNfjq8Y5ZcCXX306jg==", + "treedepth": 8 +} diff --git a/tests/modules/algod_client/__snapshots__/test_get_v2_blocks_round_txids/test_basic_request_and_response_validation.json b/tests/modules/algod_client/__snapshots__/test_get_v2_blocks_round_txids/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..d6dbc129 --- /dev/null +++ b/tests/modules/algod_client/__snapshots__/test_get_v2_blocks_round_txids/test_basic_request_and_response_validation.json @@ -0,0 +1,9 @@ +{ + "block_tx_ids": [ + "W6SAFSKT3V4SMLQXG3YDLI4TOBEGPPVQ5PQNJ7BCQ6K7WEDVDFEQ", + "Q5T6IHV62WN5YRGGBZ5PTTOGD4UEEJ2IJVWVVQPDSRZ5JYLNY2LQ", + "GX4OEJETJKWAFK4RK26SYSLBIAUHP7KQVK6N7CONESCS5UZOZSXQ", + "5UJZEZJDYQZZC5DTUYYGMW2W65KFMETQLYC34JPFSMBCQXLX6T4Q", + "ONXCSR5POM7B53L56LOVJUD5VUNQFPDXOSODIH6LOXMBTQALWB5A" + ] +} diff --git a/tests/modules/algod_client/__snapshots__/test_get_v2_ledger_supply/test_basic_request_and_response_validation.json b/tests/modules/algod_client/__snapshots__/test_get_v2_ledger_supply/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..410bcfc5 --- /dev/null +++ b/tests/modules/algod_client/__snapshots__/test_get_v2_ledger_supply/test_basic_request_and_response_validation.json @@ -0,0 +1,5 @@ +{ + "current_round": 58979813, + "online_money": 4932435556983377, + "total_money": 10123916871417672 +} diff --git a/tests/modules/algod_client/__snapshots__/test_get_v2_ledger_sync/test_basic_request_and_response_validation.json b/tests/modules/algod_client/__snapshots__/test_get_v2_ledger_sync/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..8a579704 --- /dev/null +++ b/tests/modules/algod_client/__snapshots__/test_get_v2_ledger_sync/test_basic_request_and_response_validation.json @@ -0,0 +1,3 @@ +{ + "round_": 0 +} diff --git a/tests/modules/algod_client/__snapshots__/test_get_v2_status/test_basic_request_and_response_validation.json b/tests/modules/algod_client/__snapshots__/test_get_v2_status/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..0d2ca9f7 --- /dev/null +++ b/tests/modules/algod_client/__snapshots__/test_get_v2_status/test_basic_request_and_response_validation.json @@ -0,0 +1,28 @@ +{ + "catchpoint": "", + "catchpoint_acquired_blocks": 0, + "catchpoint_processed_accounts": 0, + "catchpoint_processed_kvs": 0, + "catchpoint_total_accounts": 0, + "catchpoint_total_blocks": 0, + "catchpoint_total_kvs": 0, + "catchpoint_verified_accounts": 0, + "catchpoint_verified_kvs": 0, + "catchup_time": 0, + "last_catchpoint": "", + "last_round": 58979812, + "last_version": "https://github.com/algorandfoundation/specs/tree/953304de35264fc3ef91bcd05c123242015eeaed", + "next_version": "https://github.com/algorandfoundation/specs/tree/953304de35264fc3ef91bcd05c123242015eeaed", + "next_version_round": 58979813, + "next_version_supported": true, + "stopped_at_unsupported_round": false, + "time_since_last_round": 2415605010, + "upgrade_delay": null, + "upgrade_next_protocol_vote_before": null, + "upgrade_no_votes": null, + "upgrade_node_vote": null, + "upgrade_vote_rounds": null, + "upgrade_votes": null, + "upgrade_votes_required": null, + "upgrade_yes_votes": null +} diff --git a/tests/modules/algod_client/__snapshots__/test_get_v2_status_wait_for_block_after_round/test_basic_request_and_response_validation.json b/tests/modules/algod_client/__snapshots__/test_get_v2_status_wait_for_block_after_round/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..a3b06269 --- /dev/null +++ b/tests/modules/algod_client/__snapshots__/test_get_v2_status_wait_for_block_after_round/test_basic_request_and_response_validation.json @@ -0,0 +1,28 @@ +{ + "catchpoint": "", + "catchpoint_acquired_blocks": 0, + "catchpoint_processed_accounts": 0, + "catchpoint_processed_kvs": 0, + "catchpoint_total_accounts": 0, + "catchpoint_total_blocks": 0, + "catchpoint_total_kvs": 0, + "catchpoint_verified_accounts": 0, + "catchpoint_verified_kvs": 0, + "catchup_time": 0, + "last_catchpoint": "", + "last_round": 58979813, + "last_version": "https://github.com/algorandfoundation/specs/tree/953304de35264fc3ef91bcd05c123242015eeaed", + "next_version": "https://github.com/algorandfoundation/specs/tree/953304de35264fc3ef91bcd05c123242015eeaed", + "next_version_round": 58979814, + "next_version_supported": true, + "stopped_at_unsupported_round": false, + "time_since_last_round": 150888008, + "upgrade_delay": null, + "upgrade_next_protocol_vote_before": null, + "upgrade_no_votes": null, + "upgrade_node_vote": null, + "upgrade_vote_rounds": null, + "upgrade_votes": null, + "upgrade_votes_required": null, + "upgrade_yes_votes": null +} diff --git a/tests/modules/algod_client/__snapshots__/test_get_v2_transactions_params/test_basic_request_and_response_validation.json b/tests/modules/algod_client/__snapshots__/test_get_v2_transactions_params/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..b91dc143 --- /dev/null +++ b/tests/modules/algod_client/__snapshots__/test_get_v2_transactions_params/test_basic_request_and_response_validation.json @@ -0,0 +1,10 @@ +{ + "consensus_version": "https://github.com/algorandfoundation/specs/tree/953304de35264fc3ef91bcd05c123242015eeaed", + "fee": 0, + "first_valid": 58979813, + "flat_fee": false, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "last_valid": 58980813, + "min_fee": 1000 +} diff --git a/tests/modules/algod_client/__snapshots__/test_get_versions/test_basic_request_and_response_validation.json b/tests/modules/algod_client/__snapshots__/test_get_versions/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..2d7757ec --- /dev/null +++ b/tests/modules/algod_client/__snapshots__/test_get_versions/test_basic_request_and_response_validation.json @@ -0,0 +1,15 @@ +{ + "build": { + "branch": "AVAIL", + "build_number": 1, + "channel": "AVAIL", + "commit_hash": "7b607ce4+", + "major": 4, + "minor": 4 + }, + "genesis_hash_b64": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "versions": [ + "v2" + ] +} diff --git a/tests/modules/algod_client/conftest.py b/tests/modules/algod_client/conftest.py new file mode 100644 index 00000000..dd0b3320 --- /dev/null +++ b/tests/modules/algod_client/conftest.py @@ -0,0 +1,19 @@ +"""Fixtures for algod client tests using mock server.""" + +import pytest + +from algokit_algod_client import AlgodClient, ClientConfig + +from tests.modules._mock_server import DEFAULT_TOKEN, MockServer, get_mock_server + + +@pytest.fixture(scope="session") +def mock_algod_server() -> MockServer: + """Session-scoped mock algod server for deterministic testing.""" + return get_mock_server("algod") + + +@pytest.fixture +def algod_client(mock_algod_server: MockServer) -> AlgodClient: + """Algod client connected to the mock server.""" + return AlgodClient(ClientConfig(base_url=mock_algod_server.base_url, token=DEFAULT_TOKEN)) diff --git a/tests/modules/algod_client/manual/__init__.py b/tests/modules/algod_client/manual/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/modules/algod_client/manual/test_block.py b/tests/modules/algod_client/manual/test_block.py new file mode 100644 index 00000000..df8aa1aa --- /dev/null +++ b/tests/modules/algod_client/manual/test_block.py @@ -0,0 +1,72 @@ +import pytest + +from algokit_algod_client import AlgodClient, ClientConfig +from algokit_algod_client.models import ParticipationUpdates + + +@pytest.mark.parametrize( + ("base_url", "block_rounds"), + [ + ("https://mainnet-api.4160.nodely.dev", [24098947, 55240407]), + ("https://testnet-api.4160.nodely.dev", [24099447, 24099347]), + ], +) +def test_block_endpoint(base_url: str, block_rounds: list[int]) -> None: + config = ClientConfig( + base_url=base_url, + token=None, + ) + algod_client = AlgodClient(config) + + for block_round in block_rounds: + resp = algod_client.block(round_=block_round, header_only=False) + + assert resp.block.header.state_proof_tracking is not None + assert resp.block.payset is not None + assert len(resp.block.payset) > 0 + + participation_updates = resp.block.header.participation_updates + if participation_updates is not None: + assert isinstance(participation_updates, ParticipationUpdates) + if participation_updates.expired_participation_accounts is not None: + assert isinstance(participation_updates.expired_participation_accounts, tuple) + if participation_updates.absent_participation_accounts is not None: + assert isinstance(participation_updates.absent_participation_accounts, tuple) + + +@pytest.mark.parametrize( + ("base_url", "block_round"), + [ + # Block 56492866 is an empty block (no transactions) with new protocol format + # (uses txn256/txn512 instead of txn) + ("https://mainnet-api.4160.nodely.dev", 56492866), + ], +) +def test_block_endpoint_empty_block(base_url: str, block_round: int) -> None: + """Test parsing of empty blocks (no transactions) with newer protocol format.""" + config = ClientConfig( + base_url=base_url, + token=None, + ) + algod_client = AlgodClient(config) + + resp = algod_client.block(round_=block_round, header_only=False) + + # Verify block header is parsed correctly + assert resp.block.header.round == block_round + assert resp.block.header.state_proof_tracking is not None + + # This block uses newer protocol format with txn256/txn512 instead of txn + # txn is missing from wire, defaults to 32 zero bytes + assert resp.block.header.txn_commitments.native_sha512_256_commitment == bytes(32) + # txn256 has actual value (not zeros) + assert resp.block.header.txn_commitments.sha256_commitment is not None + assert resp.block.header.txn_commitments.sha256_commitment != bytes(32) + assert len(resp.block.header.txn_commitments.sha256_commitment) == 32 + # txn512 has actual value (64 bytes) + assert resp.block.header.txn_commitments.sha512_commitment is not None + assert resp.block.header.txn_commitments.sha512_commitment != bytes(64) + assert len(resp.block.header.txn_commitments.sha512_commitment) == 64 + + # Empty block has no transactions + assert resp.block.payset is None diff --git a/tests/modules/algod_client/manual/test_ledger_state_delta.py b/tests/modules/algod_client/manual/test_ledger_state_delta.py new file mode 100644 index 00000000..97a7bc64 --- /dev/null +++ b/tests/modules/algod_client/manual/test_ledger_state_delta.py @@ -0,0 +1,26 @@ +import pytest + +from algokit_algod_client import AlgodClient, ClientConfig +from algokit_algod_client.models import LedgerStateDelta + + +@pytest.mark.parametrize( + ("base_url", "block_rounds"), + [ + ("https://mainnet-api.4160.nodely.dev", [24098947, 55240407]), + ("https://testnet-api.4160.nodely.dev", [24099447, 24099347]), + ], +) +def test_ledger_state_delta_endpoint(base_url: str, block_rounds: list[int]) -> None: + config = ClientConfig( + base_url=base_url, + token=None, + ) + algod_client = AlgodClient(config) + + for block_round in block_rounds: + raw_delta = algod_client.ledger_state_delta(round_=block_round) + + assert isinstance(raw_delta, LedgerStateDelta) + assert raw_delta.accounts is not None + assert raw_delta.block.header.txn_commitments.sha256_commitment is not None diff --git a/tests/modules/algod_client/manual/test_pending_transaction_information.py b/tests/modules/algod_client/manual/test_pending_transaction_information.py new file mode 100644 index 00000000..c70832b0 --- /dev/null +++ b/tests/modules/algod_client/manual/test_pending_transaction_information.py @@ -0,0 +1,63 @@ +import pytest + +from algokit_transact.signer import AddressWithSigners +from algokit_utils.algorand import AlgorandClient +from algokit_utils.models.amount import AlgoAmount +from algokit_utils.transactions.transaction_composer import PaymentParams + + +@pytest.fixture +def algorand() -> AlgorandClient: + return AlgorandClient.default_localnet() + + +@pytest.fixture +def sender(algorand: AlgorandClient) -> AddressWithSigners: + account = algorand.account.random() + dispenser = algorand.account.localnet_dispenser() + algorand.account.ensure_funded( + account, dispenser, AlgoAmount.from_algo(10), min_funding_increment=AlgoAmount.from_algo(1) + ) + return account + + +@pytest.fixture +def receiver(algorand: AlgorandClient) -> AddressWithSigners: + account = algorand.account.random() + dispenser = algorand.account.localnet_dispenser() + algorand.account.ensure_funded( + account, dispenser, AlgoAmount.from_algo(1), min_funding_increment=AlgoAmount.from_algo(1) + ) + return account + + +@pytest.mark.localnet +def test_pending_transaction_broadcast( + algorand: AlgorandClient, sender: AddressWithSigners, receiver: AddressWithSigners +) -> None: + """Test broadcasting a transaction and retrieving pending transaction information.""" + # Get the algod_client from the AlgorandClient so we use the same client consistently + algod_client = algorand.client.algod + + # Build payment transaction using Algokit + txn = algorand.create_transaction.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_micro_algo(500_000), + note=b"Test payment transaction", + ) + ) + + # Sign the transaction + signed_blob = sender.signer([txn], [0])[0] + + # Send the signed transaction using the raw algod_client + response = algod_client.send_raw_transaction(signed_blob) + # Get pending transaction information + pending_txn = algod_client.pending_transaction_information(txid=response.tx_id) + + # Verify pending transaction response (typed model) + assert pending_txn.pool_error == "" + assert pending_txn.confirmed_round is not None + assert pending_txn.confirmed_round > 0 diff --git a/tests/modules/algod_client/manual/test_raw_transaction.py b/tests/modules/algod_client/manual/test_raw_transaction.py new file mode 100644 index 00000000..db601562 --- /dev/null +++ b/tests/modules/algod_client/manual/test_raw_transaction.py @@ -0,0 +1,39 @@ +import pytest + +from algokit_transact.signer import AddressWithSigners +from algokit_utils.algorand import AlgorandClient +from algokit_utils.models.amount import AlgoAmount +from algokit_utils.transactions.transaction_composer import PaymentParams + + +@pytest.mark.localnet +def test_raw_transaction_broadcast() -> None: + """Test broadcasting a raw transaction using the localnet algod client directly.""" + algorand = AlgorandClient.default_localnet() + # Get the algod_client from the AlgorandClient so we use the same client consistently + algod_client = algorand.client.algod + + sender: AddressWithSigners = algorand.account.random() + receiver: AddressWithSigners = algorand.account.random() + dispenser = algorand.account.localnet_dispenser() + algorand.account.ensure_funded( + sender, dispenser, AlgoAmount.from_algo(10), min_funding_increment=AlgoAmount.from_algo(1) + ) + algorand.account.ensure_funded( + receiver, dispenser, AlgoAmount.from_algo(1), min_funding_increment=AlgoAmount.from_algo(1) + ) + + txn = algorand.create_transaction.payment( + PaymentParams( + sender=sender.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_micro_algo(500_000), + note=b"Test payment transaction", + ) + ) + + signed_blob = sender.signer([txn], [0])[0] + + res = algod_client.send_raw_transaction(signed_blob) + assert isinstance(res.tx_id, str) + assert res.tx_id diff --git a/tests/modules/algod_client/manual/test_simulate_transactions.py b/tests/modules/algod_client/manual/test_simulate_transactions.py new file mode 100644 index 00000000..96173917 --- /dev/null +++ b/tests/modules/algod_client/manual/test_simulate_transactions.py @@ -0,0 +1,52 @@ +import pytest + +from algokit_algod_client.models import ( + SimulateRequest, + SimulateRequestTransactionGroup, + SimulateTraceConfig, +) +from algokit_transact import PaymentTransactionFields, SignedTransaction, Transaction, TransactionType +from algokit_utils.algorand import AlgorandClient + + +@pytest.mark.localnet +def test_simulate_transactions() -> None: + """Test simulating transactions using the localnet algod client directly.""" + algorand = AlgorandClient.default_localnet() + algod_client = algorand.client.algod + + # Build two simple unsigned transactions using algokit-transact helpers + sender = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ" + recv = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ" + t1 = Transaction( + transaction_type=TransactionType.Payment, + sender=sender, + first_valid=1, + last_valid=1000, + payment=PaymentTransactionFields(receiver=recv, amount=0, close_remainder_to=None), + ) + t2 = t1 + + req = SimulateRequest( + txn_groups=[ + SimulateRequestTransactionGroup( + txns=[ + SignedTransaction(txn=t1), + SignedTransaction(txn=t2), + ] + ) + ], + allow_empty_signatures=True, + allow_more_logging=True, + allow_unnamed_resources=True, + round_=0, + extra_opcode_budget=1000, + exec_trace_config=SimulateTraceConfig(enable=True, stack_change=True, scratch_change=True, state_change=True), + fix_signers=True, + ) + + resp = algod_client.simulate_transactions( + body=req, + ) + assert len(resp.txn_groups) == 1 + assert len(resp.txn_groups[0].txn_results) == 2 diff --git a/tests/modules/algod_client/manual/test_suggested_params.py b/tests/modules/algod_client/manual/test_suggested_params.py new file mode 100644 index 00000000..527a2943 --- /dev/null +++ b/tests/modules/algod_client/manual/test_suggested_params.py @@ -0,0 +1,23 @@ +import httpx +import pytest + +from algokit_algod_client import AlgodClient, ClientConfig +from algokit_utils.algorand import AlgorandClient + + +@pytest.mark.localnet +def test_get_suggested_params() -> None: + """Test suggested params using localnet.""" + algod_client = AlgorandClient.default_localnet().client.algod + params = algod_client.suggested_params() + assert isinstance(params.genesis_id, str) + assert params.genesis_id + assert isinstance(params.min_fee, int) + assert params.min_fee > 0 + + +def test_suggested_params_error_handling() -> None: + """Test error handling for invalid host.""" + bad = AlgodClient(ClientConfig(base_url="http://invalid-host:4001", token="a" * 64)) + with pytest.raises(httpx.HTTPError): + bad.suggested_params() diff --git a/tests/modules/algod_client/manual/test_tx_id.py b/tests/modules/algod_client/manual/test_tx_id.py new file mode 100644 index 00000000..c4cf188f --- /dev/null +++ b/tests/modules/algod_client/manual/test_tx_id.py @@ -0,0 +1,51 @@ +import pytest + +import algokit_algod_client +import algokit_indexer_client + +_ROUND = 24098947 + + +def test_algod_tx_id_matches_indexer() -> None: + algod_client = algokit_algod_client.AlgodClient( + algokit_algod_client.ClientConfig( + base_url="https://mainnet-api.algonode.cloud", + token=None, + ) + ) + indexer_client = algokit_indexer_client.IndexerClient( + algokit_indexer_client.ClientConfig( + base_url="https://mainnet-idx.algonode.cloud", + token=None, + ) + ) + + algod_txns = algod_client.block(_ROUND).block.payset + assert algod_txns is not None + algod_txn = algod_txns[0].signed_transaction.signed_transaction.txn + + idx_txns = indexer_client.lookup_block(_ROUND).transactions + assert idx_txns is not None + idx_txn = idx_txns[0] + + assert algod_txn.tx_id() == idx_txn.id_ + + +def test_algod_inner_tx_id() -> None: + algod_client = algokit_algod_client.AlgodClient( + algokit_algod_client.ClientConfig( + base_url="https://mainnet-api.algonode.cloud", + token=None, + ) + ) + + algod_txns = algod_client.block(35214367).block.payset + assert algod_txns is not None + apply_data = algod_txns[46].signed_transaction.apply_data + assert apply_data is not None + eval_data = apply_data.eval_delta + assert eval_data is not None + inner_txn = (eval_data.inner_txns or [])[0].signed_transaction.txn + + with pytest.raises(ValueError, match="Cannot compute transaction id without genesis hash"): + assert inner_txn.tx_id() diff --git a/tests/modules/algod_client/test_delete_v2_catchup_catchpoint.py b/tests/modules/algod_client/test_delete_v2_catchup_catchpoint.py new file mode 100644 index 00000000..e155fde1 --- /dev/null +++ b/tests/modules/algod_client/test_delete_v2_catchup_catchpoint.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: DELETE v2_catchup_CATCHPOINT + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/algod_client/test_delete_v2_ledger_sync.py b/tests/modules/algod_client/test_delete_v2_ledger_sync.py new file mode 100644 index 00000000..89616ec9 --- /dev/null +++ b/tests/modules/algod_client/test_delete_v2_ledger_sync.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: DELETE v2_ledger_sync + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/algod_client/test_get_genesis.py b/tests/modules/algod_client/test_get_genesis.py new file mode 100644 index 00000000..2f7c3c9c --- /dev/null +++ b/tests/modules/algod_client/test_get_genesis.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_algod_client import AlgodClient + +from tests.fixtures.schemas.algod import GenesisSchema +from tests.modules.conftest import DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET genesis + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(algod_client: AlgodClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = algod_client.genesis() + + validate_with_schema(result, GenesisSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/algod_client/test_get_health.py b/tests/modules/algod_client/test_get_health.py new file mode 100644 index 00000000..ef99622b --- /dev/null +++ b/tests/modules/algod_client/test_get_health.py @@ -0,0 +1,15 @@ +import pytest + +from algokit_algod_client import AlgodClient + +# Polytest Suite: GET health + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(algod_client: AlgodClient) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + # health_check returns None on success (200 OK with empty body) + result = algod_client.health_check() + assert result is None diff --git a/tests/modules/algod_client/test_get_ready.py b/tests/modules/algod_client/test_get_ready.py new file mode 100644 index 00000000..408379c2 --- /dev/null +++ b/tests/modules/algod_client/test_get_ready.py @@ -0,0 +1,15 @@ +import pytest + +from algokit_algod_client import AlgodClient + +# Polytest Suite: GET ready + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(algod_client: AlgodClient) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + # get_ready returns None on success (200 OK) + result = algod_client.ready() + assert result is None diff --git a/tests/modules/algod_client/test_get_v2_accounts_address.py b/tests/modules/algod_client/test_get_v2_accounts_address.py new file mode 100644 index 00000000..abe10507 --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_accounts_address.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_algod_client import AlgodClient + +from tests.fixtures.schemas.algod import AccountSchema +from tests.modules.conftest import TEST_ADDRESS, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_accounts_ADDRESS + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(algod_client: AlgodClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = algod_client.account_information(TEST_ADDRESS) + + validate_with_schema(result, AccountSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/algod_client/test_get_v2_accounts_address_applications_application_id.py b/tests/modules/algod_client/test_get_v2_accounts_address_applications_application_id.py new file mode 100644 index 00000000..1a425797 --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_accounts_address_applications_application_id.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_algod_client import AlgodClient + +from tests.fixtures.schemas.algod import AccountApplicationResponseSchema +from tests.modules.conftest import TEST_ADDRESS, TEST_APP_ID, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_accounts_ADDRESS_applications_APPLICATION-ID + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(algod_client: AlgodClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = algod_client.account_application_information(address=TEST_ADDRESS, application_id=TEST_APP_ID) + + validate_with_schema(result, AccountApplicationResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/algod_client/test_get_v2_accounts_address_assets_asset_id.py b/tests/modules/algod_client/test_get_v2_accounts_address_assets_asset_id.py new file mode 100644 index 00000000..b4e4ee89 --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_accounts_address_assets_asset_id.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_algod_client import AlgodClient + +from tests.fixtures.schemas.algod import AccountAssetResponseSchema +from tests.modules.conftest import TEST_ADDRESS, TEST_ASSET_ID, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_accounts_ADDRESS_assets_ASSET-ID + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(algod_client: AlgodClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = algod_client.account_asset_information(TEST_ADDRESS, TEST_ASSET_ID) + + validate_with_schema(result, AccountAssetResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/algod_client/test_get_v2_accounts_address_transactions_pending.py b/tests/modules/algod_client/test_get_v2_accounts_address_transactions_pending.py new file mode 100644 index 00000000..eba8c65e --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_accounts_address_transactions_pending.py @@ -0,0 +1,23 @@ +import pytest + +from algokit_algod_client import AlgodClient + +from tests.modules.conftest import TEST_ADDRESS + +# Polytest Suite: GET v2_accounts_ADDRESS_transactions_pending + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="TODO: Re-enable once msgpack handling is fixed in mock server") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(algod_client: AlgodClient) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = algod_client.pending_transactions_by_address(TEST_ADDRESS) + + assert result is not None + assert isinstance(result.total_transactions, int) + # top_transactions is None when there are no pending transactions (total_transactions == 0) + # or a list when there are pending transactions + if result.total_transactions > 0: + assert result.top_transactions is not None diff --git a/tests/modules/algod_client/test_get_v2_applications_application_id.py b/tests/modules/algod_client/test_get_v2_applications_application_id.py new file mode 100644 index 00000000..19137df0 --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_applications_application_id.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_algod_client import AlgodClient + +from tests.fixtures.schemas.algod import ApplicationSchema +from tests.modules.conftest import TEST_APP_ID, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_applications_APPLICATION-ID + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(algod_client: AlgodClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = algod_client.application_by_id(application_id=TEST_APP_ID) + + validate_with_schema(result, ApplicationSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/algod_client/test_get_v2_applications_application_id_box.py b/tests/modules/algod_client/test_get_v2_applications_application_id_box.py new file mode 100644 index 00000000..77cee877 --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_applications_application_id_box.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: GET v2_applications_APPLICATION-ID_box + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/algod_client/test_get_v2_applications_application_id_boxes.py b/tests/modules/algod_client/test_get_v2_applications_application_id_boxes.py new file mode 100644 index 00000000..dfe1e2cd --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_applications_application_id_boxes.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: GET v2_applications_APPLICATION-ID_boxes + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/algod_client/test_get_v2_assets_asset_id.py b/tests/modules/algod_client/test_get_v2_assets_asset_id.py new file mode 100644 index 00000000..289d06f8 --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_assets_asset_id.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_algod_client import AlgodClient + +from tests.fixtures.schemas.algod import AssetSchema +from tests.modules.conftest import TEST_ASSET_ID, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_assets_ASSET-ID + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(algod_client: AlgodClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = algod_client.asset_by_id(asset_id=TEST_ASSET_ID) + + validate_with_schema(result, AssetSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/algod_client/test_get_v2_blocks_round.py b/tests/modules/algod_client/test_get_v2_blocks_round.py new file mode 100644 index 00000000..49491bed --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_blocks_round.py @@ -0,0 +1,21 @@ +import pytest + +from algokit_algod_client import AlgodClient + +from tests.modules.conftest import TEST_ROUND + +# Polytest Suite: GET v2_blocks_ROUND + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.skip(reason="TODO: Re-enable once msgpack handling is fixed in mock server") +def test_basic_request_and_response_validation(algod_client: AlgodClient) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = algod_client.block(round_=TEST_ROUND) + + assert result is not None + assert result.block is not None + assert result.block.header is not None + assert result.block.header.round == TEST_ROUND diff --git a/tests/modules/algod_client/test_get_v2_blocks_round_hash.py b/tests/modules/algod_client/test_get_v2_blocks_round_hash.py new file mode 100644 index 00000000..710b3e45 --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_blocks_round_hash.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_algod_client import AlgodClient + +from tests.fixtures.schemas.algod import BlockHashResponseSchema +from tests.modules.conftest import TEST_ROUND, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_blocks_ROUND_hash + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(algod_client: AlgodClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = algod_client.block_hash(round_=TEST_ROUND) + + validate_with_schema(result, BlockHashResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/algod_client/test_get_v2_blocks_round_lightheader_proof.py b/tests/modules/algod_client/test_get_v2_blocks_round_lightheader_proof.py new file mode 100644 index 00000000..aa205e32 --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_blocks_round_lightheader_proof.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_algod_client import AlgodClient + +from tests.fixtures.schemas.algod import LightBlockHeaderProofSchema +from tests.modules.conftest import TEST_ROUND, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_blocks_ROUND_lightheader_proof + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(algod_client: AlgodClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = algod_client.light_block_header_proof(round_=TEST_ROUND) + + validate_with_schema(result, LightBlockHeaderProofSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/algod_client/test_get_v2_blocks_round_transactions_txid_proof.py b/tests/modules/algod_client/test_get_v2_blocks_round_transactions_txid_proof.py new file mode 100644 index 00000000..055109ff --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_blocks_round_transactions_txid_proof.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: GET v2_blocks_ROUND_transactions_TXID_proof + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/algod_client/test_get_v2_blocks_round_txids.py b/tests/modules/algod_client/test_get_v2_blocks_round_txids.py new file mode 100644 index 00000000..02bbcde4 --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_blocks_round_txids.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_algod_client import AlgodClient + +from tests.fixtures.schemas.algod import BlockTxidsResponseSchema +from tests.modules.conftest import TEST_ROUND, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_blocks_ROUND_txids + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(algod_client: AlgodClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = algod_client.block_tx_ids(round_=TEST_ROUND) + + validate_with_schema(result, BlockTxidsResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/algod_client/test_get_v2_deltas_round.py b/tests/modules/algod_client/test_get_v2_deltas_round.py new file mode 100644 index 00000000..57f27023 --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_deltas_round.py @@ -0,0 +1,20 @@ +import pytest + +from algokit_algod_client import AlgodClient + +from tests.modules.conftest import TEST_ROUND + +# Polytest Suite: GET v2_deltas_ROUND + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="TODO: Re-enable once msgpack handling is fixed in mock server") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(algod_client: AlgodClient) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = algod_client.ledger_state_delta(round_=TEST_ROUND) + + assert result is not None + assert result.block is not None + assert result.block.header.round == TEST_ROUND diff --git a/tests/modules/algod_client/test_get_v2_deltas_round_txn_group.py b/tests/modules/algod_client/test_get_v2_deltas_round_txn_group.py new file mode 100644 index 00000000..d0a82183 --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_deltas_round_txn_group.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: GET v2_deltas_ROUND_txn_group + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/algod_client/test_get_v2_deltas_txn_group_id.py b/tests/modules/algod_client/test_get_v2_deltas_txn_group_id.py new file mode 100644 index 00000000..374c681b --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_deltas_txn_group_id.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: GET v2_deltas_txn_group_ID + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/algod_client/test_get_v2_devmode_blocks_offset.py b/tests/modules/algod_client/test_get_v2_devmode_blocks_offset.py new file mode 100644 index 00000000..5e9ad2e3 --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_devmode_blocks_offset.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: GET v2_devmode_blocks_offset + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/algod_client/test_get_v2_experimental.py b/tests/modules/algod_client/test_get_v2_experimental.py new file mode 100644 index 00000000..15e65518 --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_experimental.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: GET v2_experimental + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/algod_client/test_get_v2_ledger_supply.py b/tests/modules/algod_client/test_get_v2_ledger_supply.py new file mode 100644 index 00000000..94cab3fd --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_ledger_supply.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_algod_client import AlgodClient + +from tests.fixtures.schemas.algod import SupplyResponseSchema +from tests.modules.conftest import DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_ledger_supply + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(algod_client: AlgodClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = algod_client.supply() + + validate_with_schema(result, SupplyResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/algod_client/test_get_v2_ledger_sync.py b/tests/modules/algod_client/test_get_v2_ledger_sync.py new file mode 100644 index 00000000..77677f24 --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_ledger_sync.py @@ -0,0 +1,18 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_algod_client import AlgodClient + +from tests.modules.conftest import DataclassSnapshotSerializer + +# Polytest Suite: GET v2_ledger_sync + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(algod_client: AlgodClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = algod_client.sync_round() + + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/algod_client/test_get_v2_stateproofs_round.py b/tests/modules/algod_client/test_get_v2_stateproofs_round.py new file mode 100644 index 00000000..42fd5f7c --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_stateproofs_round.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: GET v2_stateproofs_ROUND + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/algod_client/test_get_v2_status.py b/tests/modules/algod_client/test_get_v2_status.py new file mode 100644 index 00000000..a2c2886b --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_status.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_algod_client import AlgodClient + +from tests.fixtures.schemas.algod import NodeStatusResponseSchema +from tests.modules.conftest import DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_status + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(algod_client: AlgodClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = algod_client.status() + + validate_with_schema(result, NodeStatusResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/algod_client/test_get_v2_status_wait_for_block_after_round.py b/tests/modules/algod_client/test_get_v2_status_wait_for_block_after_round.py new file mode 100644 index 00000000..1eb34530 --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_status_wait_for_block_after_round.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_algod_client import AlgodClient + +from tests.fixtures.schemas.algod import NodeStatusResponseSchema +from tests.modules.conftest import TEST_ROUND, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_status_wait-for-block-after_ROUND + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(algod_client: AlgodClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = algod_client.status_after_block(round_=TEST_ROUND) + + validate_with_schema(result, NodeStatusResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/algod_client/test_get_v2_transactions_params.py b/tests/modules/algod_client/test_get_v2_transactions_params.py new file mode 100644 index 00000000..f405a25d --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_transactions_params.py @@ -0,0 +1,18 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_algod_client import AlgodClient + +from tests.modules.conftest import DataclassSnapshotSerializer + +# Polytest Suite: GET v2_transactions_params + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(algod_client: AlgodClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = algod_client.suggested_params() + + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/algod_client/test_get_v2_transactions_pending.py b/tests/modules/algod_client/test_get_v2_transactions_pending.py new file mode 100644 index 00000000..fe5bb00d --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_transactions_pending.py @@ -0,0 +1,21 @@ +import pytest + +from algokit_algod_client import AlgodClient + +# Polytest Suite: GET v2_transactions_pending + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.skip(reason="TODO: Re-enable once msgpack handling is fixed in mock server") +def test_basic_request_and_response_validation(algod_client: AlgodClient) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = algod_client.pending_transactions() + + assert result is not None + assert isinstance(result.total_transactions, int) + # top_transactions is None when there are no pending transactions (total_transactions == 0) + # or a list when there are pending transactions + if result.total_transactions > 0: + assert result.top_transactions is not None diff --git a/tests/modules/algod_client/test_get_v2_transactions_pending_txid.py b/tests/modules/algod_client/test_get_v2_transactions_pending_txid.py new file mode 100644 index 00000000..c078728e --- /dev/null +++ b/tests/modules/algod_client/test_get_v2_transactions_pending_txid.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: GET v2_transactions_pending_TXID + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/algod_client/test_get_versions.py b/tests/modules/algod_client/test_get_versions.py new file mode 100644 index 00000000..bcade9d0 --- /dev/null +++ b/tests/modules/algod_client/test_get_versions.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_algod_client import AlgodClient + +from tests.fixtures.schemas.algod import VersionSchema +from tests.modules.conftest import DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET versions + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(algod_client: AlgodClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = algod_client.version() + + validate_with_schema(result, VersionSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/algod_client/test_post_v2_catchup_catchpoint.py b/tests/modules/algod_client/test_post_v2_catchup_catchpoint.py new file mode 100644 index 00000000..832a9149 --- /dev/null +++ b/tests/modules/algod_client/test_post_v2_catchup_catchpoint.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: POST v2_catchup_CATCHPOINT + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/algod_client/test_post_v2_devmode_blocks_offset_offset.py b/tests/modules/algod_client/test_post_v2_devmode_blocks_offset_offset.py new file mode 100644 index 00000000..0cea7661 --- /dev/null +++ b/tests/modules/algod_client/test_post_v2_devmode_blocks_offset_offset.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: POST v2_devmode_blocks_offset_OFFSET + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/algod_client/test_post_v2_ledger_sync_round.py b/tests/modules/algod_client/test_post_v2_ledger_sync_round.py new file mode 100644 index 00000000..78cda2a4 --- /dev/null +++ b/tests/modules/algod_client/test_post_v2_ledger_sync_round.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: POST v2_ledger_sync_ROUND + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/algod_client/test_post_v2_shutdown.py b/tests/modules/algod_client/test_post_v2_shutdown.py new file mode 100644 index 00000000..e54a29d0 --- /dev/null +++ b/tests/modules/algod_client/test_post_v2_shutdown.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: POST v2_shutdown + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/algod_client/test_post_v2_teal_compile.py b/tests/modules/algod_client/test_post_v2_teal_compile.py new file mode 100644 index 00000000..7fb666ef --- /dev/null +++ b/tests/modules/algod_client/test_post_v2_teal_compile.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: POST v2_teal_compile + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/algod_client/test_post_v2_teal_disassemble.py b/tests/modules/algod_client/test_post_v2_teal_disassemble.py new file mode 100644 index 00000000..e7126d8b --- /dev/null +++ b/tests/modules/algod_client/test_post_v2_teal_disassemble.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: POST v2_teal_disassemble + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/algod_client/test_post_v2_teal_dryrun.py b/tests/modules/algod_client/test_post_v2_teal_dryrun.py new file mode 100644 index 00000000..23bf1b8d --- /dev/null +++ b/tests/modules/algod_client/test_post_v2_teal_dryrun.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: POST v2_teal_dryrun + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/algod_client/test_post_v2_transactions.py b/tests/modules/algod_client/test_post_v2_transactions.py new file mode 100644 index 00000000..43add2b8 --- /dev/null +++ b/tests/modules/algod_client/test_post_v2_transactions.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: POST v2_transactions + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/algod_client/test_post_v2_transactions_async.py b/tests/modules/algod_client/test_post_v2_transactions_async.py new file mode 100644 index 00000000..c6c88988 --- /dev/null +++ b/tests/modules/algod_client/test_post_v2_transactions_async.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: POST v2_transactions_async + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/algod_client/test_post_v2_transactions_simulate.py b/tests/modules/algod_client/test_post_v2_transactions_simulate.py new file mode 100644 index 00000000..77a9e648 --- /dev/null +++ b/tests/modules/algod_client/test_post_v2_transactions_simulate.py @@ -0,0 +1,12 @@ +import pytest + +# Polytest Suite: POST v2_transactions_simulate + +# Polytest Group: Common Tests + + +@pytest.mark.skip(reason="Test not implemented") +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(): + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + raise Exception("TEST NOT IMPLEMENTED") diff --git a/tests/modules/conftest.py b/tests/modules/conftest.py new file mode 100644 index 00000000..5b7b2086 --- /dev/null +++ b/tests/modules/conftest.py @@ -0,0 +1,80 @@ +"""Shared test fixtures and utilities for module tests. + +Mock server fixtures are in individual module conftest files: +- algod_client/conftest.py +- indexer_client/conftest.py +- kmd_client/conftest.py +""" + +import base64 +from dataclasses import fields, is_dataclass +from enum import Enum +from pathlib import Path + +# Load .env file from project root for local development +# Supports MOCK_ALGOD_URL, MOCK_INDEXER_URL, MOCK_KMD_URL +# Must happen before other imports that may use these env vars +from dotenv import load_dotenv + +load_dotenv(Path(__file__).parent.parent.parent / ".env") + +import pytest # noqa: E402 +from syrupy.assertion import SnapshotAssertion # noqa: E402 +from syrupy.extensions.json import JSONSnapshotExtension # noqa: E402 + +from algokit_utils.algorand import AlgorandClient # noqa: E402 + +# Test data constants matching TS mock server recordings +TEST_ADDRESS = "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" +TEST_APP_ID = 718348254 +TEST_APP_ID_WITH_BOXES = 742949200 # xgov testnet +TEST_BOX_NAME = "b64:cBbHBNV+zUy/Mz5IRhIrBLxr1on5wmidhXEavV+SasC8" +TEST_ASSET_ID = 705457144 +TEST_TXID = "VIXTUMAPT7NR4RB2WVOGMETW4QY43KIDA3HWDWWXS3UEDKGTEECQ" +TEST_ROUND = 24099447 + + +def _dataclass_to_dict(obj: object) -> object: # noqa: PLR0911 + """Recursively convert a dataclass to a dict for JSON serialization.""" + if obj is None: + return None + if isinstance(obj, Enum): + return obj.value + if is_dataclass(obj) and not isinstance(obj, type): + return {f.name: _dataclass_to_dict(getattr(obj, f.name)) for f in fields(obj)} + if isinstance(obj, bytes | bytearray | memoryview): + return base64.b64encode(bytes(obj)).decode("ascii") + if isinstance(obj, list | tuple): + return [_dataclass_to_dict(item) for item in obj] + if isinstance(obj, dict): + return {k: _dataclass_to_dict(v) for k, v in obj.items()} + return obj + + +class DataclassSnapshotSerializer: + """Serializer that converts dataclass models to JSON-serializable dicts.""" + + @staticmethod + def serialize(data: object) -> object: + return _dataclass_to_dict(data) + + +def validate_with_schema(result: object, schema_class: type) -> None: + """Validate a dataclass API response against its Pydantic schema. + + Mirrors the TS approach of calling Schema.parse(result) in every polytest + to ensure the real API response matches the OAS-generated schema. + """ + schema_class.model_validate(_dataclass_to_dict(result)) + + +@pytest.fixture +def snapshot_json(snapshot: SnapshotAssertion) -> SnapshotAssertion: + """Snapshot fixture configured for JSON output.""" + return snapshot.with_defaults(extension_class=JSONSnapshotExtension) + + +@pytest.fixture +def algorand_localnet() -> AlgorandClient: + """AlgorandClient configured for localnet (real network, not mock).""" + return AlgorandClient.default_localnet() diff --git a/tests/modules/crypto/__init__.py b/tests/modules/crypto/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/modules/crypto/test_signing.py b/tests/modules/crypto/test_signing.py new file mode 100644 index 00000000..c9c0740a --- /dev/null +++ b/tests/modules/crypto/test_signing.py @@ -0,0 +1,230 @@ +"""Tests for wrapped-secret Ed25519 signing, mirroring crypto_ts/signer.spec.ts.""" + +import os + +from exceptiongroup import ExceptionGroup +import nacl.signing +import pytest + +from algokit_crypto import ( + ed25519_verifier, + pynacl_ed25519_generator, + pynacl_ed25519_signing_key_from_wrapped_secret, + peikert_hd_wallet_generator, +) + + +class TestSigningBasics: + """Basic signing and verification tests.""" + + def test_generate_and_verify_with_pynacl(self) -> None: + """Generate a keypair, sign, and verify using PyNaCl directly.""" + signing_key = nacl.signing.SigningKey.generate() + pubkey = bytes(signing_key.verify_key) + message = b"hello world" + signed = signing_key.sign(message) + signature = signed.signature + + assert ed25519_verifier(signature, message, pubkey) is True + assert ed25519_verifier(signature, b"wrong message", pubkey) is False + + def test_generate_and_verify_with_generator(self) -> None: + """Generate a keypair using pynacl_ed25519_generator, sign, and verify.""" + keypair = pynacl_ed25519_generator() + message = b"test message" + signature = keypair["raw_ed25519_signer"](message) + + assert ed25519_verifier(signature, message, keypair["ed25519_pubkey"]) is True + + def test_hd_wallet_sign_and_verify(self) -> None: + """Generate an HD wallet, sign with HD signer, verify with ed25519_verifier.""" + wallet = peikert_hd_wallet_generator() + account = wallet["account_generator"](0, 0) + message = b"HD signing test" + signature = account["raw_ed25519_signer"](message) + + assert ed25519_verifier(signature, message, account["ed25519_pubkey"]) is True + + +class TestWrappedSeedSigning: + """Tests for wrapped Ed25519 seed signing.""" + + def test_wrapped_seed_signing(self) -> None: + """Create a wrapped seed, get signing key, sign, and verify.""" + seed = bytearray(os.urandom(32)) + + class WrappedSeed: + def unwrap_ed25519_seed(self) -> bytearray: + return bytearray(seed) + + def wrap_ed25519_seed(self) -> None: + pass + + signing_key = pynacl_ed25519_signing_key_from_wrapped_secret(WrappedSeed()) + message = b"wrapped seed test" + signature = signing_key["raw_ed25519_signer"](message) + + assert ed25519_verifier(signature, message, signing_key["ed25519_pubkey"]) is True + + def test_wrapped_seed_rejects_invalid_length_pubkey(self) -> None: + """31-byte seed should raise ValueError during pubkey derivation.""" + + class BadWrappedSeed: + def unwrap_ed25519_seed(self) -> bytearray: + return bytearray(31) + + def wrap_ed25519_seed(self) -> None: + pass + + with pytest.raises(ValueError, match="Expected unwrapped ed25519 seed to be 32 bytes, got 31."): + pynacl_ed25519_signing_key_from_wrapped_secret(BadWrappedSeed()) + + def test_wrapped_seed_rejects_invalid_length_signing(self) -> None: + """Second unwrap returns 31 bytes, should raise ValueError during signing.""" + seed = bytearray(os.urandom(32)) + unwrap_count = 0 + + class BadSignWrappedSeed: + def unwrap_ed25519_seed(self) -> bytearray: + nonlocal unwrap_count + unwrap_count += 1 + if unwrap_count == 1: + return bytearray(seed) + return bytearray(31) + + def wrap_ed25519_seed(self) -> None: + pass + + signing_key = pynacl_ed25519_signing_key_from_wrapped_secret(BadSignWrappedSeed()) + + with pytest.raises(ValueError, match="Expected unwrapped ed25519 seed to be 32 bytes, got 31."): + signing_key["raw_ed25519_signer"](b"\x01\x02\x03") + + def test_wrapped_seed_reports_both_pubkey_and_wrap_failures(self) -> None: + """Both unwrap and wrap fail; error should contain both messages.""" + + class BothFailWrappedSeed: + def unwrap_ed25519_seed(self) -> bytearray: + raise RuntimeError("unwrap failed") + + def wrap_ed25519_seed(self) -> None: + raise RuntimeError("wrap failed") + + with pytest.raises( + ExceptionGroup, + match="Deriving Ed25519 public key failed and failed to re-wrap Ed25519 secret", + ): + pynacl_ed25519_signing_key_from_wrapped_secret(BothFailWrappedSeed()) + + def test_wrapped_seed_reports_both_signing_and_wrap_failures(self) -> None: + """Both signing (unwrap) and wrap fail; error should contain both messages.""" + seed = bytearray(os.urandom(32)) + unwrap_should_fail = False + wrap_should_fail = False + + class FailableWrappedSeed: + def unwrap_ed25519_seed(self) -> bytearray: + if unwrap_should_fail: + raise RuntimeError("unwrap failed") + return bytearray(seed) + + def wrap_ed25519_seed(self) -> None: + if wrap_should_fail: + raise RuntimeError("wrap failed") + + signing_key = pynacl_ed25519_signing_key_from_wrapped_secret(FailableWrappedSeed()) + + unwrap_should_fail = True + wrap_should_fail = True + + with pytest.raises( + ExceptionGroup, + match="Signing failed and failed to re-wrap Ed25519 secret", + ): + signing_key["raw_ed25519_signer"](b"\x01\x02\x03") + + def test_wrapped_seed_zeroes_secret_after_signing(self) -> None: + """The bytearray secret should be zeroed after successful signing.""" + seed = bytearray(os.urandom(32)) + returned_secret: bytearray | None = None + + class ZeroCheckWrappedSeed: + def unwrap_ed25519_seed(self) -> bytearray: + nonlocal returned_secret + returned_secret = bytearray(seed) + return returned_secret + + def wrap_ed25519_seed(self) -> None: + pass + + signing_key = pynacl_ed25519_signing_key_from_wrapped_secret(ZeroCheckWrappedSeed()) + signing_key["raw_ed25519_signer"](b"\x0a\x14\x1e") + + assert returned_secret is not None + assert all(b == 0 for b in returned_secret) + + def test_wrapped_seed_zeroes_secret_after_failed_wrap(self) -> None: + """The bytearray secret should still be zeroed even if wrap fails.""" + seed = bytearray(os.urandom(32)) + unwrap_count = 0 + wrap_count = 0 + returned_secret: bytearray | None = None + + class ZeroOnFailWrappedSeed: + def unwrap_ed25519_seed(self) -> bytearray: + nonlocal unwrap_count, returned_secret + unwrap_count += 1 + if unwrap_count == 1: + return bytearray(seed) + returned_secret = bytearray(seed) + return returned_secret + + def wrap_ed25519_seed(self) -> None: + nonlocal wrap_count + wrap_count += 1 + if wrap_count > 1: + raise RuntimeError("wrap failed") + + signing_key = pynacl_ed25519_signing_key_from_wrapped_secret(ZeroOnFailWrappedSeed()) + + with pytest.raises(RuntimeError, match="wrap failed"): + signing_key["raw_ed25519_signer"](b"\x01\x02\x03") + + assert returned_secret is not None + assert all(b == 0 for b in returned_secret) + + +class TestWrappedHdExtendedKeySigning: + """Tests for wrapped HD extended private key signing.""" + + def test_wrapped_hd_extended_key_signing(self) -> None: + """Create a wrapped HD extended key, get signing key, sign, and verify.""" + wallet = peikert_hd_wallet_generator() + account = wallet["account_generator"](0, 0) + extended_key = bytearray(account["extended_private_key"]) + + class WrappedHdKey: + def unwrap_hd_extended_private_key(self) -> bytearray: + return bytearray(extended_key) + + def wrap_hd_extended_private_key(self) -> None: + pass + + signing_key = pynacl_ed25519_signing_key_from_wrapped_secret(WrappedHdKey()) + message = b"wrapped HD key test" + signature = signing_key["raw_ed25519_signer"](message) + + assert ed25519_verifier(signature, message, signing_key["ed25519_pubkey"]) is True + + def test_wrapped_hd_extended_key_rejects_invalid_length(self) -> None: + """95-byte key should raise ValueError.""" + + class BadWrappedHdKey: + def unwrap_hd_extended_private_key(self) -> bytearray: + return bytearray(95) + + def wrap_hd_extended_private_key(self) -> None: + pass + + with pytest.raises(ValueError, match="Expected unwrapped HD extended key to be 96 bytes, got 95."): + pynacl_ed25519_signing_key_from_wrapped_secret(BadWrappedHdKey()) diff --git a/tests/modules/indexer_client/__init__.py b/tests/modules/indexer_client/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts/test_basic_request_and_response_validation.json b/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..f05d71ef --- /dev/null +++ b/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts/test_basic_request_and_response_validation.json @@ -0,0 +1,38 @@ +{ + "accounts": [ + { + "address": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ", + "amount": 416118344628, + "amount_without_pending_rewards": 416118344628, + "apps_local_state": null, + "apps_total_extra_pages": null, + "apps_total_schema": null, + "assets": null, + "auth_addr": null, + "closed_at_round": null, + "created_apps": null, + "created_assets": null, + "created_at_round": 3331015, + "deleted": false, + "incentive_eligible": null, + "last_heartbeat": null, + "last_proposed": null, + "min_balance": 100000, + "participation": null, + "pending_rewards": 0, + "reward_base": 27521, + "rewards": 74126551, + "round_": 57774717, + "sig_type": null, + "status": "Offline", + "total_apps_opted_in": 0, + "total_assets_opted_in": 0, + "total_box_bytes": 0, + "total_boxes": 0, + "total_created_apps": 0, + "total_created_assets": 0 + } + ], + "current_round": 57774717, + "next_token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ" +} diff --git a/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts_account_id/test_basic_request_and_response_validation.json b/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts_account_id/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..6ac229b1 --- /dev/null +++ b/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts_account_id/test_basic_request_and_response_validation.json @@ -0,0 +1,757 @@ +{ + "account": { + "address": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "amount": 13857000, + "amount_without_pending_rewards": 13857000, + "apps_local_state": null, + "apps_total_extra_pages": null, + "apps_total_schema": { + "num_byte_slices": 8, + "num_uints": 23 + }, + "assets": [ + { + "amount": 0, + "asset_id": 705457144, + "deleted": false, + "is_frozen": false, + "opted_in_at_round": 42227833, + "opted_out_at_round": null + } + ], + "auth_addr": null, + "closed_at_round": null, + "created_apps": [ + { + "created_at_round": 42225864, + "deleted": false, + "deleted_at_round": null, + "id_": 705408386, + "params": { + "approval_program": "CiADAAEEJgYLYXVjdGlvbl9lbmQMcHJldmlvdXNfYmlkD3ByZXZpb3VzX2JpZGRlcgNhc2EKYXNhX2Ftb3VudAVjbGFpbTEYQAADiAGjMRtBAKaABCgmsgKABPCqcCOABDDG1YqABNt/6EOABOZUYluABB7BK+82GgCOBgABABMAMQA9AFMAXwAxGRREMRhENhoBF8AwiABqI0MxGRREMRhENhoBFzYaAhcxFiMJSTgQJBJEiABwI0MxGRREMRhEiACQI0MxGRREMRhEMRYjCUk4ECMSRIgAfiNDMRkURDEYRIgAoiNDMRkURDEYRDYaARfAMIgAzyNDMRkURDEYFEQjQ4oBADEAMgkSRCIrZUQURCuL/2exMgqL/7IRshQkshAisgGziYoDADEAMgkSRCIoZUQURIv/OBQyChJEi/84EicETGcyB4v+CChMZymL/WeJigAAiYoBADIHIihlRAxEi/84AEkxABJEi/84CCIpZURLAQxEKUsBZypPAmcxACcFTwJmiYoAADEAIicFY0xJTwJEMQAiKmVEEkEACiIpZUSLAEwJjAGxMQCyB4sBSbIII7IQIrIBszEAiwBPAgknBUxmiYoBADIHIihlRA1EsSIqZUQiKmVEIicEZUSyErIUshWL/7IRJLIQIrIBs4mKAAAoImcpImcnBCJnKyJnKjIDZ4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "cHJldmlvdXNfYmlk", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlkZGVy", + "value": { + "bytes_": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", + "type_": 1, + "uint": 0 + } + }, + { + "key": "YXNh", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "YXNhX2Ftb3VudA==", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + } + ], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 4 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "version": null + } + }, + { + "created_at_round": 42225963, + "deleted": false, + "deleted_at_round": null, + "id_": 705410358, + "params": { + "approval_program": "CCADAAEEJgYLaGlnaGVzdF9iaWQDYXNhDmhpZ2hlc3RfYmlkZGVyC2F1Y3Rpb25fZW5kB2FzYV9hbXQAMRsiEkAA+DYaAIAEKCayAhJAANc2GgCABPCqcCMSQACcNhoAgAQ5BCruEkAAaDYaAIAEtYkGhhJAAEw2GgCABMkBKDESQAAeNhoAgAQkN408EkAAAQAxGYEFEjEYIhMQRIgBmCNDMRkiEjEYIhMQRDYaASJVNQU2GgIiVTUGNAU0BogBWCNDMRkiEjEYIhMQRIgBPiNDMRkiEjEYIhMQRDYaASJVNQQxFiMJNQM0AzgQIxJENAM0BIgA2iNDMRkiEjEYIhMQRDYaARc1ADYaAhc1ATEWIwk1AjQCOBAkEkQ0ADQBNAKIAGcjQzEZIhIxGCITEEQ2GgEiVYgAKSNDMRkiEkAAAQAxGCISRIgAAiNDigAAKSJnJwQiZysiZygiZyonBWeJigEAMQAyCRJEKWQiEkQpi//AMGexJLIQIrIBMgqyFIv/wDCyESKyErOJigMAMQAyCRJEK2QiEkSL/zgUMgoSRIv/OBEpZBJEJwSL/zgSZysyB4v+CGcoi/1niYoCALEjshCL/rIHi/+yCCKyAbOJigIAMgcrZAxEi/44CChkDUSL/jgAMQASRIv+OAcyChJEKmQnBRNBAAcqZChkiP+8KIv+OAhnKov+OABniYoAADIJKGSI/6WJigIAsSSyECKyASlkshEnBGSyEipkshSL/8AcshWziYoAALEjshAisgEyCbIHMgmyCSKyCLOJ", + "clear_state_program": "CIEAQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "YXNh", + "value": { + "bytes_": "", + "type_": 2, + "uint": 705457144 + } + }, + { + "key": "YXNhX2FtdA==", + "value": { + "bytes_": "", + "type_": 2, + "uint": 1 + } + }, + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 1721928880 + } + }, + { + "key": "aGlnaGVzdF9iaWQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 10000 + } + }, + { + "key": "aGlnaGVzdF9iaWRkZXI=", + "value": { + "bytes_": "", + "type_": 1, + "uint": 0 + } + } + ], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 4 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 42354158, + "deleted": false, + "deleted_at_round": null, + "id_": 708093293, + "params": { + "approval_program": "CiACAQgmAQQVH3x1MRtBAJ6ABP5r32mABHPAS02ABOAER0WABHjNzgWABIMeel82GgCOBQABABcANQBIAF4AMRkURDEYRDYaATYaAogAaihMULAiQzEZFEQxGEQ2GgFXAgCIAGBJFRZXBgJMUChMULAiQzEZFEQxGEQ2GgGIAEsoTFCwIkMxGRREMRhENhoBNhoCiAA7KExQsCJDMRkURDEYRDYaAYgANihMULAiQzEZFEQxGBREIkOKAgGL/heL/xcIFomKAQGL/4mKAQGL/4mKAgGL/xcjC4v+TCNYiYoBAYv/iQ==", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 42377330, + "deleted": false, + "deleted_at_round": null, + "id_": 709373991, + "params": { + "approval_program": "CiABASYBBBUffHUxG0EAfoAEV3/iSYAEFW7njDYaAI4CAAEAUwAxGRREMRhENhoBNhoCNhoDNhoENhoFNhoGNhoHNhoINhoJNhoKNhoLNhoMNhoNNhoONhoPVwAINhoPVwgINhoPVxAINhoPVxgIiAAmKExQsCJDMRkURDEYRDYaATYaAogATyhMULAiQzEZFEQxGBREIkOKEgGL7ovvUIvwUIvxUIvyUIvzUIv0UIv1UIv2UIv3UIv4UIv5UIv6UIv7UIv8UIv9UIv+UIv/UIACABJMUImKAgGL/ov/UIk=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 42409494, + "deleted": false, + "deleted_at_round": null, + "id_": 709806536, + "params": { + "approval_program": "CiABATEbQQCKgATAPy4cNhoAjgEAAQAxGRREMRhENhoBNhoCNhoDNhoENhoFNhoGNhoHNhoINhoJNhoKNhoLNhoMNhoNNhoONhoPVwAINhoPVwgINhoPVxAINhoPVxgBF8AwNhoPVxkINhoPVyEBF8AyMRYiCUk4ECISRDYaD1ciARfAHIgAFYAEFR98dUxQsCJDMRkURDEYFEQiQ4oWAYvqi+tQi+xQi+1Qi+5Qi+9Qi/BQi/FQi/JQi/NQi/RQi/VQi/ZQi/dQi/hQi/lQi/pQi/xQsIv7Fov9Fov/cwBEFov+OBdJFRZXBgJMUE8DTwNQTwJQgAIAGlBMUIk=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 42416068, + "deleted": false, + "deleted_at_round": null, + "id_": 709982020, + "params": { + "approval_program": "CiACAQQmAQIABDEbQQApgASOp1DSNhoAjgEAAQAxGRREMRhENhoBNhoCiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigIBi/+BAFmL/4ECWYv/TwJLAlJMi/8Vi/9OAlJMSRUjCBZXBgIoTFBMUExQi/4VIwgWVwYCKExQi/5QTFCJ", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 42670849, + "deleted": false, + "deleted_at_round": null, + "id_": 713725461, + "params": { + "approval_program": "CiABASYBBBUffHUxG0EAPIAEryCdjIAEcT1y5DYaAI4CAAEAFAAxGRREMRhENhoBiAAjKExQsCJDMRkURDEYRDYaAYgAFihMULAiQzEZFEQxGBREIkOKAQGL/4mKAQGL/4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 43110878, + "deleted": false, + "deleted_at_round": null, + "id_": 716754254, + "params": { + "approval_program": "CiACAQQmAQIABDEbQQApgASOp1DSNhoAjgEAAQAxGRREMRhENhoBNhoCiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigIBi/+BAFmL/4ECWYv/TwJLAlJMi/8Vi/9OAlJMSRUjCBZXBgIoTFBMUExQi/4VIwgWVwYCKExQi/5QTFCJ", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 43267993, + "deleted": false, + "deleted_at_round": null, + "id_": 717891588, + "params": { + "approval_program": "CiADAAEEJgYLYXVjdGlvbl9lbmQMcHJldmlvdXNfYmlkD3ByZXZpb3VzX2JpZGRlcgNhc2EKYXNhX2Ftb3VudAVjbGFpbTEYQAADiAGjMRtBAKaABCgmsgKABPCqcCOABDDG1YqABNt/6EOABOZUYluABB7BK+82GgCOBgABABMAMQA9AFMAXwAxGRREMRhENhoBF8AwiABqI0MxGRREMRhENhoBFzYaAhcxFiMJSTgQJBJEiABwI0MxGRREMRhEiACQI0MxGRREMRhEMRYjCUk4ECMSRIgAfiNDMRkURDEYRIgAoiNDMRkURDEYRDYaARfAMIgAzyNDMRkURDEYFEQjQ4oBADEAMgkSRCIrZUQURCuL/2exMgqL/7IRshQkshAisgGziYoDADEAMgkSRCIoZUQURIv/OBQyChJEi/84EicETGcyB4v+CChMZymL/WeJigAAiYoBADIHIihlRAxEi/84AEkxABJEi/84CCIpZURLAQxEKUsBZypPAmcxACcFTwJmiYoAADEAIicFY0xJTwJEMQAiKmVEEkEACiIpZUSLAEwJjAGxMQCyB4sBSbIII7IQIrIBszEAiwBPAgknBUxmiYoBADIHIihlRA1EsSIqZUQiKmVEIicEZUSyErIUshWL/7IRJLIQIrIBs4mKAAAoImcpImcnBCJnKyJnKjIDZ4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "YXNh", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "YXNhX2Ftb3VudA==", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlk", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlkZGVy", + "value": { + "bytes_": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", + "type_": 1, + "uint": 0 + } + } + ], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 4 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "version": null + } + }, + { + "created_at_round": 43268243, + "deleted": false, + "deleted_at_round": null, + "id_": 717893078, + "params": { + "approval_program": "CiADAAEEJgYLYXVjdGlvbl9lbmQMcHJldmlvdXNfYmlkD3ByZXZpb3VzX2JpZGRlcgNhc2EKYXNhX2Ftb3VudAVjbGFpbTEYQAADiAGjMRtBAKaABCgmsgKABPCqcCOABDDG1YqABNt/6EOABOZUYluABB7BK+82GgCOBgABABMAMQA9AFMAXwAxGRREMRhENhoBF8AwiABqI0MxGRREMRhENhoBFzYaAhcxFiMJSTgQJBJEiABwI0MxGRREMRhEiACQI0MxGRREMRhEMRYjCUk4ECMSRIgAfiNDMRkURDEYRIgAoiNDMRkURDEYRDYaARfAMIgAzyNDMRkURDEYFEQjQ4oBADEAMgkSRCIrZUQURCuL/2exMgqL/7IRshQkshAisgGziYoDADEAMgkSRCIoZUQURIv/OBQyChJEi/84EicETGcyB4v+CChMZymL/WeJigAAiYoBADIHIihlRAxEi/84AEkxABJEi/84CCIpZURLAQxEKUsBZypPAmcxACcFTwJmiYoAADEAIicFY0xJTwJEMQAiKmVEEkEACiIpZUSLAEwJjAGxMQCyB4sBSbIII7IQIrIBszEAiwBPAgknBUxmiYoBADIHIihlRA1EsSIqZUQiKmVEIicEZUSyErIUshWL/7IRJLIQIrIBs4mKAAAoImcpImcnBCJnKyJnKjIDZ4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "cHJldmlvdXNfYmlk", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlkZGVy", + "value": { + "bytes_": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", + "type_": 1, + "uint": 0 + } + }, + { + "key": "YXNh", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "YXNhX2Ftb3VudA==", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + } + ], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 4 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "version": null + } + }, + { + "created_at_round": 43298070, + "deleted": false, + "deleted_at_round": null, + "id_": 718129252, + "params": { + "approval_program": "CiADAAEEJgYLYXVjdGlvbl9lbmQMcHJldmlvdXNfYmlkD3ByZXZpb3VzX2JpZGRlcgNhc2EKYXNhX2Ftb3VudAVjbGFpbTEYQAADiAGjMRtBAKaABCgmsgKABPCqcCOABDDG1YqABNt/6EOABOZUYluABB7BK+82GgCOBgABABMAMQA9AFMAXwAxGRREMRhENhoBF8AwiABqI0MxGRREMRhENhoBFzYaAhcxFiMJSTgQJBJEiABwI0MxGRREMRhEiACQI0MxGRREMRhEMRYjCUk4ECMSRIgAfiNDMRkURDEYRIgAoiNDMRkURDEYRDYaARfAMIgAzyNDMRkURDEYFEQjQ4oBADEAMgkSRCIrZUQURCuL/2exMgqL/7IRshQkshAisgGziYoDADEAMgkSRCIoZUQURIv/OBQyChJEi/84EicETGcyB4v+CChMZymL/WeJigAAiYoBADIHIihlRAxEi/84AEkxABJEi/84CCIpZURLAQxEKUsBZypPAmcxACcFTwJmiYoAADEAIicFY0xJTwJEMQAiKmVEEkEACiIpZUSLAEwJjAGxMQCyB4sBSbIII7IQIrIBszEAiwBPAgknBUxmiYoBADIHIihlRA1EsSIqZUQiKmVEIicEZUSyErIUshWL/7IRJLIQIrIBs4mKAAAoImcpImcnBCJnKyJnKjIDZ4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "YXNh", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "YXNhX2Ftb3VudA==", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlk", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlkZGVy", + "value": { + "bytes_": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", + "type_": 1, + "uint": 0 + } + } + ], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 4 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "version": null + } + }, + { + "created_at_round": 43334411, + "deleted": false, + "deleted_at_round": null, + "id_": 718348254, + "params": { + "approval_program": "CiABATEbQQAmgASlPlpBNhoAjgEAAQAxGRREMRhENhoBiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigEBi/+J", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 43453866, + "deleted": false, + "deleted_at_round": null, + "id_": 719046155, + "params": { + "approval_program": "CiABASYBBBUffHUxGEAAA4gA0jEbQQCMgAQx4uVggASPjC9xgATfX6OPgATxp30WgASsnZwXNhoAjgUAAQARACQANwBMADEZFEQxGESIAF4oTFCwIkMxGRREMRhENhoBiABZKExQsCJDMRkURDEYRDYaAYgATChMULAiQzEZFEQxGEQ2GgEXwBw2GgKIADkiQzEZFEQxGEQ2GgGIAEEoTFCwIkMxGRREMRgURCJDigABgAgAAAAAAAAAA4mKAQGL/4mKAQGL/4mKAgCL/xeL/oAJbG9jYWxfaW50TwJmiYoBAYv/iYoAAIAKZ2xvYmFsX2ludIEqZ4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "Z2xvYmFsX2ludA==", + "value": { + "bytes_": "", + "type_": 2, + "uint": 42 + } + } + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "version": null + } + }, + { + "created_at_round": 43487500, + "deleted": false, + "deleted_at_round": null, + "id_": 719241638, + "params": { + "approval_program": "CiABATEbQQAjgARv4y6HNhoAjgEAAQAxGRREMRhEiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigABgAMxMjNJFRZXBgJMUIk=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 43489481, + "deleted": false, + "deleted_at_round": null, + "id_": 719253364, + "params": { + "approval_program": "CiABASYBBBUffHUxG0EAX4AEQdnf4YAEL8rd9oAEnL09PTYaAI4DAAEAGQAxADEZFEQxGESIAEFJFRZXBgJMUChMULAiQzEZFEQxGESIADJJFRZXBgJMUChMULAiQzEZFEQxGESIACQWKExQsCJDMRkURDEYFEQiQ4oAAYADYXNkiYoAAYAEQUJDRImKAAEiiQ==", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 43489614, + "deleted": false, + "deleted_at_round": null, + "id_": 719254146, + "params": { + "approval_program": "CiABASYBBBUffHUxG0EAX4AEQdnf4YAEL8rd9oAEnL09PTYaAI4DAAEAGQAxADEZFEQxGESIAEFJFRZXBgJMUChMULAiQzEZFEQxGESIADNJFRZXBgJMUChMULAiQzEZFEQxGESIACkWKExQsCJDMRkURDEYFEQiQ4oAAYAEdGVzdImKAAGACEFRSURCQT09iYoAAYEziQ==", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 43715014, + "deleted": false, + "deleted_at_round": null, + "id_": 720689424, + "params": { + "approval_program": "CiABATEbQQAmgARBbn/KNhoAjgEAAQAxGRREMRhENhoBiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigEBi/+BAFmL/4EKWYv/TgJSiQ==", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 43777502, + "deleted": false, + "deleted_at_round": null, + "id_": 721104877, + "params": { + "approval_program": "CiABATEbQQA1gAQjqAI8NhoAjgEAAQAxGRREMRhENhoBF8AwNhoCF8AyNhoDF8AciAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigMBi/0Wi/4WUIk=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 46110739, + "deleted": false, + "deleted_at_round": null, + "id_": 729762198, + "params": { + "approval_program": "CiAEAQAKeyYEBBUffHUHAAP/AAJIaQVIZWxsbwH/iAABQ4oAATEbQQDSggcETFxhugSX6OSnBHbE3hEEwcp3CQRt52LCBFn8UoIEnZ7ssDYaAI4HAAIADAAjADYARQBRAGIjiSIxGZCBAxpEIokxGRREMRhENhoBNhoCiACaFihMULAiiTEZFEQxGEQ2GgGIAJwoTFCwIokxGRREMRhENhoBiACpIokxGRREMRhEiACrIokxGRREMRhENhoBI1OIANMiiTEZFEQxGESIAPdPAhZLAhUWVwYCTwNQSwMVgQ0IgAIADU8DUEwWVwYCUE8CUE8CUExQKExQsCKJMRmNBgACAAIACgAKAAoABCOJIokxGBREIokjiYoCAYv+JFmL/hWL/k4CUov/EkSBKomKAQGL/yRZi/8Vi/9OAlJJiAAGSEsBEkSJigECi/9JiYoBAIv/VwAIgAEAEkSJigAAggIE2T83TgsAAyoABmhlbGxvMVCwggIEHnKvThYABAALAAVoZWxsbwADKgAGaGVsbG8yULCJigEAi/9BACeCAgQRxUe6HQAAAAAAAAAqAAAAAAAAACsAEgADKgAGaGVsbG8zULCJigAEKSUqK4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 2, + "num_uints": 1 + }, + "local_state_schema": { + "num_byte_slices": 2, + "num_uints": 1 + }, + "version": null + } + }, + { + "created_at_round": 48160169, + "deleted": false, + "deleted_at_round": null, + "id_": 733078310, + "params": { + "approval_program": "CiADAQAEJgMEFR98dQSf2DX4AgAEMRhAACCAFGdsb2JhbF9zdGF0ZV9iaWdfaW50gc2YoKfWoao7ZzEbQQDfgAT+a99pKYIGBOpFE9ME7zRjvAQWiv26BI6nUNIEcT1y5AQLkZhONhoAjggAjQBzAFgASQA6ACQAFQACI0MxGRREMRhENhoBiAD0KExQsCJDMRkURDEYRCg2GgFQsCJDMRkURDEYRDYaATYaAogAjyhMULAiQzEZFEQxGEQoNhoBULAiQzEZFEQxGEQoNhoBULAiQzEZFEQxGEQ2GgFXAgBJFRZXBgJMUChMULAiQzEZFEQxGEQxFiIJSTgQIhJEiAAzKExQsCJDMRkURDEYRDYaATYaAogAEShMULAiQzEZQP9YMRgURCJDigIBi/4Xi/8XCBaJigEBi/84CBaJigIBi/8jWYv/gQJZi/9PAksCUov/FYv/TwNPAlJLARUkCBZXBgIqTFBPAlBMUIv+FSQIFlcGAipMUIv+UExQiYoBATEAsYGgjQayCLIHIrIQI7IBtov/F7IYKbIagQayECOyAbO3AT5JVwQATFcABCgSRIk=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "Z2xvYmFsX3N0YXRlX2JpZ19pbnQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 33399922244455501 + } + } + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 47943829, + "deleted": false, + "deleted_at_round": null, + "id_": 732773208, + "params": { + "approval_program": "CiADAQIEJgIEFR98dQIABDEbQQFVgAT+a99pgASf2DX4gATqRRPTgATvNGO8gAQWiv26gASOp1DSgARxPXLkgAQOGJh9gAT6J+dBgAT+85NWgARfH5cTNhoAjgsAAQAXADEATwBiAHUAiwCeAK0A0gDlADEZFEQxGEQ2GgE2GgKIAPEoTFCwIkMxGRREMRhEMRYiCUk4ECISRIgA4yhMULAiQzEZFEQxGEQ2GgFXAgCIANZJFRZXBgJMUChMULAiQzEZFEQxGEQ2GgGIAMEoTFCwIkMxGRREMRhENhoBiAC0KExQsCJDMRkURDEYRDYaATYaAogApChMULAiQzEZFEQxGEQ2GgGIAM8oTFCwIkMxGRREMRhENhoBiADCIkMxGRREMRhEMRYjCUk4ECISRDEWIglJOBCBBhJEiAC8KExQsCJDMRkURDEYRDYaAYgAuShMULAiQzEZFEQxGEQ2GgGIAKwoTFCwIkMxGRREMRgURCJDigIBi/4Xi/8XCBaJigEBi/84CBaJigEBi/+JigEBi/+JigEBi/+JigIBi/+BAFmL/yNZi/9PAksCUkyL/xWL/04CUkxJFSQIFlcGAilMUExQTFCL/hUkCBZXBgIpTFCL/lBMUImKAQGL/4mKAQCAEmdsb2JhbF9zdGF0aWNfaW50c4v/Z4mKAgGL/zgXSRUWVwYCTFCJigEBi/+JigEBi/9XABBJVwAIF0xXCAgXCBaL/1cQEElXAAgXTFcICBcJFlCJ", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + } + ], + "created_assets": [ + { + "created_at_round": 42227833, + "deleted": false, + "destroyed_at_round": null, + "id_": 705457144, + "params": { + "clawback": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "decimals": 0, + "default_frozen": false, + "freeze": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "manager": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "metadata_hash": null, + "name": "gold nugget", + "name_b64": "Z29sZCBudWdnZXQ=", + "reserve": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "total": 1, + "unit_name": "piece", + "unit_name_b64": "cGllY2U=", + "url": "https://path/to/my/asset/details", + "url_b64": "aHR0cHM6Ly9wYXRoL3RvL215L2Fzc2V0L2RldGFpbHM=" + } + } + ], + "created_at_round": 42225822, + "deleted": false, + "incentive_eligible": null, + "last_heartbeat": null, + "last_proposed": null, + "min_balance": 3355500, + "participation": null, + "pending_rewards": 0, + "reward_base": 27521, + "rewards": 0, + "round_": 57772761, + "sig_type": "sig", + "status": "Offline", + "total_apps_opted_in": 0, + "total_assets_opted_in": 1, + "total_box_bytes": 0, + "total_boxes": 0, + "total_created_apps": 21, + "total_created_assets": 1 + }, + "current_round": 57772761 +} diff --git a/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts_account_id_apps_local_state/test_basic_request_and_response_validation.json b/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts_account_id_apps_local_state/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..ea4dd44f --- /dev/null +++ b/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts_account_id_apps_local_state/test_basic_request_and_response_validation.json @@ -0,0 +1,5 @@ +{ + "apps_local_states": null, + "current_round": 57774717, + "next_token": null +} diff --git a/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts_account_id_assets/test_basic_request_and_response_validation.json b/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts_account_id_assets/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..2da0c481 --- /dev/null +++ b/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts_account_id_assets/test_basic_request_and_response_validation.json @@ -0,0 +1,14 @@ +{ + "assets": [ + { + "amount": 0, + "asset_id": 705457144, + "deleted": false, + "is_frozen": false, + "opted_in_at_round": 42227833, + "opted_out_at_round": null + } + ], + "current_round": 57774717, + "next_token": "705457144" +} diff --git a/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts_account_id_created_applications/test_basic_request_and_response_validation.json b/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts_account_id_created_applications/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..38ad59b5 --- /dev/null +++ b/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts_account_id_created_applications/test_basic_request_and_response_validation.json @@ -0,0 +1,691 @@ +{ + "applications": [ + { + "created_at_round": 42225864, + "deleted": false, + "deleted_at_round": null, + "id_": 705408386, + "params": { + "approval_program": "CiADAAEEJgYLYXVjdGlvbl9lbmQMcHJldmlvdXNfYmlkD3ByZXZpb3VzX2JpZGRlcgNhc2EKYXNhX2Ftb3VudAVjbGFpbTEYQAADiAGjMRtBAKaABCgmsgKABPCqcCOABDDG1YqABNt/6EOABOZUYluABB7BK+82GgCOBgABABMAMQA9AFMAXwAxGRREMRhENhoBF8AwiABqI0MxGRREMRhENhoBFzYaAhcxFiMJSTgQJBJEiABwI0MxGRREMRhEiACQI0MxGRREMRhEMRYjCUk4ECMSRIgAfiNDMRkURDEYRIgAoiNDMRkURDEYRDYaARfAMIgAzyNDMRkURDEYFEQjQ4oBADEAMgkSRCIrZUQURCuL/2exMgqL/7IRshQkshAisgGziYoDADEAMgkSRCIoZUQURIv/OBQyChJEi/84EicETGcyB4v+CChMZymL/WeJigAAiYoBADIHIihlRAxEi/84AEkxABJEi/84CCIpZURLAQxEKUsBZypPAmcxACcFTwJmiYoAADEAIicFY0xJTwJEMQAiKmVEEkEACiIpZUSLAEwJjAGxMQCyB4sBSbIII7IQIrIBszEAiwBPAgknBUxmiYoBADIHIihlRA1EsSIqZUQiKmVEIicEZUSyErIUshWL/7IRJLIQIrIBs4mKAAAoImcpImcnBCJnKyJnKjIDZ4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "cHJldmlvdXNfYmlk", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlkZGVy", + "value": { + "bytes_": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", + "type_": 1, + "uint": 0 + } + }, + { + "key": "YXNh", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "YXNhX2Ftb3VudA==", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + } + ], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 4 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "version": null + } + }, + { + "created_at_round": 42225963, + "deleted": false, + "deleted_at_round": null, + "id_": 705410358, + "params": { + "approval_program": "CCADAAEEJgYLaGlnaGVzdF9iaWQDYXNhDmhpZ2hlc3RfYmlkZGVyC2F1Y3Rpb25fZW5kB2FzYV9hbXQAMRsiEkAA+DYaAIAEKCayAhJAANc2GgCABPCqcCMSQACcNhoAgAQ5BCruEkAAaDYaAIAEtYkGhhJAAEw2GgCABMkBKDESQAAeNhoAgAQkN408EkAAAQAxGYEFEjEYIhMQRIgBmCNDMRkiEjEYIhMQRDYaASJVNQU2GgIiVTUGNAU0BogBWCNDMRkiEjEYIhMQRIgBPiNDMRkiEjEYIhMQRDYaASJVNQQxFiMJNQM0AzgQIxJENAM0BIgA2iNDMRkiEjEYIhMQRDYaARc1ADYaAhc1ATEWIwk1AjQCOBAkEkQ0ADQBNAKIAGcjQzEZIhIxGCITEEQ2GgEiVYgAKSNDMRkiEkAAAQAxGCISRIgAAiNDigAAKSJnJwQiZysiZygiZyonBWeJigEAMQAyCRJEKWQiEkQpi//AMGexJLIQIrIBMgqyFIv/wDCyESKyErOJigMAMQAyCRJEK2QiEkSL/zgUMgoSRIv/OBEpZBJEJwSL/zgSZysyB4v+CGcoi/1niYoCALEjshCL/rIHi/+yCCKyAbOJigIAMgcrZAxEi/44CChkDUSL/jgAMQASRIv+OAcyChJEKmQnBRNBAAcqZChkiP+8KIv+OAhnKov+OABniYoAADIJKGSI/6WJigIAsSSyECKyASlkshEnBGSyEipkshSL/8AcshWziYoAALEjshAisgEyCbIHMgmyCSKyCLOJ", + "clear_state_program": "CIEAQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "aGlnaGVzdF9iaWQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 10000 + } + }, + { + "key": "aGlnaGVzdF9iaWRkZXI=", + "value": { + "bytes_": "", + "type_": 1, + "uint": 0 + } + }, + { + "key": "YXNh", + "value": { + "bytes_": "", + "type_": 2, + "uint": 705457144 + } + }, + { + "key": "YXNhX2FtdA==", + "value": { + "bytes_": "", + "type_": 2, + "uint": 1 + } + }, + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 1721928880 + } + } + ], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 4 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 42354158, + "deleted": false, + "deleted_at_round": null, + "id_": 708093293, + "params": { + "approval_program": "CiACAQgmAQQVH3x1MRtBAJ6ABP5r32mABHPAS02ABOAER0WABHjNzgWABIMeel82GgCOBQABABcANQBIAF4AMRkURDEYRDYaATYaAogAaihMULAiQzEZFEQxGEQ2GgFXAgCIAGBJFRZXBgJMUChMULAiQzEZFEQxGEQ2GgGIAEsoTFCwIkMxGRREMRhENhoBNhoCiAA7KExQsCJDMRkURDEYRDYaAYgANihMULAiQzEZFEQxGBREIkOKAgGL/heL/xcIFomKAQGL/4mKAQGL/4mKAgGL/xcjC4v+TCNYiYoBAYv/iQ==", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 42377330, + "deleted": false, + "deleted_at_round": null, + "id_": 709373991, + "params": { + "approval_program": "CiABASYBBBUffHUxG0EAfoAEV3/iSYAEFW7njDYaAI4CAAEAUwAxGRREMRhENhoBNhoCNhoDNhoENhoFNhoGNhoHNhoINhoJNhoKNhoLNhoMNhoNNhoONhoPVwAINhoPVwgINhoPVxAINhoPVxgIiAAmKExQsCJDMRkURDEYRDYaATYaAogATyhMULAiQzEZFEQxGBREIkOKEgGL7ovvUIvwUIvxUIvyUIvzUIv0UIv1UIv2UIv3UIv4UIv5UIv6UIv7UIv8UIv9UIv+UIv/UIACABJMUImKAgGL/ov/UIk=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 42409494, + "deleted": false, + "deleted_at_round": null, + "id_": 709806536, + "params": { + "approval_program": "CiABATEbQQCKgATAPy4cNhoAjgEAAQAxGRREMRhENhoBNhoCNhoDNhoENhoFNhoGNhoHNhoINhoJNhoKNhoLNhoMNhoNNhoONhoPVwAINhoPVwgINhoPVxAINhoPVxgBF8AwNhoPVxkINhoPVyEBF8AyMRYiCUk4ECISRDYaD1ciARfAHIgAFYAEFR98dUxQsCJDMRkURDEYFEQiQ4oWAYvqi+tQi+xQi+1Qi+5Qi+9Qi/BQi/FQi/JQi/NQi/RQi/VQi/ZQi/dQi/hQi/lQi/pQi/xQsIv7Fov9Fov/cwBEFov+OBdJFRZXBgJMUE8DTwNQTwJQgAIAGlBMUIk=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 42416068, + "deleted": false, + "deleted_at_round": null, + "id_": 709982020, + "params": { + "approval_program": "CiACAQQmAQIABDEbQQApgASOp1DSNhoAjgEAAQAxGRREMRhENhoBNhoCiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigIBi/+BAFmL/4ECWYv/TwJLAlJMi/8Vi/9OAlJMSRUjCBZXBgIoTFBMUExQi/4VIwgWVwYCKExQi/5QTFCJ", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 42670849, + "deleted": false, + "deleted_at_round": null, + "id_": 713725461, + "params": { + "approval_program": "CiABASYBBBUffHUxG0EAPIAEryCdjIAEcT1y5DYaAI4CAAEAFAAxGRREMRhENhoBiAAjKExQsCJDMRkURDEYRDYaAYgAFihMULAiQzEZFEQxGBREIkOKAQGL/4mKAQGL/4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 43110878, + "deleted": false, + "deleted_at_round": null, + "id_": 716754254, + "params": { + "approval_program": "CiACAQQmAQIABDEbQQApgASOp1DSNhoAjgEAAQAxGRREMRhENhoBNhoCiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigIBi/+BAFmL/4ECWYv/TwJLAlJMi/8Vi/9OAlJMSRUjCBZXBgIoTFBMUExQi/4VIwgWVwYCKExQi/5QTFCJ", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 43267993, + "deleted": false, + "deleted_at_round": null, + "id_": 717891588, + "params": { + "approval_program": "CiADAAEEJgYLYXVjdGlvbl9lbmQMcHJldmlvdXNfYmlkD3ByZXZpb3VzX2JpZGRlcgNhc2EKYXNhX2Ftb3VudAVjbGFpbTEYQAADiAGjMRtBAKaABCgmsgKABPCqcCOABDDG1YqABNt/6EOABOZUYluABB7BK+82GgCOBgABABMAMQA9AFMAXwAxGRREMRhENhoBF8AwiABqI0MxGRREMRhENhoBFzYaAhcxFiMJSTgQJBJEiABwI0MxGRREMRhEiACQI0MxGRREMRhEMRYjCUk4ECMSRIgAfiNDMRkURDEYRIgAoiNDMRkURDEYRDYaARfAMIgAzyNDMRkURDEYFEQjQ4oBADEAMgkSRCIrZUQURCuL/2exMgqL/7IRshQkshAisgGziYoDADEAMgkSRCIoZUQURIv/OBQyChJEi/84EicETGcyB4v+CChMZymL/WeJigAAiYoBADIHIihlRAxEi/84AEkxABJEi/84CCIpZURLAQxEKUsBZypPAmcxACcFTwJmiYoAADEAIicFY0xJTwJEMQAiKmVEEkEACiIpZUSLAEwJjAGxMQCyB4sBSbIII7IQIrIBszEAiwBPAgknBUxmiYoBADIHIihlRA1EsSIqZUQiKmVEIicEZUSyErIUshWL/7IRJLIQIrIBs4mKAAAoImcpImcnBCJnKyJnKjIDZ4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "YXNhX2Ftb3VudA==", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlk", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlkZGVy", + "value": { + "bytes_": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", + "type_": 1, + "uint": 0 + } + }, + { + "key": "YXNh", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + } + ], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 4 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "version": null + } + }, + { + "created_at_round": 43268243, + "deleted": false, + "deleted_at_round": null, + "id_": 717893078, + "params": { + "approval_program": "CiADAAEEJgYLYXVjdGlvbl9lbmQMcHJldmlvdXNfYmlkD3ByZXZpb3VzX2JpZGRlcgNhc2EKYXNhX2Ftb3VudAVjbGFpbTEYQAADiAGjMRtBAKaABCgmsgKABPCqcCOABDDG1YqABNt/6EOABOZUYluABB7BK+82GgCOBgABABMAMQA9AFMAXwAxGRREMRhENhoBF8AwiABqI0MxGRREMRhENhoBFzYaAhcxFiMJSTgQJBJEiABwI0MxGRREMRhEiACQI0MxGRREMRhEMRYjCUk4ECMSRIgAfiNDMRkURDEYRIgAoiNDMRkURDEYRDYaARfAMIgAzyNDMRkURDEYFEQjQ4oBADEAMgkSRCIrZUQURCuL/2exMgqL/7IRshQkshAisgGziYoDADEAMgkSRCIoZUQURIv/OBQyChJEi/84EicETGcyB4v+CChMZymL/WeJigAAiYoBADIHIihlRAxEi/84AEkxABJEi/84CCIpZURLAQxEKUsBZypPAmcxACcFTwJmiYoAADEAIicFY0xJTwJEMQAiKmVEEkEACiIpZUSLAEwJjAGxMQCyB4sBSbIII7IQIrIBszEAiwBPAgknBUxmiYoBADIHIihlRA1EsSIqZUQiKmVEIicEZUSyErIUshWL/7IRJLIQIrIBs4mKAAAoImcpImcnBCJnKyJnKjIDZ4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlk", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlkZGVy", + "value": { + "bytes_": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", + "type_": 1, + "uint": 0 + } + }, + { + "key": "YXNh", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "YXNhX2Ftb3VudA==", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + } + ], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 4 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "version": null + } + }, + { + "created_at_round": 43298070, + "deleted": false, + "deleted_at_round": null, + "id_": 718129252, + "params": { + "approval_program": "CiADAAEEJgYLYXVjdGlvbl9lbmQMcHJldmlvdXNfYmlkD3ByZXZpb3VzX2JpZGRlcgNhc2EKYXNhX2Ftb3VudAVjbGFpbTEYQAADiAGjMRtBAKaABCgmsgKABPCqcCOABDDG1YqABNt/6EOABOZUYluABB7BK+82GgCOBgABABMAMQA9AFMAXwAxGRREMRhENhoBF8AwiABqI0MxGRREMRhENhoBFzYaAhcxFiMJSTgQJBJEiABwI0MxGRREMRhEiACQI0MxGRREMRhEMRYjCUk4ECMSRIgAfiNDMRkURDEYRIgAoiNDMRkURDEYRDYaARfAMIgAzyNDMRkURDEYFEQjQ4oBADEAMgkSRCIrZUQURCuL/2exMgqL/7IRshQkshAisgGziYoDADEAMgkSRCIoZUQURIv/OBQyChJEi/84EicETGcyB4v+CChMZymL/WeJigAAiYoBADIHIihlRAxEi/84AEkxABJEi/84CCIpZURLAQxEKUsBZypPAmcxACcFTwJmiYoAADEAIicFY0xJTwJEMQAiKmVEEkEACiIpZUSLAEwJjAGxMQCyB4sBSbIII7IQIrIBszEAiwBPAgknBUxmiYoBADIHIihlRA1EsSIqZUQiKmVEIicEZUSyErIUshWL/7IRJLIQIrIBs4mKAAAoImcpImcnBCJnKyJnKjIDZ4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "YXNhX2Ftb3VudA==", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlk", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlkZGVy", + "value": { + "bytes_": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", + "type_": 1, + "uint": 0 + } + }, + { + "key": "YXNh", + "value": { + "bytes_": "", + "type_": 2, + "uint": 0 + } + } + ], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 4 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "version": null + } + }, + { + "created_at_round": 43334411, + "deleted": false, + "deleted_at_round": null, + "id_": 718348254, + "params": { + "approval_program": "CiABATEbQQAmgASlPlpBNhoAjgEAAQAxGRREMRhENhoBiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigEBi/+J", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 43453866, + "deleted": false, + "deleted_at_round": null, + "id_": 719046155, + "params": { + "approval_program": "CiABASYBBBUffHUxGEAAA4gA0jEbQQCMgAQx4uVggASPjC9xgATfX6OPgATxp30WgASsnZwXNhoAjgUAAQARACQANwBMADEZFEQxGESIAF4oTFCwIkMxGRREMRhENhoBiABZKExQsCJDMRkURDEYRDYaAYgATChMULAiQzEZFEQxGEQ2GgEXwBw2GgKIADkiQzEZFEQxGEQ2GgGIAEEoTFCwIkMxGRREMRgURCJDigABgAgAAAAAAAAAA4mKAQGL/4mKAQGL/4mKAgCL/xeL/oAJbG9jYWxfaW50TwJmiYoBAYv/iYoAAIAKZ2xvYmFsX2ludIEqZ4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "Z2xvYmFsX2ludA==", + "value": { + "bytes_": "", + "type_": 2, + "uint": 42 + } + } + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "version": null + } + }, + { + "created_at_round": 43487500, + "deleted": false, + "deleted_at_round": null, + "id_": 719241638, + "params": { + "approval_program": "CiABATEbQQAjgARv4y6HNhoAjgEAAQAxGRREMRhEiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigABgAMxMjNJFRZXBgJMUIk=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 43489481, + "deleted": false, + "deleted_at_round": null, + "id_": 719253364, + "params": { + "approval_program": "CiABASYBBBUffHUxG0EAX4AEQdnf4YAEL8rd9oAEnL09PTYaAI4DAAEAGQAxADEZFEQxGESIAEFJFRZXBgJMUChMULAiQzEZFEQxGESIADJJFRZXBgJMUChMULAiQzEZFEQxGESIACQWKExQsCJDMRkURDEYFEQiQ4oAAYADYXNkiYoAAYAEQUJDRImKAAEiiQ==", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 43489614, + "deleted": false, + "deleted_at_round": null, + "id_": 719254146, + "params": { + "approval_program": "CiABASYBBBUffHUxG0EAX4AEQdnf4YAEL8rd9oAEnL09PTYaAI4DAAEAGQAxADEZFEQxGESIAEFJFRZXBgJMUChMULAiQzEZFEQxGESIADNJFRZXBgJMUChMULAiQzEZFEQxGESIACkWKExQsCJDMRkURDEYFEQiQ4oAAYAEdGVzdImKAAGACEFRSURCQT09iYoAAYEziQ==", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 43715014, + "deleted": false, + "deleted_at_round": null, + "id_": 720689424, + "params": { + "approval_program": "CiABATEbQQAmgARBbn/KNhoAjgEAAQAxGRREMRhENhoBiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigEBi/+BAFmL/4EKWYv/TgJSiQ==", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 43777502, + "deleted": false, + "deleted_at_round": null, + "id_": 721104877, + "params": { + "approval_program": "CiABATEbQQA1gAQjqAI8NhoAjgEAAQAxGRREMRhENhoBF8AwNhoCF8AyNhoDF8AciAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigMBi/0Wi/4WUIk=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 46110739, + "deleted": false, + "deleted_at_round": null, + "id_": 729762198, + "params": { + "approval_program": "CiAEAQAKeyYEBBUffHUHAAP/AAJIaQVIZWxsbwH/iAABQ4oAATEbQQDSggcETFxhugSX6OSnBHbE3hEEwcp3CQRt52LCBFn8UoIEnZ7ssDYaAI4HAAIADAAjADYARQBRAGIjiSIxGZCBAxpEIokxGRREMRhENhoBNhoCiACaFihMULAiiTEZFEQxGEQ2GgGIAJwoTFCwIokxGRREMRhENhoBiACpIokxGRREMRhEiACrIokxGRREMRhENhoBI1OIANMiiTEZFEQxGESIAPdPAhZLAhUWVwYCTwNQSwMVgQ0IgAIADU8DUEwWVwYCUE8CUE8CUExQKExQsCKJMRmNBgACAAIACgAKAAoABCOJIokxGBREIokjiYoCAYv+JFmL/hWL/k4CUov/EkSBKomKAQGL/yRZi/8Vi/9OAlJJiAAGSEsBEkSJigECi/9JiYoBAIv/VwAIgAEAEkSJigAAggIE2T83TgsAAyoABmhlbGxvMVCwggIEHnKvThYABAALAAVoZWxsbwADKgAGaGVsbG8yULCJigEAi/9BACeCAgQRxUe6HQAAAAAAAAAqAAAAAAAAACsAEgADKgAGaGVsbG8zULCJigAEKSUqK4k=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 2, + "num_uints": 1 + }, + "local_state_schema": { + "num_byte_slices": 2, + "num_uints": 1 + }, + "version": null + } + }, + { + "created_at_round": 47943829, + "deleted": false, + "deleted_at_round": null, + "id_": 732773208, + "params": { + "approval_program": "CiADAQIEJgIEFR98dQIABDEbQQFVgAT+a99pgASf2DX4gATqRRPTgATvNGO8gAQWiv26gASOp1DSgARxPXLkgAQOGJh9gAT6J+dBgAT+85NWgARfH5cTNhoAjgsAAQAXADEATwBiAHUAiwCeAK0A0gDlADEZFEQxGEQ2GgE2GgKIAPEoTFCwIkMxGRREMRhEMRYiCUk4ECISRIgA4yhMULAiQzEZFEQxGEQ2GgFXAgCIANZJFRZXBgJMUChMULAiQzEZFEQxGEQ2GgGIAMEoTFCwIkMxGRREMRhENhoBiAC0KExQsCJDMRkURDEYRDYaATYaAogApChMULAiQzEZFEQxGEQ2GgGIAM8oTFCwIkMxGRREMRhENhoBiADCIkMxGRREMRhEMRYjCUk4ECISRDEWIglJOBCBBhJEiAC8KExQsCJDMRkURDEYRDYaAYgAuShMULAiQzEZFEQxGEQ2GgGIAKwoTFCwIkMxGRREMRgURCJDigIBi/4Xi/8XCBaJigEBi/84CBaJigEBi/+JigEBi/+JigEBi/+JigIBi/+BAFmL/yNZi/9PAksCUkyL/xWL/04CUkxJFSQIFlcGAilMUExQTFCL/hUkCBZXBgIpTFCL/lBMUImKAQGL/4mKAQCAEmdsb2JhbF9zdGF0aWNfaW50c4v/Z4mKAgGL/zgXSRUWVwYCTFCJigEBi/+JigEBi/9XABBJVwAIF0xXCAgXCBaL/1cQEElXAAgXTFcICBcJFlCJ", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + { + "created_at_round": 48160169, + "deleted": false, + "deleted_at_round": null, + "id_": 733078310, + "params": { + "approval_program": "CiADAQAEJgMEFR98dQSf2DX4AgAEMRhAACCAFGdsb2JhbF9zdGF0ZV9iaWdfaW50gc2YoKfWoao7ZzEbQQDfgAT+a99pKYIGBOpFE9ME7zRjvAQWiv26BI6nUNIEcT1y5AQLkZhONhoAjggAjQBzAFgASQA6ACQAFQACI0MxGRREMRhENhoBiAD0KExQsCJDMRkURDEYRCg2GgFQsCJDMRkURDEYRDYaATYaAogAjyhMULAiQzEZFEQxGEQoNhoBULAiQzEZFEQxGEQoNhoBULAiQzEZFEQxGEQ2GgFXAgBJFRZXBgJMUChMULAiQzEZFEQxGEQxFiIJSTgQIhJEiAAzKExQsCJDMRkURDEYRDYaATYaAogAEShMULAiQzEZQP9YMRgURCJDigIBi/4Xi/8XCBaJigEBi/84CBaJigIBi/8jWYv/gQJZi/9PAksCUov/FYv/TwNPAlJLARUkCBZXBgIqTFBPAlBMUIv+FSQIFlcGAipMUIv+UExQiYoBATEAsYGgjQayCLIHIrIQI7IBtov/F7IYKbIagQayECOyAbO3AT5JVwQATFcABCgSRIk=", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": [ + { + "key": "Z2xvYmFsX3N0YXRlX2JpZ19pbnQ=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 33399922244455501 + } + } + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + } + ], + "current_round": 57774717, + "next_token": "733078310" +} diff --git a/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts_account_id_created_assets/test_basic_request_and_response_validation.json b/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts_account_id_created_assets/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..05c557a4 --- /dev/null +++ b/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts_account_id_created_assets/test_basic_request_and_response_validation.json @@ -0,0 +1,29 @@ +{ + "assets": [ + { + "created_at_round": 42227833, + "deleted": false, + "destroyed_at_round": null, + "id_": 705457144, + "params": { + "clawback": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "decimals": 0, + "default_frozen": false, + "freeze": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "manager": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "metadata_hash": null, + "name": "gold nugget", + "name_b64": "Z29sZCBudWdnZXQ=", + "reserve": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "total": 1, + "unit_name": "piece", + "unit_name_b64": "cGllY2U=", + "url": "https://path/to/my/asset/details", + "url_b64": "aHR0cHM6Ly9wYXRoL3RvL215L2Fzc2V0L2RldGFpbHM=" + } + } + ], + "current_round": 57774717, + "next_token": "705457144" +} diff --git a/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts_account_id_transactions/test_basic_request_and_response_validation.json b/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts_account_id_transactions/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..0fdb5115 --- /dev/null +++ b/tests/modules/indexer_client/__snapshots__/test_get_v2_accounts_account_id_transactions/test_basic_request_and_response_validation.json @@ -0,0 +1,9734 @@ +{ + "current_round": 57772761, + "next_token": "nlCEAgAAAAABAAAA", + "transactions": [ + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 52406089, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 52406085, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "GTFDMF7TDGBT73MSYJTTDMMTJVLP5JRONW4TVDHH764JNQ6JXV4Q", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 52406285, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 1000000, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1749466145, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "qZrOYBMZjkrdUK5GJ9x/th2PsdjlESjLg35dgjcxp4Hn+b5Llc+E8IqurzJwfggz88iw5iVwxpdxcKaZuXtMAA==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 52406084, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 52406081, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "YLBWRMCQP7S3JTNFDCNEVZUNTRD46DTSYCBFWOJ7NMJE4EXIELYQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 52406281, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 1000000, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1749466131, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "9oUk+sDme7cslSGBHEU06ncv9yyz/VP02aYGbzflyitvgCG38Ei8nI9I6id6SMtHW+TdNHKS07Jwvt+jm5x8CQ==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAI=" + ], + "application_id": 733078310, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 48160209, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 48160207, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "NVHVUGFN4EMYAC4MSC47GBAW3YR2V3KEV2AMNBTYTUQETPRGFBEA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 48160407, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAD" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1738046482, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "lfkoJJ4EpaCalqS4ES/4jAKjidwrpbbs77tHtZJ4Pqmgoyrd0uGE3hKJ1qI/4+bsN0SvYtC/CTPWxlqi2xe1Aw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "n9g1+A==" + ], + "application_id": 733078310, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 48160189, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 48160185, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": "BeNvPf6T8vc4x8p0Yn7RFOimBEeRV5XwJVfC8gHsMDo=", + "heartbeat_transaction": null, + "id_": "EM4HTYPG2QG22PNLSN6FFF4JF5ECCE3TFFCHMUEE2W6KUS5O3DOQ", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 48160385, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAACcQ" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1738046428, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "+n+qN9JKjWNxSsOk4cArj7mAno3ykOTGGvwlnse6nJYK4hWSrKYcJOJhrYZX+7BTFJ5XWHIeNLdImBfpv6YcDQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 48160189, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 48160185, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": "BeNvPf6T8vc4x8p0Yn7RFOimBEeRV5XwJVfC8gHsMDo=", + "heartbeat_transaction": null, + "id_": "DTSRZQI4DNQE4GURDFQNEIZEDCZBF26MUDSFFM3AQYELONRGSFTA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 48160385, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 10000, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1738046428, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "SyJ7ic9NHoxa1Xu2NzAlKtlJWjU3/wpLFP9tJ9rNMf458rV9EBKF6YPZ06AY03H73NgCHHy8prqExnzCc1sWAA==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": null, + "application_id": 0, + "approval_program": "CiADAQAEJgMEFR98dQSf2DX4AgAEMRhAACCAFGdsb2JhbF9zdGF0ZV9iaWdfaW50gc2YoKfWoao7ZzEbQQDfgAT+a99pKYIGBOpFE9ME7zRjvAQWiv26BI6nUNIEcT1y5AQLkZhONhoAjggAjQBzAFgASQA6ACQAFQACI0MxGRREMRhENhoBiAD0KExQsCJDMRkURDEYRCg2GgFQsCJDMRkURDEYRDYaATYaAogAjyhMULAiQzEZFEQxGEQoNhoBULAiQzEZFEQxGEQoNhoBULAiQzEZFEQxGEQ2GgFXAgBJFRZXBgJMUChMULAiQzEZFEQxGEQxFiIJSTgQIhJEiAAzKExQsCJDMRkURDEYRDYaATYaAogAEShMULAiQzEZQP9YMRgURCJDigIBi/4Xi/8XCBaJigEBi/84CBaJigIBi/8jWYv/gQJZi/9PAksCUov/FYv/TwNPAlJLARUkCBZXBgIqTFBPAlBMUIv+FSQIFlcGAipMUIv+UExQiYoBATEAsYGgjQayCLIHIrIQI7IBtov/F7IYKbIagQayECOyAbO3AT5JVwQATFcABCgSRIk=", + "box_references": null, + "clear_state_program": "CoEBQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 48160169, + "created_app_id": 733078310, + "created_asset_id": null, + "fee": 1000, + "first_valid": 48160166, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": [ + { + "key": "Z2xvYmFsX3N0YXRlX2JpZ19pbnQ=", + "value": { + "action": 2, + "bytes_": null, + "uint": 33399922244455501 + } + } + ], + "group": null, + "heartbeat_transaction": null, + "id_": "CYUSHREHH7CPCUO5XRW6A6PSQPPRD6USM5OZ5N6OEJJOBI2MNZFA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 48160366, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "QUxHT0tJVF9ERVBMT1lFUjpqeyJuYW1lIjoiVGVzdENvbnRyYWN0IiwidmVyc2lvbiI6IjEuMCJ9", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1738046375, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "+c9ARW87x9ehPuBZbRGnWyaJjol0VVxMfu1iJdFD66kPKHbfTLTVO5gp3PYb0prRtOpYU6ydJGdz7ykD08qIAg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 47943891, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 47943888, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "B56BUFXZCU3MCWRXZ4A7NVHHJHHAH4CLMLQ5LWEZ2567YDSFQ4JA", + "inner_txns": null, + "intra_round_offset": 9, + "keyreg_transaction": null, + "last_valid": 47944088, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 20000, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1737461598, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "hGMjRxxWQk/Ydx14umQ7oReVhJifBSyQDsNiUmqawxIiC+4ZfXG7nhe9UbJpZZRBPcCgGPsjF3tn7wKV+4wsDw==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 47943846, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 47943842, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": "0juEZckbk2qT4zC6P9ANgdS8YcpqXe4s+IENrgnoOv0=", + "heartbeat_transaction": null, + "id_": "ZZL2IWZ7IPWVYR64UFUW6DAJOC4CBQGEPBEU4A5VHSF4ANR2NJYQ", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 47944042, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 10000, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1737461478, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "t07pnFYlp+wpfFdIU4p+7FBOmB2INCaWZbgMKd3ZECWCPUT/t+x0dd+1wVcMU9Ah+QW6Pdaby3PgrmvblyIRDg==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAE=" + ], + "application_id": 732773208, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 47943846, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 47943842, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": "0juEZckbk2qT4zC6P9ANgdS8YcpqXe4s+IENrgnoOv0=", + "heartbeat_transaction": null, + "id_": "6WK5K5VJIOMUL7V3FKB73CD43CJEPECQ3WWNARDRVF6PJGIX7QSA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 47944042, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAC" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1737461478, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "SGdBnJGjvhqTChvK/B21GZSdpdF/lbaSyp2I0snhNj6D+TryqYGrtO+GXAkVH311gxWpd89jl0FGJdph5YEmBQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": null, + "application_id": 0, + "approval_program": "CiADAQIEJgIEFR98dQIABDEbQQFVgAT+a99pgASf2DX4gATqRRPTgATvNGO8gAQWiv26gASOp1DSgARxPXLkgAQOGJh9gAT6J+dBgAT+85NWgARfH5cTNhoAjgsAAQAXADEATwBiAHUAiwCeAK0A0gDlADEZFEQxGEQ2GgE2GgKIAPEoTFCwIkMxGRREMRhEMRYiCUk4ECISRIgA4yhMULAiQzEZFEQxGEQ2GgFXAgCIANZJFRZXBgJMUChMULAiQzEZFEQxGEQ2GgGIAMEoTFCwIkMxGRREMRhENhoBiAC0KExQsCJDMRkURDEYRDYaATYaAogApChMULAiQzEZFEQxGEQ2GgGIAM8oTFCwIkMxGRREMRhENhoBiADCIkMxGRREMRhEMRYjCUk4ECISRDEWIglJOBCBBhJEiAC8KExQsCJDMRkURDEYRDYaAYgAuShMULAiQzEZFEQxGEQ2GgGIAKwoTFCwIkMxGRREMRgURCJDigIBi/4Xi/8XCBaJigEBi/84CBaJigEBi/+JigEBi/+JigEBi/+JigIBi/+BAFmL/yNZi/9PAksCUkyL/xWL/04CUkxJFSQIFlcGAilMUExQTFCL/hUkCBZXBgIpTFCL/lBMUImKAQGL/4mKAQCAEmdsb2JhbF9zdGF0aWNfaW50c4v/Z4mKAgGL/zgXSRUWVwYCTFCJigEBi/+JigEBi/9XABBJVwAIF0xXCAgXCBaL/1cQEElXAAgXTFcICBcJFlCJ", + "box_references": null, + "clear_state_program": "CoEBQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 47943829, + "created_app_id": 732773208, + "created_asset_id": null, + "fee": 1000, + "first_valid": 47943825, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "SZU2VR2GTN3EUDPSL7MDPZ6YK6DQYCQA6JIBRCFHK76YIUFLYNTA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 47944025, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "QUxHT0tJVF9ERVBMT1lFUjpqeyJuYW1lIjoiVGVzdENvbnRyYWN0IiwidmVyc2lvbiI6IjEuMCJ9", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1737461433, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "j22Un7+1SkqWCqd7w4L6xwTAWfJPaBOnHXhf/xmdu4hVHqBD6gdF76Ovp+NhHNMbvidGRyBbawM/JuxVNjI+BQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 47711200, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 47711196, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "YHGP3Z6G45WMF5GPSNB2GO3PY247LOYX2MBHMPT63XWIU227GFEQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 47711206, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 1000000, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1736830678, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "G9OjDdmLMTSPIcATPx8VNY8xe1At4e3+37vcbjhbbHtUfy9p3of+YAMLby1xqe4SC0igcAmyUppeTNDvq6W4Bg==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 47710338, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 47710335, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "K6HPXBB5IAZ2JNKD6UX4BEDXIEKEN2W3IJVOZGUO66MBWBVHDU4Q", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 47710345, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 1000000, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1736828359, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "SRjXlQjzy0b30GV2K6HQgmztFH2J4Y3LtnGhbTVS+enrruBmW9YaZ+IDpJPyVt9KUqgZzYlJSjBZlpzIq+b8CQ==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 47709527, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 47709523, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "AIE5A6EPMXA2KVT7JUZ47ZRIQUT6R27OXSMN375QD6DVLSLDUUYA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 47709533, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 1000000, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1736826182, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "N7ZaeTjt7ya+4qPahHvxvptqx+gslrwCShz7bwQPseh7WdWwof24yiIbz5ihLQwMrrpHvi1lLKIjmZw0bYRvAg==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 47709491, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 47709488, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "CQAI7HJBB2PS5GSD6BIJNNE5DE36CF6VLOGUFHHAYEMHYSO57ONQ", + "inner_txns": null, + "intra_round_offset": 9, + "keyreg_transaction": null, + "last_valid": 47709498, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 1000000, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1736826086, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "4siENMAdu/iV9rlEmplifOUizO1DJRaFm41T3w9BNISYv2zXF5uObI8/635xKcMfnIIcRF2rV8B++ENte58YDA==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAACA=", + "AAAAAAAAABc=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46783368, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46783365, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "EL226GU6CNKGKZAITLLURWF4AAANR5OAIE7RRZ7ZNN737GU6SSIQ", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 46783395, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAA3" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1734333054, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "EXPp+tNWxlkqU+F5NbXuPNsnx+U+w5x9c8DoVgF2kEZkO9I+1NsDUn+tu5CHW0dqqd8tbqn+h/mNgYA4P3NtCw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAM=", + "AAAAAAAAAAI=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46783287, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46783282, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "3XB6HLLSNGTQWFCHQJDNG3LVIIFQZKMSNE35PB7BJ73YBMLOUOQA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46783312, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAF" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1734332833, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "hsB1TKPonrZLjumvqWvg87V3f77TBXoOQzNBq1IxQa+xrlpHbAGihcQhtvr2HdR4ifhHjCF3cnBruXEQyFBbDQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAM=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46783261, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46783259, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "HOC5BXZK2HYELIR3VABDU2NVWK2NE6PWGKQCUJXGBNGNZGHTFZ3Q", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46783289, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAE" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1734332761, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "6B+2cIcQ7xaBLeMWXeN4QC67XvEKzq/DLemBOIPQTJnuwcBXwvvP39Se5PWnFgvLF3b6bq1Zzvz2aUnpBeqMDQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAE=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46616529, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46616526, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "MTOFFX47AJ6HRIHUFPWT32SQOOEEXJSBCZFIEFQHTMF73GKJHKYQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46616556, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAC" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1733875283, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "DUVu10y9L4bfHc/6wshH/9+BmuW0ZbI3WS7wKd6qEpCc2JxtFzI4Pb1gQwWrDTJTTKQmk91GrVTQJJL2qWs6AA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46372902, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46372900, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "ELC6ZNSQADEPWNLD3GZNQAHEAWOLBNW4QT5RYVSIWT3AWSORMXGA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46373900, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 0, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1733207728, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "VTM9wnodXBiJrQfZFWmyknadEmdWmL76eXAVKLGOYxBqzNnb6LToFaLMWLXeKkc5LwgRDslXjtTJm2GV9KWvCg==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46370587, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46370585, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "RIFOMQEJMWBJK63YR4UAW2I47OORBTLZPBBHYIGEMP42I37VO2BA", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 46371585, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "NTdkOGE4YjQtOGM5NC00OTQ2LWFhM2QtMDNkZDNjZDllNjMw", + "payment_transaction": { + "amount": 200000, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1733201414, + "sender": "A3Q4VQFQ5DLEIWCMUX6V7YFZ7BUPWUXWY4YVNJQODUODSQ7KVEFOZUNFUQ", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "kw/xucmqO7zct0INLa6fU8/+YldCpjrwwju0S3/DFrEXhNtUBA41lxb10YM1VqitTugh1inZYb0iz59X1o0ZDA==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46370272, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46370270, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "WZUMSVED52UNG4H7FARTHUVLM3FE2FAFA36IVU5FZTDFM5QST2UA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46371270, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "OTU1ZTg2MzUtY2UyNC00OWU0LTkxM2EtZmI4NzNlMzU0YjU0", + "payment_transaction": { + "amount": 2000000, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1733200557, + "sender": "A3Q4VQFQ5DLEIWCMUX6V7YFZ7BUPWUXWY4YVNJQODUODSQ7KVEFOZUNFUQ", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "TzfEqLKTo+Dz05V7CY8nMREbn0XjdnHdxanFNS4siafOo0yMPKea7MqMTQOFfWk/0ahgKfQljtRodUsYfVT5Aw==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAI=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46204306, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46204303, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "IJIMCA4E7HYDG66Y4T6VROS2UVHZW2X5FEM2SWSVZV55JFJV7EBQ", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 46204333, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAD" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1732746809, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "NdHSCpqH4ooL8jK4LlYUzOxPd+SShrSrybRHIkg9JicHx0vUeEb568FhMCyz+aAvMoTCkGRK51PWj3bbSH/gCA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46182886, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46182884, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "QSVI67NON47OJ54N324TQS5JNMIUIILIHFBH4WVCJPV3J5VUCFUA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46183884, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "NGJhNjNmMDAtOTg4OS00MDU3LWFmYmQtNTE4MzUyNmIwY2E2", + "payment_transaction": { + "amount": 2000000, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1732688397, + "sender": "A3Q4VQFQ5DLEIWCMUX6V7YFZ7BUPWUXWY4YVNJQODUODSQ7KVEFOZUNFUQ", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "51b1oWtZP6EL1ADUbpo0A074yZNoFvgq4Pe2S50gUd1VrykpF3OO7ZCe5kflHbNukHOsv/dO23YeHwgP588YBg==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46160396, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46160392, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "6F6BTBEUUP47UBLN3UG653X63NSQXFWT6FB57M7AJDHSPTTC3PDQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46161392, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 0, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1732627038, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "ML+eI/qAujvXVkH5cQfHIMV4LonVE9D/6eCgTuxQodkLvLAP++jggfQ/fV4Mj0YsBhBuYzdXJY4AGfeCc3ybDQ==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46159295, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46159291, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "TZJEFE62OPINVRYV4TRGRH2EDXP5UKBCCASGCO4ULNLGIRPFHYVA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46160291, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 0, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1732624030, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "+l+U82F0q09U3fxTgduOMk0mR+6M/OIKIR/W2QyzHjxrpHOJo+a0GphJSHmRuoFAYtHC7eK+fNbzLGP+leuXAQ==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "c8BLTQ==", + "AAA=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46149138, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46149134, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "UMAWEDJM3QDKEFFJH7FC6C4EK4PKRDBATMQC6NKL2BHTRXEBD2FA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46149164, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAA" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1732596260, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "7LT8DVjk7JKcf3Nc7pDX5hop8evEKAGYQTh4fn6aCREKwH/9/bB+2vF4yvSwiqGV3UynKuN+rvW5vz2rkI3UDw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "c8BLTQ==", + "AAA=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46149130, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46149124, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "XJTJHJWOX44TE46HXWQ3F4MYQW6VTLQ3P4QYR274PYGUBSBXUY6Q", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46149154, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAA" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1732596238, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "igUZMMJ2Czt+/3afR1N3qQUc0FSDxd6BB7qZ6njgMnEfH5w+A0UjziXyykFthDlOB4PekmbMaXDgCLYzMYcEDw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "c8BLTQ==", + "AAA=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46149115, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46149112, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "CR253GUUSMA27U3LTRO5ADV6CXMGFPGC4PKVRVTUV3PCPIZB4NDQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46149142, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAA" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1732596197, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "F7IwIzzyV1/pKH0CkkBKmwFDuikxENL+tt3r2BiBIZyQl5oIhd6lZOBkGHIkL5GPWJsNYOnZ2nW1UHIL7uXTDQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAE=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46149109, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46149106, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "WPORTWXSJZAKZZGRY6GU3OAGEDXY2R2C6EJ2SVV33YMSBCGPVCJA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46149136, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAC" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1732596181, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "pcAvqjle1YMkU1cqxW4dTLG+C2A1hw7qDTa4pf6aHN5rA7Ly376C25RBjrASbZstZL3pdWSEQFFR9ThHdOv8AA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAE=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46118231, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46118226, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "K2M6MF7WCXI3JJA3KNEQUKGTXIONWFJOUDRHWYTLOG43V3OPK26Q", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46118256, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAC" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1732511876, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "ckBKlzNKd4FpDezj53OGV66ui60V6q0MQorUaVbET1hfwUXuuE++7kErJ6Vn268ID96bSfm+Xaf1T9rlRPiyCQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAE=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46117684, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46117681, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "63MYFYWI7GIIOKWWCZE6IUWHQFYSJYJV7O2IYSI6UTA2VPSM56CQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46117711, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAC" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1732510366, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "7cpGHZkt0FzlzXLykGtO/ynf5bDFv58WO5nxrhXOEdei5PKS2k+s84/Nd/v+wKCG+xk5kHs9wUGyLvHwubAtCg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAE=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46117671, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46117668, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "3MNAOGERKULE2L2XOPZX7I2QQK3SFGJAAFYJDMUFAGKJR45ZFMZA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46117698, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAC" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1732510330, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "Kfvpx0d8HYU8vFljXoXKmrXGg0Gux0lwRLq1k/P5dJ0HAWKrswu+cUA+OEJrfyvhbemIW/f/xi/T8rH5XO94Dw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAE=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46117566, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46117563, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "G4QKV5JTTUS3CAMWEXTQMGUWWSO4R2EK7YHHHBMXEB3MFF436RQA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46117593, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAC" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1732510041, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "7voAIFH3lhlibybfVzm/ccXP2YMpI7qrP/Ol3oQNl806FzdulIdaadXmPdwPx+2NvhXnbbyps+qTtGcDlgW+Aw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAE=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46117009, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46117007, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "ZIIPZBMLYFB4SDBK4AEWLY7XJ5HBO2F44WCVEIDA7MPATOEFQ42A", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46117037, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAC" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1732508510, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "fHf4xigzaBc3yvlZL5GqKQKxj3Qv8vxH9IthUSumo5f8l/bQeTFjIW51f/Un6TLWUyaII9rzxDrsvC80hCe6DA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAE=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46117004, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46117001, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "BA5L6FXENM5C5LZ7XT77XKXGKUUAC3ZXEUIICHOCXDWUROPAL3WA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46117031, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAC" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1732508497, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "pTV4LjdYfEgwGiXJAa3sgeaFpEivAR4bU8eFmmnWHYc3KbJ29Uy2oV8aPe1i+WSGdMHjvuuQxaCCfKVJughGDg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAE=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46111509, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46111506, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "XN33SOC3XR3X2ZFQSPMKJPJSHUBYV5V5SFP5IHBSS2KTSTPGSTAQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46111536, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAC" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1732493502, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "qTdt7fsMuJJwo2SoyxrpnJKJYbIYaLn/bmrZFrzEhntz4Q0+F6stLG5bgauFVZGQgHLmnvZn2T12hm2q8KjgDA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAE=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46111430, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46111426, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "HWETAEFTYGH2WHGDIXX253K2ZISZPQUKH7WZ6RZ3CTMPMTZNLFTA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46111456, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAC" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1732493286, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "x+MdMqBxg/ZbfJ2oL3YfrzyIrznMsvFY17SitCYqR5/NjJOMgoJVpENfZPhY+wpiweHtf9AAPrCQnDi+PFkSBA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAE=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46111284, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46111280, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "TXHJ3UV74ULAYQ7FQRAWOZCDAR5CUQAZIT3BLNXDBMYODPY2AEPA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46111310, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAC" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1732492884, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "xoF1X8ftjGxUtRzVaqu1y9a/X3Mi9TlWMXZ3tZJapktgyutPR+Vpg6Xbqu4clRPEQR7zg7+dvVBVnYsD3pJvAA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAE=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46111069, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46111067, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "VCYTFQJUBEASC7M3T3CXVOD2PPN6MBXY6X6UUFR5PL7YNR5DMRMA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46111097, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAC" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1732492300, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "VZvEopzF8xuqVHcXKqpxw6y/cKYF7kP5aGEvqamm4dr/T3/BPSwddFmhsuPAPOnend5B4iWfjLxoe2EakyTsAQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAE=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46110991, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46110988, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "IZ3UID3RNLZK7CAEOMRK2SC5IWKJRYMLDWMLYISTAQTHCLLSQWDQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46111018, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAC" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1732492088, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "luqbSduewhJSaVX+hXJ3RUyqsUxeyzet0hLosKNGGuHPy5ar6MqjA5rs/pxt0DyBpnKVIBzGbSikHR3Zc5R9Dw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "TFxhug==" + ], + "application_id": 0, + "approval_program": "CiAEAQAKeyYEBBUffHUHAAP/AAJIaQVIZWxsbwH/iAABQ4oAATEbQQDSggcETFxhugSX6OSnBHbE3hEEwcp3CQRt52LCBFn8UoIEnZ7ssDYaAI4HAAIADAAjADYARQBRAGIjiSIxGZCBAxpEIokxGRREMRhENhoBNhoCiACaFihMULAiiTEZFEQxGEQ2GgGIAJwoTFCwIokxGRREMRhENhoBiACpIokxGRREMRhEiACrIokxGRREMRhENhoBI1OIANMiiTEZFEQxGESIAPdPAhZLAhUWVwYCTwNQSwMVgQ0IgAIADU8DUEwWVwYCUE8CUE8CUExQKExQsCKJMRmNBgACAAIACgAKAAoABCOJIokxGBREIokjiYoCAYv+JFmL/hWL/k4CUov/EkSBKomKAQGL/yRZi/8Vi/9OAlJJiAAGSEsBEkSJigECi/9JiYoBAIv/VwAIgAEAEkSJigAAggIE2T83TgsAAyoABmhlbGxvMVCwggIEHnKvThYABAALAAVoZWxsbwADKgAGaGVsbG8yULCJigEAi/9BACeCAgQRxUe6HQAAAAAAAAAqAAAAAAAAACsAEgADKgAGaGVsbG8zULCJigAEKSUqK4k=", + "box_references": null, + "clear_state_program": "CoEBQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 2, + "num_uints": 1 + }, + "local_state_schema": { + "num_byte_slices": 2, + "num_uints": 1 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 46110739, + "created_app_id": 729762198, + "created_asset_id": null, + "fee": 1000, + "first_valid": 46110736, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "5TXBL4HM7GJR63XGZYVQ42VXDAIVORDVVE5EDN4A3L4VTI4BITEQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 46110766, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "QUxHT0tJVF9ERVBMT1lFUjpqeyJuYW1lIjoiQ29udHJhY3QiLCJ2ZXJzaW9uIjoiMS4wIn0=", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1732491400, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "xx1ZuADvVkZPgcXF1L8OUhJkYOzfQBnS1jwi9xiS43gQuMA419Vj50juiKIG9TV77j6wyzPzyh2DGgF/KzbiDA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 45068334, + "created_app_id": null, + "created_asset_id": null, + "fee": 0, + "first_valid": 45068331, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": "7tVOL7qNOjMx2DWpn3mvrWni0r0oPpOJ188FqX8EuJ4=", + "heartbeat_transaction": null, + "id_": "3XFLMOD6OVS7W77FGG6KLCNSDX7MZKIL5AGW2JR4IX5YDI5R2DTQ", + "inner_txns": null, + "intra_round_offset": 139, + "keyreg_transaction": null, + "last_valid": 45068341, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 0, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1729643716, + "sender": "T6BJNZLU2J5NDBNTIUDKSTZUQ2HMDHC7U2FUP7EWP4DXSCFLY6DFLWZGMM", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "vR1kaElF18kivhlkyRnObPQIzRpKkqsl38NPt6Nh29xrl0RFuMgCmiiUd2RspHWE2H9CuMHcGtubzK9mWx3eBA==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "j4wvcQ==", + "AAAAAAAAACo=" + ], + "application_id": 719046155, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 44376109, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 44376106, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "Z6A2GW3I4HZS42NFF5HKJH4ZNWXVK7QXGQ272CCOWVNQPJEH664Q", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 44376136, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAq" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1727752117, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "YgKU3GuylavMLhR3dDIVcJBUlbmyEFk9gLj7v+Si+Rr6wSvhJMc942Ge4kHysXWa4mLNgkhmWxbeNIsbU/3mDw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAI=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 44376100, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 44376098, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "RMTRRYIHE6AZJ2JIVKLULRATPRPRIQMXCLKO7OLGBKRNP6MO3WTQ", + "inner_txns": null, + "intra_round_offset": 2, + "keyreg_transaction": null, + "last_valid": 44376128, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAD" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1727752092, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "Q7OiGHQlSPu44a2snkAZsjbDqEAs1XKmErwqQtJ7mAUeN+iBHMBCAzY1AMG6x2E9ALYYzTWkieAUCMIm4VMZBw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "jqdQ0g==", + "AAEAAgACAAAAAAAAAAEAAAAAAAAAAg==", + "AAQAFgACAAAAAAAAAAEAAAAAAAAAAgABMw==" + ], + "application_id": 709982020, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 44343659, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 44343656, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "Z4E4YKPOHQBEX2Q4ZKC4TMCHFGHLEV7G5FBYNKE4TSH5BKXYECNA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 44343686, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAEABoAAQACAAIAAAAAAAAAAQAAAAAAAAACAAQAFgACAAAAAAAAAAEAAAAAAAAAAgABMw==" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1727663414, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "Jj+eOJJpd+qH8xNqJVnxiTqyWTm/RSRBuS/cBtBsfncTB2ef1EQegWFotmCTGMb0MEHyxEwla6+4rb/Ot5eBCQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "eM3OBQ==", + "AAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQ=", + "AAAAAAAAAAI=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 44343635, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 44343633, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "MEKECGEQMM5ZP73F76NPZTDD4NSYZRAWSDZFNQL3RW3OP4GIZMWA", + "inner_txns": null, + "intra_round_offset": 15, + "keyreg_transaction": null, + "last_valid": 44343663, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAD" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1727663349, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "Shm2fKnAnuJNS810Yq5m8tJQ16U3iyUxx7jBNd1GXcZrZt8WSsSIRmW4xaN1XbDw/0QPI6GgC5S5kDidEeQhBQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [ + "ELJEB3OYX325FATYL765AM5ZSJPSWZX745TYM5KCLTTSHJN2BJSHEMQ2JE" + ], + "application_args": [ + "I6gCPA==", + "AA==", + "AQ==", + "AQ==" + ], + "application_id": 721104877, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [ + 600011882 + ], + "foreign_assets": [ + 162491529 + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 44249878, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 44249876, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "WEQJBF3V5GSGZSK5ZHYLPF6DBDXIWM3LYMNSL2DFTQBVWYV5YXUQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 44249906, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAJr2yJAAAAACPDdGo=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1727407264, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "HFcHBZjnIzvjJkIwO0p9XGDO4R+AYLlv37zmDZ5ma6HQw236qR1SOf+EMJd7ymFL3Z1VlMHx+SaMX5MTcjIKBw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "31+jjw==", + "AAAAAAAAAAM=" + ], + "application_id": 719046155, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 44225160, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 44225157, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "M3JMAQKBYRTFFSKB5BC3L7OCG2LCZPBNJ76ZLSGEK5446RXNM53Q", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 44226157, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAD" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1727339830, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "gjwOkTrFcSdp6ZpX74nRgnD0rNoNkTTpEYh+g/2U9BovEke5dbtsSo5ZaiQ9Gesp74Bl9x2XnUGY+nx+CJh/CQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "31+jjw==", + "AAAAAAAAAAE=" + ], + "application_id": 719046155, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 44225108, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 44225105, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "NRJN5GI2YKXJPRUSU2KTEH5VV2FHHY75LLDUCLECK7RL65KNQXCQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 44225135, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAB" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1727339688, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "IMUi72210vDnM5cjhvzfWgldSgIceYkwQ38OKJzXmb9io98Du8ehvq7BC+uHXS3HjjiLuhDapmToQtxZVNeJBw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "pT5aQQ==", + "AAoAAAAAAAAAewAFdGVzdCA=" + ], + "application_id": 718348254, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 44224835, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 44224833, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "OUQEBRIXBLCFGEYLIY45XKBNYVIYRJRCTE53HF6R55IUYBIIPOQA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 44224863, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAKAAAAAAAAAHsABXRlc3Qg" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1727338943, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "+RvxuI/0scPBFaOMpXB9uT589CvDAA1nTUzm+7ZOqPNGZjjL8bs6qKNd9okugTiJOTN0TwtcnjVb3LNfOTNOCw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAI=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 44086313, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 44086309, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": "6gTT1HtyCcHHa0CruRq3eYYH7NR0yCw7qH2pj6u+tXs=", + "heartbeat_transaction": null, + "id_": "4F6MENUZVN645YL3ISGVEYFZSGCL3VWAI3747RX5GWIQUCWMITNA", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 44086339, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAD" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726960560, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "bMVQNNPOmZp/uuSl/tYGWE+dyAfrjbKjC5XnN5y5UWgtF8W+nYi/Nn3XeNuzbt8X5Vlm4+xRTGB7ECz6jLZ8CQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 44086313, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 44086305, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": "6gTT1HtyCcHHa0CruRq3eYYH7NR0yCw7qH2pj6u+tXs=", + "heartbeat_transaction": null, + "id_": "QKZDEYJIXUCPHYBNVXP3LG2ZKA2GSZ7HNRI5LQYAWQLG56OFB3TA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 44086335, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 100, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726960560, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "EevcxPH8jurlzoljsjM4VD8XLqxDET7TfOGi86W6+/es0rxB7AQVOdPHkB7UliOGYzxaL/TxJaiKBQx6AWekAg==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAE=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 44086299, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 44086295, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "F7XPICDMSL67TMTO2UXP7YGPTRAY53QUCWG3GQSYVA5LSOXPP3WQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 44086325, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAC" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726960521, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "fhecW8mjyB8N7xm/f3DkR6LLAfK8aecSRSb9SBNZbRI3ry2PKzkLBcwCQaG3memYiHiPj/f+GKYGY6q+NgHmBA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 44086194, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 44086190, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "5S3FI2UEDF7OL6GIAIMDEUFWZGQSFSP335AZDKWXYWRFEZCWJT5Q", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 44086220, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 10000, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726960236, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "YiBx2ETJB7ujBVFkk14pDKSC2zYbn37YzsUL9RAoMcg5Um7G1fjLcGmtA3AaE7CgdoVMuuB0uQN6twuBF0omDQ==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 44081766, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 44081763, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "VZT7RHFIW72VNT2IFHM65UO4S6IZ7ZMEYDZQFRJJCA7Y5GMPYD6Q", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 44081793, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 10000, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726948131, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "dtAYzovUhXy6VB1O6PODXc7FBgXsCDRIiFW/I/tWMpRx+n37F/PJQDhXxDuC7x9SbBVHC5ezfoRzU44xZzxRBg==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 44037404, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 44037401, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "YGREGOUKDI6VLS5IA7D54FPUJC5TZKE3W7ZLHL277LWAAZQGEF5A", + "inner_txns": null, + "intra_round_offset": 6, + "keyreg_transaction": null, + "last_valid": 44037431, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 10000, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726826870, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "mwEmEM5nxbzNpAMNvdJyrGwhU9fvMRvQtXS3/VG5Q4ykkG5WLG1HtJ3vJEs+0avTV8nUBTOrvIzFCT9rMt/oCA==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 44037381, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 44037378, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "JR5AUTMPNEU37ZYDRZLQ5MEH64J4HZ6FABQLTGRICDFNXLUPUHZA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 44037408, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 10000, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726826806, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "x40sTV07wFk1JPzlm7+4z6m+Vm0gPlmeP6Vdn+Kc2afU6eIoQDH8DxuAStXtLMndplYof90vN3Nyis7YrI8CDw==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": { + "access": null, + "accounts": [ + "WU3UBNMSCMPQH27UOCVFCAPETWBLLVES3CHUGH7JLYRWQE62SV26NBDBUQ", + "WU3UBNMSCMPQH27UOCVFCAPETWBLLVES3CHUGH7JLYRWQE62SV26NBDBUQ" + ], + "application_args": [ + "I6gCPA==", + "AA==", + "AQ==", + "AQ==" + ], + "application_id": 721104877, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [ + 1, + 2 + ], + "foreign_assets": [ + 1, + 2 + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 44001934, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 44001931, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "2WW5GH6RNIP4JHLCPWQ6UUDK2N6XILC4FTPP53PBP5T4EKHNB3CQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 44001961, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAABAAAAAAAAAAE=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726729931, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "s6geJpracNX3agORjqDfK7bnQ/so4pvBt8+33ybDK/MpfYh9TNCRT6mrqWJKJwFbvt3JOvo4AtIe4KQG2dl6Dw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [ + "WU3UBNMSCMPQH27UOCVFCAPETWBLLVES3CHUGH7JLYRWQE62SV26NBDBUQ" + ], + "application_args": [ + "I6gCPA==", + "AA==", + "AQ==", + "AQ==" + ], + "application_id": 721104877, + "approval_program": null, + "box_references": [ + { + "app": 0, + "name": "QVE9PQ==" + } + ], + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [ + 2 + ], + "foreign_assets": [ + 1 + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43936178, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43936175, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "IUDPXA25K7ZZX727OSKGBMQZCKXNHOTHBQO4ACH3XOI3LT3FZ6FQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43937175, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAABAAAAAAAAAAI=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726550432, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "bHD3GLPbZ0bcjYGw6/W6Q360Fp95VutahNSHLohkvR97i4uMXnU9ogz8sS4Lb7FjnTG/XSj/sL/FxiSsigsUCw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [ + "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + ], + "application_args": [ + "I6gCPA==", + "AA==", + "AQ==", + "AA==" + ], + "application_id": 721104877, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [ + 2 + ], + "foreign_assets": [ + 1 + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43905276, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43905273, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "ZKTGR4FXM2FGIMRFMEJR756ZJJY3C7IGETSONIGLK6TXBLXLZYOQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43906273, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAABAAAAAAAAAAI=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726466131, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "tdNG/v5grJOQ3T4GhK+3XABoWBy+ALkPaFcMz0qp5FqKdIBubiCkAkNsKCrWnXqmBP8E8XLM1+AA/8P1hsWpBw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [ + "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + ], + "application_args": [ + "I6gCPA==", + "AA==", + "AQ==", + "AA==" + ], + "application_id": 721104877, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [ + 1, + 2 + ], + "foreign_assets": [ + 1, + 2 + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43898808, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43898805, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "2X3BZIMS2JVDYJLKLKJUO73EQQQ575W4FKALX6NBTQT6UKBZWMOQ", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 43899805, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAABAAAAAAAAAAE=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726448584, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "1iwH5JiZf2G2LyjeC1xxpwR1b3diumDZjvaGqAiEHvBBeibPthHnGujf60+zxptOE1Wl515agzOrpgioSaI5CA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [ + "WU3UBNMSCMPQH27UOCVFCAPETWBLLVES3CHUGH7JLYRWQE62SV26NBDBUQ" + ], + "application_args": [ + "I6gCPA==", + "AA==", + "AQ==", + "AQ==" + ], + "application_id": 721104877, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [ + 1 + ], + "foreign_assets": [ + 1 + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43896382, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43896379, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "LW457TANAH47PEFWDEVPE4ZC2V4LJ6HS7I6ZDAOFSNWT7MXLOV5Q", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 43897379, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAABAAAAAAAAAAE=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726441981, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "cvwCDcMV0BfmegB4aalWDbdSz9zqrw3CS0gw9UUDC7l0GtOiD4QJZkVq935endsXe57XhUdpdvyqWn80a31pBA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [ + "WU3UBNMSCMPQH27UOCVFCAPETWBLLVES3CHUGH7JLYRWQE62SV26NBDBUQ", + "WU3UBNMSCMPQH27UOCVFCAPETWBLLVES3CHUGH7JLYRWQE62SV26NBDBUQ" + ], + "application_args": [ + "I6gCPA==", + "AA==", + "AQ==", + "AQ==" + ], + "application_id": 721104877, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [ + 1, + 2 + ], + "foreign_assets": [ + 1, + 2 + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43896342, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43896339, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "DSA36L6JWJPJ5EAKLCPIZWCAD2IEHPXTXDPS4KS24OW4MLBGY6HA", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 43897339, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAABAAAAAAAAAAE=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726441870, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "LwAfVR0fIIjewhx6SK5QPtBP+zdyPrZOa23Q2664ByeeLyTNDQim2rDtIEAGxtdLFrIbZsnfltLF/adKZGAIBg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [ + "WU3UBNMSCMPQH27UOCVFCAPETWBLLVES3CHUGH7JLYRWQE62SV26NBDBUQ" + ], + "application_args": [ + "I6gCPA==", + "AA==", + "AQ==", + "AQ==" + ], + "application_id": 721104877, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [ + 1 + ], + "foreign_assets": [ + 1 + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43896333, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43896330, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "K2SRIRBC3DY6CVTHNXWXYV3SSEZKKM2RGC26V5LDXCOSS5WTBL5Q", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43897330, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAABAAAAAAAAAAE=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726441846, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "tewQx/XmJon4KrayL0Rzuz5iHnRdmd4t/R5sVMV06NUCX/jeS4pLQtiNhTKdU7qFwmkj4rxmZvG9PpCHFMQiBQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "I6gCPA==", + "AA==", + "AQ==", + "AA==" + ], + "application_id": 721104877, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [ + 1 + ], + "foreign_assets": [ + 1 + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43896073, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43896070, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "VIBTZKRMCX6AWSK3LU5QTCUKMS3G35LRA7VUZ4JCLBMEZFUELFXA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43897070, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAABAAAAAAAAAAE=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726441139, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "5cfDgc6fJitLZAuzz1jj0Xs1Jks/M5tL7+j0mNhzh4fZhTn3ntm9/2G8C0N6DuZ7GjiYijkUGhTPKlpuQ8rzBQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [ + "ELJEB3OYX325FATYL765AM5ZSJPSWZX745TYM5KCLTTSHJN2BJSHEMQ2JE" + ], + "application_args": [ + "I6gCPA==", + "AA==", + "AQ==", + "AQ==" + ], + "application_id": 721104877, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [ + 1, + 3 + ], + "foreign_assets": [ + 1, + 2 + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43870137, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43870134, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "6SHBELUKCWRUDLQYMVXTCEMCT2GRPQESJN5LFS5QQQ5UC2VPSFCA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43871134, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAABAAAAAAAAAAE=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726370447, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "4djj5OH7MXo+IAcz38uYRHwURF6WiIxnDBi+/5BzMcyZ5nET320ELv9quMONTIzVeXW5TaI7IS9V0Xu24u6SDw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "I6gCPA==", + "AA==", + "AQ==", + "AA==" + ], + "application_id": 721104877, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [ + 1 + ], + "foreign_assets": [ + 1 + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43846948, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43846945, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "E465UKYAN5VGTQJG2HMWIYA4DO3LNNHJ2ULBORL5YSMQN3CPXMIA", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 43847945, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAABAAAAAAAAAAE=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726307108, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "T+RKaZrkr+9AXvOJ07B394gobHz56rxVIhCt0DEZuGq8MVOE2CF60hSX1NkvKznJsDl0Zr3QSS/B6ViVRMYzCQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [ + "ELJEB3OYX325FATYL765AM5ZSJPSWZX745TYM5KCLTTSHJN2BJSHEMQ2JE" + ], + "application_args": [ + "I6gCPA==", + "AA==", + "AQ==", + "AQ==" + ], + "application_id": 721104877, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [ + 600011882 + ], + "foreign_assets": [ + 162491529 + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43800821, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43800818, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "NORJZEBNOYCCNWHOSSKATTYXTLZQUNLZHBUVSI2CW4QHCRNMN7CQ", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 43801818, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAJr2yJAAAAACPDdGo=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726181226, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "l3ab7VZQoXQuXrE99pg44YExye45HvIekKC73NpQKRig4yOuBytRAbRYE7QucJtTxXcVeOkf8MmYCXCx40QaBQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [ + "ELJEB3OYX325FATYL765AM5ZSJPSWZX745TYM5KCLTTSHJN2BJSHEMQ2JE" + ], + "application_args": [ + "I6gCPA==", + "AA==", + "AQ==", + "AQ==" + ], + "application_id": 721104877, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [ + 600011882 + ], + "foreign_assets": [ + 162491529 + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43777694, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43777691, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "UBEH4QXDDFS36QHO6BCIV7PPM4TCWZKDO2EQXDBJA7ZUYCPKXV7Q", + "inner_txns": null, + "intra_round_offset": 5, + "keyreg_transaction": null, + "last_valid": 43778691, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAJr2yJAAAAACPDdGo=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726118122, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "pljpsUCGM6IvAtFdr5OZOYLia0GqA5N9A0bw3mVHSTE4iUb3h5NwR+EQNKSFjtOV2g62rk9dCNzFjeCVKpmNDQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [ + "ELJEB3OYX325FATYL765AM5ZSJPSWZX745TYM5KCLTTSHJN2BJSHEMQ2JE" + ], + "application_args": [ + "I6gCPA==", + "AA==", + "AQ==", + "AQ==" + ], + "application_id": 721104877, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [ + 600011882 + ], + "foreign_assets": [ + 162491529 + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43777647, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43777645, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "NFSIZKLWS2JVD3VLUEJNQLZRXUQ7A5BOZPYT4NUUT3Z6YXYOQIXA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43778645, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAJr2yJAAAAACPDdGo=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726117993, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "mZzqSrlonrkcwdvnvAUy2eLpLXG3d+tafG+7We/BiaABLSYYRAQQQdVNZo178KiIG48/Ko7eaLl/CUN4HL5jBA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [ + "ELJEB3OYX325FATYL765AM5ZSJPSWZX745TYM5KCLTTSHJN2BJSHEMQ2JE" + ], + "application_args": [ + "I6gCPA==", + "AA==", + "AQ==", + "AQ==" + ], + "application_id": 721104877, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [ + 600011882 + ], + "foreign_assets": [ + 162491529 + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43777612, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43777609, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "WJ3UXD5THCNGAC7WBSI62JVI3PKRC5ZQP7RZN6C4WEKFW6HKH6AA", + "inner_txns": null, + "intra_round_offset": 9, + "keyreg_transaction": null, + "last_valid": 43778609, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAJr2yJAAAAACPDdGo=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726117898, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "KIBfTdQmixC+5oWbq+uwCu9Twg65WGSOwXC/RYWRRkS3T3Ey/CjQCgQ1qqViKrfbxhVWhzyM41qRue0OCuObCg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": null, + "application_id": 0, + "approval_program": "CiABATEbQQA1gAQjqAI8NhoAjgEAAQAxGRREMRhENhoBF8AwNhoCF8AyNhoDF8AciAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigMBi/0Wi/4WUIk=", + "box_references": null, + "clear_state_program": "CoEBQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43777502, + "created_app_id": 721104877, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43777500, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "XYHKXJ3RIG3ED2TPG2HETP2K4LL6U2N4FVERZRABOX5PDZMW7BSA", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 43778500, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "QUxHT0tJVF9ERVBMT1lFUjpqeyJuYW1lIjogIlNhbXBsZVJlZmVyZW5jZVR5cGVzIiwgInZlcnNpb24iOiAidjEuMCIsICJkZWxldGFibGUiOiBudWxsLCAidXBkYXRhYmxlIjogbnVsbH0=", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726117600, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "Sz6PM/nKh1+oHBIuck4s/Sc1BwkGH9psL/7i6T5NpP3EsZTtOWALWewQkzLsyx9gwBBKmnqg28a3kZy2kqioCQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "eM3OBQ==", + "AAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQ=", + "AAAAAAAAAAI=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43775147, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43775144, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "MGTLY3F4PNVNODVH4TZFOAM6JGDXNZOECXBXQUIMXXACWW5F7H5A", + "inner_txns": null, + "intra_round_offset": 9, + "keyreg_transaction": null, + "last_valid": 43776144, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAD" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726111216, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "qH+dHpv4NYYOcFRvispQHEp5dt8xTuI68FjRb1eOH7W8NFxAA3nle9kuVXsBAgDsUfCWDkcb/bbgVi5QTuVOBw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "4ARHRQ==", + "AAhRVl/NG4A=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43775140, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43775137, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "XPF7FKDKDEREUVRFQ4FDKOUJQU3SWIXC4XBXIXSZK4IVVBBE2HNA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43776137, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAIUVZfzRuA" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726111197, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "U2UuRrPlL6b3Jqgen+VFjTLY3xMivuf+sVT6yQ4rMr7mEzOTuQav4AIdomu38SMKkE9mJZrNj9Huw7ZQMf99AQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAI=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43775134, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43775132, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "VN4XY53AVUAQ3QNCOFCCBXRPRITYMBHNHJHTFAIGVDL3Z4JJJUMQ", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 43776132, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAD" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726111181, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "GVObd0Dltjf+3Xgagasca7R6PZjgWCHkGtPL7uEbT8G6YNGL75+aMZ5OfSKNrDH2DaNyu4xfO6n9d1qakfUmAg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAHs=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43768962, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43768959, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "FMR6TWEX4QHY6EAT5V5ANTEQTUUFO4WBR27LONGLRSBBOEBA5LPA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43769959, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAB8" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726094341, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "W9NTEIxXz5U0GE0mHpDr1yhcy0OMGWU9yIYlqqGnBhUGaCondx+p3H1tlDxQq37zS8MsRxh5sXhdgJSkR3IRAA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "//////////8=", + "AAAAAAAAAAA=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43752448, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43752445, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "V7PQMUKE53ZWFUHCDZ3A6G4CSSFFKQM2DO55W7WAJMCRWLPFSQJQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43753445, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98df//////////" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726049325, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "ipremI8f7B6gejf96iB36PgziyI7Mir8SRb70DSSxBTyE8t1bZzWhBKv59nPKJAfoDUvgN8auxA6Qmhka6EgDw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "ACAA6NSlD/8=", + "ACAA6NSlD/8=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43752425, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43752422, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "IBCPVBTD4CIORZTZH2GUUABNPFXUY624BFFV5MYJ5JDPEJX3U7OA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43753422, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQBAAdGpSh/+" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726049262, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "wBFSxCApOci/KGEcrxQW82So0KVbo37ngXlCJxW8FZX0DuGedVVaGU1TBs26CgpvsHDoEj1rlIGikagPFXg6DA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AB////////8=", + "AB////////8=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43752419, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43752417, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "22ZK35TILCARSN5PEWBAMTWZLCWMNIG2I3SLVAQLT2SQ7XOPPNWA", + "inner_txns": null, + "intra_round_offset": 31, + "keyreg_transaction": null, + "last_valid": 43753417, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQA////////+" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726049246, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "t3Sf39DfxvwsYstjVpDelTT7/cpy0+v8vegdOpvqpiBN1JmN7G5L4yHe6uFOScH9aaiDusr8aor3zhv0HneGBA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AABlDhJO8cc=", + "AABlDhJO8cc=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43752405, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43752403, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "XPZ2IGLNYJ7OEQBBAWEOW2ESLXI2O4RWIDJP7MN6P5IDQ35PTG4Q", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43753403, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAyhwkneOO" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726049208, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "cpxM9d61G/sw6TcxRjHLQ+JImcOu1pZYQnsOjtfq75CDZq41luGTnwEYNci5gGApEG6P9SdgFsjQEyQR7L4IBA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "4ARHRQ==", + "AAABHqk9GAA=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43752190, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43752187, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "LKIBUWTZZ46NPGBHDDDXLHMS6PORHYK6YSYIF3MEBRFY4QFYMJBA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43753187, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAR6pPRgA" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726048627, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "204jHbAgHH7mQrxWUwImrdsVh48UCXBXeANZH5nXss6WCw0/L0vMGpb5OlxuxRneZHviZkCzDs3PmMPlFHy/BA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "4ARHRQ==", + "AAABHmG2jAA=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43739730, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43739728, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "TD7C24YYAPEKK775KUWABSBHGR7NSZRV6NC4WGL3GRRWLSS4NWTA", + "inner_txns": null, + "intra_round_offset": 9, + "keyreg_transaction": null, + "last_valid": 43740728, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAR5htowA" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726014648, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "8XNtNg9V/r7W3SSyQjr1FFQiN6LKOvrlaEmcf0pukBHb6zEgD8kOS30ERBA9Z78el+DyxohFrXdauVdkD+SJBQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "4ARHRQ==", + "AARfzFpP+AA=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43739476, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43739473, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "ELWPXPO7BEKCRO6HM5B4K3624FRH74DYEVBQBHNLDPZS566VMDVA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43740473, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAEX8xaT/gA" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726013956, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "GdbKuim7RokrqtaeejK6VQpjzshtprmXgMwn0rMoleCgVyj5+NISwFMdI1qVd0gHmPcCafndZm7hO/D2zCQoDg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "eM3OBQ==", + "AAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQ=", + "AAAAAAAAAAI=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43737699, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43737697, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "57YQX3RL2XOQXDOPKR33S4ZR6O67LNOYOVRMQOC27GQSD3PNGB7Q", + "inner_txns": null, + "intra_round_offset": 9, + "keyreg_transaction": null, + "last_valid": 43738697, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAD" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1726009118, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "+t5Jz36JrdZ/a5a53APP0Xq7K/PDpaXnSkicIwYDli1s6uy9g7V4L5lbqp2ffZ6u/emt15KPUx40PKVmDs7GAA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": null, + "application_id": 0, + "approval_program": "CiABATEbQQAmgARBbn/KNhoAjgEAAQAxGRREMRhENhoBiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigEBi/+BAFmL/4EKWYv/TgJSiQ==", + "box_references": null, + "clear_state_program": "CoEBQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43715014, + "created_app_id": 720689424, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43715012, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "T45D56C4WUIBUVHFWX4ZZZLHUDNWLMCYGR56MF7BISBV2NTWH4YQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43716012, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "QUxHT0tJVF9ERVBMT1lFUjpqeyJuYW1lIjogIlNhbXBsZV9OZXN0ZWRfU3RydWN0IiwgInZlcnNpb24iOiAidjEuMCIsICJkZWxldGFibGUiOiBudWxsLCAidXBkYXRhYmxlIjogbnVsbH0=", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725947203, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "FAWsRpX4GBF5SoGy3OoPwUKxd03cDrJq96PpVKUWUgMv6/lJOq0G+tO5EHe/EmTjaBQRjASfHn1L8NoWomEMAw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "jqdQ0g==", + "AAIABAAWAAIAAAAAAAAAAQAAAAAAAAADAAIAAAAAAAAAAQAAAAAAAAAF", + "AAQABgAAAANhc2Q=" + ], + "application_id": 709982020, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43711429, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43711426, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "BCXY3TVVJQZFANYZGOP2GY7REFF73S4MV7MMD2JGKL2YZ3HG5Z7A", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 43712426, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAEAC4AAgAEABYAAgAAAAAAAAABAAAAAAAAAAMAAgAAAAAAAAABAAAAAAAAAAUABAAGAAAAA2FzZA==" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725937446, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "XeJBog4jJvPjFVkd0c0s0Sf1EFwUR7ENV8q4NYAkS8oU+lpUJgqlZccPyrIiUzGWHwtKs+J5HN7e0jLYrIwZCA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "cT1y5A==", + "AA==" + ], + "application_id": 713725461, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43707080, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43707077, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "QVZAGBN64ND7T45DBVY2WL4VSKJEBOTH4EVUZUWR45QMYMN6WCDA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43708077, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQA=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725925626, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "GCHGek6uQ6twD4q15eDJ+jj49h3AdnmS0jOyCvYXSKTmRoAxZUF4RkeSl+Tqye9PvHkrCpNt+Xfc4ZjCZiwiCg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "jqdQ0g==", + "AAIABAAmAAQAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAQABAAAAAAAAAAE=", + "AAQAFgACAAAAAAAAAAEAAAAAAAAAAQABMg==" + ], + "application_id": 709982020, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43705629, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43705626, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "YIX52ZVNMSXVEVICFTLIILQWUMD3POHDZ5CJXPV4IH3KSKCRIQNQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43706626, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAEADYAAgAEACYABAAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAABAAEAAAAAAAAAAQAEABYAAgAAAAAAAAABAAAAAAAAAAEAATI=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725921692, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "v2wfgtYVfuuAAsOA0NvyZyPi2Zu2xFkqroc25lOf0zWaQlR+JSfu88shlQZ5hrnxX8RgaYM7w/8jsRTgoS5TDQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "jqdQ0g==", + "AAMABgAQABoAAQAAAAAAAAABAAEAAAAAAAAAAgABAAAAAAAAAAM=", + "AAQADgABAAAAAAAAAAQABDUgaGk=" + ], + "application_id": 709982020, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43705007, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43705004, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "MIM6AMUMVPM3OIU547EINGPDWYPRDX2KBFKFVASU6X6XX6HLZMYQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43706004, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAEACoAAwAGABAAGgABAAAAAAAAAAEAAQAAAAAAAAACAAEAAAAAAAAAAwAEAA4AAQAAAAAAAAAEAAQ1IGhp" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725920006, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "uDZXg65ZFLwwRpFDuiEGP+4qPOcxvvAC8rSxU/WG4k1AWn5yFY2UVLgE2jnQmCOw3ZlNpcm4tgS078tWFekKAg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "eM3OBQ==", + "AAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQ=", + "AAAAAAAAAAE=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43704748, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43704745, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "FQSGHVEULVCX236J5JSI7O7L634QITP3T5AOIKYYDDUOUECZJNAA", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 43705745, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAC" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725919302, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "Qvm+QRRaqZUoBNML5hlaoucpryFCd/gCogeFBGu7MeXgYt2A2HbYY7hRP8whEa+gjIKjKU8EJOlg0kuTBRfeBQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "jqdQ0g==", + "AAMABgAQACIAAQAAAAAAAAABAAIAAAAAAAAAAgAAAAAAAAADAAEAAAAAAAAABA==", + "AAQABgAAAAIxMg==" + ], + "application_id": 709982020, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43684421, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43684418, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "Z7YLVE32CGHNRVSYFXTQLKJ7LPNAZH4D3UAA63KQMIEBPVJUOMHQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43685418, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAEADIAAwAGABAAIgABAAAAAAAAAAEAAgAAAAAAAAACAAAAAAAAAAMAAQAAAAAAAAAEAAQABgAAAAIxMg==" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725863944, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "WA2UwFvKvqSVGsVtU3JYFdXrTbBaVSjtyNygsTyCXbZ42kEvTRDXijyOrMeGKmDBoTbX16oVwgp5Bkk3gtpOCw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "jqdQ0g==", + "AAEAAgABAAAAAAAAAAE=", + "AAQAFgACAAAAAAAAAAEAAAAAAAAAAgABMw==" + ], + "application_id": 709982020, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43683903, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43683900, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "SJKC2MLEAR6R7NIOSKUFLV2NXUWANNCQWTB72YNOLLFPWEWU3RBA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43684900, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAEABIAAQACAAEAAAAAAAAAAQAEABYAAgAAAAAAAAABAAAAAAAAAAIAATM=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725862532, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "8Fetnl3KEdMWRTW3adA8/qkBHNwvfZEtkO1aQlWRuW3CIVg7E1uFSGQGlJafXxNghmIfjuCBoUsMTHG/gjBKCg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "jqdQ0g==", + "AAEAAgABAAAAAAAAAAE=", + "AAQAFgACAAAAAAAAAAEAAAAAAAAAAgABMw==" + ], + "application_id": 709982020, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43683863, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43683860, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "SLMB7DQLMOL65MMXJVN3VGLI5LG6TJBFVWKTBWKH6Y5DJ6RHDEZQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43684860, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAEABIAAQACAAEAAAAAAAAAAQAEABYAAgAAAAAAAAABAAAAAAAAAAIAATM=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725862421, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "bhlJMwBrv28Cxu01TZu5v9sCMzeqdIoNvh4IHuHxOtw7+5C1BtaaebeiIKkq0TopTz+fG+KnbihtQOM3od7PAA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "eM3OBQ==", + "AAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQ=", + "AAAAAAAAAAE=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43681092, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43681089, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "5ZSXCKCLIOJLKGFLKHJGCC4IBLLEAFOB54KY3MHQEJYFYN56HEUA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43682089, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAC" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725854859, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "cpAdxlYAn3W+Bg/TQjqe1tjk4iJz7MJ+kA/ChJdyVU6SkCJNZv7WwOUqahR1U0t5LTcp34tXXb5Pwguu8G1gBw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "eM3OBQ==", + "AAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQ=", + "AAAAAAAAAAI=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43680943, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43680940, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "2NEQB6KLABHT44X4AOMX7Q5KINGLEEXKQ5NUETYFKTGCQ67K772Q", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43681940, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAD" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725854452, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "SvlXsefg/8Z8PSLLADuOoGBX045hxUFwmtHcoY+K6WXFPrkJfiPuLIR0pagPXnd/sSlF7UySJDMadhWw38BDCw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "4ARHRQ==", + "AAABHqk9GAA=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43680883, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43680880, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "SHHFPAUW7ITOSTRSOZSW2JWCOUPXYN6AAGD6DF7RZXLIZEKWAFOQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43681880, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAR6pPRgA" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725854287, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "7kjnHywqw4fI6yPmkBe9ngcO0Weg6zG2D/h5ubB5y+99gJPIHLVGnWwSa1R84cLbh0AnigZcg/M4dgVL5tqbCg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "c8BLTQ==", + "AALXbQ==" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43680875, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43680872, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "2HXJUSM2J4P3W5OGPDSKH4AHK5ZIX7YZDUGJUNXODJWP5LBTE3VQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43681872, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAC120=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725854265, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "tyXW2uBp8hQFA2O4GIePa4CzIrvqYs/8lrZONsMNymctO7NUSsrNYicPLcL43FAIzIKfGvc2I1LrgLBIThgsDA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAI=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43680847, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43680845, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "MZOQOY6JW6W4IW3LL374SN77XXFS2TU4YUNCUQPSLM4MSM56EKGQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43681845, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAD" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725854188, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "TSOk1WZJAK6xHriC7P0noeKg8i05xb9S/8wn1VffyHQQ13zJWaYmP2S0J+mWpsNR3hCpNzbZPsBZg79HXXBfBg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "4ARHRQ==", + "AAABHqsG24A=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43679716, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43679713, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "4DCWLTD4SAF5XUVX6M3VL5LIZKQ2VZNL6CIQCIMBBSVCZJSNFXYA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43680713, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAR6rBtuA" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725851124, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "NwwcNx2b2tnh041Jgt/xDhEe+0WApIJX5BHHqp59ngXlM82Jw/bKeI2ZpRhdIzcAHhtT/FP68ayBRyN/2f+WCA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "ryCdjA==", + "11nQz0NjCD3XwrDJhUmkKZ978gFCGicgS73jTdDTkaI=" + ], + "application_id": 713725461, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43676558, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43676555, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "QSQKTFX2WPLBF6G35TD5AOK6FCFHS36DPTQVNLG3ZKVD4EABO32A", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43677555, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dddZ0M9DYwg918KwyYVJpCmfe/IBQhonIEu9403Q05Gi" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725842537, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "ADxwtJSWuke33xgbVUR87R3hetW0divvHK3A4brH+AA169B/tCYrRRIMDjR/5y949B1hjszrwNEzQK8GfMhrDQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "cT1y5A==", + "gA==" + ], + "application_id": 713725461, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43676289, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43676286, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "MT2UQV5G5JBMHOE4QLWEOPMNUBW2PKMCAMLNMHUDXUFLRHEFOZ4A", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43677286, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dYA=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725841808, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "fgw3A84hJK1IubFDhUT6KKqn2qUMdSs33Ej2B8uNUH68ficEPfSmXUfGRNPfjrxwyrYsyQDmtTVdxhXkN1t2Cw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "4ARHRQ==", + "AAAAAAAAAHs=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43627500, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43627497, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "S3ZOJM42GP7X2CEWGBDE6SGUQ2J2HUBZUEDBJCJC2X62FQ2GMDWA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43628497, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAB7" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725708768, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "iDUwe5+02zGwjLTRFCkZd3XlXAH+IDwh3W6LQF8PweD2+SnOoWNSmviOT+OhJzgf9ALmxA16ufUIb1sSOvBzDA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "jqdQ0g==", + "AAEAAgACAAAAAAAAAAEAAAAAAAAAAg==", + "AAQADgABAAAAAAAAAAMABGZvdXI=" + ], + "application_id": 709982020, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43586778, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43586775, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "LLDAGIZ65UQU7OJS6TEOHKE5B7TXA5JBJVJ4GQ6T53PN7OQSHP6Q", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43587775, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAEABoAAQACAAIAAAAAAAAAAQAAAAAAAAACAAQADgABAAAAAAAAAAMABGZvdXI=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725597795, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "n2Ua6X+KZk466lhPNXdOJIYc/7lmWbuFRpoFX2u300d7ivEVpCbImos7Ibmfr7lu7GR6kADe6+CW5P97Znz2Cw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "eM3OBQ==", + "AAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQ=", + "AAAAAAAAAAI=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43563584, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43563581, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "IJQMVLJTD5VT4LEOZ5NPZP35KOE4HNVWHZ4PF62MBBG6DMJDNUVQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43564581, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAD" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725534514, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "3vCTQyvORe9dUgUsOevI1IatrW/yruBaeG0rb9VdWpJOIvN9GBa4thAdpihsfZJIKW6cEqiR26vTaZ4LrXzpDQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "gx56Xw==", + "AAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQ=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43563544, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43563541, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "QBZUH7LBAZNMD46FOALPHX3MDBZUV3PBVVSIO3TBEYHQU5UH73GQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43564541, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAE" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725534404, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "dEUNjWs2+IjIAEnYoydprWwqJ72MLevWsr7bDij/a6koMXeDtkgN/ysL5qaSILBrwn4IS0lerv4Km8zvH8r9Ag==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAB4PM=", + "AAAAAAAB4PM=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43554597, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43554594, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "OIENKIWQZKBO6S4PBFDHPXCKIGDYFAGBXJ4GOWQESBTK2IWNDH5A", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43555594, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAA8Hm" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725510038, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "71avaUHwErJ0GdTtbbjr2p3LiRsERlxKsG/vSPQ06zhdsmr+4WNsTeJWd/F9QFiYErvPtPdP2BKCF/+OjpaCBg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "c8BLTQ==", + "AALXbQ==" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43554365, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43554363, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "RYF7OPOQTDLK33MXSRE3CZQXIZUEJOX6QW2AHE36UTPJ5EL7UMUQ", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 43555363, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAC120=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725509403, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "8gWwb4BC4RrLDYkmKmhbLT9mZlT5KRWdNVPLp4xTY7LzJLga3HFny+pyaBXdWrq36NX0NrN/9P8HxMbQAr2cAw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "c8BLTQ==", + "AARBQkNE" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43553890, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43553888, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "QLMSXR7VPJM2U7RJ2PXCL272XFRRE6LDKTHUSATVES5A7ZZ4PVPA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43554888, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAEQUJDRA==" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725508108, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "X2vLQX52ImD5j3kDDztTwvFYnPT6BM2LYuEZcRaOqTXaFV648V4hlX8hnV+pB5l12tWV0XIzyeNV9HoCnPCxAQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "c8BLTQ==", + "AARBQkNE" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43553845, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43553842, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "UGO4N5A5TEXYXWR42DBSKKFUCOTVEFHMUUJR7HY2C4YPXFAYYTZA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43554842, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAEQUJDRA==" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725507984, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "sYxlFkUf6Zr60pV42X6GIR591nYiMfCeHwlo+tYIcPjJvFOVSM6MpdMK2jtG0Qeu2RTBkJ9A3FdsXchDc02HBA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAACI=", + "AAAAAAAAAAQ=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43549655, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43549653, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "RMIXQFZQQJYZTJHHFGQDRFGJMX3YNQL6AMTGTKVMCUSTAUN4KBYA", + "inner_txns": null, + "intra_round_offset": 31, + "keyreg_transaction": null, + "last_valid": 43550653, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAm" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725496565, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "vfU4W1RG0n66rElRo6nbqPkNG44Cax1YKTfypDgV5ZwsBAoPm1rQSiwDq0ebvkaKe4MfwXrGI3IpiHO0X4IDBA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "L8rd9g==" + ], + "application_id": 719254146, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43529449, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43529446, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "VYAGZXE2JWWQZA3ZV7ZJAJB3XQL7REWJWNWJE5ARL4GCXRYUO4HA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43530446, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAIQVFJREJBPT0=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725441514, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "ewrZNkF2pYXcT7LwIYgioOipPWi0ytql02kfhYTBF562QxU08XOB4N7PVflY2qJG5FQXnu+LCQgxUNUGi2sIAQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "Qdnf4Q==" + ], + "application_id": 719254146, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43529442, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43529439, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "KWFELHNJ5QPOT3MX6WKSTCRIMRQ3Z73NVR7FPXZ4FBHMWEXLUF6A", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43530439, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAEdGVzdA==" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725441495, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "iYc5b+j6EzCRzGmDKFn7JWxXBnlYNZa0JNu36iKcYRA43mOKML/1Ky4GmbXCwZfhWI6wwtG4196uieWiywPWCw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": null, + "application_id": 0, + "approval_program": "CiABASYBBBUffHUxG0EAX4AEQdnf4YAEL8rd9oAEnL09PTYaAI4DAAEAGQAxADEZFEQxGESIAEFJFRZXBgJMUChMULAiQzEZFEQxGESIADNJFRZXBgJMUChMULAiQzEZFEQxGESIACkWKExQsCJDMRkURDEYFEQiQ4oAAYAEdGVzdImKAAGACEFRSURCQT09iYoAAYEziQ==", + "box_references": null, + "clear_state_program": "CoEBQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43489614, + "created_app_id": 719254146, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43489612, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "4ZGYRG4T6BNVOJ35SLXY574KVU5CFBY7BSULG4BKSGDECN5T7TIQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43490612, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "QUxHT0tJVF9ERVBMT1lFUjpqeyJuYW1lIjoiU2FtcGxlU2l4IDMiLCJ2ZXJzaW9uIjoiMSJ9", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725332859, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "OQQkVTKuC3AtmnKEyk6zMLfHfia3Yoezsx0sm/Xw66lKRG0JrE/Q2oJSzXS+doIpSl9oRrjaT3AwxcadBCfDAA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": null, + "application_id": 0, + "approval_program": "CiABASYBBBUffHUxG0EAX4AEQdnf4YAEL8rd9oAEnL09PTYaAI4DAAEAGQAxADEZFEQxGESIAEFJFRZXBgJMUChMULAiQzEZFEQxGESIADJJFRZXBgJMUChMULAiQzEZFEQxGESIACQWKExQsCJDMRkURDEYFEQiQ4oAAYADYXNkiYoAAYAEQUJDRImKAAEiiQ==", + "box_references": null, + "clear_state_program": "CoEBQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43489481, + "created_app_id": 719253364, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43489479, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "4ODQ6YYYHBP4QC4BCGQ4UUTQ4NVNCBRALZ23HICQWUDNC6MR4QNA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43490479, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "QUxHT0tJVF9ERVBMT1lFUjpqeyJuYW1lIjoiU2FtcGxlU2l4IDIiLCJ2ZXJzaW9uIjoiMiJ9", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725332493, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "GEPRWLUGUKU3vkPaYom8ZUfWXTo+RasaSAT5TqdsOpIDH1S0Vah2lsJ3FR/7UuDU2m2sWEz7ensU7ehrR2hXCQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": null, + "application_id": 0, + "approval_program": "CiABATEbQQAjgARv4y6HNhoAjgEAAQAxGRREMRhEiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigABgAMxMjNJFRZXBgJMUIk=", + "box_references": null, + "clear_state_program": "CoEBQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43487500, + "created_app_id": 719241638, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43487496, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "YC7IPKGCGYO2F7J62JCT7QYL2BTSPZ5WJQ4DOK7BW5W5EGPZ7VEA", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 43488496, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "QUxHT0tJVF9ERVBMT1lFUjpqeyJuYW1lIjoiU2FtcGxlU2l4IiwidmVyc2lvbiI6IjEifQ==", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725327076, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "OkfOKS3o2H8yq5MCOBSQcZcDcvbK6QKwgbhCv8UOZybI/Hr3ot8PX11ntRrTL6mXk8sJ8zaJvfrRbr8m69AfDw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": null, + "application_id": 0, + "approval_program": "CiABASYBBBUffHUxGEAAA4gA0jEbQQCMgAQx4uVggASPjC9xgATfX6OPgATxp30WgASsnZwXNhoAjgUAAQARACQANwBMADEZFEQxGESIAF4oTFCwIkMxGRREMRhENhoBiABZKExQsCJDMRkURDEYRDYaAYgATChMULAiQzEZFEQxGEQ2GgEXwBw2GgKIADkiQzEZFEQxGEQ2GgGIAEEoTFCwIkMxGRREMRgURCJDigABgAgAAAAAAAAAA4mKAQGL/4mKAQGL/4mKAgCL/xeL/oAJbG9jYWxfaW50TwJmiYoBAYv/iYoAAIAKZ2xvYmFsX2ludIEqZ4k=", + "box_references": null, + "clear_state_program": "CoEBQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43453866, + "created_app_id": 719046155, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43453864, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": [ + { + "key": "Z2xvYmFsX2ludA==", + "value": { + "action": 2, + "bytes_": null, + "uint": 42 + } + } + ], + "group": null, + "heartbeat_transaction": null, + "id_": "TDXXV2PL5DDFVPDXIP3GCL7OKX7Q33NZVJJ5TNMLHCLCNJ74UO5A", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43454864, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "QUxHT0tJVF9ERVBMT1lFUjpqeyJuYW1lIjogIlNhbXBsZV9FaWdodCIsICJ2ZXJzaW9uIjogInYxLjAiLCAiZGVsZXRhYmxlIjogbnVsbCwgInVwZGF0YWJsZSI6IG51bGx9", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1725235315, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "l+bE8GKX+BGCHvTvMQZ4+wb5JlM6MCMNow2cOUmy4hJ2z1kfJZd8TFUvwVq4EUvlA31uddl0hN/sITjfCtAGAg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "pT5aQQ==", + "AAoAAAAAB1vNFQAESm9obg==" + ], + "application_id": 718348254, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43334434, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43334432, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "BIVEPHMPLY5BL76MWU55TP65EWPI4UQZD2O2FOFLIL4SQO6Z7WXA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43335432, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAKAAAAAAdbzRUABEpvaG4=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1724909431, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "X3HvOCh3NzmDDjQ2/p/2SU5l/NY4dU90DHo/uP90k9HNi149ucQde7mPrS5nqEpNfTfT4PsBZ9s/hTq6/5GvAg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": null, + "application_id": 0, + "approval_program": "CiABATEbQQAmgASlPlpBNhoAjgEAAQAxGRREMRhENhoBiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigEBi/+J", + "box_references": null, + "clear_state_program": "CoEBQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43334411, + "created_app_id": 718348254, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43334409, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "TMDUP6K7R2VG2X2ZKD6GUXNKFGQUHZSUE5AU6ULLQ6JW2IWWQ75Q", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43335409, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "QUxHT0tJVF9ERVBMT1lFUjpqeyJuYW1lIjogIlNhbXBsZV9TZXZlbiIsICJ2ZXJzaW9uIjogInYxLjAiLCAiZGVsZXRhYmxlIjogbnVsbCwgInVwZGF0YWJsZSI6IG51bGx9", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1724909368, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "Zaw3KqcSING9dZbRpjlgpD2uZ6N65s6/amaQk/VIP6klW4Z8sYEzOAnJSI5KByKn/SSdR73nl3Ur+A9v8X/3CQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": null, + "application_id": 0, + "approval_program": "CiADAAEEJgYLYXVjdGlvbl9lbmQMcHJldmlvdXNfYmlkD3ByZXZpb3VzX2JpZGRlcgNhc2EKYXNhX2Ftb3VudAVjbGFpbTEYQAADiAGjMRtBAKaABCgmsgKABPCqcCOABDDG1YqABNt/6EOABOZUYluABB7BK+82GgCOBgABABMAMQA9AFMAXwAxGRREMRhENhoBF8AwiABqI0MxGRREMRhENhoBFzYaAhcxFiMJSTgQJBJEiABwI0MxGRREMRhEiACQI0MxGRREMRhEMRYjCUk4ECMSRIgAfiNDMRkURDEYRIgAoiNDMRkURDEYRDYaARfAMIgAzyNDMRkURDEYFEQjQ4oBADEAMgkSRCIrZUQURCuL/2exMgqL/7IRshQkshAisgGziYoDADEAMgkSRCIoZUQURIv/OBQyChJEi/84EicETGcyB4v+CChMZymL/WeJigAAiYoBADIHIihlRAxEi/84AEkxABJEi/84CCIpZURLAQxEKUsBZypPAmcxACcFTwJmiYoAADEAIicFY0xJTwJEMQAiKmVEEkEACiIpZUSLAEwJjAGxMQCyB4sBSbIII7IQIrIBszEAiwBPAgknBUxmiYoBADIHIihlRA1EsSIqZUQiKmVEIicEZUSyErIUshWL/7IRJLIQIrIBs4mKAAAoImcpImcnBCJnKyJnKjIDZ4k=", + "box_references": null, + "clear_state_program": "CoEBQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 4 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43298070, + "created_app_id": 718129252, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43298068, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": [ + { + "key": "YXNh", + "value": { + "action": 2, + "bytes_": null, + "uint": 0 + } + }, + { + "key": "YXNhX2Ftb3VudA==", + "value": { + "action": 2, + "bytes_": null, + "uint": 0 + } + }, + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "action": 2, + "bytes_": null, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlk", + "value": { + "action": 2, + "bytes_": null, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlkZGVy", + "value": { + "action": 1, + "bytes_": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", + "uint": 0 + } + } + ], + "group": null, + "heartbeat_transaction": null, + "id_": "J22ALEEVV7TG2K3S5WZKLMTHXHFQTS3O2P7IEF5XCMWGJDAYWBRA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43299068, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "QUxHT0tJVF9ERVBMT1lFUjpqeyJuYW1lIjoiQXVjdGlvbiA1IiwidmVyc2lvbiI6IjUifQ==", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1724810356, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "IG+59InRSBzA5cm5DWaAOHEEHzkyduTK3RD43aDSIhnfWPCFQVrOIlVkq4AcfnGnfbXY7/pzqAPxF/b1TPl0Ag==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": null, + "application_id": 0, + "approval_program": "CiADAAEEJgYLYXVjdGlvbl9lbmQMcHJldmlvdXNfYmlkD3ByZXZpb3VzX2JpZGRlcgNhc2EKYXNhX2Ftb3VudAVjbGFpbTEYQAADiAGjMRtBAKaABCgmsgKABPCqcCOABDDG1YqABNt/6EOABOZUYluABB7BK+82GgCOBgABABMAMQA9AFMAXwAxGRREMRhENhoBF8AwiABqI0MxGRREMRhENhoBFzYaAhcxFiMJSTgQJBJEiABwI0MxGRREMRhEiACQI0MxGRREMRhEMRYjCUk4ECMSRIgAfiNDMRkURDEYRIgAoiNDMRkURDEYRDYaARfAMIgAzyNDMRkURDEYFEQjQ4oBADEAMgkSRCIrZUQURCuL/2exMgqL/7IRshQkshAisgGziYoDADEAMgkSRCIoZUQURIv/OBQyChJEi/84EicETGcyB4v+CChMZymL/WeJigAAiYoBADIHIihlRAxEi/84AEkxABJEi/84CCIpZURLAQxEKUsBZypPAmcxACcFTwJmiYoAADEAIicFY0xJTwJEMQAiKmVEEkEACiIpZUSLAEwJjAGxMQCyB4sBSbIII7IQIrIBszEAiwBPAgknBUxmiYoBADIHIihlRA1EsSIqZUQiKmVEIicEZUSyErIUshWL/7IRJLIQIrIBs4mKAAAoImcpImcnBCJnKyJnKjIDZ4k=", + "box_references": null, + "clear_state_program": "CoEBQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 4 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43268243, + "created_app_id": 717893078, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43268240, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": [ + { + "key": "YXNh", + "value": { + "action": 2, + "bytes_": null, + "uint": 0 + } + }, + { + "key": "YXNhX2Ftb3VudA==", + "value": { + "action": 2, + "bytes_": null, + "uint": 0 + } + }, + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "action": 2, + "bytes_": null, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlk", + "value": { + "action": 2, + "bytes_": null, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlkZGVy", + "value": { + "action": 1, + "bytes_": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", + "uint": 0 + } + } + ], + "group": null, + "heartbeat_transaction": null, + "id_": "DPQJCSWYBCY3YBC5XCLN2NPNYUTNCFB7IE3GPX7ZC32BRASHZYQQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43269240, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "QUxHT0tJVF9ERVBMT1lFUjpqeyJuYW1lIjoiQXVjdGlvbiAzIiwidmVyc2lvbiI6IjEifQ==", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1724729294, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "+H6HLWoFtLBd/DnTmUPGirdPDetsHLVCEZG4WtWmglvQDhnngrEH/dWUkWVAV8yQANkDfVaBuJLOOZlwIQdtCg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": null, + "application_id": 0, + "approval_program": "CiADAAEEJgYLYXVjdGlvbl9lbmQMcHJldmlvdXNfYmlkD3ByZXZpb3VzX2JpZGRlcgNhc2EKYXNhX2Ftb3VudAVjbGFpbTEYQAADiAGjMRtBAKaABCgmsgKABPCqcCOABDDG1YqABNt/6EOABOZUYluABB7BK+82GgCOBgABABMAMQA9AFMAXwAxGRREMRhENhoBF8AwiABqI0MxGRREMRhENhoBFzYaAhcxFiMJSTgQJBJEiABwI0MxGRREMRhEiACQI0MxGRREMRhEMRYjCUk4ECMSRIgAfiNDMRkURDEYRIgAoiNDMRkURDEYRDYaARfAMIgAzyNDMRkURDEYFEQjQ4oBADEAMgkSRCIrZUQURCuL/2exMgqL/7IRshQkshAisgGziYoDADEAMgkSRCIoZUQURIv/OBQyChJEi/84EicETGcyB4v+CChMZymL/WeJigAAiYoBADIHIihlRAxEi/84AEkxABJEi/84CCIpZURLAQxEKUsBZypPAmcxACcFTwJmiYoAADEAIicFY0xJTwJEMQAiKmVEEkEACiIpZUSLAEwJjAGxMQCyB4sBSbIII7IQIrIBszEAiwBPAgknBUxmiYoBADIHIihlRA1EsSIqZUQiKmVEIicEZUSyErIUshWL/7IRJLIQIrIBs4mKAAAoImcpImcnBCJnKyJnKjIDZ4k=", + "box_references": null, + "clear_state_program": "CoEBQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 4 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43267993, + "created_app_id": 717891588, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43267990, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": [ + { + "key": "YXNh", + "value": { + "action": 2, + "bytes_": null, + "uint": 0 + } + }, + { + "key": "YXNhX2Ftb3VudA==", + "value": { + "action": 2, + "bytes_": null, + "uint": 0 + } + }, + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "action": 2, + "bytes_": null, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlk", + "value": { + "action": 2, + "bytes_": null, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlkZGVy", + "value": { + "action": 1, + "bytes_": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", + "uint": 0 + } + } + ], + "group": null, + "heartbeat_transaction": null, + "id_": "U4FZGTLWWO4CCQ6W32GU3NIYAC5A4YPVTUSJXKA2SXRH2QRSLRNQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43268990, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "QUxHT0tJVF9ERVBMT1lFUjpqeyJuYW1lIjoiQXVjdGlvbiAxIiwidmVyc2lvbiI6IjEifQ==", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1724728620, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "i9ID+RUyNIJMtoS4vUBR0GAPwQIFyWMTHZPde38PNQ30UcMV+HcNztq9qeyPOJkjW/zuLItYebCLlbRzAdj6Aw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": null, + "application_id": 0, + "approval_program": "CiACAQQmAQIABDEbQQApgASOp1DSNhoAjgEAAQAxGRREMRhENhoBNhoCiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigIBi/+BAFmL/4ECWYv/TwJLAlJMi/8Vi/9OAlJMSRUjCBZXBgIoTFBMUExQi/4VIwgWVwYCKExQi/5QTFCJ", + "box_references": null, + "clear_state_program": "CoEBQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 43110878, + "created_app_id": 716754254, + "created_asset_id": null, + "fee": 1000, + "first_valid": 43110876, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "P4XPFOOJQXN3UJ6IKMLACOZAPG3NVLHSELHTHSYWORIHPOVTIL4Q", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 43111876, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "QUxHT0tJVF9ERVBMT1lFUjpqeyJuYW1lIjoiU2FtcGxlIEZvdXIgLSBuZXciLCJ2ZXJzaW9uIjoiMS4wLjAifQ==", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1724300301, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "U/lg/QPKSKQpXu6ysawwMmLRLKfT2VAci01jiW27S5KKQ5LztSC035S/i7qCjne3jkqRZ4XNqUAuO9dEX96BCw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "cT1y5A==", + "AA==" + ], + "application_id": 713725461, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42670903, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42670901, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "Q6Q3MAJAS6VOOPPRDBDR4GCDPRIUXCQTNIBKIBCYTPVREHOBWVUQ", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 42671901, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQA=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1723101177, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "k9QUsZxdlfBJ4vYoVvW+h3yfO5VwNoGJvzuM5wQUeaGR6l5FJSi1q93hS4m0jzjBkLlLfkfHYbZouf9IhQakBw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "ryCdjA==", + "11nQz0NjCD3XwrDJhUmkKZ978gFCGicgS73jTdDTkaI=" + ], + "application_id": 713725461, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42670901, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42670899, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "6YD3MPUIGUKMJ3NOJ3ZPHNC3GVDOFCTHMV6ADPMOI2BC6K3ZEE6Q", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 42671899, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dddZ0M9DYwg918KwyYVJpCmfe/IBQhonIEu9403Q05Gi" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1723101171, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "3E2NLPLicGHTiMmpIYUzByCsrW5qpGngK93u5SK2lsg4r+/GWpoVmfY60FCAeDv6TJWcPQ39Ulj2SjZZtQ7VAg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": null, + "application_id": 0, + "approval_program": "CiABASYBBBUffHUxG0EAPIAEryCdjIAEcT1y5DYaAI4CAAEAFAAxGRREMRhENhoBiAAjKExQsCJDMRkURDEYRDYaAYgAFihMULAiQzEZFEQxGBREIkOKAQGL/4mKAQGL/4k=", + "box_references": null, + "clear_state_program": "CoEBQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42670849, + "created_app_id": 713725461, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42670847, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "2LBS4PWXIOEYZNA7TI5UENPKCAOOEBQBCDOQS733STUPIP2SR2IA", + "inner_txns": null, + "intra_round_offset": 32, + "keyreg_transaction": null, + "last_valid": 42671847, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "QUxHT0tJVF9ERVBMT1lFUjpqeyJuYW1lIjogIlNhbXBsZUZpdmUiLCAidmVyc2lvbiI6ICJ2MS4wIiwgImRlbGV0YWJsZSI6IG51bGwsICJ1cGRhdGFibGUiOiBudWxsfQ==", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1723101028, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "SGeLzWlmRjhY3onWoi5pQRbvyRYmiuVS1Ju5fcwevTjU1h75uFlsihBgL/jeYm2J+YIgitHKYpbyn4WearZBBg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "jqdQ0g==", + "AAMABgAwAFoABQAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAEAAAAAAAAAAUABQAAAAAAAAAGAAAAAAAAAAcAAAAAAAAACAAAAAAAAAAJAAAAAAAAAAoABQAAAAAAAABvAAAAAAAAAN4AAAAAAAABTQAAAAAAAAG8AAAAAAAAAis=", + "AAQALgAFAAAAAAAAApoAAAAAAAADCQAAAAAAAAN4AAAAAAAAA+cAAAAAAAAEVwFOTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2NpbmcgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuIFV0IGVuaW0gYWQgbWluaW0gdmVuaWFtLCBxdWlzIG5vc3RydWQgZXhlcmNpdGF0aW9uIHVsbGFtY28gbGFib3JpcyBuaXNpIHV0IGFsaXF1aXAgZXggZWEgY29tbW9kbyBjb25zZXF1YXQuIER1aXMgYXV0ZSBpcnVyZSBkb2xvciBpbiByZXByZWhlbmRlcml0IGluIHZvbHVwdGF0ZSB2ZWxpdCBlc3NlIGNpbGx1bSBkb2xvcmUgZXUgZnVnaWF0IG51bGxhIHBhcmlhdHVyLg==" + ], + "application_id": 709982020, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42416155, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42416153, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "QLQS5F2U2OZJQJVQWZE5F6DKPDMY4LXEKHWE6NFHGTWJJGKKFA7A", + "inner_txns": null, + "intra_round_offset": 62, + "keyreg_transaction": null, + "last_valid": 42417153, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAEAIoAAwAGADAAWgAFAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQAAAAAAAAABQAFAAAAAAAAAAYAAAAAAAAABwAAAAAAAAAIAAAAAAAAAAkAAAAAAAAACgAFAAAAAAAAAG8AAAAAAAAA3gAAAAAAAAFNAAAAAAAAAbwAAAAAAAACKwAEAC4ABQAAAAAAAAKaAAAAAAAAAwkAAAAAAAADeAAAAAAAAAPnAAAAAAAABFcBTkxvcmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNjaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvciBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEgYWxpcXVhLiBVdCBlbmltIGFkIG1pbmltIHZlbmlhbSwgcXVpcyBub3N0cnVkIGV4ZXJjaXRhdGlvbiB1bGxhbWNvIGxhYm9yaXMgbmlzaSB1dCBhbGlxdWlwIGV4IGVhIGNvbW1vZG8gY29uc2VxdWF0LiBEdWlzIGF1dGUgaXJ1cmUgZG9sb3IgaW4gcmVwcmVoZW5kZXJpdCBpbiB2b2x1cHRhdGUgdmVsaXQgZXNzZSBjaWxsdW0gZG9sb3JlIGV1IGZ1Z2lhdCBudWxsYSBwYXJpYXR1ci4=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1722406463, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "YRLhsEPTpkIbC/tgwZz1+HcMlN/x0aiZZR/QbYTnXddw6QdoABn1+/LhRgAdGWJ01aYeGkMGDzHXK6o+u1MFAA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": null, + "application_id": 0, + "approval_program": "CiACAQQmAQIABDEbQQApgASOp1DSNhoAjgEAAQAxGRREMRhENhoBNhoCiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigIBi/+BAFmL/4ECWYv/TwJLAlJMi/8Vi/9OAlJMSRUjCBZXBgIoTFBMUExQi/4VIwgWVwYCKExQi/5QTFCJ", + "box_references": null, + "clear_state_program": "CoEBQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42416068, + "created_app_id": 709982020, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42416066, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "KFGNN6YVVMZ36Y353EFYEYQRX6GRYH5NVSG66UCBLSLCK3IUTPHA", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 42417066, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "QUxHT0tJVF9ERVBMT1lFUjpqeyJuYW1lIjogIlNhbXBsZUZvdXIiLCAidmVyc2lvbiI6ICJ2MS4wIiwgImRlbGV0YWJsZSI6IG51bGwsICJ1cGRhdGFibGUiOiBudWxsfQ==", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1722406226, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "wPZSf/O3vKHXx/e++fu5tZqa4xR59u1EpOcGIJ+y6R+6PhHopY7ogJzVySTUIIXuhXILYpA3e9dsh3qE085ICw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "wD8uHA==", + "AAAAAAAAAAE=", + "AAAAAAAAAAI=", + "AAAAAAAAAAM=", + "AAAAAAAAAAQ=", + "AAAAAAAAAAU=", + "AAAAAAAAAAY=", + "AAAAAAAAAAc=", + "AAAAAAAAAAg=", + "AAAAAAAAAAk=", + "AAAAAAAAAAo=", + "AAAAAAAAAAs=", + "AAAAAAAAAAw=", + "AAAAAAAAAA0=", + "AAAAAAAAAA4=", + "AAAAAAAAAA8AAAAAAAAAEAAAAAAAAAARAAAAAAAAAAASAQA=" + ], + "application_id": 709806536, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [ + 705410358 + ], + "foreign_assets": [ + 705457144 + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42412547, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42412545, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": "V5t9TByjm6M6pY9B76O+myDggseVS6bZP1lgizX665w=", + "heartbeat_transaction": null, + "id_": "QYKMVTOB4JF5PKLGJVYUD3ATSOTMVOHPE36UYDETNUG7LWPEFLKQ", + "inner_txns": null, + "intra_round_offset": 3, + "keyreg_transaction": null, + "last_valid": 42413545, + "lease": null, + "local_state_delta": null, + "logs": [ + "AAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQAAAAAAAAABQAAAAAAAAAGAAAAAAAAAAcAAAAAAAAACAAAAAAAAAAJAAAAAAAAAAoAAAAAAAAACwAAAAAAAAAMAAAAAAAAAA0AAAAAAAAADgAAAAAAAAAPAAAAAAAAABAAAAAAAAAAEQAAAAAAAAAS", + "FR98dQAAAAAqDGv4AAAAACoLtTYAAAAAAJU7IAAaACB232oofzq1syNMtKRoaL9ijcqGUttahJXIL0ASfwXYZA==" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1722396573, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "al6Qbe6APLFFUyh5nd1eCzyz4L903r86qP7ZMqHhM/tu4QMhkxTfAHp/GljeqDFmZPA+oEugUNwWSXIBYvX2Bg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42412547, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42412544, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": "V5t9TByjm6M6pY9B76O+myDggseVS6bZP1lgizX665w=", + "heartbeat_transaction": null, + "id_": "O3PWUKD7HK23GI2MWSSGQ2F7MKG4VBSS3NNIJFOIF5ABE7YF3BSA", + "inner_txns": null, + "intra_round_offset": 2, + "keyreg_transaction": null, + "last_valid": 42413544, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 1000, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1722396573, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "ODJlCJzGZ3HL0kzKhfoSBgC5rL9Jfwr9Lr448Bsx85HU0xsC4PxCZbiFsc6J+J4comFOVjzpIJERp6m1MUJGBQ==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": null, + "application_id": 0, + "approval_program": "CiABATEbQQCKgATAPy4cNhoAjgEAAQAxGRREMRhENhoBNhoCNhoDNhoENhoFNhoGNhoHNhoINhoJNhoKNhoLNhoMNhoNNhoONhoPVwAINhoPVwgINhoPVxAINhoPVxgBF8AwNhoPVxkINhoPVyEBF8AyMRYiCUk4ECISRDYaD1ciARfAHIgAFYAEFR98dUxQsCJDMRkURDEYFEQiQ4oWAYvqi+tQi+xQi+1Qi+5Qi+9Qi/BQi/FQi/JQi/NQi/RQi/VQi/ZQi/dQi/hQi/lQi/pQi/xQsIv7Fov9Fov/cwBEFov+OBdJFRZXBgJMUE8DTwNQTwJQgAIAGlBMUIk=", + "box_references": null, + "clear_state_program": "CoEBQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42409494, + "created_app_id": 709806536, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42409492, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "FQDJGCDXBJ6ASUA37MHFJ3MWCXQBHZ7KXEN5PLYYO4VRKVLEOW7Q", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 42410492, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "QUxHT0tJVF9ERVBMT1lFUjpqeyJuYW1lIjogIlNhbXBsZVRocmVlIiwgInZlcnNpb24iOiAidjEuMCIsICJkZWxldGFibGUiOiBudWxsLCAidXBkYXRhYmxlIjogbnVsbH0=", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1722388279, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "EiaGfPstTAxgFCrxWt01G1AXQy8cJfUuMCdfbiwyH/uESWsf9k7X3C1wTWrsU2FwrJ7XqJylatm60aPOxYaGAQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "FW7njA==", + "AAAAAAAAAAE=", + "AAAAAAAAAAI=" + ], + "application_id": 709373991, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42377378, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42377376, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "OBFQVYNZETIJCBPMM2DDMRZBVPJG6VL7ALIAX5Y2UEGA7PXG6TSA", + "inner_txns": null, + "intra_round_offset": 6, + "keyreg_transaction": null, + "last_valid": 42378376, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAABAAAAAAAAAAI=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1722300615, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "oh+UbZk973Sj2vm23BwdsoK9qd9rPaErFnvN8g4w46DAc24lnyz+9JRJYVsb/yV9xkoPF8vtNELJGw1i4T0uBQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "V3/iSQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAI=", + "AAAAAAAAAAM=", + "AAAAAAAAAAQ=", + "AAAAAAAAAAU=", + "AAAAAAAAAAY=", + "AAAAAAAAAAc=", + "AAAAAAAAAAg=", + "AAAAAAAAAAk=", + "AAAAAAAAAAo=", + "AAAAAAAAAAs=", + "AAAAAAAAAAw=", + "AAAAAAAAAA0=", + "AAAAAAAAAA4=", + "AAAAAAAAAA8AAAAAAAAAEAAAAAAAAAARAAAAAAAAABI=" + ], + "application_id": 709373991, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42377359, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42377357, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "FW3SE3274H2SEFKOVKTZTMCT753WNXZVSA7XWWIO6DOATESRNQ7A", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 42378357, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQASAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQAAAAAAAAABQAAAAAAAAAGAAAAAAAAAAcAAAAAAAAACAAAAAAAAAAJAAAAAAAAAAoAAAAAAAAACwAAAAAAAAAMAAAAAAAAAA0AAAAAAAAADgAAAAAAAAAPAAAAAAAAABAAAAAAAAAAEQAAAAAAAAAS" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1722300562, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "YjhHrVHH8CkQmqhGYuxYyYXE3/BzBIh4BwZjAP1m8H+iYC+CgAJN1SwW2XNwQKV6h0GvoqoqZdLjjww2rExxDw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": null, + "application_id": 0, + "approval_program": "CiABASYBBBUffHUxG0EAfoAEV3/iSYAEFW7njDYaAI4CAAEAUwAxGRREMRhENhoBNhoCNhoDNhoENhoFNhoGNhoHNhoINhoJNhoKNhoLNhoMNhoNNhoONhoPVwAINhoPVwgINhoPVxAINhoPVxgIiAAmKExQsCJDMRkURDEYRDYaATYaAogATyhMULAiQzEZFEQxGBREIkOKEgGL7ovvUIvwUIvxUIvyUIvzUIv0UIv1UIv2UIv3UIv4UIv5UIv6UIv7UIv8UIv9UIv+UIv/UIACABJMUImKAgGL/ov/UIk=", + "box_references": null, + "clear_state_program": "CoEBQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42377330, + "created_app_id": 709373991, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42377327, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "PHLN3RL2ALSYTB5DFALC2WWP5BAJ6EBDOD2COU2BWGNRMOGYRJEA", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 42378327, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "QUxHT0tJVF9ERVBMT1lFUjpqeyJuYW1lIjogIlNhbXBsZVR3byIsICJ2ZXJzaW9uIjogInYxLjAiLCAiZGVsZXRhYmxlIjogbnVsbCwgInVwZGF0YWJsZSI6IG51bGx9", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1722300483, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "KDE4huM5M0YlayRS+KmFc3hE4SaGZqOGuBDUASInISBaOGOeyjnHPvVgQg7MTu4LQXCaWvJ/rvHapOfublTQBA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "gx56Xw==", + "AAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQ=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42375441, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42375439, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "ZZYWQONLJDCRS4ZWATMP2RQ32B5Y7THQBVNTUIKX5ZUBGQUHPPYA", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 42376439, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAE" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1722295345, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "RdlkqavM4T72FOWvfOwMhW9S1sVfAMNcAb3fu/7d1Csk3/RZcFNjlo+cp2tOsa5JWf8OtzyaDwTvRntP1SP3Cw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "eM3OBQ==", + "AAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQ=", + "AAAAAAAAAAM=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42375415, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42375413, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "D5RK65DRYBTHDB6GHLXR26RR4NERQZI2HQHVQWDM7OU4KUPHLTNQ", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 42376413, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAE" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1722295274, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "HTi3QFiOpsD+VyBS4Bo9A9RYilA6gQxnZco9cdWGm+5+jU63gOy6THQU/CPV7k55qrvxkT7PqT8q7HVNUyqGBw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "4ARHRQ==", + "AAAAAAAB2ZI=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42375378, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42375376, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "HH5ZWA26JANKLZQDM2Z2GDALDG3PJUIOFUFSZLWMKF6FBMN6GK6A", + "inner_txns": null, + "intra_round_offset": 6, + "keyreg_transaction": null, + "last_valid": 42376376, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAdmS" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1722295173, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "25QLzjNj9aFFhKQv+HymFSj11fA0/bXhS5MVeqPkI7opzTMetJ2HZiNz224XpoDnrVHzV+8F8FTdR8M5/v4GBg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "c8BLTQ==", + "AAVoZWxsbw==" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42375133, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42375130, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "KSQS73MYZTKD3JTR43CUYVJO3YDPUUSJQMYO5DU5ZQRZRHCHZD5Q", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 42376130, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAFaGVsbG8=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1722294503, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "1L0EOzkCmKgy1XgotfESfVjehqNrsAByk9GhrEjdB7Gvu0UUhacM7cUIgCh3bq8w0Usxia4XWpSUyC9FnRHICg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "/mvfaQ==", + "AAAAAAAAAAE=", + "AAAAAAAAAAI=" + ], + "application_id": 708093293, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42358241, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42358238, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "Z7PZ63UGTLF3FFCYKVBESDMGF5LM5QQRZUT42ACQERMCKNND7SLQ", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 42359238, + "lease": null, + "local_state_delta": null, + "logs": [ + "FR98dQAAAAAAAAAD" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1722248346, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "iCE+OfSTNYOGWVi9lQizWTIc9iiFhLfs0V6tjNJwYCJWRexn3weGhAfsWO7gkVzrXc/ufNPZLv3p/HQRpxCaBw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": null, + "application_id": 0, + "approval_program": "CiACAQgmAQQVH3x1MRtBAJ6ABP5r32mABHPAS02ABOAER0WABHjNzgWABIMeel82GgCOBQABABcANQBIAF4AMRkURDEYRDYaATYaAogAaihMULAiQzEZFEQxGEQ2GgFXAgCIAGBJFRZXBgJMUChMULAiQzEZFEQxGEQ2GgGIAEsoTFCwIkMxGRREMRhENhoBNhoCiAA7KExQsCJDMRkURDEYRDYaAYgANihMULAiQzEZFEQxGBREIkOKAgGL/heL/xcIFomKAQGL/4mKAQGL/4mKAgGL/xcjC4v+TCNYiYoBAYv/iQ==", + "box_references": null, + "clear_state_program": "CoEBQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42354158, + "created_app_id": 708093293, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42354155, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "63XJDYTKTJTHEJ33226ZUPX2GILJEN5RG7LCEC4UHR7JIVAY3LPQ", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 42355155, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "QUxHT0tJVF9ERVBMT1lFUjpqeyJuYW1lIjogIlNhbXBsZU9uZSIsICJ2ZXJzaW9uIjogInYxLjAiLCAiZGVsZXRhYmxlIjogbnVsbCwgInVwZGF0YWJsZSI6IG51bGx9", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1722237143, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "doq8bn8o9K3HDI8UTECuwj26VXzCm/AmoZapoMyuht0t5/yUEFkY/EKSs6rq2lny+gX0qxf2dI0Cn5kclgLEDg==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "8KpwIw==", + "AAAAAAAAJxA=", + "AAAAAAAAjKA=" + ], + "application_id": 705410358, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42227864, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42227859, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": [ + { + "key": "YXNhX2FtdA==", + "value": { + "action": 2, + "bytes_": null, + "uint": 1 + } + }, + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "action": 2, + "bytes_": null, + "uint": 1721928880 + } + }, + { + "key": "aGlnaGVzdF9iaWQ=", + "value": { + "action": 2, + "bytes_": null, + "uint": 10000 + } + } + ], + "group": "kk6u1A9C9x1roBZOci/4Ne3XtHOtxKRq2O7OLVCbKOc=", + "heartbeat_transaction": null, + "id_": "MEF2BZU4JXIU2I7ORQRFZQ3QVT7ZWJ5VQQ4HZ4BWVZK4CEDERQ3A", + "inner_txns": null, + "intra_round_offset": 5, + "keyreg_transaction": null, + "last_valid": 42228859, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1721892883, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "zUlazFAWR7MYhoYAX+GZDMq8Y6c6KFdHMUcVHfAihie9KWqbJmH9A1NbrwScU7wPtebCu+WxIIGkMjx69s9ABQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": { + "amount": 1, + "asset_id": 705457144, + "close_amount": 0, + "close_to": null, + "receiver": "5VLJQQVCC2FARS5OKXWDPPYKJLJNEP7SKFHXD76DRN4WCV7SGI6W2IB5ME", + "sender": null + }, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42227864, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42227859, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": "kk6u1A9C9x1roBZOci/4Ne3XtHOtxKRq2O7OLVCbKOc=", + "heartbeat_transaction": null, + "id_": "5JZDTA4H7SMWADF4TNE447CNBEOJEBZ5ECKEPHH5LEWQ7DMBRGXQ", + "inner_txns": null, + "intra_round_offset": 4, + "keyreg_transaction": null, + "last_valid": 42228859, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1721892883, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "qpXbPIEwJkkjavMLcm7XwMWsRwXWLemIuJcSUhYehGJ7c4Q4HdVum27BLsgvXBvMFd7vrrX5zHHTSbMQpAWRDA==" + }, + "state_proof_transaction": null, + "tx_type": "axfer" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "KCayAg==", + "AA==" + ], + "application_id": 705410358, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [ + 705457144 + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42227864, + "created_app_id": null, + "created_asset_id": null, + "fee": 2000, + "first_valid": 42227859, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": [ + { + "key": "YXNh", + "value": { + "action": 2, + "bytes_": null, + "uint": 705457144 + } + } + ], + "group": "kk6u1A9C9x1roBZOci/4Ne3XtHOtxKRq2O7OLVCbKOc=", + "heartbeat_transaction": null, + "id_": "QY4K4IC2Z5RQ5OM2LHZH7UAFJJ44VUDSVOIAI67LMVTU4BHODP5A", + "inner_txns": [ + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": { + "amount": 0, + "asset_id": 705457144, + "close_amount": 0, + "close_to": null, + "receiver": "5VLJQQVCC2FARS5OKXWDPPYKJLJNEP7SKFHXD76DRN4WCV7SGI6W2IB5ME", + "sender": null + }, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42227864, + "created_app_id": null, + "created_asset_id": null, + "fee": 0, + "first_valid": 42227859, + "genesis_hash": null, + "genesis_id": null, + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": null, + "inner_txns": null, + "intra_round_offset": 2, + "keyreg_transaction": null, + "last_valid": 42228859, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1721892883, + "sender": "5VLJQQVCC2FARS5OKXWDPPYKJLJNEP7SKFHXD76DRN4WCV7SGI6W2IB5ME", + "sender_rewards": 0, + "signature": null, + "state_proof_transaction": null, + "tx_type": "axfer" + } + ], + "intra_round_offset": 2, + "keyreg_transaction": null, + "last_valid": 42228859, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1721892883, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "aJjwZDVvDhYTp/IEjFz/y1cNSlC065MVv5dpTNXkIjr/ApI1J9VlTYyT+1Ib+KkpR1VMqdmruQdndrRWhkKTDQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42227864, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42227859, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": "kk6u1A9C9x1roBZOci/4Ne3XtHOtxKRq2O7OLVCbKOc=", + "heartbeat_transaction": null, + "id_": "7NQ7LPLJNGE2WPSCA27XN46Z6KWHPFVW6WXQBEVIV5ZXDZHRCVRA", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 42228859, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 200000, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "5VLJQQVCC2FARS5OKXWDPPYKJLJNEP7SKFHXD76DRN4WCV7SGI6W2IB5ME" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1721892883, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "zn925awVV+KN0q4f6NKoie1+fG5NBCeOuwg4GyF1swMomXaIzL0g9HpkNd6E9eFZXw1P1bnInBWVOu4HR2KgDQ==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": null, + "asset_config_transaction": { + "asset_id": 0, + "params": { + "clawback": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "decimals": 0, + "default_frozen": false, + "freeze": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "manager": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "metadata_hash": null, + "name": "gold nugget", + "name_b64": "Z29sZCBudWdnZXQ=", + "reserve": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "total": 1, + "unit_name": "piece", + "unit_name_b64": "cGllY2U=", + "url": "https://path/to/my/asset/details", + "url_b64": "aHR0cHM6Ly9wYXRoL3RvL215L2Fzc2V0L2RldGFpbHM=" + } + }, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42227833, + "created_app_id": null, + "created_asset_id": 705457144, + "fee": 1000, + "first_valid": 42227831, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "WJWQV5CNLXUYSATNV6CBRP3YE5REJBDH3SZUAAGIPU77ZURKH5BA", + "inner_txns": null, + "intra_round_offset": 32, + "keyreg_transaction": null, + "last_valid": 42228831, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1721892798, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "Vhrf6Xw8nat8g/HqGwQbBmAzvBBp/Lygwuvdne4+X0Xm1I3ILDR3UF37HWZp3ewlZUHroCFFfaQH9DQyX0FiDw==" + }, + "state_proof_transaction": null, + "tx_type": "acfg" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": null, + "application_id": 0, + "approval_program": "CCADAAEEJgYLaGlnaGVzdF9iaWQDYXNhDmhpZ2hlc3RfYmlkZGVyC2F1Y3Rpb25fZW5kB2FzYV9hbXQAMRsiEkAA+DYaAIAEKCayAhJAANc2GgCABPCqcCMSQACcNhoAgAQ5BCruEkAAaDYaAIAEtYkGhhJAAEw2GgCABMkBKDESQAAeNhoAgAQkN408EkAAAQAxGYEFEjEYIhMQRIgBmCNDMRkiEjEYIhMQRDYaASJVNQU2GgIiVTUGNAU0BogBWCNDMRkiEjEYIhMQRIgBPiNDMRkiEjEYIhMQRDYaASJVNQQxFiMJNQM0AzgQIxJENAM0BIgA2iNDMRkiEjEYIhMQRDYaARc1ADYaAhc1ATEWIwk1AjQCOBAkEkQ0ADQBNAKIAGcjQzEZIhIxGCITEEQ2GgEiVYgAKSNDMRkiEkAAAQAxGCISRIgAAiNDigAAKSJnJwQiZysiZygiZyonBWeJigEAMQAyCRJEKWQiEkQpi//AMGexJLIQIrIBMgqyFIv/wDCyESKyErOJigMAMQAyCRJEK2QiEkSL/zgUMgoSRIv/OBEpZBJEJwSL/zgSZysyB4v+CGcoi/1niYoCALEjshCL/rIHi/+yCCKyAbOJigIAMgcrZAxEi/44CChkDUSL/jgAMQASRIv+OAcyChJEKmQnBRNBAAcqZChkiP+8KIv+OAhnKov+OABniYoAADIJKGSI/6WJigIAsSSyECKyASlkshEnBGSyEipkshSL/8AcshWziYoAALEjshAisgEyCbIHMgmyCSKyCLOJ", + "box_references": null, + "clear_state_program": "CIEAQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 4 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42225963, + "created_app_id": 705410358, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42225960, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": [ + { + "key": "YXNh", + "value": { + "action": 2, + "bytes_": null, + "uint": 0 + } + }, + { + "key": "YXNhX2FtdA==", + "value": { + "action": 2, + "bytes_": null, + "uint": 0 + } + }, + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "action": 2, + "bytes_": null, + "uint": 0 + } + }, + { + "key": "aGlnaGVzdF9iaWQ=", + "value": { + "action": 2, + "bytes_": null, + "uint": 0 + } + }, + { + "key": "aGlnaGVzdF9iaWRkZXI=", + "value": { + "action": 1, + "bytes_": null, + "uint": 0 + } + } + ], + "group": null, + "heartbeat_transaction": null, + "id_": "DYCFY6LH46N3BPK3TSQEVCS2RX3S2SE7YBQ37NNKJRUOCZDNNBDA", + "inner_txns": null, + "intra_round_offset": 4, + "keyreg_transaction": null, + "last_valid": 42226960, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1721887706, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "LW9foLAkKE9TqK+8wO8c0bXWt2mrgmxbIZdS+NXHgzpvTvHwdq5TWZqVfvqKLWNEbWuYDZ9wBulZeH6gEvXrAA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": null, + "application_id": 0, + "approval_program": "CiADAAEEJgYLYXVjdGlvbl9lbmQMcHJldmlvdXNfYmlkD3ByZXZpb3VzX2JpZGRlcgNhc2EKYXNhX2Ftb3VudAVjbGFpbTEYQAADiAGjMRtBAKaABCgmsgKABPCqcCOABDDG1YqABNt/6EOABOZUYluABB7BK+82GgCOBgABABMAMQA9AFMAXwAxGRREMRhENhoBF8AwiABqI0MxGRREMRhENhoBFzYaAhcxFiMJSTgQJBJEiABwI0MxGRREMRhEiACQI0MxGRREMRhEMRYjCUk4ECMSRIgAfiNDMRkURDEYRIgAoiNDMRkURDEYRDYaARfAMIgAzyNDMRkURDEYFEQjQ4oBADEAMgkSRCIrZUQURCuL/2exMgqL/7IRshQkshAisgGziYoDADEAMgkSRCIoZUQURIv/OBQyChJEi/84EicETGcyB4v+CChMZymL/WeJigAAiYoBADIHIihlRAxEi/84AEkxABJEi/84CCIpZURLAQxEKUsBZypPAmcxACcFTwJmiYoAADEAIicFY0xJTwJEMQAiKmVEEkEACiIpZUSLAEwJjAGxMQCyB4sBSbIII7IQIrIBszEAiwBPAgknBUxmiYoBADIHIihlRA1EsSIqZUQiKmVEIicEZUSyErIUshWL/7IRJLIQIrIBs4mKAAAoImcpImcnBCJnKyJnKjIDZ4k=", + "box_references": null, + "clear_state_program": "CoEBQw==", + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 4 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 1 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42225864, + "created_app_id": 705408386, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42225862, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": [ + { + "key": "YXNh", + "value": { + "action": 2, + "bytes_": null, + "uint": 0 + } + }, + { + "key": "YXNhX2Ftb3VudA==", + "value": { + "action": 2, + "bytes_": null, + "uint": 0 + } + }, + { + "key": "YXVjdGlvbl9lbmQ=", + "value": { + "action": 2, + "bytes_": null, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlk", + "value": { + "action": 2, + "bytes_": null, + "uint": 0 + } + }, + { + "key": "cHJldmlvdXNfYmlkZGVy", + "value": { + "action": 1, + "bytes_": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", + "uint": 0 + } + } + ], + "group": null, + "heartbeat_transaction": null, + "id_": "GJN4USDOQUQT5TLUKJNJVOJBQ6SUHFS2MQAJIC6APZVBXULGEVPQ", + "inner_txns": null, + "intra_round_offset": 2, + "keyreg_transaction": null, + "last_valid": 42226862, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "QUxHT0tJVF9ERVBMT1lFUjpqeyJuYW1lIjogIkF1Y3Rpb24iLCAidmVyc2lvbiI6ICJ2MS4wIiwgImRlbGV0YWJsZSI6IG51bGwsICJ1cGRhdGFibGUiOiBudWxsfQ==", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1721887439, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "ymsmKc9zDdrmcdFJgz7PZTlNw17T4m60IuF7kgc7arsTsNZs50IcEwkHLOT7Ln1OId5sZSYEVvqw9YYwMuWmBA==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42225822, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42225820, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "RXZ6XSMUNRX7DFMUQCKFHMOSEZ7EYIOKKFNPUXKXAEL32PFRU7TQ", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 42226820, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 10000000, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1721887325, + "sender": "GD64YIY3TWGDMCNPP553DZPPR6LDUSFQOIJVFDPPXWEG3FVOJCCDBBHU5A", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "lf91r4jV34vpvAH/TUU0cN74FL9Z7dOzoc9onepQKjuCo+BWR48tqCJjOywEgXP0va9khRleLRRIWuSveXjbAw==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + } + ] +} diff --git a/tests/modules/indexer_client/__snapshots__/test_get_v2_applications/test_basic_request_and_response_validation.json b/tests/modules/indexer_client/__snapshots__/test_get_v2_applications/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..34814bc2 --- /dev/null +++ b/tests/modules/indexer_client/__snapshots__/test_get_v2_applications/test_basic_request_and_response_validation.json @@ -0,0 +1,69 @@ +{ + "applications": [ + { + "created_at_round": 8857943, + "deleted": false, + "deleted_at_round": null, + "id_": 12174882, + "params": { + "approval_program": "AiAFAAQBBQImCgdDcmVhdG9yCFJlZ0JlZ2luBlJlZ0VuZAlWb3RlQmVnaW4HVm90ZUVuZAhyZWdpc3RlcgR2b3RlBXZvdGVkCmNhbmRpZGF0ZWEKY2FuZGlkYXRlYiIxGBJBACYoMQBnMRsjEkEA9Sk2GgAXZyo2GgEXZys2GgIXZycENhoDF2ckQyUxGRJBAAooZDEAEkEAyyRDIzEZEkEACihkMQASQQC6JEMhBDEZEkAArjYaACcFEkAAkDYaACcGEkAAAiJDMgYrZA8yBicEZA4QQQCNIjEYYUEAhiIhBHAASCQPQQB7MgQhBBJBAHMzARAjEkEAayhkMwEUEkEAYjMBESEEEkEAWTMBEiQSQQBRIjEYJwdjQAAuSDYaAScIEjYaAScJEhFBADciNhoBZUAAAkgiJAg1ATYaATQBZyInBzYaAWYkQ0gkQzIGKWQPMgYqZA4QJDEZEhBBAAQkQyRDIkMkQw==", + "clear_state_program": "AiABASJD", + "creator": "VHRSBAJWA7FAK4AYWKAP3GQFTJNXZZISD6ZBPPGE7OJWRRCOWZPDYMBIY4", + "extra_program_pages": null, + "global_state": [ + { + "key": "Vm90ZUVuZA==", + "value": { + "bytes_": "", + "type_": 2, + "uint": 100 + } + }, + { + "key": "UmVnRW5k", + "value": { + "bytes_": "", + "type_": 2, + "uint": 20 + } + }, + { + "key": "Q3JlYXRvcg==", + "value": { + "bytes_": "qeMggTYHygVwGLKA/ZoFmlt85RIfshe8xPuTaMROtl4=", + "type_": 1, + "uint": 0 + } + }, + { + "key": "UmVnQmVnaW4=", + "value": { + "bytes_": "", + "type_": 2, + "uint": 1 + } + }, + { + "key": "Vm90ZUJlZ2lu", + "value": { + "bytes_": "", + "type_": 2, + "uint": 20 + } + } + ], + "global_state_schema": { + "num_byte_slices": 1, + "num_uints": 6 + }, + "local_state_schema": { + "num_byte_slices": 1, + "num_uints": 0 + }, + "version": null + } + } + ], + "current_round": 57774717, + "next_token": "12174882" +} diff --git a/tests/modules/indexer_client/__snapshots__/test_get_v2_applications_application_id/test_basic_request_and_response_validation.json b/tests/modules/indexer_client/__snapshots__/test_get_v2_applications_application_id/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..b538b67d --- /dev/null +++ b/tests/modules/indexer_client/__snapshots__/test_get_v2_applications_application_id/test_basic_request_and_response_validation.json @@ -0,0 +1,25 @@ +{ + "application": { + "created_at_round": 43334411, + "deleted": false, + "deleted_at_round": null, + "id_": 718348254, + "params": { + "approval_program": "CiABATEbQQAmgASlPlpBNhoAjgEAAQAxGRREMRhENhoBiAAVgAQVH3x1TFCwIkMxGRREMRgURCJDigEBi/+J", + "clear_state_program": "CoEBQw==", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "extra_program_pages": null, + "global_state": null, + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "version": null + } + }, + "current_round": 57772761 +} diff --git a/tests/modules/indexer_client/__snapshots__/test_get_v2_applications_application_id_box/test_basic_request_and_response_validation.json b/tests/modules/indexer_client/__snapshots__/test_get_v2_applications_application_id_box/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..4b88b4cd --- /dev/null +++ b/tests/modules/indexer_client/__snapshots__/test_get_v2_applications_application_id_box/test_basic_request_and_response_validation.json @@ -0,0 +1,5 @@ +{ + "name": "cBbHBNV+zUy/Mz5IRhIrBLxr1on5wmidhXEavV+SasC8", + "round_": 57778751, + "value": "wAAAAABpU8zQ" +} diff --git a/tests/modules/indexer_client/__snapshots__/test_get_v2_applications_application_id_boxes/test_basic_request_and_response_validation.json b/tests/modules/indexer_client/__snapshots__/test_get_v2_applications_application_id_boxes/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..0b4c3c15 --- /dev/null +++ b/tests/modules/indexer_client/__snapshots__/test_get_v2_applications_application_id_boxes/test_basic_request_and_response_validation.json @@ -0,0 +1,147 @@ +{ + "application_id": 742949200, + "boxes": [ + { + "name": "cBbHBNV+zUy/Mz5IRhIrBLxr1on5wmidhXEavV+SasC8" + }, + { + "name": "cDqC5F01TebLXwBrtEL4dhCDwzka+7sB42/UTFixHkYh" + }, + { + "name": "cEHBCLH/d9bJNobiuCNfGJHwUlER/fuZ7ynevoNMpZwl" + }, + { + "name": "cFFWKaq6ItT7XfLyJeAfcAtB/4zSeu23atP+HLSEK8/1" + }, + { + "name": "cGE=" + }, + { + "name": "cHl8j/nyR64vdoNuN4x+aeLlnqarB0+6dsg9J4rrDCvn" + }, + { + "name": "cKz+oqV8t6foebWUijJgD505NwlSKlYPrjvUFDE2o4pC" + }, + { + "name": "cLkZttiVMuLuCgq5u+YN/YtxHT/OdA5ZmSZXu7HGX/K/" + }, + { + "name": "cL9UPdZjo3Z9FLhN9NGg0NV1KXOXpLBk2Ojij+y65eck" + }, + { + "name": "cNBstNczQBNe/LBHEqxdb2c0DwunO47edTR6YCbCkIQg" + }, + { + "name": "cO0VHTiGbM/6ESqNLzaGWzJnYNWX93+or4coHcPLw+WQ" + }, + { + "name": "cgAAAAAAAAAA" + }, + { + "name": "eBbwaB67IJgOwUaQYk4I1fv3j42+AKoAvGrT0k92xp7W" + }, + { + "name": "eDqC5F01TebLXwBrtEL4dhCDwzka+7sB42/UTFixHkYh" + }, + { + "name": "eJucuRnIeDwRaSePIZxZuEwipcwfbDnCDjSAo6jr2OY6" + }, + { + "name": "eMIf23kSvoy2MLwuR7M+9CvnBVoGMFKbayiK4wBHPJ0s" + }, + { + "name": "eNBstNczQBNe/LBHEqxdb2c0DwunO47edTR6YCbCkIQg" + }, + { + "name": "eNDN+qCWLVrJ0QiJnhBnPgqC5PnxfQU/HTuFVlo2NcSj" + }, + { + "name": "eNFZC62wAEdOY1UwZiN2D5W33NQ6dStEQriFsYwSWWds" + }, + { + "name": "eNGlPHc/pMVpn/aqACrj7z10OC9Stmfaqhobmx+NkcQi" + }, + { + "name": "eNJdYrIG2kkcMYr8igB72QfuZ3PK1JIWny4psboHi7XV" + }, + { + "name": "eNLXkGqNnlhFs/rD8L/id3DGweks3sCoiqW4ChJ29B8R" + }, + { + "name": "eNMhI15Crc0P8hxj10vO31VKi6mH/KT/4tpxxn4qipWW" + }, + { + "name": "eNNYV9h9KfUB9ZWUC78lWAn+Cmj/27KVLwJOxxxX3p52" + }, + { + "name": "eNQWhwXuXp/9BD8RT5c/8U/wI7vOF2fm04I+CPP1iAHD" + }, + { + "name": "eNcb/rMhoVL3+qidpX4k1sFNYcDAqK8AS9BXc7gJ5Fuw" + }, + { + "name": "eNeFZYvCW0R/hBgm5wYtN+WJliKdqRWlT3DynifE+p6H" + }, + { + "name": "eNgA2s7Hp61Me3YdjbWszmwf4w7N8FUR6Br7vpNojk8O" + }, + { + "name": "eNiAQi2MkBR7+NIJ+wK6H8lUvKYFumWBymJyzqYdPd7T" + }, + { + "name": "eNlFiCtMEwroKJ26H8Zcbwkjx9lBr1Sw+QlcZ8Up3z34" + }, + { + "name": "eNlm7n8TRCZwTP33Ot0HLMnoHnvUYaf50tmULFiRmKRH" + }, + { + "name": "eNoK0lKTAck+atpoKOhFCwLQll0FBygk78XP66Q4E7ZL" + }, + { + "name": "eNo3Oi64WXMs3l3A9Il2ZTrQah4yAq3eBcdQwBY7g6yL" + }, + { + "name": "eNqBfHruBujubUlcU5DSQE+El78nxxPODN4uWCGvg7nJ" + }, + { + "name": "eNt90lnq8VBqx5zqBBMPILcL8Lz20a1RfPD4m6q701lv" + }, + { + "name": "eNuqccSwdV/gGc+eF1NFTRm+aCbIE94u9skso5JSkBw+" + }, + { + "name": "eNviGd5RPlB8FgErItom36C6IVDrUXFfBrAmUOvc/Hlq" + }, + { + "name": "eNv2Kh3R1Af68xOmzyInXkjZlk2rksWtKvUP0i4N+XrQ" + }, + { + "name": "eNwarNhLfroiPQBtfBBVgkOkNOWU60K4fljAxAwqWfhX" + }, + { + "name": "eNxIamqJbFro3kWF1/lSAXMOnt5fFpEFlfHNQRVfCULN" + }, + { + "name": "eN3f/pSq2B68BLvwxgg4acnHNO4A0Ow7Z5BF6WDtKKfr" + }, + { + "name": "eN6IwkuJb1KmhBwRbu+dCUluw7DhNXgyMUuWm4RTK4Ho" + }, + { + "name": "eN8FM7UWccKVv66R6qrW3j1wKleARbLOsKSea5/qfycQ" + }, + { + "name": "eN836TbOFCSh45ncezteyz4rGtb6s3r5TATshdv/+zh0" + }, + { + "name": "eN+CZK0GVPF89WmZ7AsPNPon3OtlWSkBNLus5qz3Zzwo" + }, + { + "name": "eN/Y+sr5NT2Pbe+tgdHpMcMXN0qJ7l4cSNUkFdtvV5Hn" + }, + { + "name": "ePe6HXv325PlbiBTB2XpxTu7I4a7sgILc/ozud4+4p//" + } + ], + "next_token": "b64:ePe6HXv325PlbiBTB2XpxTu7I4a7sgILc/ozud4+4p//" +} diff --git a/tests/modules/indexer_client/__snapshots__/test_get_v2_applications_application_id_logs/test_basic_request_and_response_validation.json b/tests/modules/indexer_client/__snapshots__/test_get_v2_applications_application_id_logs/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..647b1417 --- /dev/null +++ b/tests/modules/indexer_client/__snapshots__/test_get_v2_applications_application_id_logs/test_basic_request_and_response_validation.json @@ -0,0 +1,19 @@ +{ + "application_id": 718348254, + "current_round": 57772761, + "log_data": [ + { + "logs": [ + "FR98dQAKAAAAAAdbzRUABEpvaG4=" + ], + "tx_id": "BIVEPHMPLY5BL76MWU55TP65EWPI4UQZD2O2FOFLIL4SQO6Z7WXA" + }, + { + "logs": [ + "FR98dQAKAAAAAAAAAHsABXRlc3Qg" + ], + "tx_id": "OUQEBRIXBLCFGEYLIY45XKBNYVIYRJRCTE53HF6R55IUYBIIPOQA" + } + ], + "next_token": "Q9GiAgAAAAAAAAAA" +} diff --git a/tests/modules/indexer_client/__snapshots__/test_get_v2_assets/test_basic_request_and_response_validation.json b/tests/modules/indexer_client/__snapshots__/test_get_v2_assets/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..66c0d41b --- /dev/null +++ b/tests/modules/indexer_client/__snapshots__/test_get_v2_assets/test_basic_request_and_response_validation.json @@ -0,0 +1,29 @@ +{ + "assets": [ + { + "created_at_round": 3219067, + "deleted": false, + "destroyed_at_round": null, + "id_": 185, + "params": { + "clawback": "WLH5LELVSEVQL45LBRQYCLJAX6KQPGWUY5WHJXVRV2NPYZUBQAFPH22Q7A", + "creator": "WLH5LELVSEVQL45LBRQYCLJAX6KQPGWUY5WHJXVRV2NPYZUBQAFPH22Q7A", + "decimals": 0, + "default_frozen": false, + "freeze": "WLH5LELVSEVQL45LBRQYCLJAX6KQPGWUY5WHJXVRV2NPYZUBQAFPH22Q7A", + "manager": "WLH5LELVSEVQL45LBRQYCLJAX6KQPGWUY5WHJXVRV2NPYZUBQAFPH22Q7A", + "metadata_hash": null, + "name": "myasset", + "name_b64": "bXlhc3NldA==", + "reserve": "WLH5LELVSEVQL45LBRQYCLJAX6KQPGWUY5WHJXVRV2NPYZUBQAFPH22Q7A", + "total": 100, + "unit_name": "MYA", + "unit_name_b64": "TVlB", + "url": null, + "url_b64": null + } + } + ], + "current_round": 57774717, + "next_token": "185" +} diff --git a/tests/modules/indexer_client/__snapshots__/test_get_v2_assets_asset_id/test_basic_request_and_response_validation.json b/tests/modules/indexer_client/__snapshots__/test_get_v2_assets_asset_id/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..a5db10a7 --- /dev/null +++ b/tests/modules/indexer_client/__snapshots__/test_get_v2_assets_asset_id/test_basic_request_and_response_validation.json @@ -0,0 +1,26 @@ +{ + "asset": { + "created_at_round": 42227833, + "deleted": false, + "destroyed_at_round": null, + "id_": 705457144, + "params": { + "clawback": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "decimals": 0, + "default_frozen": false, + "freeze": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "manager": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "metadata_hash": null, + "name": "gold nugget", + "name_b64": "Z29sZCBudWdnZXQ=", + "reserve": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "total": 1, + "unit_name": "piece", + "unit_name_b64": "cGllY2U=", + "url": "https://path/to/my/asset/details", + "url_b64": "aHR0cHM6Ly9wYXRoL3RvL215L2Fzc2V0L2RldGFpbHM=" + } + }, + "current_round": 57772761 +} diff --git a/tests/modules/indexer_client/__snapshots__/test_get_v2_assets_asset_id_balances/test_basic_request_and_response_validation.json b/tests/modules/indexer_client/__snapshots__/test_get_v2_assets_asset_id_balances/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..3b88754b --- /dev/null +++ b/tests/modules/indexer_client/__snapshots__/test_get_v2_assets_asset_id_balances/test_basic_request_and_response_validation.json @@ -0,0 +1,22 @@ +{ + "balances": [ + { + "address": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "amount": 0, + "deleted": false, + "is_frozen": false, + "opted_in_at_round": 42227833, + "opted_out_at_round": null + }, + { + "address": "5VLJQQVCC2FARS5OKXWDPPYKJLJNEP7SKFHXD76DRN4WCV7SGI6W2IB5ME", + "amount": 1, + "deleted": false, + "is_frozen": false, + "opted_in_at_round": 42227864, + "opted_out_at_round": null + } + ], + "current_round": 57772761, + "next_token": "5VLJQQVCC2FARS5OKXWDPPYKJLJNEP7SKFHXD76DRN4WCV7SGI6W2IB5ME" +} diff --git a/tests/modules/indexer_client/__snapshots__/test_get_v2_assets_asset_id_transactions/test_basic_request_and_response_validation.json b/tests/modules/indexer_client/__snapshots__/test_get_v2_assets_asset_id_transactions/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..d5826849 --- /dev/null +++ b/tests/modules/indexer_client/__snapshots__/test_get_v2_assets_asset_id_transactions/test_basic_request_and_response_validation.json @@ -0,0 +1,235 @@ +{ + "current_round": 57772761, + "next_token": "mFiEAgAAAAAEAAAA", + "transactions": [ + { + "application_transaction": null, + "asset_config_transaction": { + "asset_id": 0, + "params": { + "clawback": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "creator": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "decimals": 0, + "default_frozen": false, + "freeze": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "manager": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "metadata_hash": null, + "name": "gold nugget", + "name_b64": "Z29sZCBudWdnZXQ=", + "reserve": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "total": 1, + "unit_name": "piece", + "unit_name_b64": "cGllY2U=", + "url": "https://path/to/my/asset/details", + "url_b64": "aHR0cHM6Ly9wYXRoL3RvL215L2Fzc2V0L2RldGFpbHM=" + } + }, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42227833, + "created_app_id": null, + "created_asset_id": 705457144, + "fee": 1000, + "first_valid": 42227831, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "WJWQV5CNLXUYSATNV6CBRP3YE5REJBDH3SZUAAGIPU77ZURKH5BA", + "inner_txns": null, + "intra_round_offset": 32, + "keyreg_transaction": null, + "last_valid": 42228831, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1721892798, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "Vhrf6Xw8nat8g/HqGwQbBmAzvBBp/Lygwuvdne4+X0Xm1I3ILDR3UF37HWZp3ewlZUHroCFFfaQH9DQyX0FiDw==" + }, + "state_proof_transaction": null, + "tx_type": "acfg" + }, + { + "application_transaction": { + "access": null, + "accounts": [], + "application_args": [ + "KCayAg==", + "AA==" + ], + "application_id": 705410358, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [ + 705457144 + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42227864, + "created_app_id": null, + "created_asset_id": null, + "fee": 2000, + "first_valid": 42227859, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": [ + { + "key": "YXNh", + "value": { + "action": 2, + "bytes_": null, + "uint": 705457144 + } + } + ], + "group": "kk6u1A9C9x1roBZOci/4Ne3XtHOtxKRq2O7OLVCbKOc=", + "heartbeat_transaction": null, + "id_": "QY4K4IC2Z5RQ5OM2LHZH7UAFJJ44VUDSVOIAI67LMVTU4BHODP5A", + "inner_txns": [ + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": { + "amount": 0, + "asset_id": 705457144, + "close_amount": 0, + "close_to": null, + "receiver": "5VLJQQVCC2FARS5OKXWDPPYKJLJNEP7SKFHXD76DRN4WCV7SGI6W2IB5ME", + "sender": null + }, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42227864, + "created_app_id": null, + "created_asset_id": null, + "fee": 0, + "first_valid": 42227859, + "genesis_hash": null, + "genesis_id": null, + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": null, + "inner_txns": null, + "intra_round_offset": 2, + "keyreg_transaction": null, + "last_valid": 42228859, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1721892883, + "sender": "5VLJQQVCC2FARS5OKXWDPPYKJLJNEP7SKFHXD76DRN4WCV7SGI6W2IB5ME", + "sender_rewards": 0, + "signature": null, + "state_proof_transaction": null, + "tx_type": "axfer" + } + ], + "intra_round_offset": 2, + "keyreg_transaction": null, + "last_valid": 42228859, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1721892883, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "aJjwZDVvDhYTp/IEjFz/y1cNSlC065MVv5dpTNXkIjr/ApI1J9VlTYyT+1Ib+KkpR1VMqdmruQdndrRWhkKTDQ==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": { + "amount": 1, + "asset_id": 705457144, + "close_amount": 0, + "close_to": null, + "receiver": "5VLJQQVCC2FARS5OKXWDPPYKJLJNEP7SKFHXD76DRN4WCV7SGI6W2IB5ME", + "sender": null + }, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 42227864, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 42227859, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": "kk6u1A9C9x1roBZOci/4Ne3XtHOtxKRq2O7OLVCbKOc=", + "heartbeat_transaction": null, + "id_": "5JZDTA4H7SMWADF4TNE447CNBEOJEBZ5ECKEPHH5LEWQ7DMBRGXQ", + "inner_txns": null, + "intra_round_offset": 4, + "keyreg_transaction": null, + "last_valid": 42228859, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1721892883, + "sender": "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "qpXbPIEwJkkjavMLcm7XwMWsRwXWLemIuJcSUhYehGJ7c4Q4HdVum27BLsgvXBvMFd7vrrX5zHHTSbMQpAWRDA==" + }, + "state_proof_transaction": null, + "tx_type": "axfer" + } + ] +} diff --git a/tests/modules/indexer_client/__snapshots__/test_get_v2_block_headers/test_basic_request_and_response_validation.json b/tests/modules/indexer_client/__snapshots__/test_get_v2_block_headers/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..ea70e126 --- /dev/null +++ b/tests/modules/indexer_client/__snapshots__/test_get_v2_block_headers/test_basic_request_and_response_validation.json @@ -0,0 +1,49 @@ +{ + "blocks": [ + { + "bonus": null, + "fees_collected": null, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "participation_updates": { + "absent_participation_accounts": [], + "expired_participation_accounts": [] + }, + "previous_block_hash": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", + "previous_block_hash_512": null, + "proposer": null, + "proposer_payout": null, + "rewards": { + "fee_sink": "A7NMWS3NT3IUDMLVO26ULGXGIIOUQ3ND2TXSER6EBGRZNOBOUIQXHIBGDE", + "rewards_calculation_round": 500000, + "rewards_level": 0, + "rewards_pool": "7777777777777777777777777777777777777777777777777774MSJUVU", + "rewards_rate": 250000000, + "rewards_residue": 0 + }, + "round_": 0, + "seed": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "state_proof_tracking": null, + "timestamp": 1560210455, + "transactions": [], + "transactions_root": "J3hisbLS0SebtaGdDYdRj+cVAPEmuLozZ3W9NJoee3M=", + "transactions_root_sha256": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", + "transactions_root_sha512": null, + "txn_counter": 0, + "upgrade_state": { + "current_protocol": "https://github.com/algorand/spec/tree/a26ed78ed8f834e2b9ccb6eb7d3ee9f629a6e622", + "next_protocol": null, + "next_protocol_approvals": 0, + "next_protocol_switch_on": 0, + "next_protocol_vote_before": 0 + }, + "upgrade_vote": { + "upgrade_approve": false, + "upgrade_delay": 0, + "upgrade_propose": null + } + } + ], + "current_round": 57780308, + "next_token": "AAAAAAAAAAA=" +} diff --git a/tests/modules/indexer_client/__snapshots__/test_get_v2_blocks_round_number/test_basic_request_and_response_validation.json b/tests/modules/indexer_client/__snapshots__/test_get_v2_blocks_round_number/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..74fd5e48 --- /dev/null +++ b/tests/modules/indexer_client/__snapshots__/test_get_v2_blocks_round_number/test_basic_request_and_response_validation.json @@ -0,0 +1,370 @@ +{ + "bonus": null, + "fees_collected": null, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "participation_updates": { + "absent_participation_accounts": [], + "expired_participation_accounts": [] + }, + "previous_block_hash": "hOHRimJmsjGBuPuoHEXmlxmJevy6490ogIxC930olFA=", + "previous_block_hash_512": null, + "proposer": null, + "proposer_payout": null, + "rewards": { + "fee_sink": "A7NMWS3NT3IUDMLVO26ULGXGIIOUQ3ND2TXSER6EBGRZNOBOUIQXHIBGDE", + "rewards_calculation_round": 24500000, + "rewards_level": 27521, + "rewards_pool": "7777777777777777777777777777777777777777777777777774MSJUVU", + "rewards_rate": 0, + "rewards_residue": 2030197303 + }, + "round_": 24099447, + "seed": "vVRd7jhGqGtiX2kZwAIw82j6RDnv1SXaedqlknx61ZQ=", + "state_proof_tracking": [ + { + "next_round": 24099328, + "online_total_weight": 0, + "type_": 0, + "voters_commitment": null + } + ], + "timestamp": 1663197976, + "transactions": [ + { + "application_transaction": { + "access": null, + "accounts": [ + "RG5HZBMB4RWG654N6R6PWEAPVBQODJ5HA3NRGUP2ZBJX7TME54YYGCJDAA", + "3T5PQZSWM63YALNDUBMV2C5QQPEJ2BN27SC36SVBYIW5KOAFWUAOACL5AA" + ], + "application_args": [ + "bWF0Y2hfb3JkZXJz", + "AAAAAAABqCA=", + "AAAAAAAAADo=", + "AAAAAAABrEM=", + "AAAAAAAAADs=", + "AAAAAAAPQkA=", + "AAAAAAADrac=" + ], + "application_id": 92138200, + "approval_program": null, + "box_references": null, + "clear_state_program": null, + "extra_program_pages": null, + "foreign_apps": [], + "foreign_assets": [ + 81981957 + ], + "global_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local_state_schema": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "on_completion": "noop", + "reject_version": null + }, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 24099447, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 24099445, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "W6SAFSKT3V4SMLQXG3YDLI4TOBEGPPVQ5PQNJ7BCQ6K7WEDVDFEQ", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 24100445, + "lease": null, + "local_state_delta": [ + { + "address": "RG5HZBMB4RWG654N6R6PWEAPVBQODJ5HA3NRGUP2ZBJX7TME54YYGCJDAA", + "delta": [ + { + "key": "Dg==", + "value": { + "action": 1, + "bytes_": "AAAAAAABnhNTAAAAAAAAITQAAAAAMGYjADA5AAAAAAABqCBCAAAAAAAAFXwAAAAACcZxADA6AAAAAAABkmpTAAAAAAAAJgcAAAAAGBSNADA7AAAAAAABovJCAAAAAAAAE4gAAAAAZEFIgDA8", + "uint": 0 + } + }, + { + "key": "YWNjb3VudEluZm8=", + "value": { + "action": 1, + "bytes_": "AAAAAADb62UAAAAAAAAAAAAAAAGU5PRAAAAAAATEtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf////w==", + "uint": 0 + } + } + ] + }, + { + "address": "3T5PQZSWM63YALNDUBMV2C5QQPEJ2BN27SC36SVBYIW5KOAFWUAOACL5AA", + "delta": [ + { + "key": "Dg==", + "value": { + "action": 1, + "bytes_": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqPpCAAAAAAAAHtwAAAAAAA9CQEk8", + "uint": 0 + } + }, + { + "key": "YWNjb3VudEluZm8=", + "value": { + "action": 1, + "bytes_": "AAAAAAAAHtwAAAAAAACr1gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH/////////w==", + "uint": 0 + } + } + ] + } + ], + "logs": [ + "bWF0Y2hfb3JkZXI=", + "AAAAAAADrac=", + "AAAAAAABqCA=", + "AAAAAAABrEM=", + "AAAAAAAAFXw=", + "AAAAAAAPQkA=", + "ibp8hYHkbG93jfR8+xAPqGDhp6cG2xNR+shTf82E7zE=", + "AAAAAAAAAAA=", + "AAAAAADb62U=", + "AAAAAATEtAA=", + "AAAAAZTk9EA=", + "3Pr4ZlZnt4Ato6BZXQuwg8idBbr8hb9KocIt1TgFtQA=", + "AAAAAAAAq9Y=", + "AAAAAAAAHtw=", + "AAAAAAAAAAA=", + "AAAAAAAAAAA=" + ], + "note": null, + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1663197976, + "sender": "6DJL462RP2DWBGMJIPDQ5PJCXRJKI34Z4GRWB3MEPAGRBAPTBL7U42RDYI", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "Xd2RGdTuIDu6UHGkQY2q8lbPbQt6UuR3RWm9h5ruWOEV1K+LDMhHagDos4+Cqnhanq2SBpB7gGAl2rbFpDimCw==" + }, + "state_proof_transaction": null, + "tx_type": "appl" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 24099447, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 24099445, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "Q5T6IHV62WN5YRGGBZ5PTTOGD4UEEJ2IJVWVVQPDSRZ5JYLNY2LQ", + "inner_txns": null, + "intra_round_offset": 1, + "keyreg_transaction": null, + "last_valid": 24099450, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "2+8E", + "payment_transaction": { + "amount": 1, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "BFO7NQTTXGYDPUEWJYLWPFZRUFQISHY4E2SKXARM7UROMAW36YYBGPSUYY" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1663197976, + "sender": "BFO7NQTTXGYDPUEWJYLWPFZRUFQISHY4E2SKXARM7UROMAW36YYBGPSUYY", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "7Ub7X+MS4kcKfTeGO5CdXmYw8Jp/hCy5XX53s7LwdejMIRAIZKZi1FAXqWGeAHxBKV3SfiQkt8+07XZMHB/HDw==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 24099447, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 24099446, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "GX4OEJETJKWAFK4RK26SYSLBIAUHP7KQVK6N7CONESCS5UZOZSXQ", + "inner_txns": null, + "intra_round_offset": 2, + "keyreg_transaction": null, + "last_valid": 24099451, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "3O8E", + "payment_transaction": { + "amount": 1, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "BFO7NQTTXGYDPUEWJYLWPFZRUFQISHY4E2SKXARM7UROMAW36YYBGPSUYY" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1663197976, + "sender": "BFO7NQTTXGYDPUEWJYLWPFZRUFQISHY4E2SKXARM7UROMAW36YYBGPSUYY", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "OLiQ/1LKpRKV/w5qLCChUeY4gupuSkq8NGxrpiTsgw5rIS0lYTCG09kWFxUU0W5Sn0jVbZboEtumXh9hy9xoBA==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 24099447, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 24099446, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "5UJZEZJDYQZZC5DTUYYGMW2W65KFMETQLYC34JPFSMBCQXLX6T4Q", + "inner_txns": null, + "intra_round_offset": 3, + "keyreg_transaction": null, + "last_valid": 24099451, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "3e8E", + "payment_transaction": { + "amount": 1, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "BFO7NQTTXGYDPUEWJYLWPFZRUFQISHY4E2SKXARM7UROMAW36YYBGPSUYY" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1663197976, + "sender": "BFO7NQTTXGYDPUEWJYLWPFZRUFQISHY4E2SKXARM7UROMAW36YYBGPSUYY", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "HLxU1HhmnRwGGHccdoE7ZY7aBrr8Ol5Qepn85Eran4VtsFiaBfcgkMVC+04dzS4QLFhT0BjTKsN11mYETUWKBw==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + }, + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 24099447, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 24099446, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "ONXCSR5POM7B53L56LOVJUD5VUNQFPDXOSODIH6LOXMBTQALWB5A", + "inner_txns": null, + "intra_round_offset": 4, + "keyreg_transaction": null, + "last_valid": 24099451, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "3u8E", + "payment_transaction": { + "amount": 1, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "BFO7NQTTXGYDPUEWJYLWPFZRUFQISHY4E2SKXARM7UROMAW36YYBGPSUYY" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1663197976, + "sender": "BFO7NQTTXGYDPUEWJYLWPFZRUFQISHY4E2SKXARM7UROMAW36YYBGPSUYY", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "Qh/iCwtexJCsIGLIA8TNzknsIi4lBgdzKhBNbVnVkgnSIFwHYznoLhrsCU+QgHWrOdwyiymBakku7G7t9GrbBQ==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + } + ], + "transactions_root": "HrkqCoO2LN8/90BejBWP05AN6dleSGRJm3ePEe5sMvU=", + "transactions_root_sha256": "K89pAIWibxpbUwkNdSZcw9K9XxsVK1OMB7e8VcD+in4=", + "transactions_root_sha512": null, + "txn_counter": 109962116, + "upgrade_state": { + "current_protocol": "https://github.com/algorandfoundation/specs/tree/433d8e9a7274b6fca703d91213e05c7e6a589e69", + "next_protocol": null, + "next_protocol_approvals": 0, + "next_protocol_switch_on": 0, + "next_protocol_vote_before": 0 + }, + "upgrade_vote": { + "upgrade_approve": false, + "upgrade_delay": 0, + "upgrade_propose": null + } +} diff --git a/tests/modules/indexer_client/__snapshots__/test_get_v2_transactions/test_basic_request_and_response_validation.json b/tests/modules/indexer_client/__snapshots__/test_get_v2_transactions/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..9159a4ab --- /dev/null +++ b/tests/modules/indexer_client/__snapshots__/test_get_v2_transactions/test_basic_request_and_response_validation.json @@ -0,0 +1,52 @@ +{ + "current_round": 57774717, + "next_token": "AQAAAAAAAAAAAAAA", + "transactions": [ + { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": null, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 1, + "created_app_id": null, + "created_asset_id": null, + "fee": 10000, + "first_valid": 0, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "QOOBRVQMX4HW5QZ2EGLQDQCQTKRF3UP3JKDGKYPCXMI6AVV35KQA", + "inner_txns": null, + "intra_round_offset": 0, + "keyreg_transaction": null, + "last_valid": 1000, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": null, + "payment_transaction": { + "amount": 100000000, + "close_amount": 0, + "close_remainder_to": null, + "receiver": "3NVE2MK2QYZQFOZ5XIRQTM7JRHNPUBV7QKLYLT7OO6QXFHXMRIAUXXNCBM" + }, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1560210480, + "sender": "GD64YIY3TWGDMCNPP553DZPPR6LDUSFQOIJVFDPPXWEG3FVOJCCDBBHU5A", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "tlAccbsxpTazfxt3Yu69Li98QvH6nDAPNHdU8LUkpBLxu1umNePq0NwfHbrtv3hW4dxKQw32SbszeMrv5X64Cg==" + }, + "state_proof_transaction": null, + "tx_type": "pay" + } + ] +} diff --git a/tests/modules/indexer_client/__snapshots__/test_get_v2_transactions_txid/test_basic_request_and_response_validation.json b/tests/modules/indexer_client/__snapshots__/test_get_v2_transactions_txid/test_basic_request_and_response_validation.json new file mode 100644 index 00000000..6b9760dc --- /dev/null +++ b/tests/modules/indexer_client/__snapshots__/test_get_v2_transactions_txid/test_basic_request_and_response_validation.json @@ -0,0 +1,51 @@ +{ + "current_round": 57772761, + "transaction": { + "application_transaction": null, + "asset_config_transaction": null, + "asset_freeze_transaction": null, + "asset_transfer_transaction": { + "amount": 5, + "asset_id": 642327435, + "close_amount": 0, + "close_to": null, + "receiver": "ATSGPNTPGMJ2U3GQRSEXA2OZGFPMKPO66NNPIKFD4LHETHYIYRIRIN6GJE", + "sender": "AT3QNHSO7VZ2CPEZGI4BG7M3TIUG7YE5KZXNAE55Z4QHHAGBEU6K2LCJUA" + }, + "auth_addr": null, + "close_rewards": 0, + "closing_amount": 0, + "confirmed_round": 39050091, + "created_app_id": null, + "created_asset_id": null, + "fee": 1000, + "first_valid": 39050089, + "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=", + "genesis_id": "testnet-v1.0", + "global_state_delta": null, + "group": null, + "heartbeat_transaction": null, + "id_": "VIXTUMAPT7NR4RB2WVOGMETW4QY43KIDA3HWDWWXS3UEDKGTEECQ", + "inner_txns": null, + "intra_round_offset": 9, + "keyreg_transaction": null, + "last_valid": 39051089, + "lease": null, + "local_state_delta": null, + "logs": null, + "note": "VHJhbnNmZXIgNSBhc3NldHMgd2l0IGlkICQ2NDIzMjc0MzU=", + "payment_transaction": null, + "receiver_rewards": 0, + "rekey_to": null, + "round_time": 1713177404, + "sender": "ATJJRFAQVMD3YVX47HZLK2GRNKZLS3YDRLJ62JJPLUCZPDJE7QPQZDTVGY", + "sender_rewards": 0, + "signature": { + "logicsig": null, + "multisig": null, + "sig": "LYTng1fmA+JQ8AocqDfp/OBvrds/WXa936muT3b4Ym98qIzouEnbMf7cOj099GV+ABecBzmw6+JrzOH/WU7TDQ==" + }, + "state_proof_transaction": null, + "tx_type": "axfer" + } +} diff --git a/tests/modules/indexer_client/common.py b/tests/modules/indexer_client/common.py new file mode 100644 index 00000000..160bb2e0 --- /dev/null +++ b/tests/modules/indexer_client/common.py @@ -0,0 +1,31 @@ +import time +from http import HTTPStatus + +from algokit_indexer_client import IndexerClient +from algokit_indexer_client.exceptions import UnexpectedStatusError +from algokit_utils.algorand import AlgorandClient +from algokit_transact.signer import AddressWithSigners +from algokit_utils.models.amount import AlgoAmount + + +def fund_account(algorand: AlgorandClient, account: AddressWithSigners) -> None: + dispenser = algorand.account.localnet_dispenser() + algorand.account.ensure_funded( + account, + dispenser, + min_spending_balance=AlgoAmount.from_algo(10), + min_funding_increment=AlgoAmount.from_algo(10), + ) + + +def wait_for_indexer(indexer: IndexerClient, txid: str, *, timeout: float = 20.0, interval: float = 0.2) -> None: + deadline = time.time() + timeout + while True: + try: + indexer.lookup_transaction_by_id(txid) + return + except UnexpectedStatusError as exc: # pragma: no cover - exercise via tests + if exc.status_code is HTTPStatus.NOT_FOUND and time.time() < deadline: + time.sleep(interval) + continue + raise diff --git a/tests/modules/indexer_client/conftest.py b/tests/modules/indexer_client/conftest.py new file mode 100644 index 00000000..b8d7b795 --- /dev/null +++ b/tests/modules/indexer_client/conftest.py @@ -0,0 +1,19 @@ +"""Fixtures for indexer client tests using mock server.""" + +import pytest + +from algokit_indexer_client import ClientConfig, IndexerClient + +from tests.modules._mock_server import DEFAULT_TOKEN, MockServer, get_mock_server + + +@pytest.fixture(scope="session") +def mock_indexer_server() -> MockServer: + """Session-scoped mock indexer server for deterministic testing.""" + return get_mock_server("indexer") + + +@pytest.fixture +def indexer_client(mock_indexer_server: MockServer) -> IndexerClient: + """Indexer client connected to the mock server.""" + return IndexerClient(ClientConfig(base_url=mock_indexer_server.base_url, token=DEFAULT_TOKEN)) diff --git a/tests/modules/indexer_client/manual/__init__.py b/tests/modules/indexer_client/manual/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/modules/indexer_client/manual/test_search_applications.py b/tests/modules/indexer_client/manual/test_search_applications.py new file mode 100644 index 00000000..1960c723 --- /dev/null +++ b/tests/modules/indexer_client/manual/test_search_applications.py @@ -0,0 +1,68 @@ +from base64 import b64decode + +import pytest + +from algokit_indexer_client import ClientConfig, IndexerClient +from algokit_utils.algorand import AlgorandClient +from algokit_transact.signer import AddressWithSigners +from algokit_utils.transactions.transaction_composer import AppCreateParams +from tests.modules.indexer_client.common import fund_account, wait_for_indexer + + +@pytest.fixture +def funded_account(algorand_localnet: AlgorandClient) -> AddressWithSigners: + account = algorand_localnet.account.random() + fund_account(algorand_localnet, account) + algorand_localnet.set_signer(sender=account.addr, signer=account.signer) + return account + + +@pytest.fixture +def localnet_indexer_client() -> IndexerClient: + """Create an indexer client connected to localnet.""" + config = ClientConfig( + base_url="http://localhost:8980", + token="a" * 64, + ) + return IndexerClient(config) + + +@pytest.mark.localnet +def test_search_applications_finds_recent_app( + algorand_localnet: AlgorandClient, + funded_account: AddressWithSigners, + localnet_indexer_client: IndexerClient, +) -> None: + """Test searching for applications using localnet indexer. + + NOTE: This test requires localnet to be running with indexer. + """ + approval_compile = algorand_localnet.client.algod.teal_compile(b"#pragma version 8\nint 1", sourcemap=False) + clear_compile = algorand_localnet.client.algod.teal_compile(b"#pragma version 8\nint 1", sourcemap=False) + approval_prog = b64decode(approval_compile.result) + clear_prog = b64decode(clear_compile.result) + + create_result = algorand_localnet.send.app_create( + AppCreateParams( + sender=funded_account.addr, + approval_program=approval_prog, + clear_state_program=clear_prog, + schema={ + "global_ints": 0, + "global_byte_slices": 0, + "local_ints": 0, + "local_byte_slices": 0, + }, + ) + ) + + app_id = create_result.app_id + tx_id = create_result.tx_id + assert app_id + assert tx_id + + wait_for_indexer(localnet_indexer_client, tx_id) + + apps = localnet_indexer_client.search_for_applications(application_id=app_id) + assert apps.applications + assert apps.applications[0].id_ == app_id diff --git a/tests/modules/indexer_client/manual/test_search_transactions.py b/tests/modules/indexer_client/manual/test_search_transactions.py new file mode 100644 index 00000000..f0cea38d --- /dev/null +++ b/tests/modules/indexer_client/manual/test_search_transactions.py @@ -0,0 +1,72 @@ +import pytest + +from algokit_indexer_client import ClientConfig, IndexerClient +from algokit_utils.algorand import AlgorandClient +from algokit_transact.signer import AddressWithSigners +from algokit_utils.models.amount import AlgoAmount +from algokit_utils.transactions.transaction_composer import PaymentParams +from tests.modules.indexer_client.common import fund_account, wait_for_indexer + + +@pytest.fixture +def funded_account(algorand_localnet: AlgorandClient) -> AddressWithSigners: + account = algorand_localnet.account.random() + fund_account(algorand_localnet, account) + algorand_localnet.set_signer(sender=account.addr, signer=account.signer) + return account + + +@pytest.fixture +def localnet_indexer_client() -> IndexerClient: + """Create an indexer client connected to localnet.""" + config = ClientConfig( + base_url="http://localhost:8980", + token="a" * 64, + ) + return IndexerClient(config) + + +@pytest.mark.localnet +def test_search_transactions_finds_recent_payment( + algorand_localnet: AlgorandClient, + funded_account: AddressWithSigners, + localnet_indexer_client: IndexerClient, +) -> None: + """Test searching for transactions using localnet indexer. + + NOTE: This test requires localnet to be running with indexer. + """ + receiver = algorand_localnet.account.random() + algorand_localnet.account.ensure_funded( + receiver, + funded_account, + min_spending_balance=AlgoAmount.from_algo(1), + min_funding_increment=AlgoAmount.from_algo(1), + ) + + send_result = algorand_localnet.send.payment( + PaymentParams( + sender=funded_account.addr, + receiver=receiver.addr, + amount=AlgoAmount.from_algo(1), + note=b"indexer test payment", + ) + ) + + tx_id = send_result.tx_id + assert tx_id + + wait_for_indexer(localnet_indexer_client, tx_id) + + lookup = localnet_indexer_client.lookup_transaction_by_id(tx_id) + assert lookup.transaction + transaction = lookup.transaction + assert transaction.tx_type == "pay" + assert transaction.sender == funded_account.addr + assert transaction.payment_transaction + assert transaction.payment_transaction.receiver == receiver.addr + assert transaction.payment_transaction.amount == 1_000_000 + + search = localnet_indexer_client.search_for_transactions(txid=tx_id) + assert search.transactions + assert search.transactions[0].id_ == tx_id diff --git a/tests/modules/indexer_client/test_get_health.py b/tests/modules/indexer_client/test_get_health.py new file mode 100644 index 00000000..f5dcddf4 --- /dev/null +++ b/tests/modules/indexer_client/test_get_health.py @@ -0,0 +1,21 @@ +import pytest + +from algokit_indexer_client import IndexerClient + +from tests.fixtures.schemas.indexer import HealthCheckSchema +from tests.modules.conftest import validate_with_schema + +# Polytest Suite: GET health + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + # Note: TS skips this test due to schema mismatch with 'migration-required' and 'read-only-mode' fields + # Python implementation handles this gracefully + result = indexer_client.health_check() + validate_with_schema(result, HealthCheckSchema) + assert result is not None + assert result.round_ is not None diff --git a/tests/modules/indexer_client/test_get_v2_accounts.py b/tests/modules/indexer_client/test_get_v2_accounts.py new file mode 100644 index 00000000..3b823ae0 --- /dev/null +++ b/tests/modules/indexer_client/test_get_v2_accounts.py @@ -0,0 +1,24 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_indexer_client import IndexerClient + +from tests.fixtures.schemas.indexer import AccountsResponseSchema +from tests.modules.conftest import DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_accounts + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = indexer_client.search_for_accounts(limit=1) + + # Assert that exactly 1 account is returned + assert result.accounts is not None + assert len(result.accounts) == 1 + + validate_with_schema(result, AccountsResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/indexer_client/test_get_v2_accounts_account_id.py b/tests/modules/indexer_client/test_get_v2_accounts_account_id.py new file mode 100644 index 00000000..1b7a196a --- /dev/null +++ b/tests/modules/indexer_client/test_get_v2_accounts_account_id.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_indexer_client import IndexerClient + +from tests.fixtures.schemas.indexer import AccountResponseSchema +from tests.modules.conftest import TEST_ADDRESS, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_accounts_ACCOUNT-ID + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = indexer_client.lookup_account_by_id(TEST_ADDRESS) + + validate_with_schema(result, AccountResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/indexer_client/test_get_v2_accounts_account_id_apps_local_state.py b/tests/modules/indexer_client/test_get_v2_accounts_account_id_apps_local_state.py new file mode 100644 index 00000000..dc3b9017 --- /dev/null +++ b/tests/modules/indexer_client/test_get_v2_accounts_account_id_apps_local_state.py @@ -0,0 +1,21 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_indexer_client import IndexerClient + +from tests.modules.conftest import TEST_ADDRESS, DataclassSnapshotSerializer + +# Polytest Suite: GET v2_accounts_ACCOUNT-ID_apps-local-state + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = indexer_client.lookup_account_app_local_states(TEST_ADDRESS) + + # NOTE: OAS spec marks apps-local-states as required but API returns null when empty. + # This is a known spec mismatch — skip schema validation until spec is fixed upstream. + # validate_with_schema(result, ApplicationLocalStatesResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/indexer_client/test_get_v2_accounts_account_id_assets.py b/tests/modules/indexer_client/test_get_v2_accounts_account_id_assets.py new file mode 100644 index 00000000..e9a8b35b --- /dev/null +++ b/tests/modules/indexer_client/test_get_v2_accounts_account_id_assets.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_indexer_client import IndexerClient + +from tests.fixtures.schemas.indexer import AssetHoldingsResponseSchema +from tests.modules.conftest import TEST_ADDRESS, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_accounts_ACCOUNT-ID_assets + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = indexer_client.lookup_account_assets(TEST_ADDRESS) + + validate_with_schema(result, AssetHoldingsResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/indexer_client/test_get_v2_accounts_account_id_created_applications.py b/tests/modules/indexer_client/test_get_v2_accounts_account_id_created_applications.py new file mode 100644 index 00000000..ec60e7a5 --- /dev/null +++ b/tests/modules/indexer_client/test_get_v2_accounts_account_id_created_applications.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_indexer_client import IndexerClient + +from tests.fixtures.schemas.indexer import ApplicationsResponseSchema +from tests.modules.conftest import TEST_ADDRESS, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_accounts_ACCOUNT-ID_created-applications + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = indexer_client.lookup_account_created_applications(TEST_ADDRESS) + + validate_with_schema(result, ApplicationsResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/indexer_client/test_get_v2_accounts_account_id_created_assets.py b/tests/modules/indexer_client/test_get_v2_accounts_account_id_created_assets.py new file mode 100644 index 00000000..a23041a3 --- /dev/null +++ b/tests/modules/indexer_client/test_get_v2_accounts_account_id_created_assets.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_indexer_client import IndexerClient + +from tests.fixtures.schemas.indexer import AssetsResponseSchema +from tests.modules.conftest import TEST_ADDRESS, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_accounts_ACCOUNT-ID_created-assets + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = indexer_client.lookup_account_created_assets(TEST_ADDRESS) + + validate_with_schema(result, AssetsResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/indexer_client/test_get_v2_accounts_account_id_transactions.py b/tests/modules/indexer_client/test_get_v2_accounts_account_id_transactions.py new file mode 100644 index 00000000..75457602 --- /dev/null +++ b/tests/modules/indexer_client/test_get_v2_accounts_account_id_transactions.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_indexer_client import IndexerClient + +from tests.fixtures.schemas.indexer import TransactionsResponseSchema +from tests.modules.conftest import TEST_ADDRESS, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_accounts_ACCOUNT-ID_transactions + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = indexer_client.lookup_account_transactions(TEST_ADDRESS) + + validate_with_schema(result, TransactionsResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/indexer_client/test_get_v2_applications.py b/tests/modules/indexer_client/test_get_v2_applications.py new file mode 100644 index 00000000..a39703e1 --- /dev/null +++ b/tests/modules/indexer_client/test_get_v2_applications.py @@ -0,0 +1,23 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_indexer_client import IndexerClient + +from tests.fixtures.schemas.indexer import ApplicationsResponseSchema +from tests.modules.conftest import DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_applications + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = indexer_client.search_for_applications(limit=1) + + assert result.applications is not None + assert len(result.applications) == 1 + + validate_with_schema(result, ApplicationsResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/indexer_client/test_get_v2_applications_application_id.py b/tests/modules/indexer_client/test_get_v2_applications_application_id.py new file mode 100644 index 00000000..fc21bbb8 --- /dev/null +++ b/tests/modules/indexer_client/test_get_v2_applications_application_id.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_indexer_client import IndexerClient + +from tests.fixtures.schemas.indexer import ApplicationResponseSchema +from tests.modules.conftest import TEST_APP_ID, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_applications_APPLICATION-ID + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = indexer_client.lookup_application_by_id(TEST_APP_ID) + + validate_with_schema(result, ApplicationResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/indexer_client/test_get_v2_applications_application_id_box.py b/tests/modules/indexer_client/test_get_v2_applications_application_id_box.py new file mode 100644 index 00000000..72adb0d5 --- /dev/null +++ b/tests/modules/indexer_client/test_get_v2_applications_application_id_box.py @@ -0,0 +1,25 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_indexer_client import IndexerClient + +from tests.fixtures.schemas.indexer import BoxSchema +from tests.modules.conftest import ( + TEST_APP_ID_WITH_BOXES, + TEST_BOX_NAME, + DataclassSnapshotSerializer, + validate_with_schema, +) + +# Polytest Suite: GET v2_applications_APPLICATION-ID_box + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = indexer_client.lookup_application_box_by_id_and_name(TEST_APP_ID_WITH_BOXES, name=TEST_BOX_NAME) + + validate_with_schema(result, BoxSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/indexer_client/test_get_v2_applications_application_id_boxes.py b/tests/modules/indexer_client/test_get_v2_applications_application_id_boxes.py new file mode 100644 index 00000000..9af5021f --- /dev/null +++ b/tests/modules/indexer_client/test_get_v2_applications_application_id_boxes.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_indexer_client import IndexerClient + +from tests.fixtures.schemas.indexer import BoxesResponseSchema +from tests.modules.conftest import TEST_APP_ID_WITH_BOXES, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_applications_APPLICATION-ID_boxes + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = indexer_client.search_for_application_boxes(TEST_APP_ID_WITH_BOXES) + + validate_with_schema(result, BoxesResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/indexer_client/test_get_v2_applications_application_id_logs.py b/tests/modules/indexer_client/test_get_v2_applications_application_id_logs.py new file mode 100644 index 00000000..beac1d1d --- /dev/null +++ b/tests/modules/indexer_client/test_get_v2_applications_application_id_logs.py @@ -0,0 +1,20 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_indexer_client import IndexerClient + +from tests.fixtures.schemas.indexer import ApplicationLogsResponseSchema +from tests.modules.conftest import TEST_APP_ID, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_applications_APPLICATION-ID_logs + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = indexer_client.lookup_application_logs_by_id(TEST_APP_ID) + + validate_with_schema(result, ApplicationLogsResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/indexer_client/test_get_v2_assets.py b/tests/modules/indexer_client/test_get_v2_assets.py new file mode 100644 index 00000000..b921db92 --- /dev/null +++ b/tests/modules/indexer_client/test_get_v2_assets.py @@ -0,0 +1,23 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_indexer_client import IndexerClient + +from tests.fixtures.schemas.indexer import AssetsResponseSchema +from tests.modules.conftest import DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_assets + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = indexer_client.search_for_assets(limit=1) + + assert result.assets is not None + assert len(result.assets) == 1 + + validate_with_schema(result, AssetsResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/indexer_client/test_get_v2_assets_asset_id.py b/tests/modules/indexer_client/test_get_v2_assets_asset_id.py new file mode 100644 index 00000000..df7ae92c --- /dev/null +++ b/tests/modules/indexer_client/test_get_v2_assets_asset_id.py @@ -0,0 +1,23 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_indexer_client import IndexerClient + +from tests.fixtures.schemas.indexer import AssetResponseSchema +from tests.modules.conftest import TEST_ASSET_ID, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_assets_ASSET-ID + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = indexer_client.lookup_asset_by_id(asset_id=TEST_ASSET_ID) + + assert result.asset is not None + assert result.asset.id_ == TEST_ASSET_ID + + validate_with_schema(result, AssetResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/indexer_client/test_get_v2_assets_asset_id_balances.py b/tests/modules/indexer_client/test_get_v2_assets_asset_id_balances.py new file mode 100644 index 00000000..7b90619c --- /dev/null +++ b/tests/modules/indexer_client/test_get_v2_assets_asset_id_balances.py @@ -0,0 +1,23 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_indexer_client import IndexerClient + +from tests.fixtures.schemas.indexer import AssetBalancesResponseSchema +from tests.modules.conftest import TEST_ASSET_ID, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_assets_ASSET-ID_balances + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + # No limit parameter to match HAR recording + result = indexer_client.lookup_asset_balances(asset_id=TEST_ASSET_ID) + + assert result.balances is not None + + validate_with_schema(result, AssetBalancesResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/indexer_client/test_get_v2_assets_asset_id_transactions.py b/tests/modules/indexer_client/test_get_v2_assets_asset_id_transactions.py new file mode 100644 index 00000000..0e4e191c --- /dev/null +++ b/tests/modules/indexer_client/test_get_v2_assets_asset_id_transactions.py @@ -0,0 +1,23 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_indexer_client import IndexerClient + +from tests.fixtures.schemas.indexer import TransactionsResponseSchema +from tests.modules.conftest import TEST_ASSET_ID, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_assets_ASSET-ID_transactions + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + # No limit parameter to match HAR recording + result = indexer_client.lookup_asset_transactions(asset_id=TEST_ASSET_ID) + + assert result.transactions is not None + + validate_with_schema(result, TransactionsResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/indexer_client/test_get_v2_block_headers.py b/tests/modules/indexer_client/test_get_v2_block_headers.py new file mode 100644 index 00000000..ef8afa27 --- /dev/null +++ b/tests/modules/indexer_client/test_get_v2_block_headers.py @@ -0,0 +1,24 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_indexer_client import IndexerClient + +from tests.fixtures.schemas.indexer import BlockHeadersResponseSchema +from tests.modules.conftest import DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_block-headers + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + # Only limit=1 to match HAR recording (no min_round/max_round) + result = indexer_client.search_for_block_headers(limit=1) + + assert result.blocks is not None + assert len(result.blocks) == 1 + + validate_with_schema(result, BlockHeadersResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/indexer_client/test_get_v2_blocks_round_number.py b/tests/modules/indexer_client/test_get_v2_blocks_round_number.py new file mode 100644 index 00000000..b6a12440 --- /dev/null +++ b/tests/modules/indexer_client/test_get_v2_blocks_round_number.py @@ -0,0 +1,23 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_indexer_client import IndexerClient + +from tests.fixtures.schemas.indexer import BlockSchema +from tests.modules.conftest import TEST_ROUND, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_blocks_ROUND-NUMBER + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = indexer_client.lookup_block(round_number=TEST_ROUND) + + assert result.round_ is not None + assert result.round_ == TEST_ROUND + + validate_with_schema(result, BlockSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/indexer_client/test_get_v2_transactions.py b/tests/modules/indexer_client/test_get_v2_transactions.py new file mode 100644 index 00000000..7663957e --- /dev/null +++ b/tests/modules/indexer_client/test_get_v2_transactions.py @@ -0,0 +1,23 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_indexer_client import IndexerClient + +from tests.fixtures.schemas.indexer import TransactionsResponseSchema +from tests.modules.conftest import DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_transactions + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = indexer_client.search_for_transactions(limit=1) + + assert result.transactions is not None + assert len(result.transactions) == 1 + + validate_with_schema(result, TransactionsResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/indexer_client/test_get_v2_transactions_txid.py b/tests/modules/indexer_client/test_get_v2_transactions_txid.py new file mode 100644 index 00000000..248796f0 --- /dev/null +++ b/tests/modules/indexer_client/test_get_v2_transactions_txid.py @@ -0,0 +1,23 @@ +import pytest +from syrupy.assertion import SnapshotAssertion + +from algokit_indexer_client import IndexerClient + +from tests.fixtures.schemas.indexer import TransactionResponseSchema +from tests.modules.conftest import TEST_TXID, DataclassSnapshotSerializer, validate_with_schema + +# Polytest Suite: GET v2_transactions_TXID + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +def test_basic_request_and_response_validation(indexer_client: IndexerClient, snapshot_json: SnapshotAssertion) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = indexer_client.lookup_transaction_by_id(txid=TEST_TXID) + + assert result.transaction is not None + assert result.transaction.id_ == TEST_TXID + + validate_with_schema(result, TransactionResponseSchema) + assert DataclassSnapshotSerializer.serialize(result) == snapshot_json diff --git a/tests/modules/kmd_client/__init__.py b/tests/modules/kmd_client/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/modules/kmd_client/conftest.py b/tests/modules/kmd_client/conftest.py new file mode 100644 index 00000000..21543493 --- /dev/null +++ b/tests/modules/kmd_client/conftest.py @@ -0,0 +1,46 @@ +"""Fixtures for KMD client tests using localnet.""" + +from collections.abc import Generator + +import pytest + +from algokit_algod_client import AlgodClient +from algokit_algod_client import ClientConfig as AlgodClientConfig +from algokit_kmd_client import ClientConfig, KmdClient + +from .fixtures import ( + get_wallet_handle, + release_wallet_handle, +) + +# Localnet configuration +LOCALNET_KMD_TOKEN = "a" * 64 +LOCALNET_KMD_URL = "http://localhost:4002" +LOCALNET_ALGOD_TOKEN = "a" * 64 +LOCALNET_ALGOD_URL = "http://localhost:4001" + + +@pytest.fixture +def localnet_kmd_client() -> KmdClient: + """KMD client connected to localnet.""" + return KmdClient(ClientConfig(base_url=LOCALNET_KMD_URL, token=LOCALNET_KMD_TOKEN)) + + +@pytest.fixture +def localnet_algod_client() -> AlgodClient: + """Algod client connected to localnet.""" + return AlgodClient(AlgodClientConfig(base_url=LOCALNET_ALGOD_URL, token=LOCALNET_ALGOD_TOKEN)) + + +@pytest.fixture +def wallet_handle(localnet_kmd_client: KmdClient) -> Generator[tuple[str, str, str], None, None]: + """Creates a wallet and provides a wallet handle token. + + Yields (wallet_handle_token, wallet_id, wallet_name). + Automatically releases the handle after the test. + """ + wallet_handle_token, wallet_id, wallet_name = get_wallet_handle(localnet_kmd_client) + try: + yield wallet_handle_token, wallet_id, wallet_name + finally: + release_wallet_handle(localnet_kmd_client, wallet_handle_token) diff --git a/tests/modules/kmd_client/fixtures.py b/tests/modules/kmd_client/fixtures.py new file mode 100644 index 00000000..cab4721b --- /dev/null +++ b/tests/modules/kmd_client/fixtures.py @@ -0,0 +1,135 @@ +"""Helper fixtures and utilities for KMD client localnet tests. + +These fixtures mirror the TypeScript test fixtures for polytest compatibility. +""" + +from uuid import uuid4 + +from algokit_common import address_from_public_key, public_key_from_address + +from algokit_kmd_client import KmdClient +from algokit_kmd_client.models import ( + CreateWalletRequest, + GenerateKeyRequest, + ImportMultisigRequest, + InitWalletHandleTokenRequest, + ReleaseWalletHandleTokenRequest, +) + +# Test constants matching TypeScript tests +TEST_WALLET_PASSWORD = "test-password-123" +TEST_WALLET_DRIVER = "sqlite" +MULTISIG_VERSION = 1 +MULTISIG_THRESHOLD = 2 +MULTISIG_KEY_COUNT = 3 + + +def generate_wallet_name() -> str: + """Generates a unique wallet name for testing.""" + return f"test-wallet-{uuid4().hex[:12]}" + + +def create_test_wallet( + client: KmdClient, + password: str = TEST_WALLET_PASSWORD, +) -> tuple[str, str]: + """Creates a test wallet and returns (wallet_id, wallet_name).""" + wallet_name = generate_wallet_name() + result = client.create_wallet( + CreateWalletRequest( + wallet_name=wallet_name, + wallet_password=password, + wallet_driver_name=TEST_WALLET_DRIVER, + ) + ) + assert result.wallet is not None + assert result.wallet.id_ is not None + return result.wallet.id_, result.wallet.name or wallet_name + + +def get_wallet_handle( + client: KmdClient, + password: str = TEST_WALLET_PASSWORD, +) -> tuple[str, str, str]: + """Creates a wallet and initializes a wallet handle token. + + Returns (wallet_handle_token, wallet_id, wallet_name). + """ + wallet_id, wallet_name = create_test_wallet(client, password) + + init_result = client.init_wallet_handle( + InitWalletHandleTokenRequest( + wallet_id=wallet_id, + wallet_password=password, + ) + ) + assert init_result.wallet_handle_token is not None + + return init_result.wallet_handle_token, wallet_id, wallet_name + + +def release_wallet_handle(client: KmdClient, wallet_handle_token: str) -> None: + """Releases a wallet handle token (locks wallet). Used for cleanup in tests.""" + try: + client.release_wallet_handle_token(ReleaseWalletHandleTokenRequest(wallet_handle_token=wallet_handle_token)) + except Exception as e: + print(f"Failed to release wallet handle: {e}") # noqa: T201 + # Ignore errors during cleanup (handle may have already expired) + + +def generate_test_key(client: KmdClient, wallet_handle_token: str) -> str: + """Generates a key in the wallet and returns the address string.""" + result = client.generate_key(GenerateKeyRequest(wallet_handle_token=wallet_handle_token)) + assert result.address is not None + return result.address + + +def generate_multiple_keys( + client: KmdClient, + wallet_handle_token: str, + count: int = MULTISIG_KEY_COUNT, +) -> list[str]: + """Generates multiple keys for multisig tests.""" + addresses: list[str] = [] + for _ in range(count): + address = generate_test_key(client, wallet_handle_token) + addresses.append(address) + return addresses + + +def address_to_public_key(address: str) -> bytes: + """Converts an Algorand address string to a public key bytes.""" + return public_key_from_address(address) + + +def public_key_to_address(public_key: bytes) -> str: + """Converts a public key to an Algorand address string.""" + return address_from_public_key(public_key) + + +def create_test_multisig( + client: KmdClient, + wallet_handle_token: str, + threshold: int = MULTISIG_THRESHOLD, + key_count: int = MULTISIG_KEY_COUNT, +) -> tuple[str, list[bytes], list[str], int]: + """Creates a multisig account with test keys. + + Returns (multisig_address, public_keys, addresses, threshold). + """ + # Generate keys + addresses = generate_multiple_keys(client, wallet_handle_token, key_count) + public_keys = [address_to_public_key(addr) for addr in addresses] + + # Import multisig + result = client.import_multisig( + ImportMultisigRequest( + wallet_handle_token=wallet_handle_token, + multisig_version=MULTISIG_VERSION, + threshold=threshold, + public_keys=public_keys, + ) + ) + assert result.address is not None + + return result.address, public_keys, addresses, threshold diff --git a/tests/modules/kmd_client/manual/__init__.py b/tests/modules/kmd_client/manual/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/modules/kmd_client/manual/test_key_management.py b/tests/modules/kmd_client/manual/test_key_management.py new file mode 100644 index 00000000..ed137c6b --- /dev/null +++ b/tests/modules/kmd_client/manual/test_key_management.py @@ -0,0 +1,73 @@ +from uuid import uuid4 + +import pytest + +from algokit_kmd_client import ClientConfig, KmdClient +from algokit_kmd_client.models import ( + CreateWalletRequest, + GenerateKeyRequest, + InitWalletHandleTokenRequest, + ListKeysRequest, + ReleaseWalletHandleTokenRequest, +) + +WALLET_PASSWORD = "testpass" + + +def _random_wallet_name(prefix: str) -> str: + return f"{prefix}_{uuid4().hex}" + + +@pytest.fixture +def localnet_kmd_client() -> KmdClient: + """Create a KMD client connected to localnet.""" + config = ClientConfig( + base_url="http://localhost:4002", + token="a" * 64, + ) + return KmdClient(config) + + +@pytest.fixture +def created_wallet(localnet_kmd_client: KmdClient) -> tuple[str, str]: + wallet_name = _random_wallet_name("wallet") + response = localnet_kmd_client.create_wallet( + CreateWalletRequest( + wallet_name=wallet_name, + wallet_password=WALLET_PASSWORD, + ) + ) + wallet = response.wallet + assert wallet is not None + assert wallet.id_ is not None + return wallet.id_, wallet_name + + +@pytest.mark.localnet +def test_key_management_flow(localnet_kmd_client: KmdClient, created_wallet: tuple[str, str]) -> None: + """Test KMD key management using localnet. + + NOTE: This test requires localnet to be running with KMD. + """ + wallet_id, _ = created_wallet + + init_response = localnet_kmd_client.init_wallet_handle( + InitWalletHandleTokenRequest(wallet_id=wallet_id, wallet_password=WALLET_PASSWORD) + ) + wallet_handle_token = init_response.wallet_handle_token + assert wallet_handle_token is not None + + try: + list_before = localnet_kmd_client.list_keys_in_wallet(ListKeysRequest(wallet_handle_token=wallet_handle_token)) + before_addresses = list_before.addresses or [] + + localnet_kmd_client.generate_key(GenerateKeyRequest(wallet_handle_token=wallet_handle_token)) + + list_after = localnet_kmd_client.list_keys_in_wallet(ListKeysRequest(wallet_handle_token=wallet_handle_token)) + after_addresses = list_after.addresses or [] + + assert len(after_addresses) == len(before_addresses) + 1 + finally: + localnet_kmd_client.release_wallet_handle_token( + ReleaseWalletHandleTokenRequest(wallet_handle_token=wallet_handle_token) + ) diff --git a/tests/modules/kmd_client/manual/test_wallet_lifecycle.py b/tests/modules/kmd_client/manual/test_wallet_lifecycle.py new file mode 100644 index 00000000..9969a300 --- /dev/null +++ b/tests/modules/kmd_client/manual/test_wallet_lifecycle.py @@ -0,0 +1,50 @@ +from uuid import uuid4 + +import pytest + +from algokit_kmd_client import ClientConfig, KmdClient +from algokit_kmd_client.models import CreateWalletRequest + +WALLET_PASSWORD = "testpass" + + +def _random_wallet_name(prefix: str) -> str: + return f"{prefix}_{uuid4().hex}" + + +@pytest.fixture +def localnet_kmd_client() -> KmdClient: + """Create a KMD client connected to localnet.""" + config = ClientConfig( + base_url="http://localhost:4002", + token="a" * 64, + ) + return KmdClient(config) + + +@pytest.fixture +def created_wallet(localnet_kmd_client: KmdClient) -> tuple[str, str]: + wallet_name = _random_wallet_name("wallet") + response = localnet_kmd_client.create_wallet( + CreateWalletRequest( + wallet_name=wallet_name, + wallet_password=WALLET_PASSWORD, + ) + ) + wallet = response.wallet + assert wallet is not None + assert wallet.name == wallet_name + assert wallet.id_ is not None + return wallet.id_, wallet_name + + +@pytest.mark.localnet +def test_wallet_lifecycle(localnet_kmd_client: KmdClient, created_wallet: tuple[str, str]) -> None: + """Test KMD wallet lifecycle using localnet. + + NOTE: This test requires localnet to be running with KMD. + """ + _, wallet_name = created_wallet + list_response = localnet_kmd_client.list_wallets() + wallets = list_response.wallets or [] + assert any(wallet.name == wallet_name for wallet in wallets) diff --git a/tests/modules/kmd_client/test_delete_v1_key.py b/tests/modules/kmd_client/test_delete_v1_key.py new file mode 100644 index 00000000..2b565532 --- /dev/null +++ b/tests/modules/kmd_client/test_delete_v1_key.py @@ -0,0 +1,44 @@ +import pytest + +from algokit_kmd_client import KmdClient +from algokit_kmd_client.models import DeleteKeyRequest, ListKeysRequest + +from tests.fixtures.schemas.kmd import ListKeysResponseSchema +from tests.modules.conftest import validate_with_schema + +from .fixtures import TEST_WALLET_PASSWORD, generate_test_key + +# Polytest Suite: DELETE v1_key + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation( + localnet_kmd_client: KmdClient, + wallet_handle: tuple[str, str, str], +) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + wallet_handle_token, _, _ = wallet_handle + + # Generate a key to delete + address = generate_test_key(localnet_kmd_client, wallet_handle_token) + + # Verify key exists + list_before = localnet_kmd_client.list_keys_in_wallet(ListKeysRequest(wallet_handle_token=wallet_handle_token)) + assert address in (list_before.addresses or []) + + # Delete the key (returns empty response) + localnet_kmd_client.delete_key( + DeleteKeyRequest( + address=address, + wallet_handle_token=wallet_handle_token, + wallet_password=TEST_WALLET_PASSWORD, + ) + ) + + # Verify key was deleted + list_after = localnet_kmd_client.list_keys_in_wallet(ListKeysRequest(wallet_handle_token=wallet_handle_token)) + validate_with_schema(list_after, ListKeysResponseSchema) + assert address not in (list_after.addresses or []) diff --git a/tests/modules/kmd_client/test_delete_v1_multisig.py b/tests/modules/kmd_client/test_delete_v1_multisig.py new file mode 100644 index 00000000..d54c0e80 --- /dev/null +++ b/tests/modules/kmd_client/test_delete_v1_multisig.py @@ -0,0 +1,44 @@ +import pytest + +from algokit_kmd_client import KmdClient +from algokit_kmd_client.models import DeleteMultisigRequest, ListMultisigRequest + +from tests.fixtures.schemas.kmd import ListMultisigResponseSchema +from tests.modules.conftest import validate_with_schema + +from .fixtures import TEST_WALLET_PASSWORD, create_test_multisig + +# Polytest Suite: DELETE v1_multisig + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation( + localnet_kmd_client: KmdClient, + wallet_handle: tuple[str, str, str], +) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + wallet_handle_token, _, _ = wallet_handle + + # Create a multisig first + multisig_address, _, _, _ = create_test_multisig(localnet_kmd_client, wallet_handle_token) + + # Verify multisig exists + list_before = localnet_kmd_client.list_multisig(ListMultisigRequest(wallet_handle_token=wallet_handle_token)) + assert multisig_address in (list_before.addresses or []) + + # Delete the multisig (returns empty response) + localnet_kmd_client.delete_multisig( + DeleteMultisigRequest( + address=multisig_address, + wallet_handle_token=wallet_handle_token, + wallet_password=TEST_WALLET_PASSWORD, + ) + ) + + # Verify multisig was deleted + list_after = localnet_kmd_client.list_multisig(ListMultisigRequest(wallet_handle_token=wallet_handle_token)) + validate_with_schema(list_after, ListMultisigResponseSchema) + assert multisig_address not in (list_after.addresses or []) diff --git a/tests/modules/kmd_client/test_get_v1_wallets.py b/tests/modules/kmd_client/test_get_v1_wallets.py new file mode 100644 index 00000000..ae305109 --- /dev/null +++ b/tests/modules/kmd_client/test_get_v1_wallets.py @@ -0,0 +1,20 @@ +import pytest + +from algokit_kmd_client import KmdClient + +from tests.fixtures.schemas.kmd import ListWalletsResponseSchema +from tests.modules.conftest import validate_with_schema + +# Polytest Suite: GET v1_wallets + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation(localnet_kmd_client: KmdClient) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = localnet_kmd_client.list_wallets() + validate_with_schema(result, ListWalletsResponseSchema) + + assert result is not None diff --git a/tests/modules/kmd_client/test_get_versions.py b/tests/modules/kmd_client/test_get_versions.py new file mode 100644 index 00000000..e0ae123b --- /dev/null +++ b/tests/modules/kmd_client/test_get_versions.py @@ -0,0 +1,20 @@ +import pytest + +from algokit_kmd_client import KmdClient + +from tests.fixtures.schemas.kmd import VersionsResponseSchema +from tests.modules.conftest import validate_with_schema + +# Polytest Suite: GET versions + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation(localnet_kmd_client: KmdClient) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + result = localnet_kmd_client.version() + validate_with_schema(result, VersionsResponseSchema) + + assert result.versions is not None diff --git a/tests/modules/kmd_client/test_post_v1_key.py b/tests/modules/kmd_client/test_post_v1_key.py new file mode 100644 index 00000000..87776267 --- /dev/null +++ b/tests/modules/kmd_client/test_post_v1_key.py @@ -0,0 +1,31 @@ +import pytest + +from algokit_kmd_client import KmdClient +from algokit_kmd_client.models import GenerateKeyRequest, ListKeysRequest + +from tests.fixtures.schemas.kmd import GenerateKeyResponseSchema +from tests.modules.conftest import validate_with_schema + +# Polytest Suite: POST v1_key + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation( + localnet_kmd_client: KmdClient, + wallet_handle: tuple[str, str, str], +) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + wallet_handle_token, _, _ = wallet_handle + + result = localnet_kmd_client.generate_key(GenerateKeyRequest(wallet_handle_token=wallet_handle_token)) + validate_with_schema(result, GenerateKeyResponseSchema) + + assert result.address is not None + + # Verify the key exists in the wallet + list_result = localnet_kmd_client.list_keys_in_wallet(ListKeysRequest(wallet_handle_token=wallet_handle_token)) + addresses = list_result.addresses or [] + assert result.address in addresses diff --git a/tests/modules/kmd_client/test_post_v1_key_export.py b/tests/modules/kmd_client/test_post_v1_key_export.py new file mode 100644 index 00000000..b1acf611 --- /dev/null +++ b/tests/modules/kmd_client/test_post_v1_key_export.py @@ -0,0 +1,37 @@ +import pytest + +from algokit_kmd_client import KmdClient +from algokit_kmd_client.models import ExportKeyRequest + +from tests.fixtures.schemas.kmd import ExportKeyResponseSchema +from tests.modules.conftest import validate_with_schema + +from .fixtures import TEST_WALLET_PASSWORD, generate_test_key + +# Polytest Suite: POST v1_key_export + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation( + localnet_kmd_client: KmdClient, + wallet_handle: tuple[str, str, str], +) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + wallet_handle_token, _, _ = wallet_handle + + # Generate a key first + address = generate_test_key(localnet_kmd_client, wallet_handle_token) + + result = localnet_kmd_client.export_key( + ExportKeyRequest( + wallet_handle_token=wallet_handle_token, + address=address, + wallet_password=TEST_WALLET_PASSWORD, + ) + ) + validate_with_schema(result, ExportKeyResponseSchema) + + assert result.private_key is not None diff --git a/tests/modules/kmd_client/test_post_v1_key_import.py b/tests/modules/kmd_client/test_post_v1_key_import.py new file mode 100644 index 00000000..8329cf70 --- /dev/null +++ b/tests/modules/kmd_client/test_post_v1_key_import.py @@ -0,0 +1,46 @@ +import secrets + +import pytest +from nacl.signing import SigningKey + +from algokit_kmd_client import KmdClient +from algokit_kmd_client.models import ImportKeyRequest + +from tests.fixtures.schemas.kmd import ImportKeyResponseSchema +from tests.modules.conftest import validate_with_schema + +from .fixtures import public_key_to_address + +# Polytest Suite: POST v1_key_import + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation( + localnet_kmd_client: KmdClient, + wallet_handle: tuple[str, str, str], +) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + wallet_handle_token, _, _ = wallet_handle + + # Generate a random ed25519 keypair + seed = secrets.token_bytes(32) + signing_key = SigningKey(seed) + # The private key for import is the 64-byte concatenation of seed + public key + private_key = bytes(signing_key) + bytes(signing_key.verify_key) + + result = localnet_kmd_client.import_key( + ImportKeyRequest( + wallet_handle_token=wallet_handle_token, + private_key=private_key, + ) + ) + validate_with_schema(result, ImportKeyResponseSchema) + + assert result.address is not None + + # Verify the imported key's address matches the public key + expected_address = public_key_to_address(bytes(signing_key.verify_key)) + assert result.address == expected_address diff --git a/tests/modules/kmd_client/test_post_v1_key_list.py b/tests/modules/kmd_client/test_post_v1_key_list.py new file mode 100644 index 00000000..4b73dcb0 --- /dev/null +++ b/tests/modules/kmd_client/test_post_v1_key_list.py @@ -0,0 +1,32 @@ +import pytest + +from algokit_kmd_client import KmdClient +from algokit_kmd_client.models import ListKeysRequest + +from tests.fixtures.schemas.kmd import ListKeysResponseSchema +from tests.modules.conftest import validate_with_schema + +from .fixtures import generate_test_key + +# Polytest Suite: POST v1_key_list + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation( + localnet_kmd_client: KmdClient, + wallet_handle: tuple[str, str, str], +) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + wallet_handle_token, _, _ = wallet_handle + + # Generate at least one key + generate_test_key(localnet_kmd_client, wallet_handle_token) + + result = localnet_kmd_client.list_keys_in_wallet(ListKeysRequest(wallet_handle_token=wallet_handle_token)) + validate_with_schema(result, ListKeysResponseSchema) + + assert result.addresses is not None + assert len(result.addresses) > 0 diff --git a/tests/modules/kmd_client/test_post_v1_master_key_export.py b/tests/modules/kmd_client/test_post_v1_master_key_export.py new file mode 100644 index 00000000..946a5bd4 --- /dev/null +++ b/tests/modules/kmd_client/test_post_v1_master_key_export.py @@ -0,0 +1,33 @@ +import pytest + +from algokit_kmd_client import KmdClient +from algokit_kmd_client.models import ExportMasterKeyRequest + +from tests.fixtures.schemas.kmd import ExportMasterKeyResponseSchema +from tests.modules.conftest import validate_with_schema + +from .fixtures import TEST_WALLET_PASSWORD + +# Polytest Suite: POST v1_master-key_export + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation( + localnet_kmd_client: KmdClient, + wallet_handle: tuple[str, str, str], +) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + wallet_handle_token, _, _ = wallet_handle + + result = localnet_kmd_client.export_master_key( + ExportMasterKeyRequest( + wallet_handle_token=wallet_handle_token, + wallet_password=TEST_WALLET_PASSWORD, + ) + ) + validate_with_schema(result, ExportMasterKeyResponseSchema) + + assert result.master_derivation_key is not None diff --git a/tests/modules/kmd_client/test_post_v1_multisig_export.py b/tests/modules/kmd_client/test_post_v1_multisig_export.py new file mode 100644 index 00000000..6d1fa0b1 --- /dev/null +++ b/tests/modules/kmd_client/test_post_v1_multisig_export.py @@ -0,0 +1,38 @@ +import pytest + +from algokit_kmd_client import KmdClient +from algokit_kmd_client.models import ExportMultisigRequest + +from tests.fixtures.schemas.kmd import ExportMultisigResponseSchema +from tests.modules.conftest import validate_with_schema + +from .fixtures import create_test_multisig + +# Polytest Suite: POST v1_multisig_export + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation( + localnet_kmd_client: KmdClient, + wallet_handle: tuple[str, str, str], +) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + wallet_handle_token, _, _ = wallet_handle + + # Create a multisig first + multisig_address, public_keys, _, threshold = create_test_multisig(localnet_kmd_client, wallet_handle_token) + + result = localnet_kmd_client.export_multisig( + ExportMultisigRequest( + wallet_handle_token=wallet_handle_token, + address=multisig_address, + ) + ) + validate_with_schema(result, ExportMultisigResponseSchema) + + assert result.multisig_version == 1 + assert result.threshold == threshold + assert result.public_keys == public_keys diff --git a/tests/modules/kmd_client/test_post_v1_multisig_import.py b/tests/modules/kmd_client/test_post_v1_multisig_import.py new file mode 100644 index 00000000..dfa5e901 --- /dev/null +++ b/tests/modules/kmd_client/test_post_v1_multisig_import.py @@ -0,0 +1,50 @@ +import pytest + +from algokit_kmd_client import KmdClient +from algokit_kmd_client.models import ImportMultisigRequest +from algokit_transact import address_from_multisig_signature, new_multisig_signature + +from tests.fixtures.schemas.kmd import ImportMultisigResponseSchema +from tests.modules.conftest import validate_with_schema + +from .fixtures import ( + MULTISIG_KEY_COUNT, + MULTISIG_THRESHOLD, + MULTISIG_VERSION, + address_to_public_key, + generate_multiple_keys, +) + +# Polytest Suite: POST v1_multisig_import + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation( + localnet_kmd_client: KmdClient, + wallet_handle: tuple[str, str, str], +) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + wallet_handle_token, _, _ = wallet_handle + + # Generate keys for multisig + addresses = generate_multiple_keys(localnet_kmd_client, wallet_handle_token, MULTISIG_KEY_COUNT) + public_keys = [address_to_public_key(addr) for addr in addresses] + + # Calculate expected multisig address + msig = new_multisig_signature(MULTISIG_VERSION, MULTISIG_THRESHOLD, addresses) + expected_address = address_from_multisig_signature(msig) + + result = localnet_kmd_client.import_multisig( + ImportMultisigRequest( + wallet_handle_token=wallet_handle_token, + multisig_version=MULTISIG_VERSION, + threshold=MULTISIG_THRESHOLD, + public_keys=public_keys, + ) + ) + validate_with_schema(result, ImportMultisigResponseSchema) + + assert result.address == expected_address diff --git a/tests/modules/kmd_client/test_post_v1_multisig_list.py b/tests/modules/kmd_client/test_post_v1_multisig_list.py new file mode 100644 index 00000000..4f9554b5 --- /dev/null +++ b/tests/modules/kmd_client/test_post_v1_multisig_list.py @@ -0,0 +1,33 @@ +import pytest + +from algokit_kmd_client import KmdClient +from algokit_kmd_client.models import ListMultisigRequest + +from tests.fixtures.schemas.kmd import ListMultisigResponseSchema +from tests.modules.conftest import validate_with_schema + +from .fixtures import create_test_multisig + +# Polytest Suite: POST v1_multisig_list + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation( + localnet_kmd_client: KmdClient, + wallet_handle: tuple[str, str, str], +) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + wallet_handle_token, _, _ = wallet_handle + + # Create a multisig first + multisig_address, _, _, _ = create_test_multisig(localnet_kmd_client, wallet_handle_token) + + result = localnet_kmd_client.list_multisig(ListMultisigRequest(wallet_handle_token=wallet_handle_token)) + validate_with_schema(result, ListMultisigResponseSchema) + + assert result.addresses is not None + # Verify the multisig is in the list + assert multisig_address in result.addresses diff --git a/tests/modules/kmd_client/test_post_v1_multisig_sign.py b/tests/modules/kmd_client/test_post_v1_multisig_sign.py new file mode 100644 index 00000000..1497815a --- /dev/null +++ b/tests/modules/kmd_client/test_post_v1_multisig_sign.py @@ -0,0 +1,62 @@ +import pytest + +from algokit_algod_client import AlgodClient +from algokit_kmd_client import KmdClient +from algokit_kmd_client.models import SignMultisigTxnRequest +from algokit_transact import PaymentTransactionFields, Transaction, TransactionType, encode_transaction_raw + +from tests.fixtures.schemas.kmd import SignMultisigResponseSchema +from tests.modules.conftest import validate_with_schema + +from .fixtures import TEST_WALLET_PASSWORD, create_test_multisig + +# Polytest Suite: POST v1_multisig_sign + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation( + localnet_kmd_client: KmdClient, + localnet_algod_client: AlgodClient, + wallet_handle: tuple[str, str, str], +) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + wallet_handle_token, _, _ = wallet_handle + + # Create a multisig account + multisig_address, public_keys, _, _ = create_test_multisig(localnet_kmd_client, wallet_handle_token) + + # Get suggested params from algod + suggested_params = localnet_algod_client.suggested_params() + + # Create a simple payment transaction from the multisig address + transaction = Transaction( + transaction_type=TransactionType.Payment, + sender=multisig_address, + first_valid=suggested_params.first_valid, + last_valid=suggested_params.last_valid, + genesis_hash=suggested_params.genesis_hash, + genesis_id=suggested_params.genesis_id, + payment=PaymentTransactionFields( + receiver=multisig_address, # Self-payment + amount=0, + ), + ) + + # Encode the transaction + transaction_bytes = encode_transaction_raw(transaction) + + # Sign with the first key + result = localnet_kmd_client.sign_multisig_transaction( + SignMultisigTxnRequest( + wallet_handle_token=wallet_handle_token, + transaction=transaction_bytes, + public_key=public_keys[0], + wallet_password=TEST_WALLET_PASSWORD, + ) + ) + validate_with_schema(result, SignMultisigResponseSchema) + + assert result.multisig is not None diff --git a/tests/modules/kmd_client/test_post_v1_multisig_signprogram.py b/tests/modules/kmd_client/test_post_v1_multisig_signprogram.py new file mode 100644 index 00000000..c4765ac9 --- /dev/null +++ b/tests/modules/kmd_client/test_post_v1_multisig_signprogram.py @@ -0,0 +1,49 @@ +import base64 + +import pytest + +from algokit_algod_client import AlgodClient +from algokit_kmd_client import KmdClient +from algokit_kmd_client.models import SignProgramMultisigRequest + +from tests.fixtures.schemas.kmd import SignProgramMultisigResponseSchema +from tests.modules.conftest import validate_with_schema + +from .fixtures import TEST_WALLET_PASSWORD, create_test_multisig + +# Polytest Suite: POST v1_multisig_signprogram + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation( + localnet_kmd_client: KmdClient, + localnet_algod_client: AlgodClient, + wallet_handle: tuple[str, str, str], +) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + wallet_handle_token, _, _ = wallet_handle + + # Create a multisig account + multisig_address, public_keys, _, _ = create_test_multisig(localnet_kmd_client, wallet_handle_token) + + # Compile a simple TEAL program (always approves) + teal_source = b"#pragma version 8\nint 1" + compile_result = localnet_algod_client.teal_compile(teal_source) + program_bytes = base64.b64decode(compile_result.result) + + # Sign the program with the first key + result = localnet_kmd_client.sign_multisig_program( + SignProgramMultisigRequest( + wallet_handle_token=wallet_handle_token, + address=multisig_address, + program=program_bytes, + public_key=public_keys[0], + wallet_password=TEST_WALLET_PASSWORD, + ) + ) + validate_with_schema(result, SignProgramMultisigResponseSchema) + + assert result.multisig is not None diff --git a/tests/modules/kmd_client/test_post_v1_program_sign.py b/tests/modules/kmd_client/test_post_v1_program_sign.py new file mode 100644 index 00000000..ce629407 --- /dev/null +++ b/tests/modules/kmd_client/test_post_v1_program_sign.py @@ -0,0 +1,48 @@ +import base64 + +import pytest + +from algokit_algod_client import AlgodClient +from algokit_kmd_client import KmdClient +from algokit_kmd_client.models import SignProgramRequest + +from tests.fixtures.schemas.kmd import SignProgramResponseSchema +from tests.modules.conftest import validate_with_schema + +from .fixtures import TEST_WALLET_PASSWORD, generate_test_key + +# Polytest Suite: POST v1_program_sign + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation( + localnet_kmd_client: KmdClient, + localnet_algod_client: AlgodClient, + wallet_handle: tuple[str, str, str], +) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + wallet_handle_token, _, _ = wallet_handle + + # Generate a key + address = generate_test_key(localnet_kmd_client, wallet_handle_token) + + # Compile a simple TEAL program (always approves) + teal_source = b"#pragma version 8\nint 1" + compile_result = localnet_algod_client.teal_compile(teal_source) + program_bytes = base64.b64decode(compile_result.result) + + # Sign the program + result = localnet_kmd_client.sign_program( + SignProgramRequest( + wallet_handle_token=wallet_handle_token, + address=address, + program=program_bytes, + wallet_password=TEST_WALLET_PASSWORD, + ) + ) + validate_with_schema(result, SignProgramResponseSchema) + + assert result.sig is not None diff --git a/tests/modules/kmd_client/test_post_v1_transaction_sign.py b/tests/modules/kmd_client/test_post_v1_transaction_sign.py new file mode 100644 index 00000000..4bb591e3 --- /dev/null +++ b/tests/modules/kmd_client/test_post_v1_transaction_sign.py @@ -0,0 +1,61 @@ +import pytest + +from algokit_algod_client import AlgodClient +from algokit_kmd_client import KmdClient +from algokit_kmd_client.models import SignTxnRequest +from algokit_transact import PaymentTransactionFields, Transaction, TransactionType, encode_transaction_raw + +from tests.fixtures.schemas.kmd import SignTransactionResponseSchema +from tests.modules.conftest import validate_with_schema + +from .fixtures import TEST_WALLET_PASSWORD, generate_test_key + +# Polytest Suite: POST v1_transaction_sign + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation( + localnet_kmd_client: KmdClient, + localnet_algod_client: AlgodClient, + wallet_handle: tuple[str, str, str], +) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + wallet_handle_token, _, _ = wallet_handle + + # Generate a key + address = generate_test_key(localnet_kmd_client, wallet_handle_token) + + # Get suggested params from algod + suggested_params = localnet_algod_client.suggested_params() + + # Create a simple payment transaction + transaction = Transaction( + transaction_type=TransactionType.Payment, + sender=address, + first_valid=suggested_params.first_valid, + last_valid=suggested_params.last_valid, + genesis_hash=suggested_params.genesis_hash, + genesis_id=suggested_params.genesis_id, + payment=PaymentTransactionFields( + receiver=address, # Self-payment + amount=0, + ), + ) + + # Encode the transaction + transaction_bytes = encode_transaction_raw(transaction) + + # Sign the transaction + result = localnet_kmd_client.sign_transaction( + SignTxnRequest( + wallet_handle_token=wallet_handle_token, + transaction=transaction_bytes, + wallet_password=TEST_WALLET_PASSWORD, + ) + ) + validate_with_schema(result, SignTransactionResponseSchema) + + assert result.signed_transaction is not None diff --git a/tests/modules/kmd_client/test_post_v1_wallet.py b/tests/modules/kmd_client/test_post_v1_wallet.py new file mode 100644 index 00000000..77190b1e --- /dev/null +++ b/tests/modules/kmd_client/test_post_v1_wallet.py @@ -0,0 +1,27 @@ +import pytest + +from algokit_kmd_client import KmdClient + +from tests.fixtures.schemas.kmd import ListWalletsResponseSchema +from tests.modules.conftest import validate_with_schema + +from .fixtures import create_test_wallet + +# Polytest Suite: POST v1_wallet + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation(localnet_kmd_client: KmdClient) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + wallet_id, wallet_name = create_test_wallet(localnet_kmd_client) + + # Verify the wallet was created + list_result = localnet_kmd_client.list_wallets() + validate_with_schema(list_result, ListWalletsResponseSchema) + wallets = list_result.wallets or [] + created_wallet = next((w for w in wallets if w.id_ == wallet_id), None) + assert created_wallet is not None + assert created_wallet.name == wallet_name diff --git a/tests/modules/kmd_client/test_post_v1_wallet_info.py b/tests/modules/kmd_client/test_post_v1_wallet_info.py new file mode 100644 index 00000000..adc90f01 --- /dev/null +++ b/tests/modules/kmd_client/test_post_v1_wallet_info.py @@ -0,0 +1,26 @@ +import pytest + +from algokit_kmd_client import KmdClient +from algokit_kmd_client.models import WalletInfoRequest + +from tests.fixtures.schemas.kmd import WalletInfoResponseSchema +from tests.modules.conftest import validate_with_schema + +# Polytest Suite: POST v1_wallet_info + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation( + localnet_kmd_client: KmdClient, + wallet_handle: tuple[str, str, str], +) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + wallet_handle_token, _, _ = wallet_handle + + result = localnet_kmd_client.wallet_info(WalletInfoRequest(wallet_handle_token=wallet_handle_token)) + validate_with_schema(result, WalletInfoResponseSchema) + + assert result.wallet_handle is not None diff --git a/tests/modules/kmd_client/test_post_v1_wallet_init.py b/tests/modules/kmd_client/test_post_v1_wallet_init.py new file mode 100644 index 00000000..4f511aab --- /dev/null +++ b/tests/modules/kmd_client/test_post_v1_wallet_init.py @@ -0,0 +1,31 @@ +import pytest + +from algokit_kmd_client import KmdClient +from algokit_kmd_client.models import InitWalletHandleTokenRequest + +from tests.fixtures.schemas.kmd import InitWalletHandleTokenResponseSchema +from tests.modules.conftest import validate_with_schema + +from .fixtures import TEST_WALLET_PASSWORD, create_test_wallet + +# Polytest Suite: POST v1_wallet_init + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation(localnet_kmd_client: KmdClient) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + # Create a wallet first + wallet_id, _ = create_test_wallet(localnet_kmd_client) + + result = localnet_kmd_client.init_wallet_handle( + InitWalletHandleTokenRequest( + wallet_id=wallet_id, + wallet_password=TEST_WALLET_PASSWORD, + ) + ) + validate_with_schema(result, InitWalletHandleTokenResponseSchema) + + assert result.wallet_handle_token is not None diff --git a/tests/modules/kmd_client/test_post_v1_wallet_release.py b/tests/modules/kmd_client/test_post_v1_wallet_release.py new file mode 100644 index 00000000..60df7e59 --- /dev/null +++ b/tests/modules/kmd_client/test_post_v1_wallet_release.py @@ -0,0 +1,28 @@ +import pytest + +from algokit_kmd_client import KmdClient +from algokit_kmd_client.exceptions import UnexpectedStatusError +from algokit_kmd_client.models import ReleaseWalletHandleTokenRequest, WalletInfoRequest + +from .fixtures import get_wallet_handle + +# Polytest Suite: POST v1_wallet_release + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation(localnet_kmd_client: KmdClient) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + # Create our own wallet handle since we need to release it (not use the fixture) + wallet_handle_token, _, _ = get_wallet_handle(localnet_kmd_client) + + # Release should succeed (returns empty response) + localnet_kmd_client.release_wallet_handle_token( + ReleaseWalletHandleTokenRequest(wallet_handle_token=wallet_handle_token) + ) + + # Verify the handle is now invalid by trying to use it + with pytest.raises(UnexpectedStatusError, match="handle does not exist"): + localnet_kmd_client.wallet_info(WalletInfoRequest(wallet_handle_token=wallet_handle_token)) diff --git a/tests/modules/kmd_client/test_post_v1_wallet_rename.py b/tests/modules/kmd_client/test_post_v1_wallet_rename.py new file mode 100644 index 00000000..30981249 --- /dev/null +++ b/tests/modules/kmd_client/test_post_v1_wallet_rename.py @@ -0,0 +1,41 @@ +import pytest + +from algokit_kmd_client import KmdClient +from algokit_kmd_client.models import RenameWalletRequest, WalletInfoRequest + +from tests.fixtures.schemas.kmd import RenameWalletResponseSchema +from tests.modules.conftest import validate_with_schema + +from .fixtures import TEST_WALLET_PASSWORD + +# Polytest Suite: POST v1_wallet_rename + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation( + localnet_kmd_client: KmdClient, + wallet_handle: tuple[str, str, str], +) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + wallet_handle_token, wallet_id, wallet_name = wallet_handle + + new_wallet_name = f"{wallet_name}-renamed" + result = localnet_kmd_client.rename_wallet( + RenameWalletRequest( + wallet_id=wallet_id, + wallet_password=TEST_WALLET_PASSWORD, + wallet_name=new_wallet_name, + ) + ) + validate_with_schema(result, RenameWalletResponseSchema) + + assert result.wallet is not None + + # Verify the wallet was renamed + wallet_info = localnet_kmd_client.wallet_info(WalletInfoRequest(wallet_handle_token=wallet_handle_token)) + assert wallet_info.wallet_handle is not None + assert wallet_info.wallet_handle.wallet is not None + assert wallet_info.wallet_handle.wallet.name == new_wallet_name diff --git a/tests/modules/kmd_client/test_post_v1_wallet_renew.py b/tests/modules/kmd_client/test_post_v1_wallet_renew.py new file mode 100644 index 00000000..e9057e78 --- /dev/null +++ b/tests/modules/kmd_client/test_post_v1_wallet_renew.py @@ -0,0 +1,28 @@ +import pytest + +from algokit_kmd_client import KmdClient +from algokit_kmd_client.models import RenewWalletHandleTokenRequest + +from tests.fixtures.schemas.kmd import RenewWalletHandleTokenResponseSchema +from tests.modules.conftest import validate_with_schema + +# Polytest Suite: POST v1_wallet_renew + +# Polytest Group: Common Tests + + +@pytest.mark.group_common_tests +@pytest.mark.localnet +def test_basic_request_and_response_validation( + localnet_kmd_client: KmdClient, + wallet_handle: tuple[str, str, str], +) -> None: + """Given a known request validate that the same request can be made using our models. Then, validate that our response model aligns with the known response""" + wallet_handle_token, _, _ = wallet_handle + + result = localnet_kmd_client.renew_wallet_handle_token( + RenewWalletHandleTokenRequest(wallet_handle_token=wallet_handle_token) + ) + validate_with_schema(result, RenewWalletHandleTokenResponseSchema) + + assert result.wallet_handle is not None diff --git a/tests/modules/test_schema_validation.py b/tests/modules/test_schema_validation.py new file mode 100644 index 00000000..a2c07a9d --- /dev/null +++ b/tests/modules/test_schema_validation.py @@ -0,0 +1,192 @@ +"""Runtime schema validation tests for all API clients.""" + +import pytest +from pydantic import ValidationError + +from tests.fixtures.schemas.algod import AccountSchema, NodeStatusResponseSchema +from tests.fixtures.schemas.indexer import AccountResponseSchema +from tests.fixtures.schemas.kmd import CreateWalletResponseSchema, WalletSchema + +# All required fields for algod AccountSchema +VALID_ALGOD_ACCOUNT: dict = { + "address": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ", + "amount": 1000000, + "amount-without-pending-rewards": 1000000, + "min-balance": 100000, + "pending-rewards": 0, + "rewards": 0, + "round": 1000, + "status": "Offline", + "total-apps-opted-in": 0, + "total-assets-opted-in": 0, + "total-created-apps": 0, + "total-created-assets": 0, +} + +# All required fields for indexer AccountSchema (includes extra fields vs algod) +VALID_INDEXER_ACCOUNT: dict = { + **VALID_ALGOD_ACCOUNT, + "total-boxes": 0, + "total-box-bytes": 0, +} + + +def test_algod_schemas_validate(): + """Algod schemas validate correct data and reject invalid data.""" + account = AccountSchema.model_validate(VALID_ALGOD_ACCOUNT) + assert account.address == VALID_ALGOD_ACCOUNT["address"] + assert account.amount == 1000000 + + # Type validation — amount should be an integer + with pytest.raises(ValidationError): + AccountSchema.model_validate({**VALID_ALGOD_ACCOUNT, "amount": "not_int"}) + + # uint64 bounds — amount cannot be negative + with pytest.raises(ValidationError): + AccountSchema.model_validate({**VALID_ALGOD_ACCOUNT, "amount": -1}) + + # Required field validation — missing fields should fail + with pytest.raises(ValidationError): + AccountSchema.model_validate({}) + + +def test_kmd_schemas_validate(): + """KMD schemas validate nested structures.""" + valid = { + "wallet": { + "id": "test-id", + "name": "test-wallet", + "driver_name": "sqlite", + "driver_version": 1, + "mnemonic_ux": False, + "supported_txs": [], + }, + } + + wallet = CreateWalletResponseSchema.model_validate(valid) + assert wallet.wallet.name == "test-wallet" + + # Type validation — wallet should be an object, not a string + with pytest.raises(ValidationError): + CreateWalletResponseSchema.model_validate({"wallet": "not_an_object"}) + + +def test_indexer_schemas_validate(): + """Indexer schemas validate with enums from models.""" + valid = { + "current-round": 1000, + "account": { + **VALID_INDEXER_ACCOUNT, + "created-at-round": 0, + "deleted": False, + "reward-base": 0, + }, + } + + response = AccountResponseSchema.model_validate(valid) + assert response.current_round == 1000 + assert response.account.address == VALID_INDEXER_ACCOUNT["address"] + + # Type validation — current-round should be an integer + with pytest.raises(ValidationError): + AccountResponseSchema.model_validate({**valid, "current-round": "not_an_int"}) + + +@pytest.mark.localnet +def test_algod_runtime_validation(algorand_localnet: object) -> None: + """Validate real algod API responses.""" + from dataclasses import asdict + + from algokit_utils.algorand import AlgorandClient + + client = algorand_localnet if isinstance(algorand_localnet, AlgorandClient) else AlgorandClient.default_localnet() + response = client.client.algod.status() + # Convert dataclass response to dict for Pydantic validation + response_dict = asdict(response) + validated = NodeStatusResponseSchema.model_validate(response_dict) + assert validated.last_round >= 0 + + +class TestBasicValidation: + """Test basic schema validation.""" + + def test_valid_data(self) -> None: + """Valid data should pass validation.""" + schema = AccountSchema.model_validate(VALID_ALGOD_ACCOUNT) + assert schema.address == VALID_ALGOD_ACCOUNT["address"] + assert schema.amount == 1000000 + + def test_invalid_type(self) -> None: + """Invalid type should fail validation.""" + with pytest.raises(ValidationError): + AccountSchema.model_validate({**VALID_ALGOD_ACCOUNT, "amount": "not_a_number"}) + + def test_missing_required_fields(self) -> None: + """Missing required fields should fail validation.""" + with pytest.raises(ValidationError) as exc_info: + AccountSchema.model_validate({"address": "test"}) + # Should report multiple missing required fields + assert "Field required" in str(exc_info.value) + + +class TestUint64Bounds: + """Test uint64 field bounds validation.""" + + def test_valid_uint64(self) -> None: + """Values within uint64 range should pass.""" + schema = AccountSchema.model_validate(VALID_ALGOD_ACCOUNT) + assert schema.amount == 1000000 + assert schema.min_balance == 100000 + + def test_max_uint64(self) -> None: + """Maximum uint64 value should pass.""" + max_uint64 = 18446744073709551615 + data = {**VALID_ALGOD_ACCOUNT, "amount": max_uint64} + schema = AccountSchema.model_validate(data) + assert schema.amount == max_uint64 + + def test_negative_uint64(self) -> None: + """Negative values should fail.""" + with pytest.raises(ValidationError) as exc_info: + AccountSchema.model_validate({**VALID_ALGOD_ACCOUNT, "amount": -1}) + assert "greater than or equal to 0" in str(exc_info.value) + + def test_overflow_uint64(self) -> None: + """Values exceeding uint64 max should fail.""" + with pytest.raises(ValidationError) as exc_info: + AccountSchema.model_validate({**VALID_ALGOD_ACCOUNT, "amount": 18446744073709551616}) + assert "less than or equal to" in str(exc_info.value) + + +class TestSchemaImports: + """Test that schemas can be imported correctly.""" + + def test_algod_schemas_import(self) -> None: + """Algod schemas should be importable.""" + from tests.fixtures.schemas.algod import ( + ApplicationSchema, + AssetSchema, + ) + + assert AccountSchema is not None + assert AssetSchema is not None + assert ApplicationSchema is not None + + def test_kmd_schemas_import(self) -> None: + """KMD schemas should be importable.""" + from tests.fixtures.schemas.kmd import CreateWalletRequestSchema + + assert WalletSchema is not None + assert CreateWalletRequestSchema is not None + + def test_indexer_schemas_import(self) -> None: + """Indexer schemas should be importable.""" + from tests.fixtures.schemas.indexer import ( + AccountSchema as IndexerAccountSchema, + BlockSchema, + TransactionSchema, + ) + + assert IndexerAccountSchema is not None + assert TransactionSchema is not None + assert BlockSchema is not None diff --git a/tests/modules/transact/__init__.py b/tests/modules/transact/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/modules/transact/_helpers.py b/tests/modules/transact/_helpers.py new file mode 100644 index 00000000..39c9a220 --- /dev/null +++ b/tests/modules/transact/_helpers.py @@ -0,0 +1,49 @@ +from collections.abc import Iterable + + +def iter_app_call_test_data() -> Iterable[tuple[str, str]]: + return ( + ("app call", "appCall"), + ("app create", "appCreate"), + ("app update", "appUpdate"), + ("app delete", "appDelete"), + ) + + +def iter_asset_config_test_data() -> Iterable[tuple[str, str]]: + return ( + ("asset create", "assetCreate"), + ("asset config", "assetConfig"), + ("asset destroy", "assetDestroy"), + ) + + +def iter_asset_transfer_test_data() -> Iterable[tuple[str, str]]: + return (("asset opt-in", "optInAssetTransfer"),) + + +def iter_asset_freeze_test_data() -> Iterable[tuple[str, str]]: + return ( + ("freeze", "assetFreeze"), + ("unfreeze", "assetUnfreeze"), + ) + + +def iter_payment_test_data() -> Iterable[tuple[str, str]]: + return (("payment", "simplePayment"),) + + +def iter_key_registration_test_data() -> Iterable[tuple[str, str]]: + return ( + ("online key registration", "onlineKeyRegistration"), + ("offline key registration", "offlineKeyRegistration"), + ("non-participation key registration", "nonParticipationKeyRegistration"), + ) + + +def iter_heartbeat_test_data() -> Iterable[tuple[str, str]]: + return (("heartbeat", "heartbeat"),) + + +def iter_state_proof_test_data() -> Iterable[tuple[str, str]]: + return (("state proof", "stateProof"),) diff --git a/tests/modules/transact/_validation.py b/tests/modules/transact/_validation.py new file mode 100644 index 00000000..cdb12e4f --- /dev/null +++ b/tests/modules/transact/_validation.py @@ -0,0 +1,141 @@ +from collections.abc import Iterable +from dataclasses import replace +from typing import Any + +import pytest + +from algokit_transact import ( + AppCallTransactionFields, + AssetConfigTransactionFields, + AssetFreezeTransactionFields, + AssetTransferTransactionFields, + BoxReference, + KeyRegistrationTransactionFields, + OnApplicationComplete, + ResourceReference, + StateSchema, + Transaction, + TransactionValidationError, + validate_transaction, +) + + +def clone_transaction(transaction: Transaction, **overrides: Any) -> Transaction: + return replace(transaction, **overrides) + + +def build_app_call( # noqa: PLR0913 + *, + app_id: int, + on_complete: OnApplicationComplete, + approval_program: bytes | None = None, + clear_state_program: bytes | None = None, + global_state_schema: StateSchema | None = None, + local_state_schema: StateSchema | None = None, + args: Iterable[bytes] | None = None, + account_references: Iterable[str] | None = None, + app_references: Iterable[int] | None = None, + asset_references: Iterable[int] | None = None, + extra_program_pages: int | None = None, + box_references: Iterable[BoxReference] | None = None, + access_references: Iterable[ResourceReference] | None = None, +) -> AppCallTransactionFields: + return AppCallTransactionFields( + app_id=app_id, + on_complete=on_complete, + approval_program=approval_program, + clear_state_program=clear_state_program, + global_state_schema=global_state_schema, + local_state_schema=local_state_schema, + args=tuple(args) if args is not None else None, + account_references=tuple(account_references) if account_references is not None else None, + app_references=tuple(app_references) if app_references is not None else None, + asset_references=tuple(asset_references) if asset_references is not None else None, + extra_program_pages=extra_program_pages, + box_references=tuple(box_references) if box_references is not None else None, + access_references=tuple(access_references) if access_references is not None else None, + ) + + +def build_asset_config( # noqa: PLR0913 + *, + asset_id: int, + total: int | None = None, + decimals: int | None = None, + default_frozen: bool | None = None, + asset_name: str | None = None, + unit_name: str | None = None, + url: str | None = None, + metadata_hash: bytes | None = None, + manager: str | None = None, + reserve: str | None = None, + freeze: str | None = None, + clawback: str | None = None, +) -> AssetConfigTransactionFields: + return AssetConfigTransactionFields( + asset_id=asset_id, + total=total, + decimals=decimals, + default_frozen=default_frozen, + asset_name=asset_name, + unit_name=unit_name, + url=url, + metadata_hash=metadata_hash, + manager=manager, + reserve=reserve, + freeze=freeze, + clawback=clawback, + ) + + +def build_asset_transfer( + *, + asset_id: int, + amount: int, + receiver: str, + asset_sender: str | None = None, + close_remainder_to: str | None = None, +) -> AssetTransferTransactionFields: + return AssetTransferTransactionFields( + asset_id=asset_id, + amount=amount, + receiver=receiver, + asset_sender=asset_sender, + close_remainder_to=close_remainder_to, + ) + + +def build_asset_freeze( + *, + asset_id: int, + freeze_target: str, + frozen: bool, +) -> AssetFreezeTransactionFields: + return AssetFreezeTransactionFields(asset_id=asset_id, freeze_target=freeze_target, frozen=frozen) + + +def build_key_registration( + *, + vote_key: bytes | None = None, + selection_key: bytes | None = None, + state_proof_key: bytes | None = None, + vote_first: int | None = None, + vote_last: int | None = None, + vote_key_dilution: int | None = None, + non_participation: bool | None = None, +) -> KeyRegistrationTransactionFields: + return KeyRegistrationTransactionFields( + vote_key=vote_key, + selection_key=selection_key, + state_proof_key=state_proof_key, + vote_first=vote_first, + vote_last=vote_last, + vote_key_dilution=vote_key_dilution, + non_participation=non_participation, + ) + + +def assert_validation_error(transaction: Transaction, message: str) -> None: + with pytest.raises(TransactionValidationError) as exc: + validate_transaction(transaction) + assert message in str(exc.value) diff --git a/tests/modules/transact/common.py b/tests/modules/transact/common.py new file mode 100644 index 00000000..a1d007ca --- /dev/null +++ b/tests/modules/transact/common.py @@ -0,0 +1,197 @@ +"""Shared helpers for Algokit Transact pytest suites. + +This module loads test data from the data factory, mirroring the approach in +the TypeScript workspace's common.ts. +""" + +import base64 +import json +from dataclasses import dataclass +from functools import lru_cache +from pathlib import Path +from typing import Any + +from algokit_common import public_key_from_address +from algokit_transact import ( + Transaction, + from_transaction_dto, +) + +TESTS_DIR = Path(__file__).resolve().parent +DATA_FACTORY_PATH = TESTS_DIR / "polytest_resources" / "data-factory" / "data" + + +@dataclass(frozen=True) +class SingleSigner: + """Single signer with secret key and public key (mirrors TS { SK, SignatureVerifier }).""" + + sk: bytes # 64-byte ed25519 private key + pk: bytes # 32-byte public key (signature verifier) + + +@dataclass(frozen=True) +class SignerInfo: + """Signer information from data factory (mirrors TS SignerInfo).""" + + single_signer: SingleSigner | None + msig_signers: tuple[SingleSigner, ...] | None + lsig: bytes | None + + +@dataclass(frozen=True) +class TransactionTestData: + """Test data loaded from data factory files (mirrors TS TransactionTestData).""" + + id: str + transaction: Transaction + unsigned_bytes: bytes + signed_bytes: bytes + signer: SignerInfo + + +def _b64_decode(value: str | None) -> bytes | None: + """Decode base64 string to bytes.""" + if value is None: + return None + return base64.b64decode(value) + + +def _parse_signer(signer: dict[str, Any]) -> SignerInfo: + """Parse signer information from data factory format.""" + single_raw = signer.get("singleSigner") + msig_raw = signer.get("msigSigners") + + single_signer = None + if single_raw: + sk = _b64_decode(single_raw.get("SK")) + pk = _b64_decode(single_raw.get("SignatureVerifier")) + if sk and pk: + single_signer = SingleSigner(sk=sk, pk=pk) + + msig_signers = None + if msig_raw and isinstance(msig_raw, list): + signers = [ + SingleSigner(sk=sk, pk=pk) + for s in msig_raw + if (sk := _b64_decode(s.get("SK"))) and (pk := _b64_decode(s.get("SignatureVerifier"))) + ] + msig_signers = tuple(signers) if signers else None + + lsig = _b64_decode(signer.get("lsig")) if isinstance(signer.get("lsig"), str) else None + + return SignerInfo(single_signer=single_signer, msig_signers=msig_signers, lsig=lsig) + + +_ADDR = "addr" # 58-char address string -> 32-byte public key +_BINARY = "binary" # base64 string -> bytes +_BINARY_LIST = "binary[]" # list of base64 strings -> list of bytes +_ADDR_LIST = "addr[]" # list of address strings -> list of public keys + + +def _dict_of(schema: dict[str, Any]) -> tuple[str, dict[str, Any]]: + """Marker for a dict where each value follows the given schema.""" + return ("dict_of", schema) + + +_MERKLE_PROOF: dict[str, Any] = {"pth": _BINARY_LIST, "hsh": {}} +_FALCON_VERIFIER: dict[str, Any] = {"k": _BINARY} +_MSIG_VERIFIER: dict[str, Any] = {"cmt": _BINARY} +_FALCON_SIG: dict[str, Any] = {"sig": _BINARY, "prf": _MERKLE_PROOF, "vkey": _FALCON_VERIFIER} +_SIGSLOT: dict[str, Any] = {"s": _FALCON_SIG} +_PARTICIPANT: dict[str, Any] = {"p": _MSIG_VERIFIER} +_REVEAL: dict[str, Any] = {"p": _PARTICIPANT, "s": _SIGSLOT} + +# Transaction schema +_TX_SCHEMA: dict[str, Any] = { + "snd": _ADDR, + "rcv": _ADDR, + "close": _ADDR, + "asnd": _ADDR, + "aclose": _ADDR, + "fadd": _ADDR, + "rekey": _ADDR, + "arcv": _ADDR, + "gh": _BINARY, + "note": _BINARY, + "lx": _BINARY, + "grp": _BINARY, + "sig": _BINARY, + "apap": _BINARY, + "apsu": _BINARY, + "votekey": _BINARY, + "selkey": _BINARY, + "sprfkey": _BINARY, + "am": _BINARY, + "apaa": _BINARY_LIST, + "apat": _ADDR_LIST, + "apar": {"c": _ADDR, "f": _ADDR, "m": _ADDR, "r": _ADDR, "am": _BINARY}, + "hb": { + "a": _ADDR, + "sd": _BINARY, + "vid": _BINARY, + "prf": {"p": _BINARY, "p1s": _BINARY, "p2": _BINARY, "p2s": _BINARY, "s": _BINARY}, + }, + "spmsg": {"b": _BINARY, "v": _BINARY}, + "sp": {"c": _BINARY, "P": _MERKLE_PROOF, "S": _MERKLE_PROOF, "r": _dict_of(_REVEAL)}, +} + + +def _apply_schema(data: dict[str, Any], schema: dict[str, Any]) -> dict[str, Any]: + """Apply schema transformations to nested data.""" + result: dict[str, Any] = {} + for key, value in data.items(): + if value is None: + continue + field_schema = schema.get(key) + if field_schema == _ADDR and isinstance(value, str) and len(value) == 58: + result[key] = public_key_from_address(value) + elif field_schema == _BINARY and isinstance(value, str): + result[key] = base64.b64decode(value) + elif field_schema == _BINARY_LIST and isinstance(value, list): + result[key] = [base64.b64decode(v) if isinstance(v, str) else v for v in value] + elif field_schema == _ADDR_LIST and isinstance(value, list): + result[key] = [public_key_from_address(v) if isinstance(v, str) and len(v) == 58 else v for v in value] + elif isinstance(field_schema, dict) and isinstance(value, dict): + result[key] = _apply_schema(value, field_schema) + elif isinstance(field_schema, tuple) and field_schema[0] == "dict_of" and isinstance(value, dict): + item_schema = field_schema[1] + result[key] = {k: _apply_schema(v, item_schema) for k, v in value.items() if isinstance(v, dict)} + else: + result[key] = value + return result + + +def from_transaction_json(data: dict[str, Any]) -> Transaction: + """Decode a transaction from JSON format (address strings, base64 binary).""" + wire_format = _apply_schema(data, _TX_SCHEMA) + return from_transaction_dto(wire_format) + + +@lru_cache(maxsize=32) +def load_test_data(name: str) -> TransactionTestData: + """Load test data from the data factory. + + Available names: simplePayment, optInAssetTransfer, simpleAssetTransfer, + assetCreate, assetDestroy, assetConfig, appCall, appCreate, appUpdate, appDelete, + onlineKeyRegistration, offlineKeyRegistration, nonParticipationKeyRegistration, + assetFreeze, assetUnfreeze, heartbeat, stateProof, lsigPayment, msigPayment, + msigDelegatedPayment, singleDelegatedPayment + """ + file_path = DATA_FACTORY_PATH / f"{name}.json" + if not file_path.exists(): + raise FileNotFoundError(f"Data factory file not found: {file_path}") + + data = json.loads(file_path.read_text()) + txn_json = data["stxn"]["txn"] + transaction = from_transaction_json(txn_json) + + return TransactionTestData( + id=data["id"], + transaction=transaction, + unsigned_bytes=_b64_decode(data["txnBlob"]) or b"", + signed_bytes=_b64_decode(data["stxnBlob"]) or b"", + signer=_parse_signer(data.get("signer", {})), + ) + + +__all__ = ["SignerInfo", "SingleSigner", "TransactionTestData", "load_test_data"] diff --git a/tests/modules/transact/conftest.py b/tests/modules/transact/conftest.py new file mode 100644 index 00000000..9c246d7d --- /dev/null +++ b/tests/modules/transact/conftest.py @@ -0,0 +1,43 @@ +from collections.abc import Callable + +import pytest + +from .common import TransactionTestData, load_test_data + +TestDataLookup = Callable[[str], TransactionTestData] + + +@pytest.fixture(scope="module") +def test_data() -> dict[str, TransactionTestData]: + """Load all test data vectors (mirrors TS testData).""" + keys = [ + "simplePayment", + "optInAssetTransfer", + "simpleAssetTransfer", + "assetCreate", + "assetConfig", + "assetDestroy", + "assetFreeze", + "assetUnfreeze", + "appCall", + "appCreate", + "appUpdate", + "appDelete", + "onlineKeyRegistration", + "offlineKeyRegistration", + "nonParticipationKeyRegistration", + "heartbeat", + "stateProof", + "lsigPayment", + "msigPayment", + "msigDelegatedPayment", + "singleDelegatedPayment", + ] + + return {key: load_test_data(key) for key in keys} + + +@pytest.fixture(scope="module") +def test_data_lookup(test_data: dict[str, TransactionTestData]) -> TestDataLookup: + """Lookup function for test data by key.""" + return test_data.__getitem__ diff --git a/tests/modules/transact/multisig/__init__.py b/tests/modules/transact/multisig/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/modules/transact/multisig/test_app_call.py b/tests/modules/transact/multisig/test_app_call.py new file mode 100644 index 00000000..d7ab78c7 --- /dev/null +++ b/tests/modules/transact/multisig/test_app_call.py @@ -0,0 +1,11 @@ +import pytest + +from tests.modules.transact._helpers import iter_app_call_test_data +from tests.modules.transact.conftest import TestDataLookup +from tests.modules.transact.transaction_asserts import assert_multisig_example + + +@pytest.mark.parametrize(("label", "key"), list(iter_app_call_test_data())) +def test_multisig_example(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A human-readable example of forming a transaction and signing it with a multisignature sig""" + assert_multisig_example(label, test_data_lookup(key)) diff --git a/tests/modules/transact/multisig/test_asset_config.py b/tests/modules/transact/multisig/test_asset_config.py new file mode 100644 index 00000000..bc0a65c4 --- /dev/null +++ b/tests/modules/transact/multisig/test_asset_config.py @@ -0,0 +1,11 @@ +import pytest + +from tests.modules.transact._helpers import iter_asset_config_test_data +from tests.modules.transact.conftest import TestDataLookup +from tests.modules.transact.transaction_asserts import assert_multisig_example + + +@pytest.mark.parametrize(("label", "key"), list(iter_asset_config_test_data())) +def test_multisig_example(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A human-readable example of forming a transaction and signing it with a multisignature sig""" + assert_multisig_example(label, test_data_lookup(key)) diff --git a/tests/modules/transact/multisig/test_asset_transfer.py b/tests/modules/transact/multisig/test_asset_transfer.py new file mode 100644 index 00000000..4d94471a --- /dev/null +++ b/tests/modules/transact/multisig/test_asset_transfer.py @@ -0,0 +1,11 @@ +import pytest + +from tests.modules.transact._helpers import iter_asset_transfer_test_data +from tests.modules.transact.conftest import TestDataLookup +from tests.modules.transact.transaction_asserts import assert_multisig_example + + +@pytest.mark.parametrize(("label", "key"), list(iter_asset_transfer_test_data())) +def test_multisig_example(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A human-readable example of forming a transaction and signing it with a multisignature sig""" + assert_multisig_example(label, test_data_lookup(key)) diff --git a/tests/modules/transact/multisig/test_heartbeat.py b/tests/modules/transact/multisig/test_heartbeat.py new file mode 100644 index 00000000..4ae5faec --- /dev/null +++ b/tests/modules/transact/multisig/test_heartbeat.py @@ -0,0 +1,11 @@ +import pytest + +from tests.modules.transact._helpers import iter_heartbeat_test_data +from tests.modules.transact.conftest import TestDataLookup +from tests.modules.transact.transaction_asserts import assert_multisig_example + + +@pytest.mark.parametrize(("label", "key"), iter_heartbeat_test_data()) +def test_multisig_example(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A human-readable example of forming a transaction and signing it with a multisignature sig""" + assert_multisig_example(label, test_data_lookup(key)) diff --git a/tests/modules/transact/multisig/test_key_registration.py b/tests/modules/transact/multisig/test_key_registration.py new file mode 100644 index 00000000..b6fd5d0d --- /dev/null +++ b/tests/modules/transact/multisig/test_key_registration.py @@ -0,0 +1,11 @@ +import pytest + +from tests.modules.transact._helpers import iter_key_registration_test_data +from tests.modules.transact.conftest import TestDataLookup +from tests.modules.transact.transaction_asserts import assert_multisig_example + + +@pytest.mark.parametrize(("label", "key"), list(iter_key_registration_test_data())) +def test_multisig_example(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A human-readable example of forming a transaction and signing it with a multisignature sig""" + assert_multisig_example(label, test_data_lookup(key)) diff --git a/tests/modules/transact/multisig/test_payment.py b/tests/modules/transact/multisig/test_payment.py new file mode 100644 index 00000000..d432f18d --- /dev/null +++ b/tests/modules/transact/multisig/test_payment.py @@ -0,0 +1,8 @@ +from tests.modules.transact.conftest import TestDataLookup +from tests.modules.transact.transaction_asserts import assert_multisig_example + + +def test_multisig_example(test_data_lookup: TestDataLookup) -> None: + """A human-readable example of forming a transaction and signing it with a multisignature sig""" + vector = test_data_lookup("simplePayment") + assert_multisig_example("payment", vector) diff --git a/tests/modules/transact/multisig/test_state_proof.py b/tests/modules/transact/multisig/test_state_proof.py new file mode 100644 index 00000000..52023987 --- /dev/null +++ b/tests/modules/transact/multisig/test_state_proof.py @@ -0,0 +1,11 @@ +import pytest + +from tests.modules.transact._helpers import iter_state_proof_test_data +from tests.modules.transact.conftest import TestDataLookup +from tests.modules.transact.transaction_asserts import assert_multisig_example + + +@pytest.mark.parametrize(("label", "key"), iter_state_proof_test_data()) +def test_multisig_example(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A human-readable example of forming a transaction and signing it with a multisignature sig""" + assert_multisig_example(label, test_data_lookup(key)) diff --git a/tests/modules/transact/test_app_call.py b/tests/modules/transact/test_app_call.py new file mode 100644 index 00000000..27dc1206 --- /dev/null +++ b/tests/modules/transact/test_app_call.py @@ -0,0 +1,74 @@ +import pytest + +from ._helpers import iter_app_call_test_data +from .conftest import TestDataLookup +from .transaction_asserts import ( + assert_assign_fee, + assert_decode_with_prefix, + assert_decode_without_prefix, + assert_encode, + assert_encode_with_signature, + assert_encoded_transaction_type, + assert_example, + assert_transaction_id, +) + +# Polytest Suite: App Call + +# Polytest Group: Transaction Tests + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_app_call_test_data())) +def test_example(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A human-readable example of forming a transaction and signing it""" + assert_example(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_app_call_test_data())) +def test_get_transaction_id(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction id can be obtained from a transaction""" + assert_transaction_id(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_app_call_test_data())) +def test_assign_fee(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A fee can be calculated and assigned to a transaction""" + assert_assign_fee(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_app_call_test_data())) +def test_get_encoded_transaction_type(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """The transaction type of an encoded transaction can be retrieved""" + assert_encoded_transaction_type(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_app_call_test_data())) +def test_decode_without_prefix(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction without TX prefix and valid fields is decoded properly""" + assert_decode_without_prefix(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_app_call_test_data())) +def test_decode_with_prefix(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction with TX prefix and valid fields is decoded properly""" + assert_decode_with_prefix(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_app_call_test_data())) +def test_encode_with_signature(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A signature can be attached to a encoded transaction""" + assert_encode_with_signature(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_app_call_test_data())) +def test_encode(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction with valid fields is encoded properly""" + assert_encode(label, test_data_lookup(key)) diff --git a/tests/modules/transact/test_asset_config.py b/tests/modules/transact/test_asset_config.py new file mode 100644 index 00000000..83a355ad --- /dev/null +++ b/tests/modules/transact/test_asset_config.py @@ -0,0 +1,74 @@ +import pytest + +from ._helpers import iter_asset_config_test_data +from .conftest import TestDataLookup +from .transaction_asserts import ( + assert_assign_fee, + assert_decode_with_prefix, + assert_decode_without_prefix, + assert_encode, + assert_encode_with_signature, + assert_encoded_transaction_type, + assert_example, + assert_transaction_id, +) + +# Polytest Suite: AssetConfig + +# Polytest Group: Transaction Tests + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_config_test_data())) +def test_example(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A human-readable example of forming a transaction and signing it""" + assert_example(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_config_test_data())) +def test_get_transaction_id(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction id can be obtained from a transaction""" + assert_transaction_id(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_config_test_data())) +def test_assign_fee(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A fee can be calculated and assigned to a transaction""" + assert_assign_fee(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_config_test_data())) +def test_get_encoded_transaction_type(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """The transaction type of an encoded transaction can be retrieved""" + assert_encoded_transaction_type(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_config_test_data())) +def test_decode_without_prefix(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction without TX prefix and valid fields is decoded properly""" + assert_decode_without_prefix(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_config_test_data())) +def test_decode_with_prefix(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction with TX prefix and valid fields is decoded properly""" + assert_decode_with_prefix(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_config_test_data())) +def test_encode_with_signature(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A signature can be attached to a encoded transaction""" + assert_encode_with_signature(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_config_test_data())) +def test_encode(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction with valid fields is encoded properly""" + assert_encode(label, test_data_lookup(key)) diff --git a/tests/modules/transact/test_asset_freeze.py b/tests/modules/transact/test_asset_freeze.py new file mode 100644 index 00000000..507f9568 --- /dev/null +++ b/tests/modules/transact/test_asset_freeze.py @@ -0,0 +1,74 @@ +import pytest + +from ._helpers import iter_asset_freeze_test_data +from .conftest import TestDataLookup +from .transaction_asserts import ( + assert_assign_fee, + assert_decode_with_prefix, + assert_decode_without_prefix, + assert_encode, + assert_encode_with_signature, + assert_encoded_transaction_type, + assert_example, + assert_transaction_id, +) + +# Polytest Suite: Asset Freeze + +# Polytest Group: Transaction Tests + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_freeze_test_data())) +def test_example(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A human-readable example of forming a transaction and signing it""" + assert_example(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_freeze_test_data())) +def test_get_transaction_id(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction id can be obtained from a transaction""" + assert_transaction_id(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_freeze_test_data())) +def test_assign_fee(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A fee can be calculated and assigned to a transaction""" + assert_assign_fee(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_freeze_test_data())) +def test_get_encoded_transaction_type(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """The transaction type of an encoded transaction can be retrieved""" + assert_encoded_transaction_type(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_freeze_test_data())) +def test_decode_without_prefix(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction without TX prefix and valid fields is decoded properly""" + assert_decode_without_prefix(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_freeze_test_data())) +def test_decode_with_prefix(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction with TX prefix and valid fields is decoded properly""" + assert_decode_with_prefix(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_freeze_test_data())) +def test_encode_with_signature(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A signature can be attached to a encoded transaction""" + assert_encode_with_signature(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_freeze_test_data())) +def test_encode(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction with valid fields is encoded properly""" + assert_encode(label, test_data_lookup(key)) diff --git a/tests/modules/transact/test_asset_transfer.py b/tests/modules/transact/test_asset_transfer.py new file mode 100644 index 00000000..922634e3 --- /dev/null +++ b/tests/modules/transact/test_asset_transfer.py @@ -0,0 +1,74 @@ +import pytest + +from ._helpers import iter_asset_transfer_test_data +from .conftest import TestDataLookup +from .transaction_asserts import ( + assert_assign_fee, + assert_decode_with_prefix, + assert_decode_without_prefix, + assert_encode, + assert_encode_with_signature, + assert_encoded_transaction_type, + assert_example, + assert_transaction_id, +) + +# Polytest Suite: Asset Transfer + +# Polytest Group: Transaction Tests + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_transfer_test_data())) +def test_example(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A human-readable example of forming a transaction and signing it""" + assert_example(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_transfer_test_data())) +def test_get_transaction_id(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction id can be obtained from a transaction""" + assert_transaction_id(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_transfer_test_data())) +def test_assign_fee(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A fee can be calculated and assigned to a transaction""" + assert_assign_fee(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_transfer_test_data())) +def test_get_encoded_transaction_type(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """The transaction type of an encoded transaction can be retrieved""" + assert_encoded_transaction_type(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_transfer_test_data())) +def test_decode_without_prefix(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction without TX prefix and valid fields is decoded properly""" + assert_decode_without_prefix(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_transfer_test_data())) +def test_decode_with_prefix(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction with TX prefix and valid fields is decoded properly""" + assert_decode_with_prefix(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_transfer_test_data())) +def test_encode_with_signature(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A signature can be attached to a encoded transaction""" + assert_encode_with_signature(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_asset_transfer_test_data())) +def test_encode(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction with valid fields is encoded properly""" + assert_encode(label, test_data_lookup(key)) diff --git a/tests/modules/transact/test_generic_transaction.py b/tests/modules/transact/test_generic_transaction.py new file mode 100644 index 00000000..c7255269 --- /dev/null +++ b/tests/modules/transact/test_generic_transaction.py @@ -0,0 +1,23 @@ +import pytest + +from algokit_transact import ( + decode_transaction, +) + +# Polytest Suite: Generic Transaction + +# Polytest Group: Generic Transaction Tests + + +@pytest.mark.group_generic_transaction_tests +def test_malformed_bytes() -> None: + """Ensure a helpful error message is thrown when attempting to decode malformed bytes""" + with pytest.raises(ValueError, match="decoded msgpack is not a dict"): + decode_transaction(b"\x01") + + +@pytest.mark.group_generic_transaction_tests +def test_encode_0_bytes() -> None: + """Ensure a helpful error message is thrown when attempting to encode 0 bytes""" + with pytest.raises(ValueError, match=r"^attempted to decode 0 bytes$"): + decode_transaction(b"") diff --git a/tests/modules/transact/test_heartbeat.py b/tests/modules/transact/test_heartbeat.py new file mode 100644 index 00000000..b2682197 --- /dev/null +++ b/tests/modules/transact/test_heartbeat.py @@ -0,0 +1,74 @@ +import pytest + +from ._helpers import iter_heartbeat_test_data +from .conftest import TestDataLookup +from .transaction_asserts import ( + assert_assign_fee, + assert_decode_with_prefix, + assert_decode_without_prefix, + assert_encode, + assert_encode_with_signature, + assert_encoded_transaction_type, + assert_example, + assert_transaction_id, +) + +# Polytest Suite: Heartbeat + +# Polytest Group: Transaction Tests + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), iter_heartbeat_test_data()) +def test_example(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A human-readable example of forming a transaction and signing it""" + assert_example(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), iter_heartbeat_test_data()) +def test_get_transaction_id(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction id can be obtained from a transaction""" + assert_transaction_id(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), iter_heartbeat_test_data()) +def test_assign_fee(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A fee can be calculated and assigned to a transaction""" + assert_assign_fee(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), iter_heartbeat_test_data()) +def test_get_encoded_transaction_type(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """The transaction type of an encoded transaction can be retrieved""" + assert_encoded_transaction_type(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), iter_heartbeat_test_data()) +def test_decode_without_prefix(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction without TX prefix and valid fields is decoded properly""" + assert_decode_without_prefix(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), iter_heartbeat_test_data()) +def test_decode_with_prefix(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction with TX prefix and valid fields is decoded properly""" + assert_decode_with_prefix(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), iter_heartbeat_test_data()) +def test_encode_with_signature(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A signature can be attached to a encoded transaction""" + assert_encode_with_signature(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), iter_heartbeat_test_data()) +def test_encode(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction with valid fields is encoded properly""" + assert_encode(label, test_data_lookup(key)) diff --git a/tests/modules/transact/test_key_registration.py b/tests/modules/transact/test_key_registration.py new file mode 100644 index 00000000..4824ff9f --- /dev/null +++ b/tests/modules/transact/test_key_registration.py @@ -0,0 +1,74 @@ +import pytest + +from ._helpers import iter_key_registration_test_data +from .conftest import TestDataLookup +from .transaction_asserts import ( + assert_assign_fee, + assert_decode_with_prefix, + assert_decode_without_prefix, + assert_encode, + assert_encode_with_signature, + assert_encoded_transaction_type, + assert_example, + assert_transaction_id, +) + +# Polytest Suite: Key Registration + +# Polytest Group: Transaction Tests + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_key_registration_test_data())) +def test_example(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A human-readable example of forming a transaction and signing it""" + assert_example(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_key_registration_test_data())) +def test_get_transaction_id(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction id can be obtained from a transaction""" + assert_transaction_id(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_key_registration_test_data())) +def test_assign_fee(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A fee can be calculated and assigned to a transaction""" + assert_assign_fee(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_key_registration_test_data())) +def test_get_encoded_transaction_type(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """The transaction type of an encoded transaction can be retrieved""" + assert_encoded_transaction_type(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_key_registration_test_data())) +def test_decode_without_prefix(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction without TX prefix and valid fields is decoded properly""" + assert_decode_without_prefix(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_key_registration_test_data())) +def test_decode_with_prefix(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction with TX prefix and valid fields is decoded properly""" + assert_decode_with_prefix(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_key_registration_test_data())) +def test_encode_with_signature(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A signature can be attached to a encoded transaction""" + assert_encode_with_signature(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), list(iter_key_registration_test_data())) +def test_encode(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction with valid fields is encoded properly""" + assert_encode(label, test_data_lookup(key)) diff --git a/tests/modules/transact/test_multisig_account.py b/tests/modules/transact/test_multisig_account.py new file mode 100644 index 00000000..b0e3bf63 --- /dev/null +++ b/tests/modules/transact/test_multisig_account.py @@ -0,0 +1,307 @@ +"""Unit tests for MultisigAccount class - mirrors multisig.spec.ts from algokit-utils-ts.""" + +import base64 + +import pytest +from algokit_common import public_key_from_address + +from algokit_transact.multisig import MultisigAccount, MultisigMetadata +from algokit_transact.signing.types import MultisigSignature + + +class TestMultisigAccountCreateMultisigSignature: + """Tests for MultisigAccount.create_multisig_signature().""" + + def test_should_create_empty_multisig_signature_with_correct_structure(self) -> None: + addrs = [ + "RIMARGKZU46OZ77OLPDHHPUJ7YBSHRTCYMQUC64KZCCMESQAFQMYU6SL2Q", + "ALGOC4J2BCZ33TCKSSAMV5GAXQBMV3HDCHDBSPRBZRNSR7BM2FFDZRFGXA", + ] + + msig_account = MultisigAccount( + params=MultisigMetadata(version=1, threshold=2, addrs=addrs), + sub_signers=[], + ) + multisig = msig_account.create_multisig_signature() + + assert multisig.version == 1 + assert multisig.threshold == 2 + assert len(multisig.subsigs) == 2 + assert multisig.subsigs[0].public_key == public_key_from_address(addrs[0]) + assert multisig.subsigs[1].public_key == public_key_from_address(addrs[1]) + assert multisig.subsigs[0].sig is None + assert multisig.subsigs[1].sig is None + + def test_should_handle_single_participant(self) -> None: + addrs = ["RIMARGKZU46OZ77OLPDHHPUJ7YBSHRTCYMQUC64KZCCMESQAFQMYU6SL2Q"] + + msig_account = MultisigAccount( + params=MultisigMetadata(version=1, threshold=1, addrs=addrs), + sub_signers=[], + ) + multisig = msig_account.create_multisig_signature() + + assert multisig.version == 1 + assert multisig.threshold == 1 + assert len(multisig.subsigs) == 1 + assert multisig.subsigs[0].public_key == public_key_from_address(addrs[0]) + + +class TestParticipantsFromMultisigSignature: + """Tests for extracting participants from multisig signatures.""" + + def test_should_extract_participants_from_multisig_signature(self) -> None: + addrs = [ + "RIMARGKZU46OZ77OLPDHHPUJ7YBSHRTCYMQUC64KZCCMESQAFQMYU6SL2Q", + "ALGOC4J2BCZ33TCKSSAMV5GAXQBMV3HDCHDBSPRBZRNSR7BM2FFDZRFGXA", + ] + + msig_account = MultisigAccount( + params=MultisigMetadata(version=1, threshold=2, addrs=addrs), + sub_signers=[], + ) + multisig = msig_account.create_multisig_signature() + extracted_participants = [subsig.public_key for subsig in multisig.subsigs] + + expected = [public_key_from_address(addr) for addr in addrs] + assert extracted_participants == expected + + def test_should_extract_participants_even_when_signatures_are_present(self) -> None: + addrs = [ + "RIMARGKZU46OZ77OLPDHHPUJ7YBSHRTCYMQUC64KZCCMESQAFQMYU6SL2Q", + "ALGOC4J2BCZ33TCKSSAMV5GAXQBMV3HDCHDBSPRBZRNSR7BM2FFDZRFGXA", + ] + + msig_account = MultisigAccount( + params=MultisigMetadata(version=1, threshold=2, addrs=addrs), + sub_signers=[], + ) + multisig = msig_account.create_multisig_signature() + signature = bytes([42] * 64) # Mock signature + signed_multisig = msig_account.apply_signature(multisig, addrs[0], signature) + + extracted_participants = [subsig.public_key for subsig in signed_multisig.subsigs] + + expected = [public_key_from_address(addr) for addr in addrs] + assert extracted_participants == expected + + +class TestMultisigAccountFromSignatureAddress: + """Tests for MultisigAccount.from_signature() and address derivation.""" + + def test_should_derive_multisig_address_matches_rust_reference(self) -> None: + """Matches Rust reference implementation.""" + addrs = [ + "RIMARGKZU46OZ77OLPDHHPUJ7YBSHRTCYMQUC64KZCCMESQAFQMYU6SL2Q", + "ALGOC4J2BCZ33TCKSSAMV5GAXQBMV3HDCHDBSPRBZRNSR7BM2FFDZRFGXA", + ] + + msig_account = MultisigAccount( + params=MultisigMetadata(version=1, threshold=2, addrs=addrs), + sub_signers=[], + ) + multisig = msig_account.create_multisig_signature() + msig_account_from_sig = MultisigAccount.from_signature(multisig) + + assert msig_account_from_sig.addr == "TZ6HCOKXK54E2VRU523LBTDQMQNX7DXOWENPFNBXOEU3SMEWXYNCRJUTBU" + + def test_should_produce_different_addresses_for_different_participant_orders(self) -> None: + addrs1 = [ + "RIMARGKZU46OZ77OLPDHHPUJ7YBSHRTCYMQUC64KZCCMESQAFQMYU6SL2Q", + "ALGOC4J2BCZ33TCKSSAMV5GAXQBMV3HDCHDBSPRBZRNSR7BM2FFDZRFGXA", + ] + addrs2 = [ + "ALGOC4J2BCZ33TCKSSAMV5GAXQBMV3HDCHDBSPRBZRNSR7BM2FFDZRFGXA", + "RIMARGKZU46OZ77OLPDHHPUJ7YBSHRTCYMQUC64KZCCMESQAFQMYU6SL2Q", + ] + + msig_account1 = MultisigAccount( + params=MultisigMetadata(version=1, threshold=2, addrs=addrs1), + sub_signers=[], + ) + msig_account2 = MultisigAccount( + params=MultisigMetadata(version=1, threshold=2, addrs=addrs2), + sub_signers=[], + ) + + assert msig_account1.addr != msig_account2.addr + + def test_should_handle_large_version_and_threshold_values(self) -> None: + addrs = [ + "RIMARGKZU46OZ77OLPDHHPUJ7YBSHRTCYMQUC64KZCCMESQAFQMYU6SL2Q", + "ALGOC4J2BCZ33TCKSSAMV5GAXQBMV3HDCHDBSPRBZRNSR7BM2FFDZRFGXA", + ] + + msig_account_large = MultisigAccount( + params=MultisigMetadata(version=254, threshold=2, addrs=addrs), + sub_signers=[], + ) + msig_account_small = MultisigAccount( + params=MultisigMetadata(version=1, threshold=2, addrs=addrs), + sub_signers=[], + ) + + assert msig_account_large.addr != msig_account_small.addr + + +class TestMultisigAccountApplySignature: + """Tests for MultisigAccount.apply_signature().""" + + def test_should_apply_signature_to_participant(self) -> None: + addrs = [ + "RIMARGKZU46OZ77OLPDHHPUJ7YBSHRTCYMQUC64KZCCMESQAFQMYU6SL2Q", + "ALGOC4J2BCZ33TCKSSAMV5GAXQBMV3HDCHDBSPRBZRNSR7BM2FFDZRFGXA", + ] + + msig_account = MultisigAccount( + params=MultisigMetadata(version=1, threshold=2, addrs=addrs), + sub_signers=[], + ) + multisig = msig_account.create_multisig_signature() + signature = bytes([42] * 64) + + signed_multisig = msig_account.apply_signature(multisig, addrs[0], signature) + + assert signed_multisig.version == multisig.version + assert signed_multisig.threshold == multisig.threshold + assert signed_multisig.subsigs[0].sig == signature + assert signed_multisig.subsigs[1].sig is None + + def test_should_replace_existing_signature(self) -> None: + addrs = [ + "RIMARGKZU46OZ77OLPDHHPUJ7YBSHRTCYMQUC64KZCCMESQAFQMYU6SL2Q", + "ALGOC4J2BCZ33TCKSSAMV5GAXQBMV3HDCHDBSPRBZRNSR7BM2FFDZRFGXA", + ] + + msig_account = MultisigAccount( + params=MultisigMetadata(version=1, threshold=2, addrs=addrs), + sub_signers=[], + ) + multisig = msig_account.create_multisig_signature() + signature1 = bytes([42] * 64) + signature2 = bytes([84] * 64) + + # Apply first signature + signed_multisig1 = msig_account.apply_signature(multisig, addrs[0], signature1) + assert signed_multisig1.subsigs[0].sig == signature1 + + # Replace with second signature + signed_multisig2 = msig_account.apply_signature(signed_multisig1, addrs[0], signature2) + assert signed_multisig2.subsigs[0].sig == signature2 + + +class TestMergeMultisignaturesViaApplySignature: + """Tests for merging multisignatures.""" + + def test_should_merge_compatible_multisignatures_by_applying_signatures_individually(self) -> None: + addrs = [ + "RIMARGKZU46OZ77OLPDHHPUJ7YBSHRTCYMQUC64KZCCMESQAFQMYU6SL2Q", + "ALGOC4J2BCZ33TCKSSAMV5GAXQBMV3HDCHDBSPRBZRNSR7BM2FFDZRFGXA", + ] + + msig_account = MultisigAccount( + params=MultisigMetadata(version=1, threshold=2, addrs=addrs), + sub_signers=[], + ) + + signature1 = bytes([11] * 64) + signature2 = bytes([22] * 64) + + # Apply both signatures to the same multisig + multisig = msig_account.create_multisig_signature() + multisig = msig_account.apply_signature(multisig, addrs[0], signature1) + multisig = msig_account.apply_signature(multisig, addrs[1], signature2) + + assert multisig.version == 1 + assert multisig.threshold == 2 + assert multisig.subsigs[0].sig == signature1 + assert multisig.subsigs[1].sig == signature2 + + def test_should_throw_error_for_incompatible_versions(self) -> None: + addrs = [ + "RIMARGKZU46OZ77OLPDHHPUJ7YBSHRTCYMQUC64KZCCMESQAFQMYU6SL2Q", + "ALGOC4J2BCZ33TCKSSAMV5GAXQBMV3HDCHDBSPRBZRNSR7BM2FFDZRFGXA", + ] + + msig_account1 = MultisigAccount( + params=MultisigMetadata(version=1, threshold=2, addrs=addrs), + sub_signers=[], + ) + msig_account2 = MultisigAccount( + params=MultisigMetadata(version=2, threshold=2, addrs=addrs), + sub_signers=[], + ) + + msig2 = msig_account2.create_multisig_signature() + + with pytest.raises(ValueError, match="Multisig signature parameters do not match"): + msig_account1.apply_signature(msig2, addrs[0], bytes(64)) + + +class TestDecodeMultisigSignature: + """Tests for encoding/decoding MultisigSignature via msgpack.""" + + def test_should_decode_encoded_multisig_signature(self) -> None: + from algokit_transact.codec.msgpack import decode_msgpack, encode_msgpack + from algokit_transact.codec.serde import from_wire, to_wire_canonical + + addrs = [ + "RIMARGKZU46OZ77OLPDHHPUJ7YBSHRTCYMQUC64KZCCMESQAFQMYU6SL2Q", + "ALGOC4J2BCZ33TCKSSAMV5GAXQBMV3HDCHDBSPRBZRNSR7BM2FFDZRFGXA", + ] + + msig_account = MultisigAccount( + params=MultisigMetadata(version=1, threshold=2, addrs=addrs), + sub_signers=[], + ) + empty_multisig = msig_account.create_multisig_signature() + signature = bytes([42] * 64) + signed_multisig = msig_account.apply_signature(empty_multisig, addrs[0], signature) + + # Encode and decode + encoded = encode_msgpack(to_wire_canonical(signed_multisig)) + decoded = from_wire(MultisigSignature, decode_msgpack(encoded)) + + assert decoded.version == empty_multisig.version + assert decoded.threshold == empty_multisig.threshold + assert len(decoded.subsigs) == len(empty_multisig.subsigs) + assert decoded.subsigs[0].public_key == public_key_from_address(addrs[0]) + assert decoded.subsigs[1].public_key == public_key_from_address(addrs[1]) + assert decoded.subsigs[0].sig == signature + assert decoded.subsigs[1].sig is None + + +class TestMultisigExample: + """Real-world example test matching observed transaction patterns.""" + + def test_should_create_multisig_matching_observed_transaction_pattern(self) -> None: + addrs = [ + "AXJVIQR43APV5HZ6F3J4MYNYR3GRRFHU56WTRFLJXFNNUJHDAX5SCGF3SQ", + "QKR2CYWG4MQQAYCAF4LQARVQLLUF2JIDQO42OQ5YN2E7CHTLDURSJGNQRU", + ] + + msig_account = MultisigAccount( + params=MultisigMetadata(version=1, threshold=2, addrs=addrs), + sub_signers=[], + ) + + # Decode the known base64 signatures + signature1 = base64.b64decode( + "H0W1kLRR68uDwacLk0N7qPuvm4NP09AmiaG+X6HPdsZOCJ5YV5ytc+jCvonAEz2sg+0k388T9ZAbqSZGag93Cg==" + ) + signature2 = base64.b64decode( + "UzvbTgDEfdG6w/HzaiwMePmNLiIk5z+hK4EZoCLR9ghgYMxy0IdS7iTCvPVFmVTDYM+r/W8Lox+lE6m4N/OvCw==" + ) + + # Apply signatures + multisig = msig_account.create_multisig_signature() + multisig = msig_account.apply_signature(multisig, addrs[0], signature1) + multisig = msig_account.apply_signature(multisig, addrs[1], signature2) + + assert multisig.version == 1 + assert multisig.threshold == 2 + assert len(multisig.subsigs) == 2 + assert multisig.subsigs[0].public_key == public_key_from_address(addrs[0]) + assert multisig.subsigs[1].public_key == public_key_from_address(addrs[1]) + assert multisig.subsigs[0].sig == signature1 + assert multisig.subsigs[1].sig == signature2 diff --git a/tests/modules/transact/test_payment.py b/tests/modules/transact/test_payment.py new file mode 100644 index 00000000..8c157d12 --- /dev/null +++ b/tests/modules/transact/test_payment.py @@ -0,0 +1,74 @@ +import pytest + + +from .conftest import TestDataLookup +from .transaction_asserts import ( + assert_assign_fee, + assert_decode_with_prefix, + assert_decode_without_prefix, + assert_encode, + assert_encode_with_signature, + assert_encoded_transaction_type, + assert_example, + assert_transaction_id, +) + +# Polytest Suite: Payment + +# Polytest Group: Transaction Tests + + +@pytest.mark.group_transaction_tests +def test_example(test_data_lookup: TestDataLookup) -> None: + """A human-readable example of forming a transaction and signing it""" + vector = test_data_lookup("simplePayment") + assert_example("payment", vector) + + +@pytest.mark.group_transaction_tests +def test_get_transaction_id(test_data_lookup: TestDataLookup) -> None: + """A transaction id can be obtained from a transaction""" + vector = test_data_lookup("simplePayment") + assert_transaction_id("payment", vector) + + +@pytest.mark.group_transaction_tests +def test_assign_fee(test_data_lookup: TestDataLookup) -> None: + """A fee can be calculated and assigned to a transaction""" + vector = test_data_lookup("simplePayment") + assert_assign_fee("payment", vector) + + +@pytest.mark.group_transaction_tests +def test_get_encoded_transaction_type(test_data_lookup: TestDataLookup) -> None: + """The transaction type of an encoded transaction can be retrieved""" + vector = test_data_lookup("simplePayment") + assert_encoded_transaction_type("payment", vector) + + +@pytest.mark.group_transaction_tests +def test_decode_without_prefix(test_data_lookup: TestDataLookup) -> None: + """A transaction without TX prefix and valid fields is decoded properly""" + vector = test_data_lookup("simplePayment") + assert_decode_without_prefix("payment", vector) + + +@pytest.mark.group_transaction_tests +def test_decode_with_prefix(test_data_lookup: TestDataLookup) -> None: + """A transaction with TX prefix and valid fields is decoded properly""" + vector = test_data_lookup("simplePayment") + assert_decode_with_prefix("payment", vector) + + +@pytest.mark.group_transaction_tests +def test_encode_with_signature(test_data_lookup: TestDataLookup) -> None: + """A signature can be attached to a encoded transaction""" + vector = test_data_lookup("simplePayment") + assert_encode_with_signature("payment", vector) + + +@pytest.mark.group_transaction_tests +def test_encode(test_data_lookup: TestDataLookup) -> None: + """A transaction with valid fields is encoded properly""" + vector = test_data_lookup("simplePayment") + assert_encode("payment", vector) diff --git a/tests/modules/transact/test_signer.py b/tests/modules/transact/test_signer.py new file mode 100644 index 00000000..d2276349 --- /dev/null +++ b/tests/modules/transact/test_signer.py @@ -0,0 +1,324 @@ +"""Tests for the signer module with ed25519 crypto integration. + +These tests match the TypeScript implementation from algokit-transact, +testing the integration between the signer module and crypto module. +""" + +import nacl.signing +import pytest + +from algokit_crypto import ( + ed25519_generator, + ed25519_verifier, + peikert_hd_wallet_generator, + pynacl_ed25519_generator, + pynacl_ed25519_verifier, +) +from algokit_transact import ( + PaymentTransactionFields, + Transaction, + TransactionType, + decode_signed_transaction, + encode_transaction, + generate_address_with_signers, +) +from algokit_transact.logicsig import LogicSig +from algokit_transact.logicsig import LogicSigAccount +from algokit_transact.signer import AddressWithSigners + +# Sample LogicSig program (just some bytes) +LSIG_PROGRAM = bytes([1, 2, 3, 4, 5]) + + +def _create_payment_transaction(sender: str) -> Transaction: + """Create a simple payment transaction for testing.""" + return Transaction( + transaction_type=TransactionType.Payment, + sender=sender, + first_valid=1, + last_valid=1000, + payment=PaymentTransactionFields( + amount=1000, + receiver="XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA", + ), + ) + + +def _run_tests( + address_with_signers: AddressWithSigners, + expected_pubkey: bytes, +) -> None: + """Run common tests on an AddressWithSigners instance. + + Args: + address_with_signers: An AddressWithSigners instance with all signing capabilities. + expected_pubkey: The expected ed25519 public key bytes. + """ + # Extract signer capabilities + addr = address_with_signers.addr + signer = address_with_signers.signer + delegated_lsig_signer = address_with_signers.delegated_lsig_signer + program_data_signer = address_with_signers.program_data_signer + mx_bytes_signer = address_with_signers.mx_bytes_signer + + # Verify the address is derived from the expected public key + from algokit_common import public_key_from_address + + assert public_key_from_address(addr) == expected_pubkey + + # Test that default verifier is the same object as the pynacl verifier + assert ed25519_verifier is pynacl_ed25519_verifier + + # Create a LogicSig and transaction + lsig = LogicSig(logic=LSIG_PROGRAM) + txn = _create_payment_transaction(lsig.address) + + # Test 1: Transaction signing and verification + stxns = signer([txn], [0]) + stxn = decode_signed_transaction(stxns[0]) + assert stxn.sig is not None + # Verify the signature against the transaction bytes + txn_bytes = encode_transaction(txn) + assert ed25519_verifier(stxn.sig, txn_bytes, expected_pubkey) is True + # Verify auth_address is set correctly when txn.sender != addr (rekeying scenario) + if txn.sender == addr: + assert stxn.auth_address is None + else: + assert stxn.auth_address == addr + + # Test 2: LogicSig delegation signing and verification + lsig_account = LogicSigAccount(logic=lsig.logic, args=lsig.args, _address=addr) + lsig_result = delegated_lsig_signer(lsig_account, None) + assert lsig_result.sig is not None + # Verify the delegation signature + delegation_bytes = lsig.bytes_to_sign_for_delegation(None) + assert ed25519_verifier(lsig_result.sig, delegation_bytes, expected_pubkey) is True + + # Test 3: Program data signing and verification + program_data = bytes([10, 20, 30]) + program_data_sig = program_data_signer(lsig, program_data) + # Verify the program data signature + program_data_bytes = lsig.program_data_to_sign(program_data) + assert ed25519_verifier(program_data_sig, program_data_bytes, expected_pubkey) is True + + # Test 4: MX bytes signing and verification + mx_bytes = bytes([5, 4, 3, 2, 1]) + mx_bytes_sig = mx_bytes_signer(mx_bytes) + # Verify the MX bytes signature + mx_bytes_to_sign = b"MX" + mx_bytes + assert ed25519_verifier(mx_bytes_sig, mx_bytes_to_sign, expected_pubkey) is True + + +class TestSigner: + """Test suite for signer functionality with different ed25519 implementations.""" + + def test_generate_signers_with_nacl(self) -> None: + """Test generate_address_with_signers using PyNaCl (equivalent to tweetnacl).""" + # Generate keypair using PyNaCl + signing_key = nacl.signing.SigningKey.generate() + verify_key = signing_key.verify_key + public_key = bytes(verify_key) + + # Create raw signer function + def raw_signer(bytes_to_sign: bytes) -> bytes: + signed = signing_key.sign(bytes_to_sign) + return signed.signature + + # Generate address with signers + address_with_signers = generate_address_with_signers( + ed25519_pubkey=public_key, + raw_ed25519_signer=raw_signer, + ) + + _run_tests(address_with_signers, public_key) + + def test_generate_signers_with_pynacl_ed25519_generator(self) -> None: + """Test generate_address_with_signers using pynacl_ed25519_generator.""" + # Test that default generator is the same object as the pynacl generator + assert ed25519_generator is pynacl_ed25519_generator + + # Generate keypair using pynacl generator + generated = ed25519_generator() + public_key = generated["ed25519_pubkey"] + raw_signer = generated["raw_ed25519_signer"] + + # Generate address with signers + address_with_signers = generate_address_with_signers( + ed25519_pubkey=public_key, + raw_ed25519_signer=raw_signer, + ) + + _run_tests(address_with_signers, public_key) + + def test_generate_signers_with_seed(self) -> None: + """Test generate_address_with_signers using pynacl_ed25519_generator with seed.""" + # Use a deterministic seed + seed = bytes([i % 256 for i in range(32)]) + + # Generate keypair using pynacl generator with seed + generated = pynacl_ed25519_generator(seed) + public_key = generated["ed25519_pubkey"] + raw_signer = generated["raw_ed25519_signer"] + + # Generate address with signers + address_with_signers = generate_address_with_signers( + ed25519_pubkey=public_key, + raw_ed25519_signer=raw_signer, + ) + + _run_tests(address_with_signers, public_key) + + # Verify deterministic generation - same seed should produce same key + generated2 = pynacl_ed25519_generator(seed) + assert generated2["ed25519_pubkey"] == public_key + + def test_mx_bytes_full_flow(self) -> None: + """Test full MX bytes signing flow with ed25519 generator.""" + # Generate a new keypair + generated = ed25519_generator() + public_key = generated["ed25519_pubkey"] + + # Generate Algorand-specific signing functions + address_with_signers = generate_address_with_signers( + ed25519_pubkey=public_key, + raw_ed25519_signer=generated["raw_ed25519_signer"], + ) + + message = b"Hello, Algorand!" + + # Sign the message using MX bytes signer + mx_bytes_sig = address_with_signers.mx_bytes_signer(message) + + # Get the bytes that were actually signed (MX domain separator + message) + signed_bytes = b"MX" + message + + # Verify the signature + is_valid = ed25519_verifier(mx_bytes_sig, signed_bytes, public_key) + assert is_valid is True + + # Demonstrate it is not a raw signature (direct message signing would fail) + is_raw_valid = ed25519_verifier(mx_bytes_sig, message, public_key) + assert is_raw_valid is False + + def test_verifier_aliases(self) -> None: + """Test that verifier aliases point to the same function.""" + assert ed25519_verifier is pynacl_ed25519_verifier + + def test_generator_aliases(self) -> None: + """Test that generator aliases point to the same function.""" + assert ed25519_generator is pynacl_ed25519_generator + + def test_seed_size_validation(self) -> None: + """Test that seed must be exactly 32 bytes.""" + # Valid seed size + valid_seed = bytes(32) + result = pynacl_ed25519_generator(valid_seed) + assert "ed25519_pubkey" in result + assert "ed25519_secret_key" in result + assert "raw_ed25519_signer" in result + + # Invalid seed sizes + with pytest.raises(ValueError, match="32 bytes"): + pynacl_ed25519_generator(bytes(31)) + + with pytest.raises(ValueError, match="32 bytes"): + pynacl_ed25519_generator(bytes(33)) + + def test_random_generation(self) -> None: + """Test that random key generation produces different keys each time.""" + generated1 = ed25519_generator() + generated2 = ed25519_generator() + + # Keys should be different (statistically almost certain) + assert generated1["ed25519_pubkey"] != generated2["ed25519_pubkey"] + assert generated1["ed25519_secret_key"] != generated2["ed25519_secret_key"] + + def test_generate_signers_with_peikert_hd_wallet_generator(self) -> None: + """Test generate_address_with_signers using peikert_hd_wallet_generator.""" + # Generate HD wallet with account generator + wallet_result = peikert_hd_wallet_generator() + account_generator = wallet_result["account_generator"] + + # Generate an account at BIP44 path m/44'/283'/0'/0/0 + generated = account_generator(0, 0) + public_key = generated["ed25519_pubkey"] + raw_signer = generated["raw_ed25519_signer"] + + # Generate address with signers + address_with_signers = generate_address_with_signers( + ed25519_pubkey=public_key, + raw_ed25519_signer=raw_signer, + ) + + _run_tests(address_with_signers, public_key) + + def test_full_xhd_mx_bytes_flow(self) -> None: + """Test full xHD MX bytes signing flow with peikert_hd_wallet_generator.""" + # Generate a new wallet with rootkey and account generator + wallet_result = peikert_hd_wallet_generator() + account_generator = wallet_result["account_generator"] + + # Generate an account at BIP44 path m/44'/283'/0'/0/0 + generated = account_generator(0, 0) + public_key = generated["ed25519_pubkey"] + + # Generate Algorand-specific signing functions + address_with_signers = generate_address_with_signers( + ed25519_pubkey=public_key, + raw_ed25519_signer=generated["raw_ed25519_signer"], + ) + + message = b"Hello, Algorand!" + + # Sign the message + mx_bytes_sig = address_with_signers.mx_bytes_signer(message) + + # Get the bytes that were actually signed (MX domain separator + message) + signed_bytes = b"MX" + message + + # Verify the signature + is_valid = ed25519_verifier(mx_bytes_sig, signed_bytes, public_key) + assert is_valid is True + + # Demonstrate it is not a raw signature + is_raw_valid = ed25519_verifier(mx_bytes_sig, message, public_key) + assert is_raw_valid is False + + def test_auth_address_when_sender_equals_signer(self) -> None: + """Test that auth_address is None when transaction sender equals signer address.""" + # Generate a new keypair + generated = ed25519_generator() + public_key = generated["ed25519_pubkey"] + + # Generate Algorand-specific signing functions + address_with_signers = generate_address_with_signers( + ed25519_pubkey=public_key, + raw_ed25519_signer=generated["raw_ed25519_signer"], + ) + + addr = address_with_signers.addr + signer = address_with_signers.signer + + # Create a transaction where sender equals the signer address + txn = Transaction( + transaction_type=TransactionType.Payment, + sender=addr, # Same as signer address + first_valid=1, + last_valid=1000, + payment=PaymentTransactionFields( + amount=1000, + receiver="XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA", + ), + ) + + # Sign the transaction + stxns = signer([txn], [0]) + stxn = decode_signed_transaction(stxns[0]) + + # Verify signature is present and valid + assert stxn.sig is not None + txn_bytes = encode_transaction(txn) + assert ed25519_verifier(stxn.sig, txn_bytes, public_key) is True + + # Verify auth_address is None when sender == signer address + assert stxn.auth_address is None diff --git a/tests/modules/transact/test_state_proof.py b/tests/modules/transact/test_state_proof.py new file mode 100644 index 00000000..924a1b49 --- /dev/null +++ b/tests/modules/transact/test_state_proof.py @@ -0,0 +1,74 @@ +import pytest + +from ._helpers import iter_state_proof_test_data +from .conftest import TestDataLookup +from .transaction_asserts import ( + assert_assign_fee, + assert_decode_with_prefix, + assert_decode_without_prefix, + assert_encode, + assert_encode_with_signature, + assert_encoded_transaction_type, + assert_example, + assert_transaction_id, +) + +# Polytest Suite: State Proof + +# Polytest Group: Transaction Tests + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), iter_state_proof_test_data()) +def test_example(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A human-readable example of forming a transaction and signing it""" + assert_example(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), iter_state_proof_test_data()) +def test_get_transaction_id(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction id can be obtained from a transaction""" + assert_transaction_id(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), iter_state_proof_test_data()) +def test_assign_fee(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A fee can be calculated and assigned to a transaction""" + assert_assign_fee(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), iter_state_proof_test_data()) +def test_get_encoded_transaction_type(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """The transaction type of an encoded transaction can be retrieved""" + assert_encoded_transaction_type(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), iter_state_proof_test_data()) +def test_decode_without_prefix(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction without TX prefix and valid fields is decoded properly""" + assert_decode_without_prefix(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), iter_state_proof_test_data()) +def test_decode_with_prefix(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction with TX prefix and valid fields is decoded properly""" + assert_decode_with_prefix(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), iter_state_proof_test_data()) +def test_encode_with_signature(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A signature can be attached to a encoded transaction""" + assert_encode_with_signature(label, test_data_lookup(key)) + + +@pytest.mark.group_transaction_tests +@pytest.mark.parametrize(("label", "key"), iter_state_proof_test_data()) +def test_encode(label: str, key: str, test_data_lookup: TestDataLookup) -> None: + """A transaction with valid fields is encoded properly""" + assert_encode(label, test_data_lookup(key)) diff --git a/tests/modules/transact/test_transaction.py b/tests/modules/transact/test_transaction.py new file mode 100644 index 00000000..3952d57b --- /dev/null +++ b/tests/modules/transact/test_transaction.py @@ -0,0 +1,124 @@ +import msgpack +import pytest + +from algokit_common import MAX_TRANSACTION_GROUP_SIZE +from algokit_transact import ( + AppCallTransactionFields, + Transaction, + TransactionType, + assign_fee, + calculate_fee, + decode_transaction, + group_transactions, +) + +from .common import TransactionTestData +from .conftest import TestDataLookup + + +def test_unknown_transaction_type() -> None: + """Ensure unknown transaction types can be decoded without errors (forward compatibility)""" + address_bytes = bytes( + [ + 230, + 185, + 154, + 253, + 65, + 13, + 19, + 221, + 14, + 138, + 126, + 148, + 184, + 121, + 29, + 48, + 92, + 117, + 6, + 238, + 183, + 225, + 250, + 65, + 14, + 118, + 26, + 59, + 98, + 44, + 225, + 20, + ] + ) + + wire_transaction = { + "amt": 1000, + "fv": 1000, + "lv": 2000, + "rcv": address_bytes, + "snd": address_bytes, + "type": "xyz", # An unknown transaction type + } + + encoded = msgpack.packb(wire_transaction) + decoded = decode_transaction(encoded) + + assert decoded.transaction_type == TransactionType.Unknown + assert decoded.first_valid == 1000 + assert decoded.last_valid == 2000 + assert decoded.sender == "424ZV7KBBUJ52DUKP2KLQ6I5GBOHKBXOW7Q7UQIOOYNDWYRM4EKOSMVVRI" + # Type-specific fields should be None for unknown transaction types + assert decoded.payment is None + assert decoded.asset_transfer is None + assert decoded.asset_config is None + assert decoded.application_call is None + assert decoded.key_registration is None + assert decoded.asset_freeze is None + assert decoded.heartbeat is None + assert decoded.state_proof is None + + +def _sample_app_call_tx() -> Transaction: + return Transaction( + transaction_type=TransactionType.AppCall, + sender="XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA", + first_valid=1, + last_valid=2, + application_call=AppCallTransactionFields(approval_program=b"\x01", clear_state_program=b"\x02"), + ) + + +def test_calculate_fee_matches_assign_fee() -> None: + tx = _sample_app_call_tx() + fee = calculate_fee(tx, fee_per_byte=10, min_fee=1000) + assigned = assign_fee(tx, fee_per_byte=10, min_fee=1000) + assert assigned.fee == fee + + +def _simple_group_test_data(test_data_lookup: TestDataLookup) -> list[TransactionTestData]: + payment = test_data_lookup("simplePayment") + opt_in = test_data_lookup("optInAssetTransfer") + return [payment, opt_in] + + +def test_group_transactions_max_size(test_data_lookup: TestDataLookup) -> None: + vectors = _simple_group_test_data(test_data_lookup) + base = vectors[0].transaction + # Create MAX_TRANSACTION_GROUP_SIZE + 1 copies (with different first_valid to avoid identical txs) + over_limit = [ + base.__class__( + transaction_type=TransactionType.Payment, + sender=base.sender, + first_valid=base.first_valid + i, + last_valid=base.last_valid + i, + payment=base.payment, + ) + for i in range(MAX_TRANSACTION_GROUP_SIZE + 1) + ] + + with pytest.raises(ValueError, match=rf"max limit of {MAX_TRANSACTION_GROUP_SIZE}"): + group_transactions(over_limit) diff --git a/tests/modules/transact/test_transaction_group.py b/tests/modules/transact/test_transaction_group.py new file mode 100644 index 00000000..6d4d2142 --- /dev/null +++ b/tests/modules/transact/test_transaction_group.py @@ -0,0 +1,101 @@ +import nacl.signing +import pytest + +from algokit_transact import ( + SignedTransaction, + decode_signed_transactions, + decode_transactions, + encode_signed_transaction, + encode_signed_transactions, + encode_transaction, + encode_transactions, + group_transactions, +) + +from .common import TransactionTestData +from .conftest import TestDataLookup + +# Polytest Suite: Transaction Group + +# Polytest Group: Transaction Group Tests + + +def _simple_group_test_data(test_data_lookup: TestDataLookup) -> list[TransactionTestData]: + payment = test_data_lookup("simplePayment") + opt_in = test_data_lookup("optInAssetTransfer") + return [payment, opt_in] + + +def _sign(message: bytes, private_key: bytes) -> bytes: + # Data factory SK is 64 bytes (Go's ed25519 format: 32-byte seed + 32-byte public) + # NaCl expects just the 32-byte seed + seed = private_key[:32] + signing_key = nacl.signing.SigningKey(seed) + return bytes(signing_key.sign(message).signature) + + +@pytest.mark.group_transaction_group_tests +def test_group_transactions(test_data_lookup: TestDataLookup) -> None: + """A collection of transactions can be grouped""" + vectors = _simple_group_test_data(test_data_lookup) + grouped = group_transactions([v.transaction for v in vectors]) + + assert len(grouped) == len(vectors) + for original_vector, grouped_txn in zip(vectors, grouped, strict=False): + assert original_vector.transaction.group is None + # Verify that group is set (a 32-byte hash) + assert grouped_txn.group is not None + assert len(grouped_txn.group) == 32 + # Verify all transactions in the group have the same group ID + group_ids = [txn.group for txn in grouped] + assert all(g == group_ids[0] for g in group_ids) + + +@pytest.mark.group_transaction_group_tests +def test_encode_transactions(test_data_lookup: TestDataLookup) -> None: + """A collection of transactions can be encoded""" + vectors = _simple_group_test_data(test_data_lookup) + grouped = group_transactions([v.transaction for v in vectors]) + encoded_grouped = encode_transactions(grouped) + + assert len(encoded_grouped) == len(grouped) + for tx_bytes, tx in zip(encoded_grouped, grouped, strict=False): + assert tx_bytes == encode_transaction(tx) + + decoded_grouped = decode_transactions(encoded_grouped) + # Compare key fields since decoder may add default values + assert len(decoded_grouped) == len(grouped) + for decoded, original in zip(decoded_grouped, grouped, strict=False): + assert decoded.transaction_type == original.transaction_type + assert decoded.sender == original.sender + assert decoded.group == original.group + + +@pytest.mark.group_transaction_group_tests +def test_encode_signed_transactions(test_data_lookup: TestDataLookup) -> None: + """A collection of signed transactions can be encoded""" + vectors = _simple_group_test_data(test_data_lookup) + grouped = group_transactions([v.transaction for v in vectors]) + encoded_grouped = encode_transactions(grouped) + + signatures: list[bytes] = [] + for vector, tx_bytes in zip(vectors, encoded_grouped, strict=False): + if vector.signer.single_signer is None: # pragma: no cover - fixtures define keys + raise AssertionError("missing signing key for test vector") + signatures.append(_sign(tx_bytes, vector.signer.single_signer.sk)) + + signed_grouped = [SignedTransaction(txn=tx, sig=sig) for tx, sig in zip(grouped, signatures, strict=False)] + + encoded_signed = encode_signed_transactions(signed_grouped) + assert len(encoded_signed) == len(signed_grouped) + + for stx_bytes, stx in zip(encoded_signed, signed_grouped, strict=False): + assert stx_bytes == encode_signed_transaction(stx) + + decoded_signed = decode_signed_transactions(encoded_signed) + # Compare key fields + assert len(decoded_signed) == len(signed_grouped) + for decoded, original in zip(decoded_signed, signed_grouped, strict=False): + assert decoded.txn.transaction_type == original.txn.transaction_type + assert decoded.txn.sender == original.txn.sender + assert decoded.sig == original.sig diff --git a/tests/modules/transact/transaction_asserts.py b/tests/modules/transact/transaction_asserts.py new file mode 100644 index 00000000..76d14717 --- /dev/null +++ b/tests/modules/transact/transaction_asserts.py @@ -0,0 +1,134 @@ +"""Helper assertions mirroring ``transaction_asserts.ts`` from TS suite.""" + +import nacl.signing + +from algokit_transact import ( + SignedTransaction, + apply_multisig_subsignature, + assign_fee, + decode_transaction, + encode_signed_transaction, + encode_transaction, + encode_transaction_raw, + estimate_transaction_size, + get_encoded_transaction_type, + get_transaction_id, + merge_multisignatures, + new_multisig_signature, +) + +from .common import TransactionTestData + + +def _sign_ed25519(message: bytes, private_key: bytes) -> bytes: + # Data factory SK is 64 bytes (Go's ed25519 format), take first 32 bytes as seed + seed = private_key[:32] + signing_key = nacl.signing.SigningKey(seed) + signed = signing_key.sign(message) + return bytes(signed.signature) + + +def _build_signed_transaction( + *, txn: TransactionTestData, signature: bytes, auth_address: str | None = None +) -> SignedTransaction: + return SignedTransaction( + txn=txn.transaction, + sig=signature, + auth_address=auth_address, + ) + + +def assert_example(label: str, test_data: TransactionTestData) -> None: + if test_data.signer.single_signer is None: + # Skip tests that require single signer when not available + return + message = encode_transaction(test_data.transaction) + signature = _sign_ed25519(message, test_data.signer.single_signer.sk) + signed_txn = _build_signed_transaction(txn=test_data, signature=signature) + encoded_signed = encode_signed_transaction(signed_txn) + assert encoded_signed == test_data.signed_bytes, label + + +def assert_transaction_id(label: str, test_data: TransactionTestData) -> None: + assert get_transaction_id(test_data.transaction) == test_data.id, label + + +def assert_encoded_transaction_type(label: str, test_data: TransactionTestData) -> None: + # unsigned_bytes from data factory is raw msgpack without TX prefix + encoded_type = get_encoded_transaction_type(test_data.unsigned_bytes) + assert encoded_type == test_data.transaction.transaction_type, label + + +def assert_decode_without_prefix(label: str, test_data: TransactionTestData) -> None: + # unsigned_bytes from data factory is already raw msgpack without prefix + decoded = decode_transaction(test_data.unsigned_bytes) + assert decoded == test_data.transaction, label + + +def assert_decode_with_prefix(label: str, test_data: TransactionTestData) -> None: + # Add TX prefix to raw bytes for this test + prefix = b"TX" + with_prefix = prefix + test_data.unsigned_bytes + decoded = decode_transaction(with_prefix) + assert decoded == test_data.transaction, label + + +def assert_encode_with_signature(label: str, test_data: TransactionTestData) -> None: + if test_data.signer.single_signer is None: + # Skip tests that require single signer when not available + return + message = encode_transaction(test_data.transaction) + signature = _sign_ed25519(message, test_data.signer.single_signer.sk) + signed_txn = _build_signed_transaction(txn=test_data, signature=signature) + encoded = encode_signed_transaction(signed_txn) + assert encoded == test_data.signed_bytes, label + + +def assert_encode(label: str, test_data: TransactionTestData) -> None: + """A transaction with valid fields is encoded properly.""" + # Use encode_transaction_raw which produces raw msgpack without TX prefix + encoded = encode_transaction_raw(test_data.transaction) + assert encoded == test_data.unsigned_bytes, label + + +def assert_assign_fee(label: str, test_data: TransactionTestData) -> None: + min_fee = 2_000 + tx_with_min = assign_fee(test_data.transaction, fee_per_byte=0, min_fee=min_fee) + assert tx_with_min.fee == min_fee, label + + extra_fee = 3_000 + tx_with_extra = assign_fee(test_data.transaction, fee_per_byte=0, min_fee=min_fee, extra_fee=extra_fee) + assert tx_with_extra.fee == min_fee + extra_fee, label + + fee_per_byte = 100 + tx_with_byte_fee = assign_fee(test_data.transaction, fee_per_byte=fee_per_byte, min_fee=1_000) + expected_fee = estimate_transaction_size(test_data.transaction) * fee_per_byte + assert tx_with_byte_fee.fee == expected_fee, label + + +def assert_multisig_example(label: str, test_data: TransactionTestData) -> None: + from algokit_common import address_from_public_key + + if test_data.signer.msig_signers is None or len(test_data.signer.msig_signers) < 2: + # Skip - no multisig signers available + return + + message = encode_transaction(test_data.transaction) + + # Get the first signer's private key for signing + signature = _sign_ed25519(message, test_data.signer.msig_signers[0].sk) + + # Convert public keys to addresses for multisig + participants = [address_from_public_key(s.pk) for s in test_data.signer.msig_signers] + + unsigned_multisig = new_multisig_signature(1, 2, participants) + applied_signatures = [ + apply_multisig_subsignature(unsigned_multisig, participant, signature) for participant in participants + ] + merged = applied_signatures[0] + for msig in applied_signatures[1:]: + merged = merge_multisignatures(merged, msig) + + signed_txn = SignedTransaction(txn=test_data.transaction, msig=merged) + encoded = encode_signed_transaction(signed_txn) + assert encoded == test_data.signed_bytes, label diff --git a/tests/modules/transact/ts_data.py b/tests/modules/transact/ts_data.py new file mode 100644 index 00000000..111850a3 --- /dev/null +++ b/tests/modules/transact/ts_data.py @@ -0,0 +1,7 @@ +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[3] + + +def as_bytes(arr: list[int]) -> bytes: + return bytes(arr) diff --git a/tests/modules/transact/validate_transaction/__init__.py b/tests/modules/transact/validate_transaction/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/modules/transact/validate_transaction/test_app_call.py b/tests/modules/transact/validate_transaction/test_app_call.py new file mode 100644 index 00000000..347d368a --- /dev/null +++ b/tests/modules/transact/validate_transaction/test_app_call.py @@ -0,0 +1,458 @@ +import pytest + +from algokit_transact import ( + BoxReference, + OnApplicationComplete, + StateSchema, + Transaction, + decode_transaction, + encode_transaction, + validate_transaction, +) +from tests.modules.transact._validation import assert_validation_error, build_app_call, clone_transaction +from tests.modules.transact.conftest import TestDataLookup + + +@pytest.fixture +def app_create_transaction(test_data_lookup: TestDataLookup) -> Transaction: + vector = test_data_lookup("appCreate") + return vector.transaction + + +@pytest.fixture +def base_update_transaction(test_data_lookup: TestDataLookup) -> Transaction: + vector = test_data_lookup("appUpdate") + return vector.transaction + + +@pytest.fixture +def base_call_transaction(test_data_lookup: TestDataLookup) -> Transaction: + vector = test_data_lookup("appCall") + return vector.transaction + + +def test_should_throw_error_when_approval_program_is_missing_for_app_creation( + app_create_transaction: Transaction, +) -> None: + tx = clone_transaction( + app_create_transaction, + application_call=build_app_call( + app_id=0, + on_complete=OnApplicationComplete.NoOp, + clear_state_program=b"\x01\x02\x03", + ), + ) + + assert_validation_error(tx, "App call validation failed: Approval program is required") + + +def test_should_throw_error_when_clear_state_program_is_missing_for_app_creation( + app_create_transaction: Transaction, +) -> None: + tx = clone_transaction( + app_create_transaction, + application_call=build_app_call( + app_id=0, + on_complete=OnApplicationComplete.NoOp, + approval_program=b"\x01\x02\x03", + ), + ) + + assert_validation_error(tx, "App call validation failed: Clear state program is required") + + +def test_should_throw_error_when_extra_program_pages_exceed_maximum(app_create_transaction: Transaction) -> None: + tx = clone_transaction( + app_create_transaction, + application_call=build_app_call( + app_id=0, + on_complete=OnApplicationComplete.NoOp, + approval_program=b"\x01\x02\x03", + clear_state_program=b"\x04\x05\x06", + extra_program_pages=4, + ), + ) + + assert_validation_error(tx, "App call validation failed: Extra program pages cannot exceed 3 pages, got 4") + + +def test_should_throw_error_when_approval_program_exceeds_max_size(app_create_transaction: Transaction) -> None: + tx = clone_transaction( + app_create_transaction, + application_call=build_app_call( + app_id=0, + on_complete=OnApplicationComplete.NoOp, + approval_program=b"\x00" * 2049, + clear_state_program=b"\x04\x05\x06", + ), + ) + + assert_validation_error(tx, "App call validation failed: Approval program cannot exceed 2048 bytes") + + +def test_should_throw_error_when_clear_state_program_exceeds_max_size(app_create_transaction: Transaction) -> None: + tx = clone_transaction( + app_create_transaction, + application_call=build_app_call( + app_id=0, + on_complete=OnApplicationComplete.NoOp, + approval_program=b"\x01\x02\x03", + clear_state_program=b"\x00" * 2049, + ), + ) + + assert_validation_error(tx, "App call validation failed: Clear state program cannot exceed 2048 bytes") + + +def test_should_throw_error_when_combined_programs_exceed_max_size(app_create_transaction: Transaction) -> None: + tx = clone_transaction( + app_create_transaction, + application_call=build_app_call( + app_id=0, + on_complete=OnApplicationComplete.NoOp, + approval_program=b"\x00" * 1500, + clear_state_program=b"\xff" * 1500, + ), + ) + + assert_validation_error( + tx, + "App call validation failed: Combined approval and clear state programs cannot exceed 2048 bytes", + ) + + +def test_should_throw_error_when_global_state_schema_exceeds_maximum_keys(app_create_transaction: Transaction) -> None: + tx = clone_transaction( + app_create_transaction, + application_call=build_app_call( + app_id=0, + on_complete=OnApplicationComplete.NoOp, + approval_program=b"\x01\x02\x03", + clear_state_program=b"\x04\x05\x06", + global_state_schema=StateSchema(num_uints=32, num_byte_slices=33), + ), + ) + + assert_validation_error(tx, "App call validation failed: Global state schema cannot exceed 64 keys") + + +def test_should_throw_error_when_local_state_schema_exceeds_maximum_keys(app_create_transaction: Transaction) -> None: + tx = clone_transaction( + app_create_transaction, + application_call=build_app_call( + app_id=0, + on_complete=OnApplicationComplete.NoOp, + approval_program=b"\x01\x02\x03", + clear_state_program=b"\x04\x05\x06", + local_state_schema=StateSchema(num_uints=8, num_byte_slices=9), + ), + ) + + assert_validation_error(tx, "App call validation failed: Local state schema cannot exceed 16 keys") + + +def test_should_validate_valid_app_creation_transaction(app_create_transaction: Transaction) -> None: + tx = clone_transaction( + app_create_transaction, + application_call=build_app_call( + app_id=0, + on_complete=OnApplicationComplete.NoOp, + approval_program=b"\x01\x02\x03", + clear_state_program=b"\x04\x05\x06", + global_state_schema=StateSchema(num_uints=32, num_byte_slices=32), + local_state_schema=StateSchema(num_uints=8, num_byte_slices=8), + extra_program_pages=3, + ), + ) + + validate_transaction(tx) + + +def test_should_validate_app_creation_with_large_programs_when_extra_pages_are_provided( + app_create_transaction: Transaction, +) -> None: + tx = clone_transaction( + app_create_transaction, + application_call=build_app_call( + app_id=0, + on_complete=OnApplicationComplete.NoOp, + approval_program=b"\xaa" * 4000, + clear_state_program=b"\x04\x05\x06", + extra_program_pages=2, + ), + ) + + validate_transaction(tx) + + +def test_should_throw_error_when_approval_program_is_missing_for_app_update( + base_update_transaction: Transaction, +) -> None: + tx = clone_transaction( + base_update_transaction, + application_call=build_app_call( + app_id=123, + on_complete=OnApplicationComplete.UpdateApplication, + clear_state_program=b"\x01\x02\x03", + ), + ) + + assert_validation_error(tx, "App call validation failed: Approval program is required") + + +def test_should_throw_error_when_clear_state_program_is_missing_for_app_update( + base_update_transaction: Transaction, +) -> None: + tx = clone_transaction( + base_update_transaction, + application_call=build_app_call( + app_id=123, + on_complete=OnApplicationComplete.UpdateApplication, + approval_program=b"\x01\x02\x03", + ), + ) + + assert_validation_error(tx, "App call validation failed: Clear state program is required") + + +def test_should_throw_error_when_trying_to_modify_global_state_schema(base_update_transaction: Transaction) -> None: + tx = clone_transaction( + base_update_transaction, + application_call=build_app_call( + app_id=123, + on_complete=OnApplicationComplete.UpdateApplication, + approval_program=b"\x01", + clear_state_program=b"\x02", + global_state_schema=StateSchema(num_uints=1, num_byte_slices=1), + ), + ) + + assert_validation_error(tx, "App call validation failed: Global state schema is immutable and cannot be changed") + + +def test_should_throw_error_when_trying_to_modify_local_state_schema(base_update_transaction: Transaction) -> None: + tx = clone_transaction( + base_update_transaction, + application_call=build_app_call( + app_id=123, + on_complete=OnApplicationComplete.UpdateApplication, + approval_program=b"\x01", + clear_state_program=b"\x02", + local_state_schema=StateSchema(num_uints=1, num_byte_slices=1), + ), + ) + + assert_validation_error(tx, "App call validation failed: Local state schema is immutable and cannot be changed") + + +def test_should_throw_error_when_trying_to_modify_extra_program_pages(base_update_transaction: Transaction) -> None: + tx = clone_transaction( + base_update_transaction, + application_call=build_app_call( + app_id=123, + on_complete=OnApplicationComplete.UpdateApplication, + approval_program=b"\x01", + clear_state_program=b"\x02", + extra_program_pages=1, + ), + ) + + assert_validation_error(tx, "App call validation failed: Extra program pages is immutable and cannot be changed") + + +def test_should_validate_valid_app_update_transaction(base_update_transaction: Transaction) -> None: + tx = clone_transaction( + base_update_transaction, + application_call=build_app_call( + app_id=123, + on_complete=OnApplicationComplete.UpdateApplication, + approval_program=b"\x01", + clear_state_program=b"\x02", + ), + ) + + validate_transaction(tx) + + +def test_should_validate_valid_app_call_transaction(base_call_transaction: Transaction) -> None: + tx = clone_transaction( + base_call_transaction, + application_call=build_app_call( + app_id=123, + on_complete=OnApplicationComplete.NoOp, + args=(b"\x01\x02\x03", b"\x04\x05\x06"), + account_references=("ADSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK",), + app_references=(456, 789), + asset_references=(101112, 131415), + ), + ) + + validate_transaction(tx) + + +@pytest.mark.parametrize( + "on_complete", + [ + OnApplicationComplete.DeleteApplication, + OnApplicationComplete.OptIn, + OnApplicationComplete.CloseOut, + OnApplicationComplete.ClearState, + ], +) +def test_should_validate_other_app_operations( + base_call_transaction: Transaction, on_complete: OnApplicationComplete +) -> None: + tx = clone_transaction( + base_call_transaction, + application_call=build_app_call(app_id=123, on_complete=on_complete), + ) + + validate_transaction(tx) + + +def test_should_throw_error_when_too_many_args_are_provided(base_call_transaction: Transaction) -> None: + args = tuple(bytes([i]) for i in range(17)) + tx = clone_transaction( + base_call_transaction, + application_call=build_app_call(app_id=123, on_complete=OnApplicationComplete.NoOp, args=args), + ) + + assert_validation_error(tx, "App call validation failed: Args cannot exceed 16 arguments") + + +def test_should_throw_error_when_args_total_size_exceeds_maximum(base_call_transaction: Transaction) -> None: + tx = clone_transaction( + base_call_transaction, + application_call=build_app_call( + app_id=123, + on_complete=OnApplicationComplete.NoOp, + args=(b"\x01" * 2049,), + ), + ) + + assert_validation_error(tx, "App call validation failed: Args total size cannot exceed 2048 bytes") + + +def test_should_throw_error_when_too_many_account_references_are_provided(base_call_transaction: Transaction) -> None: + accounts = tuple("A" * 58 for _ in range(9)) # Max is 8 + tx = clone_transaction( + base_call_transaction, + application_call=build_app_call( + app_id=123, on_complete=OnApplicationComplete.NoOp, account_references=accounts + ), + ) + + assert_validation_error(tx, "App call validation failed: Account references cannot exceed 8 refs") + + +def test_should_throw_error_when_too_many_app_references_are_provided(base_call_transaction: Transaction) -> None: + apps = tuple(range(1, 10)) + tx = clone_transaction( + base_call_transaction, + application_call=build_app_call(app_id=123, on_complete=OnApplicationComplete.NoOp, app_references=apps), + ) + + assert_validation_error(tx, "App call validation failed: App references cannot exceed 8 refs") + + +def test_should_throw_error_when_too_many_asset_references_are_provided(base_call_transaction: Transaction) -> None: + assets = tuple(range(1, 10)) + tx = clone_transaction( + base_call_transaction, + application_call=build_app_call(app_id=123, on_complete=OnApplicationComplete.NoOp, asset_references=assets), + ) + + assert_validation_error(tx, "App call validation failed: Asset references cannot exceed 8 refs") + + +def test_should_throw_error_when_box_references_exceed_limit(base_call_transaction: Transaction) -> None: + app_call = base_call_transaction.application_call + assert app_call is not None + boxes = tuple(BoxReference(app_id=app_call.app_id, name=b"box") for _ in range(9)) + tx = clone_transaction( + base_call_transaction, + application_call=build_app_call( + app_id=app_call.app_id, + on_complete=OnApplicationComplete.NoOp, + approval_program=app_call.approval_program, + clear_state_program=app_call.clear_state_program, + box_references=boxes, + ), + ) + + assert_validation_error(tx, "App call validation failed: Box references cannot exceed 8 refs") + + +def test_box_references_round_trip(base_call_transaction: Transaction) -> None: + app_call = base_call_transaction.application_call + assert app_call is not None + boxes = ( + BoxReference(app_id=app_call.app_id, name=b"self"), + BoxReference(app_id=1234, name=b"foreign"), + ) + tx = clone_transaction( + base_call_transaction, + application_call=build_app_call( + app_id=app_call.app_id, + on_complete=app_call.on_complete, + approval_program=app_call.approval_program, + clear_state_program=app_call.clear_state_program, + app_references=(1234,), + box_references=boxes, + ), + ) + + decoded = decode_transaction(encode_transaction(tx)) + assert decoded == tx + + +def test_box_reference_must_reference_known_app(base_call_transaction: Transaction) -> None: + app_call = base_call_transaction.application_call + assert app_call is not None + tx = clone_transaction( + base_call_transaction, + application_call=build_app_call( + app_id=app_call.app_id, + on_complete=app_call.on_complete, + approval_program=app_call.approval_program, + clear_state_program=app_call.clear_state_program, + app_references=(1234,), + box_references=(BoxReference(app_id=9999, name=b"bad"),), + ), + ) + + assert_validation_error( + tx, + "App call validation failed: Box reference for app ID 9999 must reference the current app or an app reference", + ) + + +def test_should_throw_error_when_total_references_exceed_limit(base_call_transaction: Transaction) -> None: + tx = clone_transaction( + base_call_transaction, + application_call=build_app_call( + app_id=123, + on_complete=OnApplicationComplete.NoOp, + account_references=("A" * 58,) * 2, + app_references=(1, 2, 3), + asset_references=(4, 5, 6, 7), + ), + ) + + assert_validation_error(tx, "App call validation failed: Total references cannot exceed 8 refs") + + +def test_should_validate_app_call_with_maximum_allowed_references(base_call_transaction: Transaction) -> None: + tx = clone_transaction( + base_call_transaction, + application_call=build_app_call( + app_id=123, + on_complete=OnApplicationComplete.NoOp, + args=tuple(bytes([i]) for i in range(16)), + account_references=("NY6DHEEFW73R2NUWY562U2NNKSKBKVYY5OOQFLD3M2II5RUNKRZDEGUGEA",) * 2, + app_references=(1, 2, 3), + asset_references=(4, 5, 6), + ), + ) + + validate_transaction(tx) diff --git a/tests/modules/transact/validate_transaction/test_asset_config.py b/tests/modules/transact/validate_transaction/test_asset_config.py new file mode 100644 index 00000000..fd45bd3b --- /dev/null +++ b/tests/modules/transact/validate_transaction/test_asset_config.py @@ -0,0 +1,302 @@ +import pytest + +from algokit_transact import Transaction, TransactionValidationError, validate_transaction +from tests.modules.transact._validation import ( + assert_validation_error, + build_asset_config, + clone_transaction, +) +from tests.modules.transact.conftest import TestDataLookup + + +@pytest.fixture +def asset_create_transaction(test_data_lookup: TestDataLookup) -> Transaction: + return test_data_lookup("assetCreate").transaction + + +@pytest.fixture +def asset_reconfig_transaction(test_data_lookup: TestDataLookup) -> Transaction: + return test_data_lookup("assetConfig").transaction + + +@pytest.fixture +def asset_destroy_transaction(test_data_lookup: TestDataLookup) -> Transaction: + return test_data_lookup("assetDestroy").transaction + + +def test_should_throw_error_when_total_is_missing_for_asset_creation(asset_create_transaction: Transaction) -> None: + tx = clone_transaction( + asset_create_transaction, + asset_config=build_asset_config( + asset_id=0, + decimals=2, + asset_name="Test Asset", + unit_name="TA", + ), + ) + + assert_validation_error(tx, "Asset config validation failed: Total is required") + + +def test_should_throw_error_when_decimals_exceed_maximum(asset_create_transaction: Transaction) -> None: + tx = clone_transaction( + asset_create_transaction, + asset_config=build_asset_config( + asset_id=0, + total=1_000_000, + decimals=20, + asset_name="Test Asset", + unit_name="TA", + ), + ) + + assert_validation_error( + tx, + "Asset config validation failed: Decimals cannot exceed 19 decimal places, got 20", + ) + + +def test_should_throw_error_when_unit_name_is_too_long(asset_create_transaction: Transaction) -> None: + tx = clone_transaction( + asset_create_transaction, + asset_config=build_asset_config( + asset_id=0, + total=1_000_000, + decimals=2, + asset_name="Test Asset", + unit_name="TOOLONGUNITNAME", + ), + ) + + assert_validation_error( + tx, + "Asset config validation failed: Unit name cannot exceed 8 bytes, got 15", + ) + + +def test_should_throw_error_when_asset_name_is_too_long(asset_create_transaction: Transaction) -> None: + long_name = "A" * 33 + tx = clone_transaction( + asset_create_transaction, + asset_config=build_asset_config( + asset_id=0, + total=1_000_000, + decimals=2, + asset_name=long_name, + unit_name="TA", + ), + ) + + assert_validation_error( + tx, + "Asset config validation failed: Asset name cannot exceed 32 bytes, got 33", + ) + + +def test_should_throw_error_when_url_is_too_long(asset_create_transaction: Transaction) -> None: + long_url = "https://" + "a" * 90 + tx = clone_transaction( + asset_create_transaction, + asset_config=build_asset_config( + asset_id=0, + total=1_000_000, + decimals=2, + asset_name="Test Asset", + unit_name="TA", + url=long_url, + ), + ) + + assert_validation_error(tx, "Asset config validation failed: Url cannot exceed 96 bytes") + + +def test_should_throw_multiple_errors_for_asset_creation(asset_create_transaction: Transaction) -> None: + long_name = "A" * 33 + long_url = "https://" + "a" * 90 + tx = clone_transaction( + asset_create_transaction, + asset_config=build_asset_config( + asset_id=0, + decimals=20, + asset_name=long_name, + unit_name="TOOLONGUNITNAME", + url=long_url, + ), + ) + + with pytest.raises(TransactionValidationError) as exc: + validate_transaction(tx) + message = str(exc.value) + assert "Asset config validation failed:" in message + assert "Total is required" in message + assert "Decimals cannot exceed 19 decimal places" in message + assert "Asset name cannot exceed 32 bytes" in message + assert "Unit name cannot exceed 8 bytes" in message + assert "Url cannot exceed 96 bytes" in message + + +def test_should_validate_valid_asset_creation_transaction(asset_create_transaction: Transaction) -> None: + tx = clone_transaction( + asset_create_transaction, + asset_config=build_asset_config( + asset_id=0, + total=1_000_000, + decimals=2, + default_frozen=False, + asset_name="Test Asset", + unit_name="TA", + url="https://example.com", + metadata_hash=b"\x00" * 32, + manager="ADSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + reserve="BNSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + freeze="CNSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + clawback="DNSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + ), + ) + + validate_transaction(tx) + + +def test_should_validate_asset_creation_with_minimum_values(asset_create_transaction: Transaction) -> None: + tx = clone_transaction( + asset_create_transaction, + asset_config=build_asset_config( + asset_id=0, + total=1, + decimals=0, + ), + ) + + validate_transaction(tx) + + +def test_should_validate_asset_creation_with_maximum_values(asset_create_transaction: Transaction) -> None: + max_name = "A" * 32 + max_unit = "MAXUNIT8" + max_url = "https://" + "a" * 88 + tx = clone_transaction( + asset_create_transaction, + asset_config=build_asset_config( + asset_id=0, + total=18_446_744_073_709_551_615, + decimals=19, + asset_name=max_name, + unit_name=max_unit, + url=max_url, + ), + ) + + validate_transaction(tx) + + +def test_should_validate_asset_creation_with_default_frozen_true(asset_create_transaction: Transaction) -> None: + tx = clone_transaction( + asset_create_transaction, + asset_config=build_asset_config( + asset_id=0, + total=1_000_000, + decimals=2, + default_frozen=True, + freeze="ADSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + ), + ) + + validate_transaction(tx) + + +def test_should_throw_error_when_modifying_total(asset_reconfig_transaction: Transaction) -> None: + tx = clone_transaction( + asset_reconfig_transaction, + asset_config=build_asset_config(asset_id=123, total=2_000_000), + ) + + assert_validation_error(tx, "Asset config validation failed: Total is immutable and cannot be changed") + + +def test_should_throw_error_when_modifying_decimals(asset_reconfig_transaction: Transaction) -> None: + tx = clone_transaction( + asset_reconfig_transaction, + asset_config=build_asset_config(asset_id=123, decimals=3), + ) + + assert_validation_error(tx, "Asset config validation failed: Decimals is immutable and cannot be changed") + + +def test_should_throw_multiple_errors_when_modifying_immutable_fields( + asset_reconfig_transaction: Transaction, +) -> None: + tx = clone_transaction( + asset_reconfig_transaction, + asset_config=build_asset_config( + asset_id=123, + total=2_000_000, + decimals=3, + default_frozen=True, + asset_name="New Name", + unit_name="NEW", + url="https://new.com", + metadata_hash=b"\x00" * 32, + ), + ) + + with pytest.raises(TransactionValidationError) as exc: + validate_transaction(tx) + message = str(exc.value) + assert "Asset config validation failed:" in message + assert "Total is immutable" in message + assert "Decimals is immutable" in message + assert "Default frozen is immutable" in message + assert "Asset name is immutable" in message + assert "Unit name is immutable" in message + assert "Url is immutable" in message + assert "Metadata hash is immutable" in message + + +def test_should_validate_valid_asset_reconfiguration(asset_reconfig_transaction: Transaction) -> None: + tx = clone_transaction( + asset_reconfig_transaction, + asset_config=build_asset_config( + asset_id=123, + manager="ADSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + reserve="BNSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + freeze="CNSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + clawback="DNSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + ), + ) + + validate_transaction(tx) + + +def test_should_validate_asset_destruction(asset_destroy_transaction: Transaction) -> None: + validate_transaction(asset_destroy_transaction) + + +def test_should_validate_asset_reconfiguration_removing_special_addresses( + asset_reconfig_transaction: Transaction, +) -> None: + tx = clone_transaction( + asset_reconfig_transaction, + asset_config=build_asset_config( + asset_id=123, + manager="", + reserve="", + freeze="", + clawback="", + ), + ) + + validate_transaction(tx) + + +def test_should_validate_asset_reconfiguration_with_single_field_change( + asset_reconfig_transaction: Transaction, +) -> None: + tx = clone_transaction( + asset_reconfig_transaction, + asset_config=build_asset_config( + asset_id=123, + manager="ADSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + ), + ) + + validate_transaction(tx) diff --git a/tests/modules/transact/validate_transaction/test_asset_freeze.py b/tests/modules/transact/validate_transaction/test_asset_freeze.py new file mode 100644 index 00000000..b3e78839 --- /dev/null +++ b/tests/modules/transact/validate_transaction/test_asset_freeze.py @@ -0,0 +1,79 @@ +import pytest + +from algokit_transact import TransactionValidationError, validate_transaction +from tests.modules.transact._validation import build_asset_freeze, clone_transaction +from tests.modules.transact.conftest import TestDataLookup + + +def test_should_throw_error_when_asset_id_is_zero(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("assetFreeze") + tx = clone_transaction( + vector.transaction, + asset_freeze=build_asset_freeze( + asset_id=0, + freeze_target="ADSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + frozen=True, + ), + ) + + with pytest.raises(TransactionValidationError) as exc: + validate_transaction(tx) + assert "Asset freeze validation failed: Asset ID must not be 0" in str(exc.value) + + +def test_should_validate_valid_asset_freeze_transaction(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("assetFreeze") + tx = clone_transaction( + vector.transaction, + asset_freeze=build_asset_freeze( + asset_id=123, + freeze_target="ADSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + frozen=True, + ), + ) + + validate_transaction(tx) + + +def test_should_validate_asset_unfreeze_transaction(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("assetUnfreeze") + tx = clone_transaction( + vector.transaction, + asset_freeze=build_asset_freeze( + asset_id=123, + freeze_target="ADSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + frozen=False, + ), + ) + + validate_transaction(tx) + + +def test_should_validate_freezing_sender_themselves(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("assetFreeze") + sender = vector.transaction.sender + tx = clone_transaction( + vector.transaction, + asset_freeze=build_asset_freeze( + asset_id=123, + freeze_target=sender, + frozen=True, + ), + ) + + validate_transaction(tx) + + +def test_should_validate_unfreezing_sender_themselves(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("assetUnfreeze") + sender = vector.transaction.sender + tx = clone_transaction( + vector.transaction, + asset_freeze=build_asset_freeze( + asset_id=123, + freeze_target=sender, + frozen=False, + ), + ) + + validate_transaction(tx) diff --git a/tests/modules/transact/validate_transaction/test_asset_transfer.py b/tests/modules/transact/validate_transaction/test_asset_transfer.py new file mode 100644 index 00000000..2ed7e9ff --- /dev/null +++ b/tests/modules/transact/validate_transaction/test_asset_transfer.py @@ -0,0 +1,126 @@ +import pytest + +from algokit_transact import TransactionValidationError, validate_transaction +from tests.modules.transact._validation import build_asset_transfer, clone_transaction +from tests.modules.transact.conftest import TestDataLookup + + +def test_should_throw_error_when_asset_id_is_zero(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("optInAssetTransfer") + tx = clone_transaction( + vector.transaction, + asset_transfer=build_asset_transfer( + asset_id=0, + amount=1000, + receiver="ADSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + ), + ) + + with pytest.raises(TransactionValidationError) as exc: + validate_transaction(tx) + assert "Asset transfer validation failed: Asset ID must not be 0" in str(exc.value) + + +def test_should_validate_valid_asset_transfer_transaction(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("optInAssetTransfer") + tx = clone_transaction( + vector.transaction, + asset_transfer=build_asset_transfer( + asset_id=123, + amount=1000, + receiver="ADSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + ), + ) + + validate_transaction(tx) + + +def test_should_validate_asset_opt_in_transaction(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("optInAssetTransfer") + sender = vector.transaction.sender + tx = clone_transaction( + vector.transaction, + asset_transfer=build_asset_transfer( + asset_id=123, + amount=0, + receiver=sender, + ), + ) + + validate_transaction(tx) + + +def test_should_validate_asset_transfer_with_clawback(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("optInAssetTransfer") + tx = clone_transaction( + vector.transaction, + asset_transfer=build_asset_transfer( + asset_id=123, + amount=1000, + receiver="ADSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + asset_sender="BNSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + ), + ) + + validate_transaction(tx) + + +def test_should_validate_asset_opt_out_transaction(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("optInAssetTransfer") + tx = clone_transaction( + vector.transaction, + asset_transfer=build_asset_transfer( + asset_id=123, + amount=1000, + receiver="ADSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + close_remainder_to="BNSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + ), + ) + + validate_transaction(tx) + + +def test_should_validate_asset_transfer_with_clawback_and_close_remainder(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("optInAssetTransfer") + tx = clone_transaction( + vector.transaction, + asset_transfer=build_asset_transfer( + asset_id=123, + amount=1000, + receiver="ADSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + asset_sender="CNSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + close_remainder_to="BNSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + ), + ) + + validate_transaction(tx) + + +def test_should_validate_asset_transfer_to_self(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("optInAssetTransfer") + sender = vector.transaction.sender + tx = clone_transaction( + vector.transaction, + asset_transfer=build_asset_transfer( + asset_id=123, + amount=1000, + receiver=sender, + ), + ) + + validate_transaction(tx) + + +def test_should_validate_asset_close_out_transaction(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("optInAssetTransfer") + tx = clone_transaction( + vector.transaction, + asset_transfer=build_asset_transfer( + asset_id=123, + amount=0, + receiver="ADSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + close_remainder_to="BNSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + ), + ) + + validate_transaction(tx) diff --git a/tests/modules/transact/validate_transaction/test_key_registration.py b/tests/modules/transact/validate_transaction/test_key_registration.py new file mode 100644 index 00000000..c3806a94 --- /dev/null +++ b/tests/modules/transact/validate_transaction/test_key_registration.py @@ -0,0 +1,257 @@ +import pytest + +from algokit_transact import TransactionValidationError, validate_transaction +from tests.modules.transact._validation import build_key_registration, clone_transaction +from tests.modules.transact.conftest import TestDataLookup + +ZERO32 = b"\x00" * 32 +ZERO64 = b"\x00" * 64 + + +def test_should_throw_error_when_vote_key_missing(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("onlineKeyRegistration") + tx = clone_transaction( + vector.transaction, + key_registration=build_key_registration( + selection_key=ZERO32, + state_proof_key=ZERO64, + vote_first=1000, + vote_last=2000, + vote_key_dilution=10000, + ), + ) + + with pytest.raises(TransactionValidationError) as exc: + validate_transaction(tx) + assert "Vote key is required" in str(exc.value) + + +def test_should_throw_error_when_selection_key_missing(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("onlineKeyRegistration") + tx = clone_transaction( + vector.transaction, + key_registration=build_key_registration( + vote_key=ZERO32, + state_proof_key=ZERO64, + vote_first=1000, + vote_last=2000, + vote_key_dilution=10000, + ), + ) + + with pytest.raises(TransactionValidationError) as exc: + validate_transaction(tx) + assert "Selection key is required" in str(exc.value) + + +def test_should_throw_error_when_state_proof_key_missing(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("onlineKeyRegistration") + tx = clone_transaction( + vector.transaction, + key_registration=build_key_registration( + vote_key=ZERO32, + selection_key=ZERO32, + vote_first=1000, + vote_last=2000, + vote_key_dilution=10000, + ), + ) + + with pytest.raises(TransactionValidationError) as exc: + validate_transaction(tx) + assert "State proof key is required" in str(exc.value) + + +def test_should_throw_error_when_vote_first_missing(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("onlineKeyRegistration") + tx = clone_transaction( + vector.transaction, + key_registration=build_key_registration( + vote_key=ZERO32, + selection_key=ZERO32, + state_proof_key=ZERO64, + vote_last=2000, + vote_key_dilution=10000, + ), + ) + + with pytest.raises(TransactionValidationError) as exc: + validate_transaction(tx) + assert "Vote first is required" in str(exc.value) + + +def test_should_throw_error_when_vote_last_missing(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("onlineKeyRegistration") + tx = clone_transaction( + vector.transaction, + key_registration=build_key_registration( + vote_key=ZERO32, + selection_key=ZERO32, + state_proof_key=ZERO64, + vote_first=1000, + vote_key_dilution=10000, + ), + ) + + with pytest.raises(TransactionValidationError) as exc: + validate_transaction(tx) + assert "Vote last is required" in str(exc.value) + + +def test_should_throw_error_when_vote_key_dilution_missing(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("onlineKeyRegistration") + tx = clone_transaction( + vector.transaction, + key_registration=build_key_registration( + vote_key=ZERO32, + selection_key=ZERO32, + state_proof_key=ZERO64, + vote_first=1000, + vote_last=2000, + ), + ) + + with pytest.raises(TransactionValidationError) as exc: + validate_transaction(tx) + assert "Vote key dilution is required" in str(exc.value) + + +def test_should_throw_error_when_vote_first_not_less_than_vote_last(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("onlineKeyRegistration") + tx = clone_transaction( + vector.transaction, + key_registration=build_key_registration( + vote_key=ZERO32, + selection_key=ZERO32, + state_proof_key=ZERO64, + vote_first=2000, + vote_last=2000, + vote_key_dilution=10000, + ), + ) + + with pytest.raises(TransactionValidationError) as exc: + validate_transaction(tx) + assert "Vote first must be less than vote last" in str(exc.value) + + +def test_should_throw_error_when_vote_first_greater_than_vote_last(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("onlineKeyRegistration") + tx = clone_transaction( + vector.transaction, + key_registration=build_key_registration( + vote_key=ZERO32, + selection_key=ZERO32, + state_proof_key=ZERO64, + vote_first=3000, + vote_last=2000, + vote_key_dilution=10000, + ), + ) + + with pytest.raises(TransactionValidationError) as exc: + validate_transaction(tx) + assert "Vote first must be less than vote last" in str(exc.value) + + +def test_should_throw_error_when_non_participation_set_for_online_registration( + test_data_lookup: TestDataLookup, +) -> None: + vector = test_data_lookup("onlineKeyRegistration") + tx = clone_transaction( + vector.transaction, + key_registration=build_key_registration( + vote_key=ZERO32, + selection_key=ZERO32, + state_proof_key=ZERO64, + vote_first=1000, + vote_last=2000, + vote_key_dilution=10000, + non_participation=True, + ), + ) + + with pytest.raises(TransactionValidationError) as exc: + validate_transaction(tx) + assert "Online key registration cannot have non participation flag set" in str(exc.value) + + +def test_should_throw_multiple_errors_for_online_registration(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("onlineKeyRegistration") + tx = clone_transaction( + vector.transaction, + key_registration=build_key_registration( + vote_first=2000, + vote_last=1000, + non_participation=True, + ), + ) + + with pytest.raises(TransactionValidationError) as exc: + validate_transaction(tx) + message = str(exc.value) + assert "Vote key is required" in message + assert "Selection key is required" in message + assert "State proof key is required" in message + assert "Vote first must be less than vote last" in message + assert "Vote key dilution is required" in message + assert "Online key registration cannot have non participation flag set" in message + + +def test_should_validate_valid_online_registration_transaction(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("onlineKeyRegistration") + tx = clone_transaction( + vector.transaction, + key_registration=build_key_registration( + vote_key=ZERO32, + selection_key=ZERO32, + state_proof_key=ZERO64, + vote_first=1000, + vote_last=2000, + vote_key_dilution=10000, + ), + ) + + validate_transaction(tx) + + +def test_should_validate_online_registration_with_non_participation_false(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("onlineKeyRegistration") + tx = clone_transaction( + vector.transaction, + key_registration=build_key_registration( + vote_key=ZERO32, + selection_key=ZERO32, + state_proof_key=ZERO64, + vote_first=1000, + vote_last=2000, + vote_key_dilution=10000, + non_participation=False, + ), + ) + + validate_transaction(tx) + + +def test_should_validate_offline_key_registration(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("offlineKeyRegistration") + validate_transaction(vector.transaction) + + +def test_should_validate_non_participation_registration(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("nonParticipationKeyRegistration") + validate_transaction(vector.transaction) + + +def test_should_validate_offline_key_registration_with_non_participation_false( + test_data_lookup: TestDataLookup, +) -> None: + vector = test_data_lookup("offlineKeyRegistration") + tx = clone_transaction( + vector.transaction, + key_registration=build_key_registration( + non_participation=False, + ), + ) + + validate_transaction(tx) diff --git a/tests/modules/transact/validate_transaction/test_payment.py b/tests/modules/transact/validate_transaction/test_payment.py new file mode 100644 index 00000000..92935924 --- /dev/null +++ b/tests/modules/transact/validate_transaction/test_payment.py @@ -0,0 +1,57 @@ +from algokit_transact import PaymentTransactionFields, validate_transaction +from tests.modules.transact._validation import clone_transaction +from tests.modules.transact.conftest import TestDataLookup + + +def test_should_validate_valid_payment_transaction(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("simplePayment") + tx = clone_transaction( + vector.transaction, + payment=PaymentTransactionFields( + amount=1000, + receiver="ADSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + ), + ) + + validate_transaction(tx) + + +def test_should_validate_payment_transaction_with_zero_amount(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("simplePayment") + tx = clone_transaction( + vector.transaction, + payment=PaymentTransactionFields( + amount=0, + receiver="ADSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + ), + ) + + validate_transaction(tx) + + +def test_should_validate_payment_transaction_with_close_remainder(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("simplePayment") + tx = clone_transaction( + vector.transaction, + payment=PaymentTransactionFields( + amount=1000, + receiver="ADSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + close_remainder_to="BNSFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFKJSDFK", + ), + ) + + validate_transaction(tx) + + +def test_should_validate_self_payment_transaction(test_data_lookup: TestDataLookup) -> None: + vector = test_data_lookup("simplePayment") + sender = vector.transaction.sender + tx = clone_transaction( + vector.transaction, + payment=PaymentTransactionFields( + amount=1000, + receiver=sender, + ), + ) + + validate_transaction(tx) diff --git a/tests/test_debug_utils.py b/tests/test_debug_utils.py index 4d3d005e..86b7d09c 100644 --- a/tests/test_debug_utils.py +++ b/tests/test_debug_utils.py @@ -1,21 +1,17 @@ import json import os -from collections.abc import Generator from dataclasses import dataclass from datetime import datetime, timezone from pathlib import Path -from unittest.mock import Mock, patch import pytest -from algosdk.abi.method import Method -from algosdk.atomic_transaction_composer import ( - AccountTransactionSigner, - AtomicTransactionComposer, - TransactionWithSigner, -) -from algosdk.transaction import PaymentTxn +from algokit_abi import arc56 +from algokit_common import sha512_256 +from algokit_transact.signer import AddressWithSigners from algokit_utils._debugging import ( + AVMDebuggerSourceMap, + AVMDebuggerSourceMapEntry, PersistSourceMapInput, cleanup_old_trace_files, persist_sourcemaps, @@ -23,9 +19,8 @@ ) from algokit_utils.algorand import AlgorandClient from algokit_utils.applications import AppFactoryCreateMethodCallParams -from algokit_utils.applications.app_client import AppClient, AppClientMethodCallParams -from algokit_utils.common import Program -from algokit_utils.models import SigningAccount +from algokit_utils.applications.app_client import AppClient +from algokit_utils.applications.app_manager import AppManager from algokit_utils.models.amount import AlgoAmount from algokit_utils.transactions.transaction_composer import ( AppCallMethodCallParams, @@ -33,6 +28,7 @@ AssetTransferParams, PaymentParams, ) +from tests.conftest import check_output_stability @pytest.fixture @@ -41,7 +37,7 @@ def algorand() -> AlgorandClient: @pytest.fixture -def funded_account(algorand: AlgorandClient) -> SigningAccount: +def funded_account(algorand: AlgorandClient) -> AddressWithSigners: new_account = algorand.account.random() dispenser = algorand.account.localnet_dispenser() algorand.account.ensure_funded( @@ -50,15 +46,15 @@ def funded_account(algorand: AlgorandClient) -> SigningAccount: min_spending_balance=AlgoAmount.from_algo(100), min_funding_increment=AlgoAmount.from_algo(100), ) - algorand.set_signer(sender=new_account.address, signer=new_account.signer) + algorand.set_signer(sender=new_account.addr, signer=new_account.signer) return new_account @pytest.fixture -def client_fixture(algorand: AlgorandClient, funded_account: SigningAccount) -> AppClient: +def client_fixture(algorand: AlgorandClient, funded_account: AddressWithSigners) -> AppClient: app_spec = (Path(__file__).parent / "artifacts" / "legacy_app_client_test" / "app_client_test.json").read_text() app_factory = algorand.client.get_app_factory( - app_spec=app_spec, default_sender=funded_account.address, default_signer=funded_account.signer + app_spec=app_spec, default_sender=funded_account.addr, default_signer=funded_account.signer ) app_client, _ = app_factory.send.create( AppFactoryCreateMethodCallParams(method="create"), @@ -71,15 +67,8 @@ def client_fixture(algorand: AlgorandClient, funded_account: SigningAccount) -> return app_client -@pytest.fixture -def mock_config() -> Generator[Mock, None, None]: - with patch("algokit_utils.transactions.transaction_composer.config", new_callable=Mock) as mock_config: - mock_config.debug = True - mock_config.project_root = None - yield mock_config - - def test_build_teal_sourcemaps(algorand: AlgorandClient, tmp_path_factory: pytest.TempPathFactory) -> None: + """Test that sourcemaps are persisted correctly with TEAL sources and verify AVM debugger format.""" cwd = tmp_path_factory.mktemp("cwd") approval = """ @@ -98,19 +87,36 @@ def test_build_teal_sourcemaps(algorand: AlgorandClient, tmp_path_factory: pytes persist_sourcemaps(sources=sources, project_root=cwd, client=algorand.client.algod) root_path = cwd / ".algokit" / "sources" - sourcemap_file_path = root_path / "sources.avm.json" app_output_path = root_path / "cool_app" - assert not (sourcemap_file_path).exists() assert (app_output_path / "approval.teal").exists() assert (app_output_path / "approval.teal.map").exists() assert (app_output_path / "clear.teal").exists() assert (app_output_path / "clear.teal.map").exists() + # Build AVMDebuggerSourceMap for AVM debugger compatibility verification + # Since sources.avm.json is no longer generated, we manually construct it + import base64 + + app_manager = AppManager(algorand.client.algod) + + sourcemap_entries = [] + for source in sources: + compiled = app_manager.compile_teal(AppManager.strip_teal_comments(source.raw_teal)) + # Compute program hash the same way as _build_avm_sourcemap + program_hash = base64.b64encode(sha512_256(compiled.compiled_base64_to_bytes)).decode() + # Normalize location for snapshot comparison (use "dummy" placeholder) + entry = AVMDebuggerSourceMapEntry(location="dummy", program_hash=program_hash) + sourcemap_entries.append(entry) + + avm_sourcemap = AVMDebuggerSourceMap(txn_group_sources=sourcemap_entries) + check_output_stability(json.dumps(avm_sourcemap.to_dict())) + def test_build_teal_sourcemaps_without_sources( algorand: AlgorandClient, tmp_path_factory: pytest.TempPathFactory ) -> None: + """Test that sourcemaps are persisted without TEAL source files and verify AVM debugger format.""" cwd = tmp_path_factory.mktemp("cwd") approval = """ @@ -121,8 +127,9 @@ def test_build_teal_sourcemaps_without_sources( #pragma version 9 int 1 """ - compiled_approval = Program(approval, algorand.client.algod) - compiled_clear = Program(clear, algorand.client.algod) + app_manager = AppManager(algorand.client.algod) + compiled_approval = app_manager.compile_teal(AppManager.strip_teal_comments(approval)) + compiled_clear = app_manager.compile_teal(AppManager.strip_teal_comments(clear)) sources = [ PersistSourceMapInput(compiled_teal=compiled_approval, app_name="cool_app", file_name="approval.teal"), PersistSourceMapInput(compiled_teal=compiled_clear, app_name="cool_app", file_name="clear"), @@ -131,10 +138,8 @@ def test_build_teal_sourcemaps_without_sources( persist_sourcemaps(sources=sources, project_root=cwd, client=algorand.client.algod, with_sources=False) root_path = cwd / ".algokit" / "sources" - sourcemap_file_path = root_path / "sources.avm.json" app_output_path = root_path / "cool_app" - assert not (sourcemap_file_path).exists() assert not (app_output_path / "approval.teal").exists() assert (app_output_path / "approval.teal.map").exists() assert json.loads((app_output_path / "approval.teal.map").read_text())["sources"] == [] @@ -142,80 +147,124 @@ def test_build_teal_sourcemaps_without_sources( assert (app_output_path / "clear.teal.map").exists() assert json.loads((app_output_path / "clear.teal.map").read_text())["sources"] == [] + # Build AVMDebuggerSourceMap for AVM debugger compatibility verification + import base64 + + sourcemap_entries = [ + AVMDebuggerSourceMapEntry( + location="dummy", + program_hash=base64.b64encode(sha512_256(compiled_approval.compiled_base64_to_bytes)).decode(), + ), + AVMDebuggerSourceMapEntry( + location="dummy", + program_hash=base64.b64encode(sha512_256(compiled_clear.compiled_base64_to_bytes)).decode(), + ), + ] -def test_simulate_and_persist_response_via_app_call( - tmp_path_factory: pytest.TempPathFactory, - client_fixture: AppClient, - mock_config: Mock, -) -> None: - mock_config.debug = True - mock_config.trace_all = True - mock_config.trace_buffer_size_mb = 256 + avm_sourcemap = AVMDebuggerSourceMap(txn_group_sources=sourcemap_entries) + check_output_stability(json.dumps(avm_sourcemap.to_dict())) + + +@dataclass +class TestFile: + __test__ = False + + name: str + content: bytes + mtime: datetime + + +def test_removes_oldest_files_when_buffer_size_exceeded(tmp_path_factory: pytest.TempPathFactory) -> None: cwd = tmp_path_factory.mktemp("cwd") - mock_config.project_root = cwd + trace_dir = cwd / "debug_traces" + trace_dir.mkdir(exist_ok=True) - client_fixture.send.call(AppClientMethodCallParams(method="hello", args=["test"])) + test_files: list[TestFile] = [ + TestFile(name="old.json", content=b"a" * (1024 * 1024), mtime=datetime(2023, 1, 1, tzinfo=timezone.utc)), + TestFile(name="newer.json", content=b"b" * (1024 * 1024), mtime=datetime(2023, 1, 2, tzinfo=timezone.utc)), + TestFile(name="newest.json", content=b"c" * (1024 * 1024), mtime=datetime(2023, 1, 3, tzinfo=timezone.utc)), + ] + + for file in test_files: + file_path = trace_dir / file.name + file_path.write_bytes(file.content) + os.utime(file_path, (file.mtime.timestamp(), file.mtime.timestamp())) + + cleanup_old_trace_files(trace_dir, buffer_size_mb=2.0) + + remaining_files = list(trace_dir.iterdir()) + remaining_names = {f.name for f in remaining_files} + + assert "old.json" not in remaining_names + assert {"newer.json", "newest.json"} == remaining_names + + +def test_does_nothing_when_total_size_within_buffer_limit(tmp_path_factory: pytest.TempPathFactory) -> None: + cwd = tmp_path_factory.mktemp("cwd") + trace_dir = cwd / "debug_traces" + trace_dir.mkdir(exist_ok=True) + + file_path = trace_dir / "trace.json" + file_path.write_bytes(b"a" * 1024) + + cleanup_old_trace_files(trace_dir, buffer_size_mb=2.0) + + assert (trace_dir / "trace.json").exists() + + +def test_simulate_and_persist_response(tmp_path_factory: pytest.TempPathFactory, algorand: AlgorandClient) -> None: + cwd = tmp_path_factory.mktemp("cwd") + composer = algorand.new_group() + composer.add_payment( + PaymentParams( + sender=algorand.account.localnet_dispenser().addr, + receiver=algorand.account.localnet_dispenser().addr, + amount=AlgoAmount.from_micro_algo(1_000_000), + ) + ) - output_path = cwd / "debug_traces" + persisted = simulate_and_persist_response(composer, cwd, algorand.client.algod) - content = list(output_path.iterdir()) - assert len(list(output_path.iterdir())) == 1 - trace_file_content = json.loads(content[0].read_text()) - simulated_txn = trace_file_content["txn-groups"][0]["txn-results"][0]["txn-result"]["txn"]["txn"] - assert simulated_txn["type"] == "appl" - assert simulated_txn["apid"] == client_fixture.app_id + assert persisted.exists() + trace = json.loads(persisted.read_text()) + txn = trace["txn-groups"][0]["txn-results"][0]["txn-result"]["txn"]["txn"] + assert txn["type"] == "pay" -def test_simulate_and_persist_response( +def test_simulate_and_persist_response_via_app_call( tmp_path_factory: pytest.TempPathFactory, - algorand: AlgorandClient, - mock_config: Mock, - funded_account: SigningAccount, + client_fixture: AppClient, + funded_account: AddressWithSigners, ) -> None: - mock_config.debug = True - mock_config.trace_all = True cwd = tmp_path_factory.mktemp("cwd") - mock_config.project_root = cwd - algod = algorand.client.algod - - payment = PaymentTxn( - sender=funded_account.address, - receiver=funded_account.address, - amt=1_000_000, - note=b"Payment", - sp=algod.suggested_params(), + composer = client_fixture.algorand.new_group() + composer.add_app_call_method_call( + AppCallMethodCallParams( + method=arc56.Method.from_signature("hello(string)string"), + args=["test"], + sender=funded_account.addr, + app_id=client_fixture.app_id, + ) ) - txn_with_signer = TransactionWithSigner(payment, AccountTransactionSigner(funded_account.private_key)) - atc = AtomicTransactionComposer() - atc.add_transaction(txn_with_signer) - simulate_and_persist_response(atc, cwd, algod) + persisted = simulate_and_persist_response(composer, cwd, client_fixture.algorand.client.algod) - output_path = cwd / "debug_traces" - content = list(output_path.iterdir()) - assert len(list(output_path.iterdir())) == 1 - trace_file_content = json.loads(content[0].read_text()) - simulated_txn = trace_file_content["txn-groups"][0]["txn-results"][0]["txn-result"]["txn"]["txn"] - assert simulated_txn["type"] == "pay" - - trace_file_path = content[0] - while trace_file_path.exists(): - tmp_atc = atc.clone() - simulate_and_persist_response(tmp_atc, cwd, algod, buffer_size_mb=0.003) + assert persisted.exists() + trace = json.loads(persisted.read_text()) + txn = trace["txn-groups"][0]["txn-results"][0]["txn-result"]["txn"]["txn"] + assert txn["type"] == "appl" + assert txn["apid"] == client_fixture.app_id @pytest.mark.parametrize( ("transactions", "expected_filename_part"), [ - # Single transaction types ({"pay": 1}, "1pay"), ({"axfer": 1}, "1axfer"), ({"appl": 1}, "1appl"), - # Multiple of same type ({"pay": 3}, "3pay"), ({"axfer": 2}, "2axfer"), ({"appl": 4}, "4appl"), - # Mixed combinations ({"pay": 2, "axfer": 1, "appl": 3}, "2pay_1axfer_3appl"), ({"pay": 1, "axfer": 1, "appl": 1}, "1pay_1axfer_1appl"), ], @@ -225,63 +274,53 @@ def test_simulate_response_filename_generation( expected_filename_part: str, tmp_path_factory: pytest.TempPathFactory, client_fixture: AppClient, - funded_account: SigningAccount, + funded_account: AddressWithSigners, monkeypatch: pytest.MonkeyPatch, - mock_config: Mock, ) -> None: - asset_id = 1 - if "axfer" in transactions: + cwd = tmp_path_factory.mktemp("cwd") + composer = client_fixture.algorand.new_group() + + if transactions.get("axfer"): asset_id = client_fixture.algorand.send.asset_create( AssetCreateParams( - sender=funded_account.address, + sender=funded_account.addr, total=100_000_000, decimals=0, unit_name="TEST", asset_name="Test Asset", ) ).asset_id + else: + asset_id = 1 - cwd = tmp_path_factory.mktemp("cwd") - mock_config.debug = True - mock_config.trace_all = True - mock_config.trace_buffer_size_mb = 256 - mock_config.project_root = cwd - atc = client_fixture.algorand.new_group() - - # Add payment transactions for i in range(transactions.get("pay", 0)): - atc.add_payment( + composer.add_payment( PaymentParams( - sender=funded_account.address, + sender=funded_account.addr, receiver=client_fixture.app_address, amount=AlgoAmount.from_micro_algo(1_000_000 * (i + 1)), note=f"Payment{i + 1}".encode(), ) ) - - # Add asset transfer transactions for i in range(transactions.get("axfer", 0)): - atc.add_asset_transfer( + composer.add_asset_transfer( AssetTransferParams( - sender=funded_account.address, - receiver=funded_account.address, + sender=funded_account.addr, + receiver=funded_account.addr, amount=1_000 * (i + 1), asset_id=asset_id, ) ) - - # Add app calls for i in range(transactions.get("appl", 0)): - atc.add_app_call_method_call( + composer.add_app_call_method_call( AppCallMethodCallParams( - method=Method.from_signature("hello(string)string"), + method=arc56.Method.from_signature("hello(string)string"), args=[f"test{i + 1}"], - sender=funded_account.address, + sender=funded_account.addr, app_id=client_fixture.app_id, ) ) - # Mock datetime mock_datetime = datetime(2023, 1, 1, 12, 0, 0, tzinfo=timezone.utc) class MockDateTime: @@ -290,91 +329,11 @@ def now(cls, tz: timezone | None = None) -> datetime: # noqa: ARG003 return mock_datetime monkeypatch.setattr("algokit_utils._debugging.datetime", MockDateTime) + persisted = simulate_and_persist_response(composer, cwd, client_fixture.algorand.client.algod) - response = atc.simulate() - assert response.simulate_response - last_round = response.simulate_response["last-round"] - expected_filename = f"20230101_120000_lr{last_round}_{expected_filename_part}.trace.avm.json" - - # Verify file exists with expected name - output_path = cwd / "debug_traces" - files = list(output_path.iterdir()) - assert len(files) == 1 - assert files[0].name == expected_filename - - # Verify transaction count - trace_file_content = json.loads(files[0].read_text()) - txn_results = trace_file_content["txn-groups"][0]["txn-results"] - expected_total_txns = sum(transactions.values()) - assert len(txn_results) == expected_total_txns - - -@dataclass -class TestFile: - __test__ = False - - name: str - content: bytes - mtime: datetime - - -def test_removes_oldest_files_when_buffer_size_exceeded( - tmp_path_factory: pytest.TempPathFactory, mock_config: Mock -) -> None: - cwd = tmp_path_factory.mktemp("cwd") - trace_dir = cwd / "debug_traces" - trace_dir.mkdir(exist_ok=True) - mock_config.debug = True - mock_config.trace_all = True - mock_config.trace_buffer_size_mb = 256 - mock_config.project_root = cwd + assert persisted.name.startswith("20230101_120000_lr") + assert expected_filename_part in persisted.name - # Create test files with different timestamps and sizes - test_files: list[TestFile] = [ - TestFile(name="old.json", content=b"a" * (1024 * 1024), mtime=datetime(2023, 1, 1, tzinfo=timezone.utc)), - TestFile(name="newer.json", content=b"b" * (1024 * 1024), mtime=datetime(2023, 1, 2, tzinfo=timezone.utc)), - TestFile(name="newest.json", content=b"c" * (1024 * 1024), mtime=datetime(2023, 1, 3, tzinfo=timezone.utc)), - ] - - # Create files with specific timestamps - for file in test_files: - file_path = trace_dir / file.name - file_path.write_bytes(file.content) - os.utime(file_path, (file.mtime.timestamp(), file.mtime.timestamp())) - - # Set buffer size to 2MB (should remove oldest file) - cleanup_old_trace_files(trace_dir, buffer_size_mb=2.0) - - # Check remaining files - remaining_files = list(trace_dir.iterdir()) - remaining_names = [f.name for f in remaining_files] - - assert len(remaining_files) == 2 - assert "newer.json" in remaining_names - assert "newest.json" in remaining_names - assert "old.json" not in remaining_names - - -def test_does_nothing_when_total_size_within_buffer_limit( - tmp_path_factory: pytest.TempPathFactory, mock_config: Mock -) -> None: - cwd = tmp_path_factory.mktemp("cwd") - mock_config.debug = True - mock_config.trace_all = True - mock_config.trace_buffer_size_mb = 256 - mock_config.project_root = cwd - - # Create test directory - trace_dir = cwd / "debug_traces" - trace_dir.mkdir() - - # Create two 512KB files (total 1MB) - content = b"a" * (512 * 1024) # 512KB - (trace_dir / "file1.json").write_bytes(content) - (trace_dir / "file2.json").write_bytes(content) - - # Set buffer size to 2MB (files total 1MB, should not remove anything) - cleanup_old_trace_files(trace_dir, buffer_size_mb=2.0) - - remaining_files = list(trace_dir.iterdir()) - assert len(remaining_files) == 2 + trace = json.loads(persisted.read_text()) + txn_results = trace["txn-groups"][0]["txn-results"] + assert len(txn_results) == sum(transactions.values()) diff --git a/tests/transactions/test_abi_return.py b/tests/transactions/test_abi_return.py index dc3d50f5..5243fe02 100644 --- a/tests/transactions/test_abi_return.py +++ b/tests/transactions/test_abi_return.py @@ -1,25 +1,19 @@ -from algosdk.abi import ABIType, Method -from algosdk.abi.method import Returns -from algosdk.atomic_transaction_composer import ABIResult - +from algokit_abi import abi, arc56 from algokit_utils.applications.abi import ABIReturn, ABIValue def get_abi_result(type_str: str, value: ABIValue) -> ABIReturn: """Helper function to simulate ABI method return value""" - abi_type = ABIType.from_string(type_str) + abi_type = abi.ABIType.from_string(type_str) encoded = abi_type.encode(value) decoded = abi_type.decode(encoded) - result = ABIResult( - method=Method(name="", args=[], returns=Returns(arg_type=type_str)), - raw_value=encoded, - return_value=decoded, - tx_id="", - tx_info={}, - decode_error=None, + method = arc56.Method( + name="", + args=(), + returns=arc56.Returns(type=abi_type), + actions=arc56.Actions(call=(), create=()), ) - - return ABIReturn(result) + return ABIReturn(method=method, raw_value=encoded, value=decoded, decode_error=None) class TestABIReturn: @@ -79,27 +73,27 @@ def test_uint64_fixed_array(self) -> None: def test_tuple(self) -> None: type_str = "(uint32,uint64,(uint32,uint64),uint32[],uint64[])" - assert get_abi_result(type_str, [0, 0, [0, 0], [0], [0]]).value == [ + assert get_abi_result(type_str, [0, 0, [0, 0], [0], [0]]).value == ( 0, 0, - [0, 0], + (0, 0), [0], [0], - ] - assert get_abi_result(type_str, [1, 1, [1, 1], [1], [1]]).value == [ + ) + assert get_abi_result(type_str, [1, 1, [1, 1], [1], [1]]).value == ( 1, 1, - [1, 1], + (1, 1), [1], [1], - ] + ) assert get_abi_result( type_str, [2**32 - 1, 2**64 - 1, [2**32 - 1, 2**64 - 1], [1, 2, 3], [1, 2, 3]], - ).value == [ + ).value == ( 2**32 - 1, 2**64 - 1, - [2**32 - 1, 2**64 - 1], + (2**32 - 1, 2**64 - 1), [1, 2, 3], [1, 2, 3], - ] + ) diff --git a/tests/transactions/test_fee_coverage.py b/tests/transactions/test_fee_coverage.py index 763bf08d..df7c6fef 100644 --- a/tests/transactions/test_fee_coverage.py +++ b/tests/transactions/test_fee_coverage.py @@ -5,7 +5,7 @@ import pytest -from algokit_utils import SigningAccount +from algokit_transact.signer import AddressWithSigners from algokit_utils.algorand import AlgorandClient from algokit_utils.applications.app_client import ( AppClient, @@ -28,7 +28,7 @@ def algorand() -> AlgorandClient: @pytest.fixture -def funded_account(algorand: AlgorandClient) -> SigningAccount: +def funded_account(algorand: AlgorandClient) -> AddressWithSigners: new_account = algorand.account.random() dispenser = algorand.account.localnet_dispenser() algorand.account.ensure_funded(new_account, dispenser, AlgoAmount.from_algo(100)) @@ -39,13 +39,13 @@ class TestCoverAppCallInnerFees: """Test covering app call inner transaction fees""" @pytest.fixture(autouse=True) - def setup(self, algorand: AlgorandClient, funded_account: SigningAccount) -> None: + def setup(self, algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: # Load inner fee contract spec spec_path = Path(__file__).parent.parent / "artifacts" / "inner-fee" / "application.json" inner_fee_spec = json.loads(spec_path.read_text()) # Create app factory - factory = algorand.client.get_app_factory(app_spec=inner_fee_spec, default_sender=funded_account.address) + factory = algorand.client.get_app_factory(app_spec=inner_fee_spec, default_sender=funded_account.addr) # Create 3 app instances self.app_client1, _ = factory.send.bare.create(params=AppFactoryCreateParams(note=b"app1")) @@ -78,7 +78,7 @@ def test_throws_when_inner_fees_not_covered(self) -> None: max_fee=AlgoAmount.from_micro_algo(expected_fee), ) - with pytest.raises(Exception, match="fee too small"): + with pytest.raises(Exception, match="too small"): self.app_client1.send.call( params, send_params={ @@ -101,7 +101,7 @@ def test_does_not_alter_fee_without_inners(self) -> None: }, ) - assert result.transaction.raw.fee == expected_fee + assert result.transaction.fee == expected_fee self._assert_min_fee(self.app_client1, params, expected_fee) def test_throws_when_max_fee_too_small(self) -> None: @@ -156,7 +156,7 @@ def test_alters_fee_handling_when_no_itxns_covered(self) -> None: }, ) - assert result.transaction.raw.fee == expected_fee + assert result.transaction.fee == expected_fee self._assert_min_fee(self.app_client1, params, expected_fee) def test_alters_fee_handling_when_all_inners_covered(self) -> None: @@ -175,7 +175,7 @@ def test_alters_fee_handling_when_all_inners_covered(self) -> None: }, ) - assert result.transaction.raw.fee == expected_fee + assert result.transaction.fee == expected_fee self._assert_min_fee(self.app_client1, params, expected_fee) def test_alters_fee_handling_when_some_inners_covered(self) -> None: @@ -194,7 +194,7 @@ def test_alters_fee_handling_when_some_inners_covered(self) -> None: }, ) - assert result.transaction.raw.fee == expected_fee + assert result.transaction.fee == expected_fee self._assert_min_fee(self.app_client1, params, expected_fee) def test_alters_fee_when_some_inners_have_surplus(self) -> None: @@ -212,7 +212,7 @@ def test_alters_fee_when_some_inners_have_surplus(self) -> None: "cover_app_call_inner_transaction_fees": True, }, ) - assert result.transaction.raw.fee == expected_fee + assert result.transaction.fee == expected_fee self._assert_min_fee(self.app_client1, params, expected_fee) def test_alters_handling_multiple_app_calls_in_group_with_inners_with_varying_fees(self) -> None: @@ -241,9 +241,10 @@ def test_alters_handling_multiple_app_calls_in_group_with_inners_with_varying_fe .send({"cover_app_call_inner_transaction_fees": True}) ) - assert result.transactions[0].raw.fee == txn_1_expected_fee + wrapped_transactions = result.transactions + assert wrapped_transactions[0].fee == txn_1_expected_fee self._assert_min_fee(self.app_client1, txn_1_params, txn_1_expected_fee) - assert result.transactions[1].raw.fee == txn_2_expected_fee + assert wrapped_transactions[1].fee == txn_2_expected_fee self._assert_min_fee(self.app_client1, txn_2_params, txn_2_expected_fee) def test_does_not_alter_static_fee_with_surplus(self) -> None: @@ -262,7 +263,7 @@ def test_does_not_alter_static_fee_with_surplus(self) -> None: }, ) - assert result.transaction.raw.fee == expected_fee + assert result.transaction.fee == expected_fee def test_alters_fee_with_large_inner_surplus_pooling(self) -> None: """Test fee handling with large inner fee surplus pooling to lower siblings""" @@ -280,7 +281,7 @@ def test_alters_fee_with_large_inner_surplus_pooling(self) -> None: }, ) - assert result.transaction.raw.fee == expected_fee + assert result.transaction.fee == expected_fee self._assert_min_fee(self.app_client1, params, expected_fee) def test_alters_fee_with_partial_inner_surplus_pooling(self) -> None: @@ -299,7 +300,7 @@ def test_alters_fee_with_partial_inner_surplus_pooling(self) -> None: }, ) - assert result.transaction.raw.fee == expected_fee + assert result.transaction.fee == expected_fee self._assert_min_fee(self.app_client1, params, expected_fee) def test_alters_fee_with_large_inner_surplus_no_pooling(self) -> None: @@ -318,7 +319,7 @@ def test_alters_fee_with_large_inner_surplus_no_pooling(self) -> None: }, ) - assert result.transaction.raw.fee == expected_fee + assert result.transaction.fee == expected_fee self._assert_min_fee(self.app_client1, params, expected_fee) def test_alters_fee_with_multiple_inner_surplus_poolings_to_lower_siblings(self) -> None: @@ -336,10 +337,10 @@ def test_alters_fee_with_multiple_inner_surplus_poolings_to_lower_siblings(self) ) result = self.app_client1.send.call(params, send_params={"cover_app_call_inner_transaction_fees": True}) - assert result.transaction.raw.fee == expected_fee + assert result.transaction.fee == expected_fee self._assert_min_fee(self.app_client1, params, expected_fee) - def test_does_not_alter_fee_when_group_covers_inner_fees(self, funded_account: SigningAccount) -> None: + def test_does_not_alter_fee_when_group_covers_inner_fees(self, funded_account: AddressWithSigners) -> None: """Test that fee is not altered when another transaction in group covers inner fees""" expected_fee = 8000 @@ -348,8 +349,8 @@ def test_does_not_alter_fee_when_group_covers_inner_fees(self, funded_account: S self.app_client1.algorand.new_group() .add_payment( params=PaymentParams( - sender=funded_account.address, - receiver=funded_account.address, + sender=funded_account.addr, + receiver=funded_account.addr, amount=AlgoAmount.from_micro_algo(0), static_fee=AlgoAmount.from_micro_algo(expected_fee), ) @@ -366,12 +367,13 @@ def test_does_not_alter_fee_when_group_covers_inner_fees(self, funded_account: S .send({"cover_app_call_inner_transaction_fees": True}) ) - assert result.transactions[0].raw.fee == expected_fee + wrapped_transactions = result.transactions + assert wrapped_transactions[0].fee == expected_fee # We could technically reduce the below to 0, however it adds more complexity # and is probably unlikely to be a common use case - assert result.transactions[1].raw.fee == 1000 + assert wrapped_transactions[1].fee == 1000 - def test_allocates_surplus_fees_to_most_constrained_first(self, funded_account: SigningAccount) -> None: + def test_allocates_surplus_fees_to_most_constrained_first(self, funded_account: AddressWithSigners) -> None: """Test that surplus fees are allocated to the most fee constrained transaction first""" result = ( @@ -387,16 +389,16 @@ def test_allocates_surplus_fees_to_most_constrained_first(self, funded_account: ) .add_payment( params=PaymentParams( - sender=funded_account.address, - receiver=funded_account.address, + sender=funded_account.addr, + receiver=funded_account.addr, amount=AlgoAmount.from_micro_algo(0), static_fee=AlgoAmount.from_micro_algo(7500), ) ) .add_payment( params=PaymentParams( - sender=funded_account.address, - receiver=funded_account.address, + sender=funded_account.addr, + receiver=funded_account.addr, amount=AlgoAmount.from_micro_algo(0), static_fee=AlgoAmount.from_micro_algo(0), ) @@ -404,22 +406,23 @@ def test_allocates_surplus_fees_to_most_constrained_first(self, funded_account: .send({"cover_app_call_inner_transaction_fees": True}) ) - assert result.transactions[0].raw.fee == 1500 - assert result.transactions[1].raw.fee == 7500 - assert result.transactions[2].raw.fee == 0 + wrapped_transactions = result.transactions + assert wrapped_transactions[0].fee == 1500 + assert wrapped_transactions[1].fee == 7500 + assert wrapped_transactions[2].fee == 0 assert result.group_id != "" - for txn in result.transactions: - assert txn.raw.group is not None - assert base64.b64encode(txn.raw.group).decode("utf-8") == result.group_id + for txn in wrapped_transactions: + assert txn.group is not None + assert base64.b64encode(txn.group).decode("utf-8") == result.group_id - def test_handles_nested_abi_method_calls(self, funded_account: SigningAccount) -> None: + def test_handles_nested_abi_method_calls(self, funded_account: AddressWithSigners) -> None: """Test fee handling with nested ABI method calls""" # Create nested contract app app_spec = (Path(__file__).parent.parent / "artifacts" / "nested_contract" / "application.json").read_text() nested_factory = self.app_client1.algorand.client.get_app_factory( app_spec=app_spec, - default_sender=funded_account.address, + default_sender=funded_account.addr, ) nested_client, _ = nested_factory.send.create( params=AppFactoryCreateMethodCallParams(method="createApplication") @@ -435,8 +438,8 @@ def test_handles_nested_abi_method_calls(self, funded_account: SigningAccount) - ) payment_params = PaymentParams( - sender=funded_account.address, - receiver=funded_account.address, + sender=funded_account.addr, + receiver=funded_account.addr, amount=AlgoAmount.from_micro_algo(0), static_fee=AlgoAmount.from_micro_algo(1500), ) @@ -453,9 +456,9 @@ def test_handles_nested_abi_method_calls(self, funded_account: SigningAccount) - result = nested_client.send.call(params, send_params={"cover_app_call_inner_transaction_fees": True}) assert len(result.transactions) == 3 - assert result.transactions[0].raw.fee == 1500 - assert result.transactions[1].raw.fee == 3500 - assert result.transactions[2].raw.fee == expected_fee + assert result.transactions[0].fee == 1500 + assert result.transactions[1].fee == 3500 + assert result.transactions[2].fee == expected_fee self._assert_min_fee( nested_client, @@ -496,14 +499,14 @@ def test_throws_when_max_fee_below_calculated(self) -> None: .send({"cover_app_call_inner_transaction_fees": True}) ) - def test_throws_when_nested_max_fee_below_calculated(self, funded_account: SigningAccount) -> None: + def test_throws_when_nested_max_fee_below_calculated(self, funded_account: AddressWithSigners) -> None: """Test that error is thrown when nested max fee is below calculated fee""" # Create nested contract app app_spec = (Path(__file__).parent.parent / "artifacts" / "nested_contract" / "application.json").read_text() nested_factory = self.app_client1.algorand.client.get_app_factory( app_spec=app_spec, - default_sender=funded_account.address, + default_sender=funded_account.addr, ) nested_client, _ = nested_factory.send.create( params=AppFactoryCreateMethodCallParams(method="createApplication") @@ -526,8 +529,8 @@ def test_throws_when_nested_max_fee_below_calculated(self, funded_account: Signi args=[ self.app_client1.algorand.create_transaction.payment( PaymentParams( - sender=funded_account.address, - receiver=funded_account.address, + sender=funded_account.addr, + receiver=funded_account.addr, amount=AlgoAmount.from_micro_algo(0), ) ), @@ -570,7 +573,7 @@ def test_throws_when_static_fee_below_calculated(self) -> None: .send({"cover_app_call_inner_transaction_fees": True}) ) - def test_throws_when_non_app_call_static_fee_too_low(self, funded_account: SigningAccount) -> None: + def test_throws_when_non_app_call_static_fee_too_low(self, funded_account: AddressWithSigners) -> None: """Test that error is thrown when static fee for non-app-call transaction is too low""" with pytest.raises( @@ -599,8 +602,8 @@ def test_throws_when_non_app_call_static_fee_too_low(self, funded_account: Signi ) .add_payment( params=PaymentParams( - sender=funded_account.address, - receiver=funded_account.address, + sender=funded_account.addr, + receiver=funded_account.addr, amount=AlgoAmount.from_micro_algo(0), static_fee=AlgoAmount.from_micro_algo(500), ) @@ -619,8 +622,8 @@ def test_handles_expensive_abi_calls_with_ensure_budget(self) -> None: ) result = self.app_client1.send.call(params, send_params={"cover_app_call_inner_transaction_fees": True}) - assert result.transaction.raw.fee == expected_fee - assert len(result.confirmation.get("inner-txns", [])) == 9 # type: ignore[union-attr] + assert result.transaction.fee == expected_fee + assert len(result.confirmation.inner_txns or []) == 9 self._assert_min_fee(self.app_client1, params, expected_fee) @pytest.mark.parametrize("cover_inner_fees", [True, False]) @@ -637,8 +640,8 @@ def test_readonly_uses_fixed_opcode_budget_without_op_up_inner_transactions(self ) # No op-up inner transactions needed regardless of fee coverage setting - assert len(result.confirmation.get("inner-txns", [])) == 0 # type: ignore[union-attr] - assert result.transaction.raw.fee == 1_000 + assert len(result.confirmation.inner_txns or []) == 0 + assert result.transaction.fee == 1_000 assert len(result.tx_ids) == 1 def test_readonly_alters_fee_handling_inner_transactions(self) -> None: @@ -666,8 +669,8 @@ def test_readonly_alters_fee_handling_inner_transactions(self) -> None: }, ) - assert result.transaction.raw.fee == expected_fee - assert len(result.confirmation.get("inner-txns", [])) == 4 # type: ignore[union-attr] + assert result.transaction.fee == expected_fee + assert len(result.confirmation.inner_txns or []) == 4 assert len(result.tx_ids) == 1 def test_readonly_throws_when_max_fee_too_small(self) -> None: @@ -684,7 +687,10 @@ def test_readonly_throws_when_max_fee_too_small(self) -> None: args=[self.app_client2.app_id, self.app_client3.app_id, [1000, 0, 200, 0, [500, 0]]], max_fee=AlgoAmount.from_micro_algo(2000), ) - with pytest.raises(ValueError, match="Fees were too small. You may need to increase the transaction `maxFee`."): + with pytest.raises( + ValueError, + match=r"Fees were too small\. You may need to increase the transaction `maxFee`\.", + ): self.app_client1.send.call( params, send_params={ @@ -702,7 +708,7 @@ def _assert_min_fee(self, app_client: AppClient, params: AppClientMethodCallPara extra_fee=None, ) - with pytest.raises(Exception, match="fee too small"): + with pytest.raises(Exception, match="too small"): app_client.send.call(params_copy) @@ -716,27 +722,27 @@ def algorand(self) -> AlgorandClient: return algorand @pytest.fixture - def inner_app_id(self, algorand: AlgorandClient, funded_account: SigningAccount) -> int: + def inner_app_id(self, algorand: AlgorandClient, funded_account: AddressWithSigners) -> int: # Load inner fee contract spec spec_path = Path(__file__).parent.parent / "artifacts" / "inner-fee" / "application.json" inner_fee_spec = json.loads(spec_path.read_text()) # Create app factory - factory = algorand.client.get_app_factory(app_spec=inner_fee_spec, default_sender=funded_account.address) + factory = algorand.client.get_app_factory(app_spec=inner_fee_spec, default_sender=funded_account.addr) # Create app app_client, _ = factory.send.bare.create() return app_client.app_id def test_delete_abi_inner_app_call_fees_should_be_covered( - self, algorand: AlgorandClient, funded_account: SigningAccount, inner_app_id: int + self, algorand: AlgorandClient, funded_account: AddressWithSigners, inner_app_id: int ) -> None: # contract spec contract_spec_path = Path(__file__).parent.parent / "artifacts" / "delete_abi_with_inner" / "application.json" contract_spec = json.loads(contract_spec_path.read_text()) # Create app factory - factory = algorand.client.get_app_factory(app_spec=contract_spec, default_sender=funded_account.address) + factory = algorand.client.get_app_factory(app_spec=contract_spec, default_sender=funded_account.addr) # Deploy the app and fund the account app_client, _ = factory.deploy( diff --git a/tests/transactions/test_resource_packing.py b/tests/transactions/test_resource_packing.py index c3e3e516..93538788 100644 --- a/tests/transactions/test_resource_packing.py +++ b/tests/transactions/test_resource_packing.py @@ -1,17 +1,17 @@ from pathlib import Path -import algosdk +import nacl.signing import pytest -from algosdk.atomic_transaction_composer import TransactionWithSigner -from algosdk.transaction import OnComplete, PaymentTxn -from algokit_utils import SigningAccount +from algokit_common import address_from_public_key, get_application_address +from algokit_transact import OnApplicationComplete +from algokit_transact.signer import AddressWithSigners from algokit_utils.algorand import AlgorandClient from algokit_utils.applications.app_client import AppClient, AppClientMethodCallParams, FundAppAccountParams from algokit_utils.applications.app_factory import AppFactoryCreateMethodCallParams from algokit_utils.errors.logic_error import LogicError from algokit_utils.models.amount import AlgoAmount -from algokit_utils.transactions.transaction_composer import PaymentParams +from algokit_utils.transactions.transaction_composer import AssetCreateParams, PaymentParams, TransactionWithSigner @pytest.fixture @@ -20,7 +20,7 @@ def algorand() -> AlgorandClient: @pytest.fixture -def funded_account(algorand: AlgorandClient) -> SigningAccount: +def funded_account(algorand: AlgorandClient) -> AddressWithSigners: new_account = algorand.account.random() dispenser = algorand.account.localnet_dispenser() algorand.account.ensure_funded(new_account, dispenser, AlgoAmount.from_algo(100)) @@ -39,12 +39,12 @@ class BaseResourcePackerTest: version: int @pytest.fixture(autouse=True) - def setup(self, algorand: AlgorandClient, funded_account: SigningAccount) -> None: + def setup(self, algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: # Create app based on version spec = load_arc32_spec(self.version) factory = algorand.client.get_app_factory( app_spec=spec, - default_sender=funded_account.address, + default_sender=funded_account.addr, ) self.app_client, _ = factory.send.create(params=AppFactoryCreateMethodCallParams(method="createApplication")) self.app_client.fund_app_account(FundAppAccountParams(amount=AlgoAmount.from_micro_algo(2334300))) @@ -53,7 +53,7 @@ def setup(self, algorand: AlgorandClient, funded_account: SigningAccount) -> Non ) @pytest.fixture - def external_client(self, algorand: AlgorandClient, funded_account: SigningAccount) -> AppClient: + def external_client(self, algorand: AlgorandClient, funded_account: AddressWithSigners) -> AppClient: external_spec = ( Path(__file__).parent.parent / "artifacts" / "resource-packer" / "ExternalApp.arc32.json" ).read_text() @@ -61,16 +61,16 @@ def external_client(self, algorand: AlgorandClient, funded_account: SigningAccou app_spec=external_spec, app_id=int(self.app_client.get_global_state()["externalAppID"].value), app_name="external", - default_sender=funded_account.address, + default_sender=funded_account.addr, ) def test_accounts_address_balance_invalid_ref(self, algorand: AlgorandClient) -> None: random_account = algorand.account.random() - with pytest.raises(LogicError, match=f"unavailable Account {random_account.address}"): + with pytest.raises(LogicError, match=f"unavailable Account {random_account.addr}"): self.app_client.send.call( AppClientMethodCallParams( method="addressBalance", - args=[random_account.address], + args=[random_account.addr], ), send_params={ "populate_app_call_resources": False, @@ -82,7 +82,7 @@ def test_accounts_address_balance_valid_ref(self, algorand: AlgorandClient) -> N self.app_client.send.call( AppClientMethodCallParams( method="addressBalance", - args=[random_account.address], + args=[random_account.addr], ), ) @@ -148,20 +148,20 @@ def test_assets_valid_asset(self) -> None: ), ) - def test_cross_product_reference_has_asset(self, funded_account: SigningAccount) -> None: + def test_cross_product_reference_has_asset(self, funded_account: AddressWithSigners) -> None: self.app_client.send.call( AppClientMethodCallParams( method="hasAsset", - args=[funded_account.address], + args=[funded_account.addr], ), ) - def test_cross_product_reference_invalid_external_local(self, funded_account: SigningAccount) -> None: + def test_cross_product_reference_invalid_external_local(self, funded_account: AddressWithSigners) -> None: with pytest.raises(LogicError, match="unavailable App"): self.app_client.send.call( AppClientMethodCallParams( method="externalLocal", - args=[funded_account.address], + args=[funded_account.addr], ), send_params={ "populate_app_call_resources": False, @@ -169,13 +169,13 @@ def test_cross_product_reference_invalid_external_local(self, funded_account: Si ) def test_cross_product_reference_external_local( - self, external_client: AppClient, funded_account: SigningAccount, algorand: AlgorandClient + self, external_client: AppClient, funded_account: AddressWithSigners, algorand: AlgorandClient ) -> None: algorand.send.app_call_method_call( external_client.params.opt_in( AppClientMethodCallParams( method="optInToApplication", - sender=funded_account.address, + sender=funded_account.addr, ), ), ) @@ -184,8 +184,8 @@ def test_cross_product_reference_external_local( self.app_client.params.call( AppClientMethodCallParams( method="externalLocal", - args=[funded_account.address], - sender=funded_account.address, + args=[funded_account.addr], + sender=funded_account.addr, ), ), ) @@ -193,11 +193,13 @@ def test_cross_product_reference_external_local( def test_address_balance_invalid_account_reference( self, ) -> None: + signing_key = nacl.signing.SigningKey.generate() + test_address = address_from_public_key(signing_key.verify_key.encode()) with pytest.raises(LogicError, match="unavailable Account"): self.app_client.send.call( AppClientMethodCallParams( method="addressBalance", - args=[algosdk.account.generate_account()[1]], + args=[test_address], ), send_params={ "populate_app_call_resources": False, @@ -207,20 +209,22 @@ def test_address_balance_invalid_account_reference( def test_address_balance( self, ) -> None: + signing_key = nacl.signing.SigningKey.generate() + test_address = address_from_public_key(signing_key.verify_key.encode()) self.app_client.send.call( AppClientMethodCallParams( method="addressBalance", - args=[algosdk.account.generate_account()[1]], - on_complete=OnComplete.NoOpOC, + args=[test_address], + on_complete=OnApplicationComplete.NoOp, ), ) - def test_cross_product_reference_invalid_has_asset(self, funded_account: SigningAccount) -> None: + def test_cross_product_reference_invalid_has_asset(self, funded_account: AddressWithSigners) -> None: with pytest.raises(LogicError, match="unavailable Asset"): self.app_client.send.call( AppClientMethodCallParams( method="hasAsset", - args=[funded_account.address], + args=[funded_account.addr], ), send_params={ "populate_app_call_resources": False, @@ -244,12 +248,12 @@ class TestResourcePackerMixed: """Test resource packing with mixed AVM versions""" @pytest.fixture(autouse=True) - def setup(self, algorand: AlgorandClient, funded_account: SigningAccount) -> None: + def setup(self, algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: # Create v8 app v8_spec = load_arc32_spec(8) v8_factory = algorand.client.get_app_factory( app_spec=v8_spec, - default_sender=funded_account.address, + default_sender=funded_account.addr, ) self.v8_client, _ = v8_factory.send.create(params=AppFactoryCreateMethodCallParams(method="createApplication")) @@ -257,13 +261,13 @@ def setup(self, algorand: AlgorandClient, funded_account: SigningAccount) -> Non v9_spec = load_arc32_spec(9) v9_factory = algorand.client.get_app_factory( app_spec=v9_spec, - default_sender=funded_account.address, + default_sender=funded_account.addr, ) self.v9_client, _ = v9_factory.send.create(params=AppFactoryCreateMethodCallParams(method="createApplication")) - def test_same_account(self, algorand: AlgorandClient, funded_account: SigningAccount) -> None: + def test_same_account(self, algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: rekeyed_to = algorand.account.random() - algorand.account.rekey_account(funded_account.address, rekeyed_to) + algorand.account.rekey_account(funded_account.addr, rekeyed_to) random_account = algorand.account.random() @@ -272,8 +276,8 @@ def test_same_account(self, algorand: AlgorandClient, funded_account: SigningAcc self.v8_client.params.call( AppClientMethodCallParams( method="addressBalance", - args=[random_account.address], - sender=funded_account.address, + args=[random_account.addr], + sender=funded_account.addr, signer=rekeyed_to.signer, ), ), @@ -282,20 +286,25 @@ def test_same_account(self, algorand: AlgorandClient, funded_account: SigningAcc self.v9_client.params.call( AppClientMethodCallParams( method="addressBalance", - args=[random_account.address], - sender=funded_account.address, + args=[random_account.addr], + sender=funded_account.addr, signer=rekeyed_to.signer, ) ) ) result = txn_group.send() - - v8_accounts = getattr(result.transactions[0].application_call, "accounts", None) or [] - v9_accounts = getattr(result.transactions[1].application_call, "accounts", None) or [] + transactions = result.transactions + + v8_accounts = ( + transactions[0].application_call.account_references if transactions[0].application_call else None + ) or [] + v9_accounts = ( + transactions[1].application_call.account_references if transactions[1].application_call else None + ) or [] assert len(v8_accounts) + len(v9_accounts) == 1 - def test_app_account(self, algorand: AlgorandClient, funded_account: SigningAccount) -> None: + def test_app_account(self, algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: self.v8_client.fund_app_account(FundAppAccountParams(amount=AlgoAmount.from_micro_algo(328500))) self.v8_client.send.call( AppClientMethodCallParams( @@ -305,7 +314,7 @@ def test_app_account(self, algorand: AlgorandClient, funded_account: SigningAcco ) external_app_id = int(self.v8_client.get_global_state()["externalAppID"].value) - external_app_addr = algosdk.logic.get_application_address(external_app_id) + external_app_addr = get_application_address(external_app_id) txn_group = algorand.send.new_group() txn_group.add_app_call_method_call( @@ -313,7 +322,7 @@ def test_app_account(self, algorand: AlgorandClient, funded_account: SigningAcco AppClientMethodCallParams( method="externalAppCall", static_fee=AlgoAmount.from_micro_algo(2_000), - sender=funded_account.address, + sender=funded_account.addr, ), ), ) @@ -322,15 +331,18 @@ def test_app_account(self, algorand: AlgorandClient, funded_account: SigningAcco AppClientMethodCallParams( method="addressBalance", args=[external_app_addr], - sender=funded_account.address, + sender=funded_account.addr, ) ) ) result = txn_group.send() + transactions = result.transactions - v8_apps = getattr(result.transactions[0].application_call, "foreign_apps", None) or [] - v9_accounts = getattr(result.transactions[1].application_call, "accounts", None) or [] + v8_apps = (transactions[0].application_call.app_references if transactions[0].application_call else None) or [] + v9_accounts = ( + transactions[1].application_call.account_references if transactions[1].application_call else None + ) or [] assert len(v8_apps) + len(v9_accounts) == 1 @@ -338,13 +350,13 @@ class TestResourcePackerMeta: """Test meta aspects of resource packing""" @pytest.fixture(autouse=True) - def setup(self, algorand: AlgorandClient, funded_account: SigningAccount) -> None: + def setup(self, algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: external_spec = ( Path(__file__).parent.parent / "artifacts" / "resource-packer" / "ExternalApp.arc32.json" ).read_text() factory = algorand.client.get_app_factory( app_spec=external_spec, - default_sender=funded_account.address, + default_sender=funded_account.addr, ) self.external_client, _ = factory.send.create( params=AppFactoryCreateMethodCallParams(method="createApplication") @@ -357,14 +369,15 @@ def test_error_during_simulate(self) -> None: method="error", ), ) - assert "Error resolving execution info via simulate in transaction 0" in exc_info.value.logic_error_str - - def test_box_with_txn_arg(self, algorand: AlgorandClient, funded_account: SigningAccount) -> None: - payment = PaymentTxn( - sender=funded_account.address, - receiver=funded_account.address, - amt=0, - sp=algorand.client.algod.suggested_params(), + assert "Error resolving execution info via simulate in transaction [0]" in exc_info.value.logic_error_str + + def test_box_with_txn_arg(self, algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: + payment = algorand.create_transaction.payment( + PaymentParams( + sender=funded_account.addr, + receiver=funded_account.addr, + amount=AlgoAmount.from_micro_algo(0), + ) ) payment_with_signer = TransactionWithSigner(payment, funded_account.signer) @@ -388,11 +401,21 @@ def test_sender_asset_holding(self) -> None: ) result = self.external_client.send.call(AppClientMethodCallParams(method="senderAssetBalance")) - assert len(getattr(result.transaction.application_call, "accounts", None) or []) == 0 + assert ( + len( + ( + result.transaction.application_call.account_references + if result.transaction.application_call + else None + ) + or [] + ) + == 0 + ) - def test_rekeyed_account(self, algorand: AlgorandClient, funded_account: SigningAccount) -> None: + def test_rekeyed_account(self, algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: auth_addr = algorand.account.random() - algorand.account.rekey_account(funded_account.address, auth_addr) + algorand.account.rekey_account(funded_account.addr, auth_addr) self.external_client.fund_app_account(FundAppAccountParams(amount=AlgoAmount.from_micro_algo(200_001))) @@ -404,9 +427,19 @@ def test_rekeyed_account(self, algorand: AlgorandClient, funded_account: Signing ) result = self.external_client.send.call(AppClientMethodCallParams(method="senderAssetBalance")) - assert len(getattr(result.transaction.application_call, "accounts", None) or []) == 0 + assert ( + len( + ( + result.transaction.application_call.account_references + if result.transaction.application_call + else None + ) + or [] + ) + == 0 + ) - def test_create_box_in_new_app(self, algorand: AlgorandClient, funded_account: SigningAccount) -> None: + def test_create_box_in_new_app(self, algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: self.external_client.fund_app_account(FundAppAccountParams(amount=AlgoAmount.from_micro_algo(200_000))) result = self.external_client.send.call( @@ -415,7 +448,7 @@ def test_create_box_in_new_app(self, algorand: AlgorandClient, funded_account: S args=[ algorand.create_transaction.payment( PaymentParams( - sender=funded_account.address, + sender=funded_account.addr, receiver=self.external_client.app_address, amount=AlgoAmount.from_algo(1), ) @@ -425,16 +458,20 @@ def test_create_box_in_new_app(self, algorand: AlgorandClient, funded_account: S ), ) - box_ref = result.transaction.application_call.boxes[0] if result.transaction.application_call.boxes else None + box_ref = ( + result.transaction.application_call.box_references[0] + if result.transaction.application_call.box_references + else None + ) assert box_ref is not None - assert box_ref.app_index == 0 # type: ignore # noqa: PGH003 + assert box_ref.app_id == 0 -def test_inner_txn_with_box(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_inner_txn_with_box(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: spec = (Path(__file__).parent.parent / "artifacts" / "testing_app_puya" / "app_spec.arc32.json").read_text() factory = algorand.client.get_app_factory( app_spec=spec, - default_sender=funded_account.address, + default_sender=funded_account.addr, ) app_client, _ = factory.send.bare.create() app_client.fund_app_account(FundAppAccountParams(amount=AlgoAmount.from_algo(1))) @@ -453,3 +490,129 @@ def test_inner_txn_with_box(algorand: AlgorandClient, funded_account: SigningAcc ) assert algorand.app.get_box_value(external_app_id, "box") == b"foo" + + +class TestResourcePackerDeterminism: + """Test that resource population produces deterministic ordering.""" + + @pytest.fixture(autouse=True) + def setup(self, algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: + # Load ARC-56 spec for the main contract + spec_path = ( + Path(__file__).parent.parent / "artifacts" / "resource-packer-puya" / "ResourcePackerPuya.arc56.json" + ) + spec = spec_path.read_text() + + factory = algorand.client.get_app_factory( + app_spec=spec, + default_sender=funded_account.addr, + ) + self.app_client, _ = factory.send.create( + params=AppFactoryCreateMethodCallParams( + method="create_application", + note=b"main_app", + ) + ) + # Fund app account for box storage MBR + self.app_client.fund_app_account(FundAppAccountParams(amount=AlgoAmount.from_micro_algo(500_000))) + + def test_order_is_deterministic( # noqa: C901 + self, algorand: AlgorandClient, funded_account: AddressWithSigners + ) -> None: + """Test that resource population produces consistent ordering across multiple iterations. + + The non-determinism comes from the simulate endpoint, not from input order. + This test builds the same transaction group 100 times and verifies that + after resource population, the resource references are always in the same order. + """ + # Create 4 random accounts + accounts = [algorand.account.random().addr for _ in range(4)] + + # Create 4 assets + assets = [] + for i in range(4): + result = algorand.send.asset_create( + AssetCreateParams( + sender=funded_account.addr, + total=1, + note=f"asset{i}".encode(), + ) + ) + assets.append(result.asset_id) + + # Create 4 external apps using the ExternalAppPuya contract + external_spec = ( + Path(__file__).parent.parent / "artifacts" / "resource-packer-puya" / "ExternalAppPuya.arc56.json" + ).read_text() + external_apps = [] + for i in range(4): + factory = algorand.client.get_app_factory( + app_spec=external_spec, + default_sender=funded_account.addr, + ) + client, _ = factory.send.create( + params=AppFactoryCreateMethodCallParams( + method="create_application", + note=f"app{i}".encode(), + ) + ) + external_apps.append(client.app_id) + + def get_resources() -> dict: + """Build and populate a transaction group, returning the resource references.""" + # Create a fresh composer for each iteration + composer = algorand.new_group() + + # Add the many_resources call + composer.add_app_call_method_call( + self.app_client.params.call( + AppClientMethodCallParams( + method="many_resources", + args=[ + accounts, # address[4] + assets, # uint64[4] + external_apps, # uint64[4] + [1, 2, 3, 4], # uint8[4] box keys + ], + static_fee=AlgoAmount.from_micro_algo(10_000), + ), + ), + ) + + # Add dummy transactions to fill the group + for i in range(10): + composer.add_app_call_method_call( + self.app_client.params.call( + AppClientMethodCallParams( + method="dummy", + note=f"{i}".encode(), # Different note each time to make txns unique + ) + ) + ) + + # Build (which triggers simulation and resource population) + build_result = composer.build() + + # Extract all resources from all transactions + resources = [] + for txn in build_result.transactions: + app_call = txn.application_call + if app_call: + for acct in app_call.account_references or []: + resources.append(f"acct:{acct}") + for asset in app_call.asset_references or []: + resources.append(f"asset:{asset}") + for app in app_call.app_references or []: + resources.append(f"app:{app}") + for box in app_call.box_references or []: + resources.append(f"box:{box.app_id}-{box.name}") + + return {"resources": tuple(resources)} + + # Collect resources from 100 iterations + all_resources = [get_resources() for _ in range(100)] + + # Verify all iterations produced identical results + first_result = all_resources[0] + for i, result in enumerate(all_resources[1:], 1): + assert result == first_result, f"Iteration {i} produced different resource ordering" diff --git a/tests/transactions/test_transaction_composer.py b/tests/transactions/test_transaction_composer.py index 1d79995c..d8f8b6c0 100644 --- a/tests/transactions/test_transaction_composer.py +++ b/tests/transactions/test_transaction_composer.py @@ -1,20 +1,16 @@ import base64 from collections.abc import Generator from pathlib import Path -from typing import TYPE_CHECKING, Any +from typing import Any from unittest.mock import Mock, patch -import algosdk import pytest -from algosdk.transaction import ( - ApplicationCallTxn, - AssetConfigTxn, - AssetCreateTxn, - PaymentTxn, -) +from algokit_abi import abi, arc56 +from algokit_transact import MultisigMetadata, TransactionValidationError, make_empty_transaction_signer +from algokit_transact.signer import AddressWithSigners +from algokit_utils import AssetDestroyParams from algokit_utils.algorand import AlgorandClient -from algokit_utils.models.account import MultisigMetadata, SigningAccount from algokit_utils.models.amount import AlgoAmount from algokit_utils.transactions.transaction_composer import ( AppCallMethodCallParams, @@ -23,13 +19,12 @@ AssetCreateParams, AssetTransferParams, PaymentParams, - SendAtomicTransactionComposerResults, + SendTransactionComposerResults, TransactionComposer, + TransactionComposerConfig, + TransactionComposerParams, ) -if TYPE_CHECKING: - from algokit_utils.models.transaction import Arc2TransactionNote - @pytest.fixture def algorand() -> AlgorandClient: @@ -45,57 +40,49 @@ def mock_config() -> Generator[Mock, None, None]: @pytest.fixture -def funded_account(algorand: AlgorandClient) -> SigningAccount: +def funded_account(algorand: AlgorandClient) -> AddressWithSigners: new_account = algorand.account.random() dispenser = algorand.account.localnet_dispenser() algorand.account.ensure_funded( new_account, dispenser, AlgoAmount.from_algo(100), min_funding_increment=AlgoAmount.from_algo(1) ) - algorand.set_signer(sender=new_account.address, signer=new_account.signer) + algorand.set_signer(sender=new_account.addr, signer=new_account.signer) return new_account @pytest.fixture -def funded_secondary_account(algorand: AlgorandClient) -> SigningAccount: - private_key, _ = algosdk.account.generate_account() - address = str(algosdk.account.address_from_private_key(private_key)) - dispenser = algorand.account.localnet_dispenser() - new_account = SigningAccount(private_key=private_key, address=address) - algorand.account.ensure_funded( - new_account, dispenser, AlgoAmount.from_algo(100), min_funding_increment=AlgoAmount.from_algo(1) +def funded_secondary_account(algorand: AlgorandClient, funded_account: AddressWithSigners) -> AddressWithSigners: + account = algorand.account.random() + algorand.send.payment( + PaymentParams(sender=funded_account.addr, receiver=account.addr, amount=AlgoAmount.from_algo(2)) ) - return new_account + return account -def test_add_transaction(algorand: AlgorandClient, funded_account: SigningAccount) -> None: - composer = TransactionComposer( - algod=algorand.client.algod, - get_signer=lambda _: funded_account.signer, - ) - txn = PaymentTxn( - sender=funded_account.address, - sp=algorand.client.algod.suggested_params(), - receiver=funded_account.address, - amt=AlgoAmount.from_algo(1).micro_algo, +def test_add_transaction(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: + composer = algorand.new_group() + txn = algorand.create_transaction.payment( + PaymentParams( + sender=funded_account.addr, + receiver=funded_account.addr, + amount=AlgoAmount.from_algo(1), + ) ) composer.add_transaction(txn) built = composer.build_transactions() assert len(built.transactions) == 1 - assert isinstance(built.transactions[0], PaymentTxn) - assert built.transactions[0].sender == funded_account.address - assert built.transactions[0].receiver == funded_account.address - assert built.transactions[0].amt == AlgoAmount.from_algo(1).micro_algo + assert built.transactions[0].payment + assert built.transactions[0].sender == funded_account.addr + assert built.transactions[0].payment.receiver == funded_account.addr + assert built.transactions[0].payment.amount == AlgoAmount.from_algo(1).micro_algo -def test_add_asset_create(algorand: AlgorandClient, funded_account: SigningAccount) -> None: - composer = TransactionComposer( - algod=algorand.client.algod, - get_signer=lambda _: funded_account.signer, - ) +def test_add_asset_create(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: + composer = algorand.new_group() expected_total = 1000 params = AssetCreateParams( - sender=funded_account.address, + sender=funded_account.addr, total=expected_total, decimals=0, default_frozen=False, @@ -107,77 +94,67 @@ def test_add_asset_create(algorand: AlgorandClient, funded_account: SigningAccou composer.add_asset_create(params) built = composer.build_transactions() response = composer.send({"max_rounds_to_wait": 20}) - created_asset = algorand.client.algod.asset_info( - algorand.client.algod.pending_transaction_info(response.tx_ids[0])["asset-index"] # type: ignore[call-overload] - )["params"] + confirmation = response.confirmations[-1] + asset_id = confirmation.asset_id + assert asset_id is not None assert len(response.tx_ids) == 1 - assert response.confirmations[-1]["confirmed-round"] > 0 # type: ignore[call-overload] - assert isinstance(built.transactions[0], AssetCreateTxn) + assert confirmation.confirmed_round is not None + assert confirmation.confirmed_round > 0 + assert built.transactions[0].asset_config txn = built.transactions[0] - assert txn.sender == funded_account.address - assert created_asset["creator"] == funded_account.address - assert txn.total == created_asset["total"] == expected_total - assert txn.decimals == created_asset["decimals"] == 0 - assert txn.default_frozen == created_asset["default-frozen"] is False - assert txn.unit_name == created_asset["unit-name"] == "TEST" - assert txn.asset_name == created_asset["name"] == "Test Asset" + assert txn.sender == funded_account.addr + created_asset = algorand.client.algod.asset_by_id(asset_id).params + assert created_asset.creator == funded_account.addr + assert txn.asset_config.total == created_asset.total == expected_total + assert txn.asset_config.decimals == created_asset.decimals == 0 + assert txn.asset_config.default_frozen is False + assert txn.asset_config.unit_name == created_asset.unit_name == "TEST" + assert txn.asset_config.asset_name == created_asset.name == "Test Asset" def test_add_asset_config( - algorand: AlgorandClient, funded_account: SigningAccount, funded_secondary_account: SigningAccount + algorand: AlgorandClient, funded_account: AddressWithSigners, funded_secondary_account: AddressWithSigners ) -> None: - # First create an asset - asset_txn = AssetCreateTxn( - sender=funded_account.address, - sp=algorand.client.algod.suggested_params(), - total=1000, - decimals=0, - default_frozen=False, - unit_name="CFG", - asset_name="Configurable Asset", - manager=funded_account.address, - ) - signed_asset_txn = asset_txn.sign(funded_account.signer.private_key) - tx_id = algorand.client.algod.send_transaction(signed_asset_txn) - asset_before_config = algorand.client.algod.asset_info( - algorand.client.algod.pending_transaction_info(tx_id)["asset-index"] # type: ignore[call-overload] + created = algorand.send.asset_create( + AssetCreateParams( + sender=funded_account.addr, + total=1000, + decimals=0, + default_frozen=False, + unit_name="CFG", + asset_name="Configurable Asset", + manager=funded_account.addr, + ) ) - asset_before_config_index = asset_before_config["index"] # type: ignore[call-overload] + asset_id = created.asset_id - composer = TransactionComposer( - algod=algorand.client.algod, - get_signer=lambda _: funded_account.signer, - ) + composer = algorand.new_group() params = AssetConfigParams( - sender=funded_account.address, - asset_id=asset_before_config_index, - manager=funded_secondary_account.address, + sender=funded_account.addr, + asset_id=asset_id, + manager=funded_secondary_account.addr, ) composer.add_asset_config(params) built = composer.build_transactions() assert len(built.transactions) == 1 - assert isinstance(built.transactions[0], AssetConfigTxn) txn = built.transactions[0] - assert txn.sender == funded_account.address - assert txn.index == asset_before_config_index - assert txn.manager == funded_secondary_account.address + assert txn.asset_config + assert txn.asset_config.asset_id == asset_id + assert txn.asset_config.manager == funded_secondary_account.addr composer.send({"max_rounds_to_wait": 20}) - updated_asset = algorand.client.algod.asset_info(asset_id=asset_before_config_index)["params"] # type: ignore[call-overload] - assert updated_asset["manager"] == funded_secondary_account.address + updated_asset = algorand.client.algod.asset_by_id(asset_id).params + assert updated_asset.manager == funded_secondary_account.addr -def test_add_app_create(algorand: AlgorandClient, funded_account: SigningAccount) -> None: - composer = TransactionComposer( - algod=algorand.client.algod, - get_signer=lambda _: funded_account.signer, - ) +def test_add_app_create(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: + composer = algorand.new_group() approval_program = "#pragma version 6\nint 1" clear_state_program = "#pragma version 6\nint 1" params = AppCreateParams( - sender=funded_account.address, + sender=funded_account.addr, approval_program=approval_program, clear_state_program=clear_state_program, schema={"global_ints": 0, "global_byte_slices": 0, "local_ints": 0, "local_byte_slices": 0}, @@ -186,146 +163,158 @@ def test_add_app_create(algorand: AlgorandClient, funded_account: SigningAccount built = composer.build_transactions() assert len(built.transactions) == 1 - assert isinstance(built.transactions[0], ApplicationCallTxn) txn = built.transactions[0] - assert txn.sender == funded_account.address - assert txn.approval_program == b"\x06\x81\x01" - assert txn.clear_program == b"\x06\x81\x01" - composer.send({"max_rounds_to_wait": 20}) + assert txn.application_call + assert txn.sender == funded_account.addr + assert txn.application_call.approval_program + assert txn.application_call.clear_state_program + response = composer.send({"max_rounds_to_wait": 20}) + assert response.confirmations[-1].app_id is not None -def test_add_app_call_method_call(algorand: AlgorandClient, funded_account: SigningAccount) -> None: - composer = TransactionComposer( - algod=algorand.client.algod, - get_signer=lambda _: funded_account.signer, - ) +def test_add_app_call_method_call(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: approval_program = Path(Path(__file__).parent.parent / "artifacts" / "hello_world" / "approval.teal").read_text() clear_state_program = Path(Path(__file__).parent.parent / "artifacts" / "hello_world" / "clear.teal").read_text() - composer.add_app_create( + create_response = algorand.send.app_create( AppCreateParams( - sender=funded_account.address, + sender=funded_account.addr, approval_program=approval_program, clear_state_program=clear_state_program, schema={"global_ints": 0, "global_byte_slices": 0, "local_ints": 0, "local_byte_slices": 0}, ) ) - response = composer.send() - app_id = algorand.client.algod.pending_transaction_info(response.tx_ids[0])["application-index"] # type: ignore[call-overload] + app_id = create_response.app_id - composer = TransactionComposer( - algod=algorand.client.algod, - get_signer=lambda _: funded_account.signer, - ) + composer = algorand.new_group() composer.add_app_call_method_call( AppCallMethodCallParams( - sender=funded_account.address, + sender=funded_account.addr, app_id=app_id, - method=algosdk.abi.Method.from_signature("hello(string)string"), + method=arc56.Method.from_signature("hello(string)string"), args=["world"], ) ) built = composer.build_transactions() assert len(built.transactions) == 1 - assert isinstance(built.transactions[0], ApplicationCallTxn) - txn = built.transactions[0] - assert txn.sender == funded_account.address + assert built.transactions[0].application_call response = composer.send({"max_rounds_to_wait": 20}) assert response.returns[-1].value == "Hello, world" -def test_simulate(algorand: AlgorandClient, funded_account: SigningAccount) -> None: - composer = TransactionComposer( - algod=algorand.client.algod, - get_signer=lambda _: funded_account.signer, +_SINGLE_ARRAY = abi.ABIType.from_string("uint8[]").encode([1]) +_TWO_ARRAYS = abi.ABIType.from_string("(uint8[],uint8[])").encode(([1], [1])) +_THREE_ARRAYS = abi.ABIType.from_string("(uint8[],uint8[],uint8[])").encode(([1], [1], [1])) + + +@pytest.mark.parametrize( + ("num_abi_args", "expected_txn_args", "expected_last_arg"), + [ + (1, 2, _SINGLE_ARRAY), + (13, 14, _SINGLE_ARRAY), + (14, 15, _SINGLE_ARRAY), + (15, 16, _SINGLE_ARRAY), + (16, 16, _TWO_ARRAYS), + (17, 16, _THREE_ARRAYS), + ], +) +def test_add_app_call_with_tuple_packing( + algorand: AlgorandClient, + funded_account: AddressWithSigners, + num_abi_args: int, + expected_txn_args: int, + expected_last_arg: bytes, +) -> None: + args_str = ",".join(["uint8[]"] * num_abi_args) + method = arc56.Method.from_signature(f"args{num_abi_args}({args_str})void") + app_call = algorand.create_transaction.app_call_method_call( + AppCallMethodCallParams( + sender=funded_account.addr, + app_id=1234, + method=method, + args=[[1]] * num_abi_args, + ) ) + txn = app_call.transactions[0] + assert txn.application_call is not None + args = txn.application_call.args or [] + assert len(args) == expected_txn_args + assert args[0] == method.selector + assert args[-1] == expected_last_arg + + +def test_simulate(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: + composer = algorand.new_group() composer.add_payment( PaymentParams( - sender=funded_account.address, - receiver=funded_account.address, + sender=funded_account.addr, + receiver=funded_account.addr, amount=AlgoAmount.from_algo(1), ) ) composer.build() simulate_response = composer.simulate() - assert simulate_response - + assert simulate_response.simulate_response is not None + assert len(simulate_response.transactions) == 1 -def test_simulate_without_signer(algorand: AlgorandClient, funded_secondary_account: SigningAccount) -> None: - """Test that simulate works without a signer being available when skip_signatures=True.""" - # No signer is loaded for funded_secondary_account - composer = algorand.new_group() +def test_simulate_without_signer(algorand: AlgorandClient, funded_secondary_account: AddressWithSigners) -> None: + composer = TransactionComposer( + TransactionComposerParams( + algod=algorand.client.algod, + get_signer=lambda _: make_empty_transaction_signer(), + ) + ) composer.add_payment( PaymentParams( - sender=funded_secondary_account.address, - receiver=funded_secondary_account.address, + sender=funded_secondary_account.addr, + receiver=funded_secondary_account.addr, amount=AlgoAmount.from_algo(1), ) ) - + composer.build() simulate_response = composer.simulate(skip_signatures=True) - assert simulate_response + assert simulate_response.simulate_response is not None assert len(simulate_response.transactions) == 1 -def test_build_transactions_without_signer(algorand: AlgorandClient, funded_secondary_account: SigningAccount) -> None: - """Test that build_transactions work without a signer being available""" - - # No signer is loaded for funded_secondary_account - composer = algorand.new_group() - composer.add_payment( - PaymentParams( - sender=funded_secondary_account.address, - receiver=funded_secondary_account.address, - amount=AlgoAmount.from_algo(1), +def test_build_fails_without_signer(algorand: AlgorandClient, funded_secondary_account: AddressWithSigners) -> None: + composer = TransactionComposer( + TransactionComposerParams( + algod=algorand.client.algod, + get_signer=lambda _: None, ) ) - - built = composer.build_transactions() - assert len(built.transactions) == 1 - assert len(built.signers) == 0 - - -def test_fails_to_build_without_signers(algorand: AlgorandClient, funded_secondary_account: SigningAccount) -> None: - """Test that build does not work without a signer being available""" - - # No signer is loaded for funded_secondary_account - composer = algorand.new_group() composer.add_payment( PaymentParams( - sender=funded_secondary_account.address, - receiver=funded_secondary_account.address, + sender=funded_secondary_account.addr, + receiver=funded_secondary_account.addr, amount=AlgoAmount.from_algo(1), ) ) - with pytest.raises(Exception) as e: # noqa: PT011 + with pytest.raises(ValueError, match=f"No signer found for address {funded_secondary_account.addr}"): composer.build() - assert str(e.value) == f"No signer found for address {funded_secondary_account.address}" - -def test_send(algorand: AlgorandClient, funded_account: SigningAccount) -> None: - composer = TransactionComposer( - algod=algorand.client.algod, - get_signer=lambda _: funded_account.signer, - ) +def test_send(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: + composer = algorand.new_group() composer.add_payment( PaymentParams( - sender=funded_account.address, - receiver=funded_account.address, + sender=funded_account.addr, + receiver=funded_account.addr, amount=AlgoAmount.from_algo(1), ) ) response = composer.send() - assert isinstance(response, SendAtomicTransactionComposerResults) + assert isinstance(response, SendTransactionComposerResults) assert len(response.tx_ids) == 1 - assert response.confirmations[-1]["confirmed-round"] > 0 # type: ignore[call-overload] + assert response.confirmations[-1].confirmed_round is not None + assert response.confirmations[-1].confirmed_round > 0 def test_arc2_note() -> None: - note_data: Arc2TransactionNote = { + note_data = { "dapp_name": "TestDApp", "format": "j", "data": '{"key":"value"}', @@ -335,166 +324,100 @@ def test_arc2_note() -> None: assert encoded_note == expected_note -def test_arc2_note_dapp_name_validation() -> None: - invalid_names = [ - "_TestDApp", # starts with underscore - "Test", # too short - "a" * 33, # too long - "Test@App!", # invalid character ! - "Test App", # contains space - ] - - for invalid_name in invalid_names: - note_data: Arc2TransactionNote = {"dapp_name": invalid_name, "format": "j", "data": {"key": "value"}} - with pytest.raises(ValueError, match="dapp_name must be"): - TransactionComposer.arc2_note(note_data) - - -def test_arc2_note_valid_dapp_names() -> None: - valid_names = [ - "TestDApp", # simple case - "test-dapp", # with hyphen - "test_dapp", # with underscore - "test.dapp", # with dot - "test@dapp", # with @ - "test/dapp", # with / - "a" * 32, # maximum length - "12345", # minimum length, numeric - ] - - for valid_name in valid_names: - note_data: Arc2TransactionNote = {"dapp_name": valid_name, "format": "j", "data": {"key": "value"}} - encoded_note = TransactionComposer.arc2_note(note_data) - assert encoded_note.startswith(valid_name.encode()) +def test_arc2_note_validates() -> None: + with pytest.raises(ValueError, match="dapp_name must be"): + TransactionComposer.arc2_note({"dapp_name": "_invalid", "format": "j", "data": "x"}) # type: ignore[arg-type] def _get_test_transaction( - default_account: SigningAccount, amount: AlgoAmount | None = None, sender: SigningAccount | None = None + default_account: AddressWithSigners, amount: AlgoAmount | None = None, sender: AddressWithSigners | None = None ) -> dict[str, Any]: return { - "sender": sender.address if sender else default_account.address, - "receiver": default_account.address, + "sender": sender.addr if sender else default_account.addr, + "receiver": default_account.addr, "amount": amount or AlgoAmount.from_algo(1), } -def test_transaction_is_capped_by_low_min_txn_fee(algorand: AlgorandClient, funded_account: SigningAccount) -> None: - with pytest.raises(ValueError, match="Transaction fee 1000 is greater than max_fee 1 µALGO"): +def test_transaction_is_capped_by_low_min_txn_fee(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: + with pytest.raises(ValueError, match="Transaction fee 1000 µALGO is greater than max fee 1 µALGO"): algorand.send.payment( PaymentParams(**_get_test_transaction(funded_account), max_fee=AlgoAmount.from_micro_algo(1)) ) def test_transaction_cap_is_ignored_if_higher_than_fee( - algorand: AlgorandClient, funded_account: SigningAccount + algorand: AlgorandClient, funded_account: AddressWithSigners ) -> None: response = algorand.send.payment( PaymentParams(**_get_test_transaction(funded_account), max_fee=AlgoAmount.from_micro_algo(1_000_000)) ) - assert isinstance(response.confirmation, dict) - assert response.confirmation["txn"]["txn"]["fee"] == AlgoAmount.from_micro_algo(1000) + assert response.confirmation.txn.txn.fee == AlgoAmount.from_micro_algo(1000) -def test_transaction_fee_is_overridable(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_transaction_fee_is_overridable(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: response = algorand.send.payment( PaymentParams(**_get_test_transaction(funded_account), static_fee=AlgoAmount.from_algo(1)) ) - assert isinstance(response.confirmation, dict) - assert response.confirmation["txn"]["txn"]["fee"] == AlgoAmount.from_algo(1) + assert response.confirmation.txn.txn.fee == AlgoAmount.from_algo(1) -def test_transaction_group_is_sent(algorand: AlgorandClient, funded_account: SigningAccount) -> None: - composer = TransactionComposer( - algod=algorand.client.algod, - get_signer=lambda _: funded_account.signer, - ) +def test_transaction_group_is_sent(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: + composer = algorand.new_group() composer.add_payment(PaymentParams(**_get_test_transaction(funded_account, amount=AlgoAmount.from_algo(1)))) composer.add_payment(PaymentParams(**_get_test_transaction(funded_account, amount=AlgoAmount.from_algo(2)))) response = composer.send() - assert isinstance(response.confirmations[0], dict) - assert isinstance(response.confirmations[1], dict) - assert response.confirmations[0].get("txn", {}).get("txn", {}).get("grp") is not None - assert response.confirmations[1].get("txn", {}).get("txn", {}).get("grp") is not None - assert response.transactions[0].payment.group is not None - assert response.transactions[1].payment.group is not None + assert response.transactions[0].group is not None + assert response.transactions[1].group is not None assert len(response.confirmations) == 2 - assert response.confirmations[0]["confirmed-round"] >= response.transactions[0].payment.first_valid_round - assert response.confirmations[1]["confirmed-round"] >= response.transactions[1].payment.first_valid_round - assert ( - response.confirmations[0]["txn"]["txn"]["grp"] - == base64.b64encode(response.transactions[0].payment.group).decode() - ) - assert ( - response.confirmations[1]["txn"]["txn"]["grp"] - == base64.b64encode(response.transactions[1].payment.group).decode() - ) + group_bytes = response.transactions[0].group + assert group_bytes is not None + expected_group = base64.b64encode(group_bytes).decode() + assert response.confirmations[0].txn.txn.group == group_bytes + assert response.confirmations[1].txn.txn.group == group_bytes + assert response.confirmations[0].txn.txn.group == base64.b64decode(expected_group.encode()) -def test_multisig_single_account(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_multisig_single_account(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: multisig = algorand.account.multisig( metadata=MultisigMetadata( version=1, threshold=1, - addresses=[funded_account.address], + addrs=[funded_account.addr], ), - signing_accounts=[funded_account], + sub_signers=[funded_account], ) algorand.send.payment( - PaymentParams(sender=funded_account.address, receiver=multisig.address, amount=AlgoAmount.from_algo(1)) + PaymentParams(sender=funded_account.addr, receiver=multisig.addr, amount=AlgoAmount.from_algo(1)) ) algorand.send.payment( - PaymentParams(sender=multisig.address, receiver=funded_account.address, amount=AlgoAmount.from_micro_algo(500)) + PaymentParams(sender=multisig.addr, receiver=funded_account.addr, amount=AlgoAmount.from_micro_algo(500)) ) -def test_multisig_double_account(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_multisig_double_account(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: account2 = algorand.account.random() algorand.account.ensure_funded(account2, funded_account, AlgoAmount.from_algo(10)) - # Setup multisig multisig = algorand.account.multisig( metadata=MultisigMetadata( version=1, threshold=2, - addresses=[funded_account.address, account2.address], + addrs=[funded_account.addr, account2.addr], ), - signing_accounts=[funded_account, account2], + sub_signers=[funded_account, account2], ) - # Fund multisig algorand.send.payment( - PaymentParams(sender=funded_account.address, receiver=multisig.address, amount=AlgoAmount.from_algo(1)) + PaymentParams(sender=funded_account.addr, receiver=multisig.addr, amount=AlgoAmount.from_algo(1)) ) - - # Use multisig algorand.send.payment( - PaymentParams(sender=multisig.address, receiver=funded_account.address, amount=AlgoAmount.from_micro_algo(500)) + PaymentParams(sender=multisig.addr, receiver=funded_account.addr, amount=AlgoAmount.from_micro_algo(500)) ) -@pytest.mark.usefixtures("mock_config") -def test_transactions_fails_in_debug_mode(algorand: AlgorandClient, funded_account: SigningAccount) -> None: - txn1 = algorand.create_transaction.payment(PaymentParams(**_get_test_transaction(funded_account))) - txn2 = algorand.create_transaction.payment( - PaymentParams(**_get_test_transaction(funded_account, amount=AlgoAmount.from_micro_algo(9999999999999))) - ) - composer = TransactionComposer( - algod=algorand.client.algod, - get_signer=lambda _: funded_account.signer, - ) - composer.add_transaction(txn1) - composer.add_transaction(txn2) - - with pytest.raises(Exception) as e: # noqa: PT011 - composer.send() - - assert f"transaction {txn2.get_txid()}: overspend" in e.value.traces[0]["failure_message"] # type: ignore[attr-defined] - - -def test_error_transformers_chaining(algorand: AlgorandClient, funded_account: SigningAccount) -> None: - """Test that error transformers work correctly and can be chained together.""" - +def test_error_transformers_chaining(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: def error_transformer_1(error: Exception) -> Exception: if "missing from" in str(error): return Exception("ASSET MISSING???") @@ -509,18 +432,324 @@ def error_transformer_2(error: Exception) -> Exception: composer.register_error_transformer(error_transformer_1) composer.register_error_transformer(error_transformer_2) - # Add a transaction that will fail (asset transfer with non-existent asset) composer.add_asset_transfer( AssetTransferParams( - sender=funded_account.address, - receiver=funded_account.address, + sender=funded_account.addr, + receiver=funded_account.addr, amount=1, - asset_id=1337, # Non-existent asset + asset_id=1337, ) ) - # Test that error transformation works for simulate (covers main error path) - with pytest.raises(Exception, match="ASSET MISSING!") as exc_info: + with pytest.raises(Exception, match="ASSET MISSING!"): composer.simulate() - assert str(exc_info.value) == "ASSET MISSING!" + +def test_error_transformers_applied_on_send(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: + def transformer(error: Exception) -> Exception: + if "missing from" in str(error): + return Exception("ASSET MISSING ON SEND") + return error + + composer = algorand.new_group() + composer.register_error_transformer(transformer) + composer.add_asset_transfer( + AssetTransferParams( + sender=funded_account.addr, + receiver=funded_account.addr, + amount=1, + asset_id=9999999, + ) + ) + + with pytest.raises(Exception, match="ASSET MISSING ON SEND"): + composer.send({"max_rounds_to_wait": 0}) + + +def test_validation_occurs_on_send(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: + params = AssetDestroyParams(asset_id=0, sender=funded_account.addr) + with pytest.raises( + TransactionValidationError, + match="Asset config validation failed: Total is required", + ): + algorand.send.asset_destroy(params) + + +def test_simulate_does_not_throw_when_disabled(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: + composer = algorand.new_group() + composer.add_asset_transfer( + AssetTransferParams( + sender=funded_account.addr, + receiver=funded_account.addr, + amount=1, + asset_id=9999999, + ) + ) + + result = composer.simulate(result_on_failure=True) + assert result.simulate_response is not None + + +def test_clone_keeps_groups_independent(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: + payment_txn = algorand.create_transaction.payment( + PaymentParams( + sender=funded_account.addr, + receiver=funded_account.addr, + amount=AlgoAmount.from_algo(1), + ) + ) + + composer1 = algorand.new_group() + composer1.add_transaction(payment_txn) + composer1.add_payment( + PaymentParams(sender=funded_account.addr, receiver=funded_account.addr, amount=AlgoAmount.from_algo(1)) + ) + + composer2 = composer1.clone() + composer2.add_payment( + PaymentParams(sender=funded_account.addr, receiver=funded_account.addr, amount=AlgoAmount.from_algo(2)) + ) + + group1 = composer1.build().transactions[0].group + group2 = composer2.build().transactions[0].group + + assert group1 is not None + assert group2 is not None + assert group1 != group2 + + +def test_send_without_params_respects_composer_config( + algorand: AlgorandClient, funded_account: AddressWithSigners +) -> None: + """Test that send() without params respects the composer's config settings. + + This test verifies that calling send() without explicit params doesn't override + the composer's configured populate_app_call_resources and cover_app_call_inner_transaction_fees + settings. We verify this by using a mock to track whether simulate_transactions is called + when building app call transactions - it should only be called if resource population is enabled. + """ + approval_program = "#pragma version 6\nint 1" + clear_state_program = "#pragma version 6\nint 1" + + # First, create an app to call + create_result = algorand.send.app_create( + AppCreateParams( + sender=funded_account.addr, + approval_program=approval_program, + clear_state_program=clear_state_program, + schema={"global_ints": 0, "global_byte_slices": 0, "local_ints": 0, "local_byte_slices": 0}, + ) + ) + app_id = create_result.app_id + + # Create a composer with populate_app_call_resources=False + composer = TransactionComposer( + TransactionComposerParams( + algod=algorand.client.algod, + get_signer=lambda addr: algorand.account.get_signer(addr), + composer_config=TransactionComposerConfig(populate_app_call_resources=False), + ) + ) + + from algokit_utils.transactions.transaction_composer import AppCallParams + + composer.add_app_call( + AppCallParams( + sender=funded_account.addr, + app_id=app_id, + ) + ) + + # Patch simulate_transactions to track calls + with patch.object( + algorand.client.algod, "simulate_transactions", side_effect=algorand.client.algod.simulate_transactions + ) as patched: + # Send without params - since populate_app_call_resources=False, + # simulate should NOT be called during build + composer.send() + + # simulate_transactions should not have been called because + # populate_app_call_resources=False was respected + assert patched.call_count == 0, ( + f"simulate_transactions was called {patched.call_count} times, " + "but should not be called when populate_app_call_resources=False" + ) + + +class TestGatherSignatures: + """Tests for the gather_signatures method.""" + + def test_should_successfully_sign_a_single_transaction( + self, algorand: AlgorandClient, funded_account: AddressWithSigners + ) -> None: + """Test that a single transaction is signed successfully.""" + composer = algorand.new_group() + composer.add_payment( + PaymentParams( + sender=funded_account.addr, + receiver=funded_account.addr, + amount=AlgoAmount.from_micro_algo(1000), + ) + ) + + signed_txns = composer.gather_signatures() + + assert len(signed_txns) == 1 + assert len(signed_txns[0]) > 0 + + def test_should_successfully_sign_multiple_transactions_with_same_signer( + self, algorand: AlgorandClient, funded_account: AddressWithSigners + ) -> None: + """Test that multiple transactions from the same sender are signed correctly.""" + composer = algorand.new_group() + composer.add_payment( + PaymentParams( + sender=funded_account.addr, + receiver=funded_account.addr, + amount=AlgoAmount.from_micro_algo(1000), + ) + ) + composer.add_payment( + PaymentParams( + sender=funded_account.addr, + receiver=funded_account.addr, + amount=AlgoAmount.from_micro_algo(2000), + ) + ) + + signed_txns = composer.gather_signatures() + + assert len(signed_txns) == 2 + assert len(signed_txns[0]) > 0 + assert len(signed_txns[1]) > 0 + + def test_should_successfully_sign_transactions_with_multiple_different_signers( + self, algorand: AlgorandClient, funded_account: AddressWithSigners + ) -> None: + """Test that transactions from different senders are each signed correctly.""" + # Create and fund a second account + sender2 = algorand.account.random() + algorand.send.payment( + PaymentParams( + sender=funded_account.addr, + receiver=sender2.addr, + amount=AlgoAmount.from_algo(10), + ) + ) + + composer = algorand.new_group() + composer.add_payment( + PaymentParams( + sender=funded_account.addr, + receiver=sender2.addr, + amount=AlgoAmount.from_micro_algo(1000), + ) + ) + composer.add_payment( + PaymentParams( + sender=sender2.addr, + receiver=funded_account.addr, + amount=AlgoAmount.from_micro_algo(1000), + signer=sender2.signer, + ) + ) + + signed_txns = composer.gather_signatures() + + assert len(signed_txns) == 2 + assert len(signed_txns[0]) > 0 + assert len(signed_txns[1]) > 0 + + def test_should_throw_error_when_no_transactions_to_sign(self, algorand: AlgorandClient) -> None: + """Test that an error is thrown when there are no transactions to sign.""" + composer = algorand.new_group() + + with pytest.raises(ValueError, match="Cannot build an empty transaction group"): + composer.gather_signatures() + + def test_should_throw_error_when_signer_returns_fewer_signed_transactions_than_expected( + self, algorand: AlgorandClient, funded_account: AddressWithSigners + ) -> None: + """Test error handling when a signer returns fewer signed transactions than requested.""" + from collections.abc import Sequence + + from algokit_transact.models.transaction import Transaction + + real_signer = algorand.account.get_signer(funded_account.addr) + + # Create a faulty signer that returns fewer signed transactions than requested + def faulty_signer(txns: Sequence[Transaction], indexes: Sequence[int]) -> list[bytes]: + # Only return one signed transaction even if multiple are requested + return real_signer(txns, [indexes[0]]) + + composer = algorand.new_group() + composer.add_payment( + PaymentParams( + sender=funded_account.addr, + receiver=funded_account.addr, + amount=AlgoAmount.from_micro_algo(1000), + signer=faulty_signer, + ) + ) + composer.add_payment( + PaymentParams( + sender=funded_account.addr, + receiver=funded_account.addr, + amount=AlgoAmount.from_micro_algo(2000), + signer=faulty_signer, + ) + ) + + with pytest.raises(ValueError, match=r"Transactions at indexes \[1\] were not signed"): + composer.gather_signatures() + + def test_should_throw_error_when_signer_returns_none_signed_transaction( + self, algorand: AlgorandClient, funded_account: AddressWithSigners + ) -> None: + """Test error handling when a signer returns None values.""" + from collections.abc import Sequence + + from algokit_transact.models.transaction import Transaction + + # Create a faulty signer that returns array of Nones + def faulty_signer(_txns: Sequence[Transaction], indexes: Sequence[int]) -> list[bytes]: + return [None] * len(indexes) # type: ignore[list-item] + + composer = algorand.new_group() + composer.add_payment( + PaymentParams( + sender=funded_account.addr, + receiver=funded_account.addr, + amount=AlgoAmount.from_micro_algo(1000), + signer=faulty_signer, + ) + ) + + # Should provide a clear error message indicating which transaction was not signed + with pytest.raises(ValueError, match=r"Transactions at indexes \[0\] were not signed"): + composer.gather_signatures() + + def test_should_throw_error_when_signer_returns_empty_array( + self, algorand: AlgorandClient, funded_account: AddressWithSigners + ) -> None: + """Test error handling when a signer returns an empty array.""" + from collections.abc import Sequence + + from algokit_transact.models.transaction import Transaction + + # Create a faulty signer that returns empty array + def faulty_signer(_txns: Sequence[Transaction], _indexes: Sequence[int]) -> list[bytes]: + return [] + + composer = algorand.new_group() + composer.add_payment( + PaymentParams( + sender=funded_account.addr, + receiver=funded_account.addr, + amount=AlgoAmount.from_micro_algo(1000), + signer=faulty_signer, + ) + ) + + with pytest.raises(ValueError, match=r"Transactions at indexes \[0\] were not signed"): + composer.gather_signatures() diff --git a/tests/transactions/test_transaction_creator.py b/tests/transactions/test_transaction_creator.py index a5852bd0..fcc613ba 100644 --- a/tests/transactions/test_transaction_creator.py +++ b/tests/transactions/test_transaction_creator.py @@ -1,20 +1,11 @@ +import base64 from pathlib import Path -import algosdk import pytest -from algosdk.transaction import ( - ApplicationCallTxn, - AssetConfigTxn, - AssetCreateTxn, - AssetDestroyTxn, - AssetFreezeTxn, - AssetTransferTxn, - KeyregTxn, - PaymentTxn, -) +from algokit_abi import arc56 +from algokit_transact.signer import AddressWithSigners from algokit_utils.algorand import AlgorandClient -from algokit_utils.models.account import SigningAccount from algokit_utils.models.amount import AlgoAmount from algokit_utils.transactions.transaction_composer import ( AppCallMethodCallParams, @@ -37,45 +28,45 @@ def algorand() -> AlgorandClient: @pytest.fixture -def funded_account(algorand: AlgorandClient) -> SigningAccount: +def funded_account(algorand: AlgorandClient) -> AddressWithSigners: new_account = algorand.account.random() dispenser = algorand.account.localnet_dispenser() algorand.account.ensure_funded( new_account, dispenser, AlgoAmount.from_algo(100), min_funding_increment=AlgoAmount.from_algo(1) ) - algorand.set_signer(sender=new_account.address, signer=new_account.signer) + algorand.set_signer(sender=new_account.addr, signer=new_account.signer) return new_account @pytest.fixture -def funded_secondary_account(algorand: AlgorandClient, funded_account: SigningAccount) -> SigningAccount: +def funded_secondary_account(algorand: AlgorandClient, funded_account: AddressWithSigners) -> AddressWithSigners: account = algorand.account.random() algorand.send.payment( - PaymentParams(sender=funded_account.address, receiver=account.address, amount=AlgoAmount.from_algo(1)) + PaymentParams(sender=funded_account.addr, receiver=account.addr, amount=AlgoAmount.from_algo(1)) ) return account -def test_create_payment_transaction(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_create_payment_transaction(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: txn = algorand.create_transaction.payment( PaymentParams( - sender=funded_account.address, - receiver=funded_account.address, + sender=funded_account.addr, + receiver=funded_account.addr, amount=AlgoAmount.from_algo(1), ) ) - assert isinstance(txn, PaymentTxn) - assert txn.sender == funded_account.address - assert txn.receiver == funded_account.address - assert txn.amt == AlgoAmount.from_algo(1).micro_algo + assert txn.payment + assert txn.sender == funded_account.addr + assert txn.payment.receiver == funded_account.addr + assert txn.payment.amount == AlgoAmount.from_algo(1).micro_algo -def test_create_asset_create_transaction(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_create_asset_create_transaction(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: expected_total = 1000 txn = algorand.create_transaction.asset_create( AssetCreateParams( - sender=funded_account.address, + sender=funded_account.addr, total=expected_total, decimals=0, default_frozen=False, @@ -85,175 +76,195 @@ def test_create_asset_create_transaction(algorand: AlgorandClient, funded_accoun ) ) - assert isinstance(txn, AssetCreateTxn) - assert txn.sender == funded_account.address - assert txn.total == expected_total - assert txn.decimals == 0 - assert txn.default_frozen is False - assert txn.unit_name == "TEST" - assert txn.asset_name == "Test Asset" - assert txn.url == "https://example.com" + assert txn.asset_config + assert txn.sender == funded_account.addr + assert txn.asset_config.total == expected_total + assert txn.asset_config.decimals == 0 + assert txn.asset_config.default_frozen is False + assert txn.asset_config.unit_name == "TEST" + assert txn.asset_config.asset_name == "Test Asset" + assert txn.asset_config.url == "https://example.com" def test_create_asset_config_transaction( - algorand: AlgorandClient, funded_account: SigningAccount, funded_secondary_account: SigningAccount + algorand: AlgorandClient, funded_account: AddressWithSigners, funded_secondary_account: AddressWithSigners ) -> None: txn = algorand.create_transaction.asset_config( AssetConfigParams( - sender=funded_account.address, + sender=funded_account.addr, asset_id=1, - manager=funded_secondary_account.address, + manager=funded_secondary_account.addr, ) ) - assert isinstance(txn, AssetConfigTxn) - assert txn.sender == funded_account.address - assert txn.index == 1 - assert txn.manager == funded_secondary_account.address + assert txn.asset_config + assert txn.sender == funded_account.addr + assert txn.asset_config.asset_id == 1 + assert txn.asset_config.manager == funded_secondary_account.addr def test_create_asset_freeze_transaction( - algorand: AlgorandClient, funded_account: SigningAccount, funded_secondary_account: SigningAccount + algorand: AlgorandClient, funded_account: AddressWithSigners, funded_secondary_account: AddressWithSigners ) -> None: txn = algorand.create_transaction.asset_freeze( AssetFreezeParams( - sender=funded_account.address, + sender=funded_account.addr, asset_id=1, - account=funded_secondary_account.address, + account=funded_secondary_account.addr, frozen=True, ) ) - assert isinstance(txn, AssetFreezeTxn) - assert txn.sender == funded_account.address - assert txn.index == 1 - assert txn.target == funded_secondary_account.address - assert txn.new_freeze_state is True + assert txn.asset_freeze + assert txn.sender == funded_account.addr + assert txn.asset_freeze.asset_id == 1 + assert txn.asset_freeze.freeze_target == funded_secondary_account.addr + assert txn.asset_freeze.frozen is True -def test_create_asset_destroy_transaction(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_create_asset_destroy_transaction(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: txn = algorand.create_transaction.asset_destroy( AssetDestroyParams( - sender=funded_account.address, + sender=funded_account.addr, asset_id=1, ) ) - assert isinstance(txn, AssetDestroyTxn) - assert txn.sender == funded_account.address - assert txn.index == 1 + assert txn.asset_config + assert txn.sender == funded_account.addr + assert txn.asset_config.asset_id == 1 def test_create_asset_transfer_transaction( - algorand: AlgorandClient, funded_account: SigningAccount, funded_secondary_account: SigningAccount + algorand: AlgorandClient, funded_account: AddressWithSigners, funded_secondary_account: AddressWithSigners ) -> None: expected_amount = 100 txn = algorand.create_transaction.asset_transfer( AssetTransferParams( - sender=funded_account.address, + sender=funded_account.addr, asset_id=1, amount=expected_amount, - receiver=funded_secondary_account.address, + receiver=funded_secondary_account.addr, + ) + ) + + assert txn.asset_transfer + assert txn.sender == funded_account.addr + assert txn.asset_transfer.asset_id == 1 + assert txn.asset_transfer.amount == expected_amount + assert txn.asset_transfer.receiver == funded_secondary_account.addr + + +def test_created_transactions_have_no_group( + algorand: AlgorandClient, funded_account: AddressWithSigners, funded_secondary_account: AddressWithSigners +) -> None: + txn = algorand.create_transaction.asset_transfer( + AssetTransferParams( + sender=funded_account.addr, + asset_id=1, + amount=10, + receiver=funded_secondary_account.addr, ) ) - assert isinstance(txn, AssetTransferTxn) - assert txn.sender == funded_account.address - assert txn.index == 1 - assert txn.amount == expected_amount - assert txn.receiver == funded_secondary_account.address + assert txn.group is None -def test_create_asset_opt_in_transaction(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_create_asset_opt_in_transaction(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: txn = algorand.create_transaction.asset_opt_in( AssetOptInParams( - sender=funded_account.address, + sender=funded_account.addr, asset_id=1, ) ) - assert isinstance(txn, AssetTransferTxn) - assert txn.sender == funded_account.address - assert txn.index == 1 - assert txn.amount == 0 - assert txn.receiver == funded_account.address + assert txn.asset_transfer + assert txn.sender == funded_account.addr + assert txn.asset_transfer.asset_id == 1 + assert txn.asset_transfer.amount == 0 + assert txn.asset_transfer.receiver == funded_account.addr -def test_create_asset_opt_out_transaction(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_create_asset_opt_out_transaction(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: txn = algorand.create_transaction.asset_opt_out( AssetOptOutParams( - sender=funded_account.address, + sender=funded_account.addr, asset_id=1, - creator=funded_account.address, + creator=funded_account.addr, ) ) - assert isinstance(txn, AssetTransferTxn) - assert txn.sender == funded_account.address - assert txn.index == 1 - assert txn.amount == 0 - assert txn.receiver == funded_account.address - assert txn.close_assets_to == funded_account.address + assert txn.asset_transfer + assert txn.sender == funded_account.addr + assert txn.asset_transfer.asset_id == 1 + assert txn.asset_transfer.amount == 0 + assert txn.asset_transfer.receiver == funded_account.addr + assert txn.asset_transfer.close_remainder_to == funded_account.addr -def test_create_app_create_transaction(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_create_app_create_transaction(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: approval_program = "#pragma version 6\nint 1" clear_state_program = "#pragma version 6\nint 1" txn = algorand.create_transaction.app_create( AppCreateParams( - sender=funded_account.address, + sender=funded_account.addr, approval_program=approval_program, clear_state_program=clear_state_program, schema={"global_ints": 0, "global_byte_slices": 0, "local_ints": 0, "local_byte_slices": 0}, ) ) - assert isinstance(txn, ApplicationCallTxn) - assert txn.sender == funded_account.address - assert txn.approval_program == b"\x06\x81\x01" - assert txn.clear_program == b"\x06\x81\x01" + assert txn.application_call + assert txn.sender == funded_account.addr + assert txn.application_call.approval_program == b"\x06\x81\x01" + assert txn.application_call.clear_state_program == b"\x06\x81\x01" -def test_create_app_call_method_call_transaction(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_create_app_call_method_call_transaction(algorand: AlgorandClient, funded_account: AddressWithSigners) -> None: approval_program = Path(Path(__file__).parent.parent / "artifacts" / "hello_world" / "approval.teal").read_text() clear_state_program = Path(Path(__file__).parent.parent / "artifacts" / "hello_world" / "clear.teal").read_text() # First create the app create_result = algorand.send.app_create( AppCreateParams( - sender=funded_account.address, + sender=funded_account.addr, approval_program=approval_program, clear_state_program=clear_state_program, schema={"global_ints": 0, "global_byte_slices": 0, "local_ints": 0, "local_byte_slices": 0}, ) ) - app_id = algorand.client.algod.pending_transaction_info(create_result.tx_ids[0])["application-index"] # type: ignore[call-overload] + confirmation = algorand.client.algod.pending_transaction_information(create_result.tx_ids[0]) + assert confirmation.app_id is not None + app_id = confirmation.app_id # Then test creating a method call transaction result = algorand.create_transaction.app_call_method_call( AppCallMethodCallParams( - sender=funded_account.address, + sender=funded_account.addr, app_id=app_id, - method=algosdk.abi.Method.from_signature("hello(string)string"), + method=arc56.Method.from_signature("hello(string)string"), args=["world"], ) ) assert len(result.transactions) == 1 - assert isinstance(result.transactions[0], ApplicationCallTxn) - assert result.transactions[0].sender == funded_account.address - assert result.transactions[0].index == app_id + transactions = result.transactions[0] + assert transactions.application_call + assert transactions.sender == funded_account.addr + assert transactions.application_call.app_id == app_id -def test_create_online_key_registration_transaction(algorand: AlgorandClient, funded_account: SigningAccount) -> None: +def test_create_online_key_registration_transaction( + algorand: AlgorandClient, funded_account: AddressWithSigners +) -> None: sp = algorand.get_suggested_params() expected_dilution = 100 - expected_first = sp.first - expected_last = sp.first + int(10e6) + expected_first = sp.first_valid + expected_last = sp.first_valid + int(10e6) txn = algorand.create_transaction.online_key_registration( OnlineKeyRegistrationParams( - sender=funded_account.address, + sender=funded_account.addr, vote_key="G/lqTV6MKspW6J8wH2d8ZliZ5XZVZsruqSBJMwLwlmo=", selection_key="LrpLhvzr+QpN/bivh6IPpOaKGbGzTTB5lJtVfixmmgk=", state_proof_key=b"RpUpNWfZMjZ1zOOjv3MF2tjO714jsBt0GKnNsw0ihJ4HSZwci+d9zvUi3i67LwFUJgjQ5Dz4zZgHgGduElnmSA==", @@ -263,10 +274,12 @@ def test_create_online_key_registration_transaction(algorand: AlgorandClient, fu ) ) - assert isinstance(txn, KeyregTxn) - assert txn.sender == funded_account.address - assert txn.selkey == "LrpLhvzr+QpN/bivh6IPpOaKGbGzTTB5lJtVfixmmgk=" - assert txn.sprfkey == b"RpUpNWfZMjZ1zOOjv3MF2tjO714jsBt0GKnNsw0ihJ4HSZwci+d9zvUi3i67LwFUJgjQ5Dz4zZgHgGduElnmSA==" - assert txn.votefst == expected_first - assert txn.votelst == expected_last - assert txn.votekd == expected_dilution + assert txn.key_registration + assert txn.sender == funded_account.addr + assert txn.key_registration.selection_key == base64.b64decode("LrpLhvzr+QpN/bivh6IPpOaKGbGzTTB5lJtVfixmmgk=") + assert txn.key_registration.state_proof_key == base64.b64decode( + "RpUpNWfZMjZ1zOOjv3MF2tjO714jsBt0GKnNsw0ihJ4HSZwci+d9zvUi3i67LwFUJgjQ5Dz4zZgHgGduElnmSA==" + ) + assert txn.key_registration.vote_first == expected_first + assert txn.key_registration.vote_last == expected_last + assert txn.key_registration.vote_key_dilution == expected_dilution diff --git a/tests/transactions/test_transaction_sender.py b/tests/transactions/test_transaction_sender.py index 51c34c97..fccb2a13 100644 --- a/tests/transactions/test_transaction_sender.py +++ b/tests/transactions/test_transaction_sender.py @@ -1,12 +1,11 @@ from pathlib import Path from unittest.mock import MagicMock, patch -import algosdk import pytest -from algosdk.transaction import OnComplete -from algokit_utils import SigningAccount -from algokit_utils._legacy_v2.application_specification import ApplicationSpecification +from algokit_abi import abi, arc32_to_arc56, arc56 +from algokit_transact import OnApplicationComplete +from algokit_transact.signer import AddressWithSigners from algokit_utils.algorand import AlgorandClient from algokit_utils.applications.app_manager import AppManager from algokit_utils.assets.asset_manager import AssetManager @@ -26,6 +25,7 @@ OnlineKeyRegistrationParams, PaymentParams, TransactionComposer, + TransactionComposerParams, ) from algokit_utils.transactions.transaction_sender import AlgorandClientTransactionSender @@ -36,23 +36,23 @@ def algorand() -> AlgorandClient: @pytest.fixture -def funded_account(algorand: AlgorandClient) -> SigningAccount: +def funded_account(algorand: AlgorandClient) -> AddressWithSigners: new_account = algorand.account.random() dispenser = algorand.account.localnet_dispenser() algorand.account.ensure_funded( new_account, dispenser, AlgoAmount.from_algo(100), min_funding_increment=AlgoAmount.from_algo(1) ) - algorand.set_signer(sender=new_account.address, signer=new_account.signer) + algorand.set_signer(sender=new_account.addr, signer=new_account.signer) return new_account @pytest.fixture -def sender(funded_account: SigningAccount) -> SigningAccount: +def sender(funded_account: AddressWithSigners) -> AddressWithSigners: return funded_account @pytest.fixture -def receiver(algorand: AlgorandClient) -> SigningAccount: +def receiver(algorand: AlgorandClient) -> AddressWithSigners: new_account = algorand.account.random() dispenser = algorand.account.localnet_dispenser() algorand.account.ensure_funded( @@ -68,27 +68,31 @@ def raw_hello_world_arc32_app_spec() -> str: @pytest.fixture -def test_hello_world_arc32_app_spec() -> ApplicationSpecification: - raw_json_spec = Path(__file__).parent.parent / "artifacts" / "hello_world" / "app_spec.arc32.json" - return ApplicationSpecification.from_json(raw_json_spec.read_text()) +def hello_world_arc56_app_spec(raw_hello_world_arc32_app_spec: str) -> arc56.Arc56Contract: + return arc32_to_arc56(raw_hello_world_arc32_app_spec) @pytest.fixture -def test_hello_world_arc32_app_id( - algorand: AlgorandClient, funded_account: SigningAccount, test_hello_world_arc32_app_spec: ApplicationSpecification +def hello_world_arc56_app_id( + algorand: AlgorandClient, funded_account: AddressWithSigners, hello_world_arc56_app_spec: arc56.Arc56Contract ) -> int: - global_schema = test_hello_world_arc32_app_spec.global_state_schema - local_schema = test_hello_world_arc32_app_spec.local_state_schema + global_schema = hello_world_arc56_app_spec.state.schema.global_state + local_schema = hello_world_arc56_app_spec.state.schema.local_state + source = hello_world_arc56_app_spec.source + assert source, "Source programs must be present" + approval_program = source.get_decoded_approval() + clear_program = source.get_decoded_clear() + response = algorand.send.app_create( AppCreateParams( - sender=funded_account.address, - approval_program=test_hello_world_arc32_app_spec.approval_program, - clear_state_program=test_hello_world_arc32_app_spec.clear_program, + sender=funded_account.addr, + approval_program=approval_program, + clear_state_program=clear_program, schema={ - "global_ints": int(global_schema.num_uints) if global_schema.num_uints else 0, - "global_byte_slices": int(global_schema.num_byte_slices) if global_schema.num_byte_slices else 0, - "local_ints": int(local_schema.num_uints) if local_schema.num_uints else 0, - "local_byte_slices": int(local_schema.num_byte_slices) if local_schema.num_byte_slices else 0, + "global_ints": int(global_schema.ints) if global_schema.ints else 0, + "global_byte_slices": int(global_schema.bytes) if global_schema.bytes else 0, + "local_ints": int(local_schema.ints) if local_schema.ints else 0, + "local_byte_slices": int(local_schema.bytes) if local_schema.bytes else 0, }, ) ) @@ -96,11 +100,13 @@ def test_hello_world_arc32_app_id( @pytest.fixture -def transaction_sender(algorand: AlgorandClient, sender: SigningAccount) -> AlgorandClientTransactionSender: +def transaction_sender(algorand: AlgorandClient, sender: AddressWithSigners) -> AlgorandClientTransactionSender: def new_group() -> TransactionComposer: return TransactionComposer( - algod=algorand.client.algod, - get_signer=lambda _: sender.signer, + TransactionComposerParams( + algod=algorand.client.algod, + get_signer=lambda _: sender.signer, + ) ) return AlgorandClientTransactionSender( @@ -112,30 +118,31 @@ def new_group() -> TransactionComposer: def test_payment( - transaction_sender: AlgorandClientTransactionSender, sender: SigningAccount, receiver: SigningAccount + transaction_sender: AlgorandClientTransactionSender, sender: AddressWithSigners, receiver: AddressWithSigners ) -> None: amount = AlgoAmount.from_algo(1) result = transaction_sender.payment( PaymentParams( - sender=sender.address, - receiver=receiver.address, + sender=sender.addr, + receiver=receiver.addr, amount=amount, ) ) assert len(result.tx_ids) == 1 - assert result.confirmations[-1]["confirmed-round"] > 0 # type: ignore[call-overload] + assert result.confirmations[-1].confirmed_round is not None + assert result.confirmations[-1].confirmed_round > 0 txn = result.transaction.payment assert txn - assert txn.sender == sender.address - assert txn.receiver == receiver.address - assert txn.amt == amount.micro_algo + assert result.transaction.sender == sender.addr + assert txn.receiver == receiver.addr + assert txn.amount == amount.micro_algo -def test_asset_create(transaction_sender: AlgorandClientTransactionSender, sender: SigningAccount) -> None: +def test_asset_create(transaction_sender: AlgorandClientTransactionSender, sender: AddressWithSigners) -> None: total = 1000 params = AssetCreateParams( - sender=sender.address, + sender=sender.addr, total=total, decimals=0, default_frozen=False, @@ -146,41 +153,43 @@ def test_asset_create(transaction_sender: AlgorandClientTransactionSender, sende result = transaction_sender.asset_create(params) assert len(result.tx_ids) == 1 - assert result.confirmations[-1]["confirmed-round"] > 0 # type: ignore[call-overload] + assert result.confirmations[-1].confirmed_round is not None + assert result.confirmations[-1].confirmed_round > 0 txn = result.transaction.asset_config assert txn - assert txn.sender == sender.address + assert result.transaction.sender == sender.addr assert txn.total == total - assert txn.decimals == 0 - assert txn.default_frozen is False + assert (txn.decimals or 0) == 0 + assert (txn.default_frozen or False) is False assert txn.unit_name == "TEST" assert txn.asset_name == "Test Asset" assert txn.url == "https://example.com" def test_asset_config( - transaction_sender: AlgorandClientTransactionSender, sender: SigningAccount, receiver: SigningAccount + transaction_sender: AlgorandClientTransactionSender, sender: AddressWithSigners, receiver: AddressWithSigners ) -> None: # First create an asset create_result = transaction_sender.asset_create( AssetCreateParams( - sender=sender.address, + sender=sender.addr, total=1000, decimals=0, default_frozen=False, unit_name="CFG", asset_name="Config Asset", url="https://example.com", - manager=sender.address, + manager=sender.addr, ) ) - asset_id = int(create_result.confirmation["asset-index"]) # type: ignore[call-overload] + assert create_result.confirmation.asset_id is not None + asset_id = int(create_result.confirmation.asset_id) # Then configure it config_params = AssetConfigParams( - sender=sender.address, + sender=sender.addr, asset_id=asset_id, - manager=receiver.address, + manager=receiver.addr, ) result = transaction_sender.asset_config(config_params) @@ -188,36 +197,37 @@ def test_asset_config( assert result.transaction.asset_config txn = result.transaction.asset_config assert txn - assert txn.sender == sender.address - assert txn.index == asset_id - assert txn.manager == receiver.address + assert result.transaction.sender == sender.addr + assert txn.asset_id == asset_id + assert txn.manager == receiver.addr def test_asset_freeze( transaction_sender: AlgorandClientTransactionSender, - sender: SigningAccount, + sender: AddressWithSigners, ) -> None: # First create an asset create_result = transaction_sender.asset_create( AssetCreateParams( - sender=sender.address, + sender=sender.addr, total=1000, decimals=0, default_frozen=False, unit_name="FRZ", url="https://example.com", asset_name="Freeze Asset", - freeze=sender.address, - manager=sender.address, + freeze=sender.addr, + manager=sender.addr, ) ) - asset_id = int(create_result.confirmation["asset-index"]) # type: ignore[call-overload] + assert create_result.confirmation.asset_id is not None + asset_id = int(create_result.confirmation.asset_id) # Then freeze it freeze_params = AssetFreezeParams( - sender=sender.address, + sender=sender.addr, asset_id=asset_id, - account=sender.address, + account=sender.addr, frozen=True, ) result = transaction_sender.asset_freeze(freeze_params) @@ -226,31 +236,32 @@ def test_asset_freeze( assert result.transaction.asset_freeze txn = result.transaction.asset_freeze assert txn - assert txn.sender == sender.address - assert txn.index == asset_id - assert txn.target == sender.address - assert txn.new_freeze_state is True + assert result.transaction.sender == sender.addr + assert txn.asset_id == asset_id + assert txn.freeze_target == sender.addr + assert bool(txn.frozen) is True -def test_asset_destroy(transaction_sender: AlgorandClientTransactionSender, sender: SigningAccount) -> None: +def test_asset_destroy(transaction_sender: AlgorandClientTransactionSender, sender: AddressWithSigners) -> None: # First create an asset create_result = transaction_sender.asset_create( AssetCreateParams( - sender=sender.address, + sender=sender.addr, total=1000, decimals=0, default_frozen=False, unit_name="DEL", asset_name="Delete Asset", - manager=sender.address, + manager=sender.addr, url="https://example.com", ) ) - asset_id = int(create_result.confirmation["asset-index"]) # type: ignore[call-overload] + assert create_result.confirmation.asset_id is not None + asset_id = int(create_result.confirmation.asset_id) # Then destroy it destroy_params = AssetDestroyParams( - sender=sender.address, + sender=sender.addr, asset_id=asset_id, ) result = transaction_sender.asset_destroy(destroy_params) @@ -258,17 +269,17 @@ def test_asset_destroy(transaction_sender: AlgorandClientTransactionSender, send assert len(result.tx_ids) == 1 txn = result.transaction.asset_config assert txn - assert txn.sender == sender.address - assert txn.index == asset_id + assert result.transaction.sender == sender.addr + assert txn.asset_id == asset_id def test_asset_transfer( - transaction_sender: AlgorandClientTransactionSender, sender: SigningAccount, receiver: SigningAccount + transaction_sender: AlgorandClientTransactionSender, sender: AddressWithSigners, receiver: AddressWithSigners ) -> None: # First create an asset create_result = transaction_sender.asset_create( AssetCreateParams( - sender=sender.address, + sender=sender.addr, total=1000, decimals=0, default_frozen=False, @@ -277,12 +288,13 @@ def test_asset_transfer( asset_name="Transfer Asset", ) ) - asset_id = int(create_result.confirmation["asset-index"]) # type: ignore[call-overload] + assert create_result.confirmation.asset_id is not None + asset_id = int(create_result.confirmation.asset_id) # Then opt-in receiver transaction_sender.asset_opt_in( AssetOptInParams( - sender=receiver.address, + sender=receiver.addr, asset_id=asset_id, signer=receiver.signer, ) @@ -291,9 +303,9 @@ def test_asset_transfer( # Then transfer it amount = 100 transfer_params = AssetTransferParams( - sender=sender.address, + sender=sender.addr, asset_id=asset_id, - receiver=receiver.address, + receiver=receiver.addr, amount=amount, ) result = transaction_sender.asset_transfer(transfer_params) @@ -301,19 +313,19 @@ def test_asset_transfer( assert len(result.tx_ids) == 1 txn = result.transaction.asset_transfer assert txn - assert txn.sender == sender.address - assert txn.index == asset_id - assert txn.receiver == receiver.address + assert result.transaction.sender == sender.addr + assert txn.asset_id == asset_id + assert txn.receiver == receiver.addr assert txn.amount == amount def test_asset_opt_in( - transaction_sender: AlgorandClientTransactionSender, sender: SigningAccount, receiver: SigningAccount + transaction_sender: AlgorandClientTransactionSender, sender: AddressWithSigners, receiver: AddressWithSigners ) -> None: # First create an asset create_result = transaction_sender.asset_create( AssetCreateParams( - sender=sender.address, + sender=sender.addr, total=1000, decimals=0, default_frozen=False, @@ -322,11 +334,12 @@ def test_asset_opt_in( asset_name="Opt Asset", ) ) - asset_id = int(create_result.confirmation["asset-index"]) # type: ignore[call-overload] + assert create_result.confirmation.asset_id is not None + asset_id = int(create_result.confirmation.asset_id) # Then opt-in opt_in_params = AssetOptInParams( - sender=receiver.address, + sender=receiver.addr, asset_id=asset_id, signer=receiver.signer, ) @@ -335,19 +348,19 @@ def test_asset_opt_in( assert len(result.tx_ids) == 1 assert result.transaction.asset_transfer txn = result.transaction.asset_transfer - assert txn.sender == receiver.address - assert txn.index == asset_id + assert result.transaction.sender == receiver.addr + assert txn.asset_id == asset_id assert txn.amount == 0 - assert txn.receiver == receiver.address + assert txn.receiver == receiver.addr def test_asset_opt_out( - transaction_sender: AlgorandClientTransactionSender, sender: SigningAccount, receiver: SigningAccount + transaction_sender: AlgorandClientTransactionSender, sender: AddressWithSigners, receiver: AddressWithSigners ) -> None: # First create an asset create_result = transaction_sender.asset_create( AssetCreateParams( - sender=sender.address, + sender=sender.addr, total=1000, decimals=0, default_frozen=False, @@ -356,12 +369,13 @@ def test_asset_opt_out( asset_name="Opt Out Asset", ) ) - asset_id = int(create_result.confirmation["asset-index"]) # type: ignore[call-overload] + assert create_result.confirmation.asset_id is not None + asset_id = int(create_result.confirmation.asset_id) # Then opt-in transaction_sender.asset_opt_in( AssetOptInParams( - sender=receiver.address, + sender=receiver.addr, asset_id=asset_id, signer=receiver.signer, ) @@ -369,27 +383,27 @@ def test_asset_opt_out( # Then opt-out opt_out_params = AssetOptOutParams( - sender=receiver.address, + sender=receiver.addr, asset_id=asset_id, - creator=sender.address, + creator=sender.addr, signer=receiver.signer, ) result = transaction_sender.asset_opt_out(params=opt_out_params) assert result.transaction.asset_transfer txn = result.transaction.asset_transfer - assert txn.sender == receiver.address - assert txn.index == asset_id + assert result.transaction.sender == receiver.addr + assert txn.asset_id == asset_id assert txn.amount == 0 - assert txn.receiver == receiver.address - assert txn.close_assets_to == sender.address + assert txn.receiver == receiver.addr + assert txn.close_remainder_to == sender.addr -def test_app_create(transaction_sender: AlgorandClientTransactionSender, sender: SigningAccount) -> None: +def test_app_create(transaction_sender: AlgorandClientTransactionSender, sender: AddressWithSigners) -> None: approval_program = "#pragma version 6\nint 1" clear_state_program = "#pragma version 6\nint 1" params = AppCreateParams( - sender=sender.address, + sender=sender.addr, approval_program=approval_program, clear_state_program=clear_state_program, schema={"global_ints": 0, "global_byte_slices": 0, "local_ints": 0, "local_byte_slices": 0}, @@ -401,36 +415,50 @@ def test_app_create(transaction_sender: AlgorandClientTransactionSender, sender: assert result.transaction.application_call txn = result.transaction.application_call - assert txn.sender == sender.address + assert result.transaction.sender == sender.addr assert txn.approval_program == b"\x06\x81\x01" - assert txn.clear_program == b"\x06\x81\x01" + assert txn.clear_state_program == b"\x06\x81\x01" def test_app_call( - test_hello_world_arc32_app_id: int, transaction_sender: AlgorandClientTransactionSender, sender: SigningAccount + hello_world_arc56_app_id: int, + transaction_sender: AlgorandClientTransactionSender, + sender: AddressWithSigners, ) -> None: - params = AppCallParams( - app_id=test_hello_world_arc32_app_id, - sender=sender.address, - on_complete=OnComplete.NoOpOC, - args=[b"\x02\xbe\xce\x11", b"test"], + method = arc56.Method.from_signature("hello(string)string") + selector = method.get_selector() + encoded_arg = abi.ABIType.from_string("string").encode("test") + + result = transaction_sender.app_call( + AppCallParams( + app_id=hello_world_arc56_app_id, + sender=sender.addr, + on_complete=OnApplicationComplete.NoOp, + args=[selector, encoded_arg], + ) ) - result = transaction_sender.app_call(params) - assert not result.abi_return # TODO: improve checks + assert result.confirmations[-1].confirmed_round is not None + assert result.confirmations[-1].confirmed_round > 0 + assert result.transaction.application_call def test_app_call_method_call( - test_hello_world_arc32_app_id: int, transaction_sender: AlgorandClientTransactionSender, sender: SigningAccount + hello_world_arc56_app_id: int, + transaction_sender: AlgorandClientTransactionSender, + sender: AddressWithSigners, ) -> None: - params = AppCallMethodCallParams( - app_id=test_hello_world_arc32_app_id, - sender=sender.address, - method=algosdk.abi.Method.from_signature("hello(string)string"), - args=["test"], + method = arc56.Method.from_signature("hello(string)string") + + result = transaction_sender.app_call_method_call( + AppCallMethodCallParams( + app_id=hello_world_arc56_app_id, + sender=sender.addr, + method=method, + args=["test"], + ) ) - result = transaction_sender.app_call_method_call(params) assert result.abi_return assert result.abi_return.value == "Hello2, test" @@ -439,14 +467,14 @@ def test_app_call_method_call( def test_payment_logging( mock_debug: MagicMock, transaction_sender: AlgorandClientTransactionSender, - sender: SigningAccount, - receiver: SigningAccount, + sender: AddressWithSigners, + receiver: AddressWithSigners, ) -> None: amount = AlgoAmount.from_algo(1) transaction_sender.payment( PaymentParams( - sender=sender.address, - receiver=receiver.address, + sender=sender.addr, + receiver=receiver.addr, amount=amount, ) ) @@ -454,34 +482,34 @@ def test_payment_logging( assert mock_debug.call_count == 1 log_message = mock_debug.call_args[0][0] assert "Sending 1,000,000 µALGO" in log_message - assert sender.address in log_message - assert receiver.address in log_message + assert sender.addr in log_message + assert receiver.addr in log_message -def test_key_registration(transaction_sender: AlgorandClientTransactionSender, sender: SigningAccount) -> None: +def test_key_registration(transaction_sender: AlgorandClientTransactionSender, sender: AddressWithSigners) -> None: sp = transaction_sender._algod.suggested_params() # noqa: SLF001 params = OnlineKeyRegistrationParams( - sender=sender.address, + sender=sender.addr, vote_key="G/lqTV6MKspW6J8wH2d8ZliZ5XZVZsruqSBJMwLwlmo=", selection_key="LrpLhvzr+QpN/bivh6IPpOaKGbGzTTB5lJtVfixmmgk=", state_proof_key=b"RpUpNWfZMjZ1zOOjv3MF2tjO714jsBt0GKnNsw0ihJ4HSZwci+d9zvUi3i67LwFUJgjQ5Dz4zZgHgGduElnmSA==", - vote_first=sp.first, - vote_last=sp.first + int(10e6), + vote_first=sp.first_valid, + vote_last=sp.first_valid + int(10e6), vote_key_dilution=100, ) result = transaction_sender.online_key_registration(params) assert len(result.tx_ids) == 1 - assert result.confirmations[-1]["confirmed-round"] > 0 # type: ignore[call-overload] - - sp = transaction_sender._algod.suggested_params() # noqa: SLF001 + assert result.confirmations[-1].confirmed_round is not None + assert result.confirmations[-1].confirmed_round > 0 off_key_reg_params = OfflineKeyRegistrationParams( - sender=sender.address, + sender=sender.addr, prevent_account_from_ever_participating_again=True, ) result = transaction_sender.offline_key_registration(off_key_reg_params) assert len(result.tx_ids) == 1 - assert result.confirmations[-1]["confirmed-round"] > 0 # type: ignore[call-overload] + assert result.confirmations[-1].confirmed_round is not None + assert result.confirmations[-1].confirmed_round > 0 diff --git a/uv.lock b/uv.lock new file mode 100644 index 00000000..05fa0bd3 --- /dev/null +++ b/uv.lock @@ -0,0 +1,2217 @@ +version = 1 +revision = 3 +requires-python = ">=3.10, <4" +resolution-markers = [ + "python_full_version >= '3.14' and platform_python_implementation != 'PyPy'", + "python_full_version >= '3.12' and python_full_version < '3.14' and platform_python_implementation != 'PyPy'", + "python_full_version < '3.12' and platform_python_implementation != 'PyPy'", + "python_full_version >= '3.12' and platform_python_implementation == 'PyPy'", + "python_full_version < '3.12' and platform_python_implementation == 'PyPy'", +] + +[[package]] +name = "alabaster" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a6/f8/d9c74d0daf3f742840fd818d69cfae176fa332022fd44e3469487d5a9420/alabaster-1.0.0.tar.gz", hash = "sha256:c00dca57bca26fa62a6d7d0a9fcce65f3e026e9bfe33e9c538fd3fbb2144fd9e", size = 24210, upload-time = "2024-07-26T18:15:03.762Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", size = 13929, upload-time = "2024-07-26T18:15:02.05Z" }, +] + +[[package]] +name = "algokit-utils" +version = "5.0.0b5" +source = { editable = "." } +dependencies = [ + { name = "exceptiongroup" }, + { name = "httpx" }, + { name = "msgpack" }, + { name = "msgpack-types" }, + { name = "pycryptodomex" }, + { name = "pynacl" }, + { name = "typing-extensions" }, + { name = "xhd-wallet-api" }, +] + +[package.dev-dependencies] +api-generator = [ + { name = "oas-generator" }, +] +dev = [ + { name = "filelock" }, + { name = "furo" }, + { name = "linkify-it-py" }, + { name = "mypy" }, + { name = "myst-parser" }, + { name = "pip" }, + { name = "pip-audit" }, + { name = "poethepoet" }, + { name = "pre-commit" }, + { name = "pydantic" }, + { name = "pydoclint" }, + { name = "pygments" }, + { name = "pytest" }, + { name = "pytest-cov" }, + { name = "pytest-httpx" }, + { name = "pytest-mock" }, + { name = "pytest-sugar" }, + { name = "pytest-xdist" }, + { name = "python-dotenv" }, + { name = "python-semantic-release" }, + { name = "requests" }, + { name = "ruff" }, + { name = "setuptools" }, + { name = "sphinx" }, + { name = "sphinx-autoapi" }, + { name = "sphinx-markdown-builder" }, + { name = "syrupy" }, + { name = "types-deprecated" }, +] + +[package.metadata] +requires-dist = [ + { name = "exceptiongroup", specifier = ">=1.3.1" }, + { name = "httpx", specifier = ">=0.23.1,<=0.28.1" }, + { name = "msgpack", specifier = ">=1.0.0,<2" }, + { name = "msgpack-types", specifier = ">=0.2.0,<=0.5.0" }, + { name = "pycryptodomex", specifier = ">=3.19,<4" }, + { name = "pynacl", specifier = ">=1.4.0,<2" }, + { name = "typing-extensions", specifier = ">=4.6.0" }, + { name = "xhd-wallet-api", specifier = ">=1.0.0" }, +] + +[package.metadata.requires-dev] +api-generator = [{ name = "oas-generator", editable = "api/oas-generator" }] +cicd = [] +dev = [ + { name = "filelock", specifier = ">=3.12.0,<4" }, + { name = "furo", specifier = ">=2024.8.6,<2026" }, + { name = "linkify-it-py", specifier = ">=2.0.3,<3" }, + { name = "mypy", specifier = ">=1.5.1,<2" }, + { name = "myst-parser", specifier = ">=4.0.0,<5" }, + { name = "pip", specifier = ">=26.0,<27" }, + { name = "pip-audit", specifier = ">=2.5.6,<3" }, + { name = "poethepoet", specifier = ">=0.19,<0.39" }, + { name = "pre-commit", specifier = ">=3.4.0,<4" }, + { name = "pydantic", specifier = ">=2.0.0,<3" }, + { name = "pydoclint", specifier = ">=0.6.0,<0.9" }, + { name = "pygments", specifier = ">=2.20.0,<3" }, + { name = "pytest", specifier = ">=9.0.3,<10" }, + { name = "pytest-cov", specifier = ">=6,<7" }, + { name = "pytest-httpx", specifier = ">=0.36.0,<0.37" }, + { name = "pytest-mock", specifier = "~=3.14" }, + { name = "pytest-sugar", specifier = ">=1.0.0,<2" }, + { name = "pytest-xdist", specifier = ">=3.6.1,<4" }, + { name = "python-dotenv", specifier = ">=1.0.0,<2" }, + { name = "python-semantic-release", specifier = ">=10.5.0,<11" }, + { name = "requests", specifier = ">=2.33.0,<3" }, + { name = "ruff", specifier = ">=0.1.6,<=0.14.8" }, + { name = "setuptools", specifier = ">=80.9.0,<81" }, + { name = "sphinx", specifier = ">=8.0.0,<9" }, + { name = "sphinx-autoapi", specifier = ">=3.4.0,<4" }, + { name = "sphinx-markdown-builder", specifier = ">=0.6.8,<0.7" }, + { name = "syrupy", specifier = ">=5.0.0,<6" }, + { name = "types-deprecated", specifier = ">=1.2.15.20241117,<2" }, +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" }, +] + +[[package]] +name = "anyio" +version = "4.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "idna" }, + { name = "sniffio" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c6/78/7d432127c41b50bccba979505f272c16cbcadcc33645d5fa3a738110ae75/anyio-4.11.0.tar.gz", hash = "sha256:82a8d0b81e318cc5ce71a5f1f8b5c4e63619620b63141ef8c995fa0db95a57c4", size = 219094, upload-time = "2025-09-23T09:19:12.58Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/15/b3/9b1a8074496371342ec1e796a96f99c82c945a339cd81a8e73de28b4cf9e/anyio-4.11.0-py3-none-any.whl", hash = "sha256:0287e96f4d26d4149305414d4e3bc32f0dcd0862365a4bddea19d7a1ec38c4fc", size = 109097, upload-time = "2025-09-23T09:19:10.601Z" }, +] + +[[package]] +name = "astroid" +version = "3.3.11" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.12' and platform_python_implementation != 'PyPy'", + "python_full_version < '3.12' and platform_python_implementation == 'PyPy'", +] +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/18/74/dfb75f9ccd592bbedb175d4a32fc643cf569d7c218508bfbd6ea7ef9c091/astroid-3.3.11.tar.gz", hash = "sha256:1e5a5011af2920c7c67a53f65d536d65bfa7116feeaf2354d8b94f29573bb0ce", size = 400439, upload-time = "2025-07-13T18:04:23.177Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/0f/3b8fdc946b4d9cc8cc1e8af42c4e409468c84441b933d037e101b3d72d86/astroid-3.3.11-py3-none-any.whl", hash = "sha256:54c760ae8322ece1abd213057c4b5bba7c49818853fc901ef09719a60dbf9dec", size = 275612, upload-time = "2025-07-13T18:04:21.07Z" }, +] + +[[package]] +name = "astroid" +version = "4.0.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.14' and platform_python_implementation != 'PyPy'", + "python_full_version >= '3.12' and python_full_version < '3.14' and platform_python_implementation != 'PyPy'", + "python_full_version >= '3.12' and platform_python_implementation == 'PyPy'", +] +sdist = { url = "https://files.pythonhosted.org/packages/b7/22/97df040e15d964e592d3a180598ace67e91b7c559d8298bdb3c949dc6e42/astroid-4.0.2.tar.gz", hash = "sha256:ac8fb7ca1c08eb9afec91ccc23edbd8ac73bb22cbdd7da1d488d9fb8d6579070", size = 405714, upload-time = "2025-11-09T21:21:18.373Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/93/ac/a85b4bfb4cf53221513e27f33cc37ad158fce02ac291d18bee6b49ab477d/astroid-4.0.2-py3-none-any.whl", hash = "sha256:d7546c00a12efc32650b19a2bb66a153883185d3179ab0d4868086f807338b9b", size = 276354, upload-time = "2025-11-09T21:21:16.54Z" }, +] + +[[package]] +name = "babel" +version = "2.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/6b/d52e42361e1aa00709585ecc30b3f9684b3ab62530771402248b1b1d6240/babel-2.17.0.tar.gz", hash = "sha256:0c54cffb19f690cdcc52a3b50bcbf71e07a808d1c80d549f2459b9d2cf0afb9d", size = 9951852, upload-time = "2025-02-01T15:17:41.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/b8/3fe70c75fe32afc4bb507f75563d39bc5642255d1d94f1f23604725780bf/babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2", size = 10182537, upload-time = "2025-02-01T15:17:37.39Z" }, +] + +[[package]] +name = "beautifulsoup4" +version = "4.14.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "soupsieve" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/77/e9/df2358efd7659577435e2177bfa69cba6c33216681af51a707193dec162a/beautifulsoup4-4.14.2.tar.gz", hash = "sha256:2a98ab9f944a11acee9cc848508ec28d9228abfd522ef0fad6a02a72e0ded69e", size = 625822, upload-time = "2025-09-29T10:05:42.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/fe/3aed5d0be4d404d12d36ab97e2f1791424d9ca39c2f754a6285d59a3b01d/beautifulsoup4-4.14.2-py3-none-any.whl", hash = "sha256:5ef6fa3a8cbece8488d66985560f97ed091e22bbc4e9c2338508a9d5de6d4515", size = 106392, upload-time = "2025-09-29T10:05:43.771Z" }, +] + +[[package]] +name = "boolean-py" +version = "5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c4/cf/85379f13b76f3a69bca86b60237978af17d6aa0bc5998978c3b8cf05abb2/boolean_py-5.0.tar.gz", hash = "sha256:60cbc4bad079753721d32649545505362c754e121570ada4658b852a3a318d95", size = 37047, upload-time = "2025-04-03T10:39:49.734Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/ca/78d423b324b8d77900030fa59c4aa9054261ef0925631cd2501dd015b7b7/boolean_py-5.0-py3-none-any.whl", hash = "sha256:ef28a70bd43115208441b53a045d1549e2f0ec6e3d08a9d142cbc41c1938e8d9", size = 26577, upload-time = "2025-04-03T10:39:48.449Z" }, +] + +[[package]] +name = "cachecontrol" +version = "0.14.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "msgpack" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/3a/0cbeb04ea57d2493f3ec5a069a117ab467f85e4a10017c6d854ddcbff104/cachecontrol-0.14.3.tar.gz", hash = "sha256:73e7efec4b06b20d9267b441c1f733664f989fb8688391b670ca812d70795d11", size = 28985, upload-time = "2025-04-30T16:45:06.135Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/4c/800b0607b00b3fd20f1087f80ab53d6b4d005515b0f773e4831e37cfa83f/cachecontrol-0.14.3-py3-none-any.whl", hash = "sha256:b35e44a3113f17d2a31c1e6b27b9de6d4405f84ae51baa8c1d3cc5b633010cae", size = 21802, upload-time = "2025-04-30T16:45:03.863Z" }, +] + +[package.optional-dependencies] +filecache = [ + { name = "filelock" }, +] + +[[package]] +name = "certifi" +version = "2025.10.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4c/5b/b6ce21586237c77ce67d01dc5507039d444b630dd76611bbca2d8e5dcd91/certifi-2025.10.5.tar.gz", hash = "sha256:47c09d31ccf2acf0be3f701ea53595ee7e0b8fa08801c6624be771df09ae7b43", size = 164519, upload-time = "2025-10-05T04:12:15.808Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e4/37/af0d2ef3967ac0d6113837b44a4f0bfe1328c2b9763bd5b1744520e5cfed/certifi-2025.10.5-py3-none-any.whl", hash = "sha256:0f212c2744a9bb6de0c56639a6f68afe01ecd92d91f14ae897c4fe7bbeeef0de", size = 163286, upload-time = "2025-10-05T04:12:14.03Z" }, +] + +[[package]] +name = "cffi" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/93/d7/516d984057745a6cd96575eea814fe1edd6646ee6efd552fb7b0921dec83/cffi-2.0.0-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:0cf2d91ecc3fcc0625c2c530fe004f82c110405f101548512cce44322fa8ac44", size = 184283, upload-time = "2025-09-08T23:22:08.01Z" }, + { url = "https://files.pythonhosted.org/packages/9e/84/ad6a0b408daa859246f57c03efd28e5dd1b33c21737c2db84cae8c237aa5/cffi-2.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f73b96c41e3b2adedc34a7356e64c8eb96e03a3782b535e043a986276ce12a49", size = 180504, upload-time = "2025-09-08T23:22:10.637Z" }, + { url = "https://files.pythonhosted.org/packages/50/bd/b1a6362b80628111e6653c961f987faa55262b4002fcec42308cad1db680/cffi-2.0.0-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:53f77cbe57044e88bbd5ed26ac1d0514d2acf0591dd6bb02a3ae37f76811b80c", size = 208811, upload-time = "2025-09-08T23:22:12.267Z" }, + { url = "https://files.pythonhosted.org/packages/4f/27/6933a8b2562d7bd1fb595074cf99cc81fc3789f6a6c05cdabb46284a3188/cffi-2.0.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3e837e369566884707ddaf85fc1744b47575005c0a229de3327f8f9a20f4efeb", size = 216402, upload-time = "2025-09-08T23:22:13.455Z" }, + { url = "https://files.pythonhosted.org/packages/05/eb/b86f2a2645b62adcfff53b0dd97e8dfafb5c8aa864bd0d9a2c2049a0d551/cffi-2.0.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5eda85d6d1879e692d546a078b44251cdd08dd1cfb98dfb77b670c97cee49ea0", size = 203217, upload-time = "2025-09-08T23:22:14.596Z" }, + { url = "https://files.pythonhosted.org/packages/9f/e0/6cbe77a53acf5acc7c08cc186c9928864bd7c005f9efd0d126884858a5fe/cffi-2.0.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9332088d75dc3241c702d852d4671613136d90fa6881da7d770a483fd05248b4", size = 203079, upload-time = "2025-09-08T23:22:15.769Z" }, + { url = "https://files.pythonhosted.org/packages/98/29/9b366e70e243eb3d14a5cb488dfd3a0b6b2f1fb001a203f653b93ccfac88/cffi-2.0.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc7de24befaeae77ba923797c7c87834c73648a05a4bde34b3b7e5588973a453", size = 216475, upload-time = "2025-09-08T23:22:17.427Z" }, + { url = "https://files.pythonhosted.org/packages/21/7a/13b24e70d2f90a322f2900c5d8e1f14fa7e2a6b3332b7309ba7b2ba51a5a/cffi-2.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cf364028c016c03078a23b503f02058f1814320a56ad535686f90565636a9495", size = 218829, upload-time = "2025-09-08T23:22:19.069Z" }, + { url = "https://files.pythonhosted.org/packages/60/99/c9dc110974c59cc981b1f5b66e1d8af8af764e00f0293266824d9c4254bc/cffi-2.0.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e11e82b744887154b182fd3e7e8512418446501191994dbf9c9fc1f32cc8efd5", size = 211211, upload-time = "2025-09-08T23:22:20.588Z" }, + { url = "https://files.pythonhosted.org/packages/49/72/ff2d12dbf21aca1b32a40ed792ee6b40f6dc3a9cf1644bd7ef6e95e0ac5e/cffi-2.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8ea985900c5c95ce9db1745f7933eeef5d314f0565b27625d9a10ec9881e1bfb", size = 218036, upload-time = "2025-09-08T23:22:22.143Z" }, + { url = "https://files.pythonhosted.org/packages/e2/cc/027d7fb82e58c48ea717149b03bcadcbdc293553edb283af792bd4bcbb3f/cffi-2.0.0-cp310-cp310-win32.whl", hash = "sha256:1f72fb8906754ac8a2cc3f9f5aaa298070652a0ffae577e0ea9bd480dc3c931a", size = 172184, upload-time = "2025-09-08T23:22:23.328Z" }, + { url = "https://files.pythonhosted.org/packages/33/fa/072dd15ae27fbb4e06b437eb6e944e75b068deb09e2a2826039e49ee2045/cffi-2.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:b18a3ed7d5b3bd8d9ef7a8cb226502c6bf8308df1525e1cc676c3680e7176739", size = 182790, upload-time = "2025-09-08T23:22:24.752Z" }, + { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" }, + { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" }, + { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" }, + { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" }, + { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" }, + { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" }, + { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" }, + { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" }, + { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" }, + { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" }, + { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" }, + { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" }, + { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" }, + { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" }, + { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" }, + { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" }, + { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" }, + { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" }, + { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" }, + { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" }, + { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" }, + { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" }, + { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" }, + { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" }, + { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" }, + { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" }, + { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" }, + { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" }, + { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" }, + { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" }, + { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" }, + { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" }, + { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" }, + { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" }, + { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" }, + { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" }, + { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" }, + { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" }, + { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" }, + { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" }, + { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" }, + { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" }, + { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" }, + { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" }, + { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" }, + { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" }, + { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" }, +] + +[[package]] +name = "cfgv" +version = "3.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/11/74/539e56497d9bd1d484fd863dd69cbbfa653cd2aa27abfe35653494d85e94/cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560", size = 7114, upload-time = "2023-08-12T20:38:17.776Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c5/55/51844dd50c4fc7a33b653bfaba4c2456f06955289ca770a5dbd5fd267374/cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9", size = 7249, upload-time = "2023-08-12T20:38:16.269Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1f/b8/6d51fc1d52cbd52cd4ccedd5b5b2f0f6a11bbf6765c782298b0f3e808541/charset_normalizer-3.4.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e824f1492727fa856dd6eda4f7cee25f8518a12f3c4a56a74e8095695089cf6d", size = 209709, upload-time = "2025-10-14T04:40:11.385Z" }, + { url = "https://files.pythonhosted.org/packages/5c/af/1f9d7f7faafe2ddfb6f72a2e07a548a629c61ad510fe60f9630309908fef/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4bd5d4137d500351a30687c2d3971758aac9a19208fc110ccb9d7188fbe709e8", size = 148814, upload-time = "2025-10-14T04:40:13.135Z" }, + { url = "https://files.pythonhosted.org/packages/79/3d/f2e3ac2bbc056ca0c204298ea4e3d9db9b4afe437812638759db2c976b5f/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:027f6de494925c0ab2a55eab46ae5129951638a49a34d87f4c3eda90f696b4ad", size = 144467, upload-time = "2025-10-14T04:40:14.728Z" }, + { url = "https://files.pythonhosted.org/packages/ec/85/1bf997003815e60d57de7bd972c57dc6950446a3e4ccac43bc3070721856/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f820802628d2694cb7e56db99213f930856014862f3fd943d290ea8438d07ca8", size = 162280, upload-time = "2025-10-14T04:40:16.14Z" }, + { url = "https://files.pythonhosted.org/packages/3e/8e/6aa1952f56b192f54921c436b87f2aaf7c7a7c3d0d1a765547d64fd83c13/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:798d75d81754988d2565bff1b97ba5a44411867c0cf32b77a7e8f8d84796b10d", size = 159454, upload-time = "2025-10-14T04:40:17.567Z" }, + { url = "https://files.pythonhosted.org/packages/36/3b/60cbd1f8e93aa25d1c669c649b7a655b0b5fb4c571858910ea9332678558/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d1bb833febdff5c8927f922386db610b49db6e0d4f4ee29601d71e7c2694313", size = 153609, upload-time = "2025-10-14T04:40:19.08Z" }, + { url = "https://files.pythonhosted.org/packages/64/91/6a13396948b8fd3c4b4fd5bc74d045f5637d78c9675585e8e9fbe5636554/charset_normalizer-3.4.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9cd98cdc06614a2f768d2b7286d66805f94c48cde050acdbbb7db2600ab3197e", size = 151849, upload-time = "2025-10-14T04:40:20.607Z" }, + { url = "https://files.pythonhosted.org/packages/b7/7a/59482e28b9981d105691e968c544cc0df3b7d6133152fb3dcdc8f135da7a/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:077fbb858e903c73f6c9db43374fd213b0b6a778106bc7032446a8e8b5b38b93", size = 151586, upload-time = "2025-10-14T04:40:21.719Z" }, + { url = "https://files.pythonhosted.org/packages/92/59/f64ef6a1c4bdd2baf892b04cd78792ed8684fbc48d4c2afe467d96b4df57/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:244bfb999c71b35de57821b8ea746b24e863398194a4014e4c76adc2bbdfeff0", size = 145290, upload-time = "2025-10-14T04:40:23.069Z" }, + { url = "https://files.pythonhosted.org/packages/6b/63/3bf9f279ddfa641ffa1962b0db6a57a9c294361cc2f5fcac997049a00e9c/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:64b55f9dce520635f018f907ff1b0df1fdc31f2795a922fb49dd14fbcdf48c84", size = 163663, upload-time = "2025-10-14T04:40:24.17Z" }, + { url = "https://files.pythonhosted.org/packages/ed/09/c9e38fc8fa9e0849b172b581fd9803bdf6e694041127933934184e19f8c3/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:faa3a41b2b66b6e50f84ae4a68c64fcd0c44355741c6374813a800cd6695db9e", size = 151964, upload-time = "2025-10-14T04:40:25.368Z" }, + { url = "https://files.pythonhosted.org/packages/d2/d1/d28b747e512d0da79d8b6a1ac18b7ab2ecfd81b2944c4c710e166d8dd09c/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:6515f3182dbe4ea06ced2d9e8666d97b46ef4c75e326b79bb624110f122551db", size = 161064, upload-time = "2025-10-14T04:40:26.806Z" }, + { url = "https://files.pythonhosted.org/packages/bb/9a/31d62b611d901c3b9e5500c36aab0ff5eb442043fb3a1c254200d3d397d9/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cc00f04ed596e9dc0da42ed17ac5e596c6ccba999ba6bd92b0e0aef2f170f2d6", size = 155015, upload-time = "2025-10-14T04:40:28.284Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f3/107e008fa2bff0c8b9319584174418e5e5285fef32f79d8ee6a430d0039c/charset_normalizer-3.4.4-cp310-cp310-win32.whl", hash = "sha256:f34be2938726fc13801220747472850852fe6b1ea75869a048d6f896838c896f", size = 99792, upload-time = "2025-10-14T04:40:29.613Z" }, + { url = "https://files.pythonhosted.org/packages/eb/66/e396e8a408843337d7315bab30dbf106c38966f1819f123257f5520f8a96/charset_normalizer-3.4.4-cp310-cp310-win_amd64.whl", hash = "sha256:a61900df84c667873b292c3de315a786dd8dac506704dea57bc957bd31e22c7d", size = 107198, upload-time = "2025-10-14T04:40:30.644Z" }, + { url = "https://files.pythonhosted.org/packages/b5/58/01b4f815bf0312704c267f2ccb6e5d42bcc7752340cd487bc9f8c3710597/charset_normalizer-3.4.4-cp310-cp310-win_arm64.whl", hash = "sha256:cead0978fc57397645f12578bfd2d5ea9138ea0fac82b2f63f7f7c6877986a69", size = 100262, upload-time = "2025-10-14T04:40:32.108Z" }, + { url = "https://files.pythonhosted.org/packages/ed/27/c6491ff4954e58a10f69ad90aca8a1b6fe9c5d3c6f380907af3c37435b59/charset_normalizer-3.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8", size = 206988, upload-time = "2025-10-14T04:40:33.79Z" }, + { url = "https://files.pythonhosted.org/packages/94/59/2e87300fe67ab820b5428580a53cad894272dbb97f38a7a814a2a1ac1011/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0", size = 147324, upload-time = "2025-10-14T04:40:34.961Z" }, + { url = "https://files.pythonhosted.org/packages/07/fb/0cf61dc84b2b088391830f6274cb57c82e4da8bbc2efeac8c025edb88772/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3", size = 142742, upload-time = "2025-10-14T04:40:36.105Z" }, + { url = "https://files.pythonhosted.org/packages/62/8b/171935adf2312cd745d290ed93cf16cf0dfe320863ab7cbeeae1dcd6535f/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc", size = 160863, upload-time = "2025-10-14T04:40:37.188Z" }, + { url = "https://files.pythonhosted.org/packages/09/73/ad875b192bda14f2173bfc1bc9a55e009808484a4b256748d931b6948442/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897", size = 157837, upload-time = "2025-10-14T04:40:38.435Z" }, + { url = "https://files.pythonhosted.org/packages/6d/fc/de9cce525b2c5b94b47c70a4b4fb19f871b24995c728e957ee68ab1671ea/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381", size = 151550, upload-time = "2025-10-14T04:40:40.053Z" }, + { url = "https://files.pythonhosted.org/packages/55/c2/43edd615fdfba8c6f2dfbd459b25a6b3b551f24ea21981e23fb768503ce1/charset_normalizer-3.4.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815", size = 149162, upload-time = "2025-10-14T04:40:41.163Z" }, + { url = "https://files.pythonhosted.org/packages/03/86/bde4ad8b4d0e9429a4e82c1e8f5c659993a9a863ad62c7df05cf7b678d75/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0", size = 150019, upload-time = "2025-10-14T04:40:42.276Z" }, + { url = "https://files.pythonhosted.org/packages/1f/86/a151eb2af293a7e7bac3a739b81072585ce36ccfb4493039f49f1d3cae8c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161", size = 143310, upload-time = "2025-10-14T04:40:43.439Z" }, + { url = "https://files.pythonhosted.org/packages/b5/fe/43dae6144a7e07b87478fdfc4dbe9efd5defb0e7ec29f5f58a55aeef7bf7/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4", size = 162022, upload-time = "2025-10-14T04:40:44.547Z" }, + { url = "https://files.pythonhosted.org/packages/80/e6/7aab83774f5d2bca81f42ac58d04caf44f0cc2b65fc6db2b3b2e8a05f3b3/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89", size = 149383, upload-time = "2025-10-14T04:40:46.018Z" }, + { url = "https://files.pythonhosted.org/packages/4f/e8/b289173b4edae05c0dde07f69f8db476a0b511eac556dfe0d6bda3c43384/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569", size = 159098, upload-time = "2025-10-14T04:40:47.081Z" }, + { url = "https://files.pythonhosted.org/packages/d8/df/fe699727754cae3f8478493c7f45f777b17c3ef0600e28abfec8619eb49c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224", size = 152991, upload-time = "2025-10-14T04:40:48.246Z" }, + { url = "https://files.pythonhosted.org/packages/1a/86/584869fe4ddb6ffa3bd9f491b87a01568797fb9bd8933f557dba9771beaf/charset_normalizer-3.4.4-cp311-cp311-win32.whl", hash = "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a", size = 99456, upload-time = "2025-10-14T04:40:49.376Z" }, + { url = "https://files.pythonhosted.org/packages/65/f6/62fdd5feb60530f50f7e38b4f6a1d5203f4d16ff4f9f0952962c044e919a/charset_normalizer-3.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016", size = 106978, upload-time = "2025-10-14T04:40:50.844Z" }, + { url = "https://files.pythonhosted.org/packages/7a/9d/0710916e6c82948b3be62d9d398cb4fcf4e97b56d6a6aeccd66c4b2f2bd5/charset_normalizer-3.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1", size = 99969, upload-time = "2025-10-14T04:40:52.272Z" }, + { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425, upload-time = "2025-10-14T04:40:53.353Z" }, + { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162, upload-time = "2025-10-14T04:40:54.558Z" }, + { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558, upload-time = "2025-10-14T04:40:55.677Z" }, + { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497, upload-time = "2025-10-14T04:40:57.217Z" }, + { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240, upload-time = "2025-10-14T04:40:58.358Z" }, + { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471, upload-time = "2025-10-14T04:40:59.468Z" }, + { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864, upload-time = "2025-10-14T04:41:00.623Z" }, + { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647, upload-time = "2025-10-14T04:41:01.754Z" }, + { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110, upload-time = "2025-10-14T04:41:03.231Z" }, + { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839, upload-time = "2025-10-14T04:41:04.715Z" }, + { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667, upload-time = "2025-10-14T04:41:05.827Z" }, + { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535, upload-time = "2025-10-14T04:41:06.938Z" }, + { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816, upload-time = "2025-10-14T04:41:08.101Z" }, + { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694, upload-time = "2025-10-14T04:41:09.23Z" }, + { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131, upload-time = "2025-10-14T04:41:10.467Z" }, + { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390, upload-time = "2025-10-14T04:41:11.915Z" }, + { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" }, + { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" }, + { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" }, + { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" }, + { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" }, + { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" }, + { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" }, + { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" }, + { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" }, + { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" }, + { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" }, + { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" }, + { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" }, + { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" }, + { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" }, + { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" }, + { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" }, + { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" }, + { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" }, + { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" }, + { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" }, + { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" }, + { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" }, + { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" }, + { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" }, + { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" }, + { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" }, + { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" }, + { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" }, + { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" }, + { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" }, + { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" }, +] + +[[package]] +name = "click" +version = "8.1.8" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593, upload-time = "2024-12-21T18:38:44.339Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2", size = 98188, upload-time = "2024-12-21T18:38:41.666Z" }, +] + +[[package]] +name = "click-option-group" +version = "0.5.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/ff/d291d66595b30b83d1cb9e314b2c9be7cfc7327d4a0d40a15da2416ea97b/click_option_group-0.5.9.tar.gz", hash = "sha256:f94ed2bc4cf69052e0f29592bd1e771a1789bd7bfc482dd0bc482134aff95823", size = 22222, upload-time = "2025-10-09T09:38:01.474Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/75/45/54bb2d8d4138964a94bef6e9afe48b0be4705ba66ac442ae7d8a8dc4ffef/click_option_group-0.5.9-py3-none-any.whl", hash = "sha256:ad2599248bd373e2e19bec5407967c3eec1d0d4fc4a5e77b08a0481e75991080", size = 11553, upload-time = "2025-10-09T09:38:00.066Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "coverage" +version = "7.11.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1c/38/ee22495420457259d2f3390309505ea98f98a5eed40901cf62196abad006/coverage-7.11.0.tar.gz", hash = "sha256:167bd504ac1ca2af7ff3b81d245dfea0292c5032ebef9d66cc08a7d28c1b8050", size = 811905, upload-time = "2025-10-15T15:15:08.542Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/95/c49df0aceb5507a80b9fe5172d3d39bf23f05be40c23c8d77d556df96cec/coverage-7.11.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:eb53f1e8adeeb2e78962bade0c08bfdc461853c7969706ed901821e009b35e31", size = 215800, upload-time = "2025-10-15T15:12:19.824Z" }, + { url = "https://files.pythonhosted.org/packages/dc/c6/7bb46ce01ed634fff1d7bb53a54049f539971862cc388b304ff3c51b4f66/coverage-7.11.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d9a03ec6cb9f40a5c360f138b88266fd8f58408d71e89f536b4f91d85721d075", size = 216198, upload-time = "2025-10-15T15:12:22.549Z" }, + { url = "https://files.pythonhosted.org/packages/94/b2/75d9d8fbf2900268aca5de29cd0a0fe671b0f69ef88be16767cc3c828b85/coverage-7.11.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0d7f0616c557cbc3d1c2090334eddcbb70e1ae3a40b07222d62b3aa47f608fab", size = 242953, upload-time = "2025-10-15T15:12:24.139Z" }, + { url = "https://files.pythonhosted.org/packages/65/ac/acaa984c18f440170525a8743eb4b6c960ace2dbad80dc22056a437fc3c6/coverage-7.11.0-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e44a86a47bbdf83b0a3ea4d7df5410d6b1a0de984fbd805fa5101f3624b9abe0", size = 244766, upload-time = "2025-10-15T15:12:25.974Z" }, + { url = "https://files.pythonhosted.org/packages/d8/0d/938d0bff76dfa4a6b228c3fc4b3e1c0e2ad4aa6200c141fcda2bd1170227/coverage-7.11.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:596763d2f9a0ee7eec6e643e29660def2eef297e1de0d334c78c08706f1cb785", size = 246625, upload-time = "2025-10-15T15:12:27.387Z" }, + { url = "https://files.pythonhosted.org/packages/38/54/8f5f5e84bfa268df98f46b2cb396b1009734cfb1e5d6adb663d284893b32/coverage-7.11.0-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ef55537ff511b5e0a43edb4c50a7bf7ba1c3eea20b4f49b1490f1e8e0e42c591", size = 243568, upload-time = "2025-10-15T15:12:28.799Z" }, + { url = "https://files.pythonhosted.org/packages/68/30/8ba337c2877fe3f2e1af0ed7ff4be0c0c4aca44d6f4007040f3ca2255e99/coverage-7.11.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:9cbabd8f4d0d3dc571d77ae5bdbfa6afe5061e679a9d74b6797c48d143307088", size = 244665, upload-time = "2025-10-15T15:12:30.297Z" }, + { url = "https://files.pythonhosted.org/packages/cc/fb/c6f1d6d9a665536b7dde2333346f0cc41dc6a60bd1ffc10cd5c33e7eb000/coverage-7.11.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e24045453384e0ae2a587d562df2a04d852672eb63051d16096d3f08aa4c7c2f", size = 242681, upload-time = "2025-10-15T15:12:32.326Z" }, + { url = "https://files.pythonhosted.org/packages/be/38/1b532319af5f991fa153c20373291dc65c2bf532af7dbcffdeef745c8f79/coverage-7.11.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:7161edd3426c8d19bdccde7d49e6f27f748f3c31cc350c5de7c633fea445d866", size = 242912, upload-time = "2025-10-15T15:12:34.079Z" }, + { url = "https://files.pythonhosted.org/packages/67/3d/f39331c60ef6050d2a861dc1b514fa78f85f792820b68e8c04196ad733d6/coverage-7.11.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3d4ed4de17e692ba6415b0587bc7f12bc80915031fc9db46a23ce70fc88c9841", size = 243559, upload-time = "2025-10-15T15:12:35.809Z" }, + { url = "https://files.pythonhosted.org/packages/4b/55/cb7c9df9d0495036ce582a8a2958d50c23cd73f84a23284bc23bd4711a6f/coverage-7.11.0-cp310-cp310-win32.whl", hash = "sha256:765c0bc8fe46f48e341ef737c91c715bd2a53a12792592296a095f0c237e09cf", size = 218266, upload-time = "2025-10-15T15:12:37.429Z" }, + { url = "https://files.pythonhosted.org/packages/68/a8/b79cb275fa7bd0208767f89d57a1b5f6ba830813875738599741b97c2e04/coverage-7.11.0-cp310-cp310-win_amd64.whl", hash = "sha256:24d6f3128f1b2d20d84b24f4074475457faedc3d4613a7e66b5e769939c7d969", size = 219169, upload-time = "2025-10-15T15:12:39.25Z" }, + { url = "https://files.pythonhosted.org/packages/49/3a/ee1074c15c408ddddddb1db7dd904f6b81bc524e01f5a1c5920e13dbde23/coverage-7.11.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3d58ecaa865c5b9fa56e35efc51d1014d4c0d22838815b9fce57a27dd9576847", size = 215912, upload-time = "2025-10-15T15:12:40.665Z" }, + { url = "https://files.pythonhosted.org/packages/70/c4/9f44bebe5cb15f31608597b037d78799cc5f450044465bcd1ae8cb222fe1/coverage-7.11.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b679e171f1c104a5668550ada700e3c4937110dbdd153b7ef9055c4f1a1ee3cc", size = 216310, upload-time = "2025-10-15T15:12:42.461Z" }, + { url = "https://files.pythonhosted.org/packages/42/01/5e06077cfef92d8af926bdd86b84fb28bf9bc6ad27343d68be9b501d89f2/coverage-7.11.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:ca61691ba8c5b6797deb221a0d09d7470364733ea9c69425a640f1f01b7c5bf0", size = 246706, upload-time = "2025-10-15T15:12:44.001Z" }, + { url = "https://files.pythonhosted.org/packages/40/b8/7a3f1f33b35cc4a6c37e759137533119560d06c0cc14753d1a803be0cd4a/coverage-7.11.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:aef1747ede4bd8ca9cfc04cc3011516500c6891f1b33a94add3253f6f876b7b7", size = 248634, upload-time = "2025-10-15T15:12:45.768Z" }, + { url = "https://files.pythonhosted.org/packages/7a/41/7f987eb33de386bc4c665ab0bf98d15fcf203369d6aacae74f5dd8ec489a/coverage-7.11.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1839d08406e4cba2953dcc0ffb312252f14d7c4c96919f70167611f4dee2623", size = 250741, upload-time = "2025-10-15T15:12:47.222Z" }, + { url = "https://files.pythonhosted.org/packages/23/c1/a4e0ca6a4e83069fb8216b49b30a7352061ca0cb38654bd2dc96b7b3b7da/coverage-7.11.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e0eb0a2dcc62478eb5b4cbb80b97bdee852d7e280b90e81f11b407d0b81c4287", size = 246837, upload-time = "2025-10-15T15:12:48.904Z" }, + { url = "https://files.pythonhosted.org/packages/5d/03/ced062a17f7c38b4728ff76c3acb40d8465634b20b4833cdb3cc3a74e115/coverage-7.11.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bc1fbea96343b53f65d5351d8fd3b34fd415a2670d7c300b06d3e14a5af4f552", size = 248429, upload-time = "2025-10-15T15:12:50.73Z" }, + { url = "https://files.pythonhosted.org/packages/97/af/a7c6f194bb8c5a2705ae019036b8fe7f49ea818d638eedb15fdb7bed227c/coverage-7.11.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:214b622259dd0cf435f10241f1333d32caa64dbc27f8790ab693428a141723de", size = 246490, upload-time = "2025-10-15T15:12:52.646Z" }, + { url = "https://files.pythonhosted.org/packages/ab/c3/aab4df02b04a8fde79068c3c41ad7a622b0ef2b12e1ed154da986a727c3f/coverage-7.11.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:258d9967520cca899695d4eb7ea38be03f06951d6ca2f21fb48b1235f791e601", size = 246208, upload-time = "2025-10-15T15:12:54.586Z" }, + { url = "https://files.pythonhosted.org/packages/30/d8/e282ec19cd658238d60ed404f99ef2e45eed52e81b866ab1518c0d4163cf/coverage-7.11.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:cf9e6ff4ca908ca15c157c409d608da77a56a09877b97c889b98fb2c32b6465e", size = 247126, upload-time = "2025-10-15T15:12:56.485Z" }, + { url = "https://files.pythonhosted.org/packages/d1/17/a635fa07fac23adb1a5451ec756216768c2767efaed2e4331710342a3399/coverage-7.11.0-cp311-cp311-win32.whl", hash = "sha256:fcc15fc462707b0680cff6242c48625da7f9a16a28a41bb8fd7a4280920e676c", size = 218314, upload-time = "2025-10-15T15:12:58.365Z" }, + { url = "https://files.pythonhosted.org/packages/2a/29/2ac1dfcdd4ab9a70026edc8d715ece9b4be9a1653075c658ee6f271f394d/coverage-7.11.0-cp311-cp311-win_amd64.whl", hash = "sha256:865965bf955d92790f1facd64fe7ff73551bd2c1e7e6b26443934e9701ba30b9", size = 219203, upload-time = "2025-10-15T15:12:59.902Z" }, + { url = "https://files.pythonhosted.org/packages/03/21/5ce8b3a0133179115af4c041abf2ee652395837cb896614beb8ce8ddcfd9/coverage-7.11.0-cp311-cp311-win_arm64.whl", hash = "sha256:5693e57a065760dcbeb292d60cc4d0231a6d4b6b6f6a3191561e1d5e8820b745", size = 217879, upload-time = "2025-10-15T15:13:01.35Z" }, + { url = "https://files.pythonhosted.org/packages/c4/db/86f6906a7c7edc1a52b2c6682d6dd9be775d73c0dfe2b84f8923dfea5784/coverage-7.11.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9c49e77811cf9d024b95faf86c3f059b11c0c9be0b0d61bc598f453703bd6fd1", size = 216098, upload-time = "2025-10-15T15:13:02.916Z" }, + { url = "https://files.pythonhosted.org/packages/21/54/e7b26157048c7ba555596aad8569ff903d6cd67867d41b75287323678ede/coverage-7.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a61e37a403a778e2cda2a6a39abcc895f1d984071942a41074b5c7ee31642007", size = 216331, upload-time = "2025-10-15T15:13:04.403Z" }, + { url = "https://files.pythonhosted.org/packages/b9/19/1ce6bf444f858b83a733171306134a0544eaddf1ca8851ede6540a55b2ad/coverage-7.11.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:c79cae102bb3b1801e2ef1511fb50e91ec83a1ce466b2c7c25010d884336de46", size = 247825, upload-time = "2025-10-15T15:13:05.92Z" }, + { url = "https://files.pythonhosted.org/packages/71/0b/d3bcbbc259fcced5fb67c5d78f6e7ee965f49760c14afd931e9e663a83b2/coverage-7.11.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:16ce17ceb5d211f320b62df002fa7016b7442ea0fd260c11cec8ce7730954893", size = 250573, upload-time = "2025-10-15T15:13:07.471Z" }, + { url = "https://files.pythonhosted.org/packages/58/8d/b0ff3641a320abb047258d36ed1c21d16be33beed4152628331a1baf3365/coverage-7.11.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:80027673e9d0bd6aef86134b0771845e2da85755cf686e7c7c59566cf5a89115", size = 251706, upload-time = "2025-10-15T15:13:09.4Z" }, + { url = "https://files.pythonhosted.org/packages/59/c8/5a586fe8c7b0458053d9c687f5cff515a74b66c85931f7fe17a1c958b4ac/coverage-7.11.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4d3ffa07a08657306cd2215b0da53761c4d73cb54d9143b9303a6481ec0cd415", size = 248221, upload-time = "2025-10-15T15:13:10.964Z" }, + { url = "https://files.pythonhosted.org/packages/d0/ff/3a25e3132804ba44cfa9a778cdf2b73dbbe63ef4b0945e39602fc896ba52/coverage-7.11.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a3b6a5f8b2524fd6c1066bc85bfd97e78709bb5e37b5b94911a6506b65f47186", size = 249624, upload-time = "2025-10-15T15:13:12.5Z" }, + { url = "https://files.pythonhosted.org/packages/c5/12/ff10c8ce3895e1b17a73485ea79ebc1896a9e466a9d0f4aef63e0d17b718/coverage-7.11.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:fcc0a4aa589de34bc56e1a80a740ee0f8c47611bdfb28cd1849de60660f3799d", size = 247744, upload-time = "2025-10-15T15:13:14.554Z" }, + { url = "https://files.pythonhosted.org/packages/16/02/d500b91f5471b2975947e0629b8980e5e90786fe316b6d7299852c1d793d/coverage-7.11.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:dba82204769d78c3fd31b35c3d5f46e06511936c5019c39f98320e05b08f794d", size = 247325, upload-time = "2025-10-15T15:13:16.438Z" }, + { url = "https://files.pythonhosted.org/packages/77/11/dee0284fbbd9cd64cfce806b827452c6df3f100d9e66188e82dfe771d4af/coverage-7.11.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:81b335f03ba67309a95210caf3eb43bd6fe75a4e22ba653ef97b4696c56c7ec2", size = 249180, upload-time = "2025-10-15T15:13:17.959Z" }, + { url = "https://files.pythonhosted.org/packages/59/1b/cdf1def928f0a150a057cab03286774e73e29c2395f0d30ce3d9e9f8e697/coverage-7.11.0-cp312-cp312-win32.whl", hash = "sha256:037b2d064c2f8cc8716fe4d39cb705779af3fbf1ba318dc96a1af858888c7bb5", size = 218479, upload-time = "2025-10-15T15:13:19.608Z" }, + { url = "https://files.pythonhosted.org/packages/ff/55/e5884d55e031da9c15b94b90a23beccc9d6beee65e9835cd6da0a79e4f3a/coverage-7.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:d66c0104aec3b75e5fd897e7940188ea1892ca1d0235316bf89286d6a22568c0", size = 219290, upload-time = "2025-10-15T15:13:21.593Z" }, + { url = "https://files.pythonhosted.org/packages/23/a8/faa930cfc71c1d16bc78f9a19bb73700464f9c331d9e547bfbc1dbd3a108/coverage-7.11.0-cp312-cp312-win_arm64.whl", hash = "sha256:d91ebeac603812a09cf6a886ba6e464f3bbb367411904ae3790dfe28311b15ad", size = 217924, upload-time = "2025-10-15T15:13:23.39Z" }, + { url = "https://files.pythonhosted.org/packages/60/7f/85e4dfe65e400645464b25c036a26ac226cf3a69d4a50c3934c532491cdd/coverage-7.11.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:cc3f49e65ea6e0d5d9bd60368684fe52a704d46f9e7fc413918f18d046ec40e1", size = 216129, upload-time = "2025-10-15T15:13:25.371Z" }, + { url = "https://files.pythonhosted.org/packages/96/5d/dc5fa98fea3c175caf9d360649cb1aa3715e391ab00dc78c4c66fabd7356/coverage-7.11.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f39ae2f63f37472c17b4990f794035c9890418b1b8cca75c01193f3c8d3e01be", size = 216380, upload-time = "2025-10-15T15:13:26.976Z" }, + { url = "https://files.pythonhosted.org/packages/b2/f5/3da9cc9596708273385189289c0e4d8197d37a386bdf17619013554b3447/coverage-7.11.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7db53b5cdd2917b6eaadd0b1251cf4e7d96f4a8d24e174bdbdf2f65b5ea7994d", size = 247375, upload-time = "2025-10-15T15:13:28.923Z" }, + { url = "https://files.pythonhosted.org/packages/65/6c/f7f59c342359a235559d2bc76b0c73cfc4bac7d61bb0df210965cb1ecffd/coverage-7.11.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:10ad04ac3a122048688387828b4537bc9cf60c0bf4869c1e9989c46e45690b82", size = 249978, upload-time = "2025-10-15T15:13:30.525Z" }, + { url = "https://files.pythonhosted.org/packages/e7/8c/042dede2e23525e863bf1ccd2b92689692a148d8b5fd37c37899ba882645/coverage-7.11.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4036cc9c7983a2b1f2556d574d2eb2154ac6ed55114761685657e38782b23f52", size = 251253, upload-time = "2025-10-15T15:13:32.174Z" }, + { url = "https://files.pythonhosted.org/packages/7b/a9/3c58df67bfa809a7bddd786356d9c5283e45d693edb5f3f55d0986dd905a/coverage-7.11.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7ab934dd13b1c5e94b692b1e01bd87e4488cb746e3a50f798cb9464fd128374b", size = 247591, upload-time = "2025-10-15T15:13:34.147Z" }, + { url = "https://files.pythonhosted.org/packages/26/5b/c7f32efd862ee0477a18c41e4761305de6ddd2d49cdeda0c1116227570fd/coverage-7.11.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:59a6e5a265f7cfc05f76e3bb53eca2e0dfe90f05e07e849930fecd6abb8f40b4", size = 249411, upload-time = "2025-10-15T15:13:38.425Z" }, + { url = "https://files.pythonhosted.org/packages/76/b5/78cb4f1e86c1611431c990423ec0768122905b03837e1b4c6a6f388a858b/coverage-7.11.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:df01d6c4c81e15a7c88337b795bb7595a8596e92310266b5072c7e301168efbd", size = 247303, upload-time = "2025-10-15T15:13:40.464Z" }, + { url = "https://files.pythonhosted.org/packages/87/c9/23c753a8641a330f45f221286e707c427e46d0ffd1719b080cedc984ec40/coverage-7.11.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:8c934bd088eed6174210942761e38ee81d28c46de0132ebb1801dbe36a390dcc", size = 247157, upload-time = "2025-10-15T15:13:42.087Z" }, + { url = "https://files.pythonhosted.org/packages/c5/42/6e0cc71dc8a464486e944a4fa0d85bdec031cc2969e98ed41532a98336b9/coverage-7.11.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5a03eaf7ec24078ad64a07f02e30060aaf22b91dedf31a6b24d0d98d2bba7f48", size = 248921, upload-time = "2025-10-15T15:13:43.715Z" }, + { url = "https://files.pythonhosted.org/packages/e8/1c/743c2ef665e6858cccb0f84377dfe3a4c25add51e8c7ef19249be92465b6/coverage-7.11.0-cp313-cp313-win32.whl", hash = "sha256:695340f698a5f56f795b2836abe6fb576e7c53d48cd155ad2f80fd24bc63a040", size = 218526, upload-time = "2025-10-15T15:13:45.336Z" }, + { url = "https://files.pythonhosted.org/packages/ff/d5/226daadfd1bf8ddbccefbd3aa3547d7b960fb48e1bdac124e2dd13a2b71a/coverage-7.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:2727d47fce3ee2bac648528e41455d1b0c46395a087a229deac75e9f88ba5a05", size = 219317, upload-time = "2025-10-15T15:13:47.401Z" }, + { url = "https://files.pythonhosted.org/packages/97/54/47db81dcbe571a48a298f206183ba8a7ba79200a37cd0d9f4788fcd2af4a/coverage-7.11.0-cp313-cp313-win_arm64.whl", hash = "sha256:0efa742f431529699712b92ecdf22de8ff198df41e43aeaaadf69973eb93f17a", size = 217948, upload-time = "2025-10-15T15:13:49.096Z" }, + { url = "https://files.pythonhosted.org/packages/e5/8b/cb68425420154e7e2a82fd779a8cc01549b6fa83c2ad3679cd6c088ebd07/coverage-7.11.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:587c38849b853b157706407e9ebdca8fd12f45869edb56defbef2daa5fb0812b", size = 216837, upload-time = "2025-10-15T15:13:51.09Z" }, + { url = "https://files.pythonhosted.org/packages/33/55/9d61b5765a025685e14659c8d07037247de6383c0385757544ffe4606475/coverage-7.11.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b971bdefdd75096163dd4261c74be813c4508477e39ff7b92191dea19f24cd37", size = 217061, upload-time = "2025-10-15T15:13:52.747Z" }, + { url = "https://files.pythonhosted.org/packages/52/85/292459c9186d70dcec6538f06ea251bc968046922497377bf4a1dc9a71de/coverage-7.11.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:269bfe913b7d5be12ab13a95f3a76da23cf147be7fa043933320ba5625f0a8de", size = 258398, upload-time = "2025-10-15T15:13:54.45Z" }, + { url = "https://files.pythonhosted.org/packages/1f/e2/46edd73fb8bf51446c41148d81944c54ed224854812b6ca549be25113ee0/coverage-7.11.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:dadbcce51a10c07b7c72b0ce4a25e4b6dcb0c0372846afb8e5b6307a121eb99f", size = 260574, upload-time = "2025-10-15T15:13:56.145Z" }, + { url = "https://files.pythonhosted.org/packages/07/5e/1df469a19007ff82e2ca8fe509822820a31e251f80ee7344c34f6cd2ec43/coverage-7.11.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9ed43fa22c6436f7957df036331f8fe4efa7af132054e1844918866cd228af6c", size = 262797, upload-time = "2025-10-15T15:13:58.635Z" }, + { url = "https://files.pythonhosted.org/packages/f9/50/de216b31a1434b94d9b34a964c09943c6be45069ec704bfc379d8d89a649/coverage-7.11.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9516add7256b6713ec08359b7b05aeff8850c98d357784c7205b2e60aa2513fa", size = 257361, upload-time = "2025-10-15T15:14:00.409Z" }, + { url = "https://files.pythonhosted.org/packages/82/1e/3f9f8344a48111e152e0fd495b6fff13cc743e771a6050abf1627a7ba918/coverage-7.11.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:eb92e47c92fcbcdc692f428da67db33337fa213756f7adb6a011f7b5a7a20740", size = 260349, upload-time = "2025-10-15T15:14:02.188Z" }, + { url = "https://files.pythonhosted.org/packages/65/9b/3f52741f9e7d82124272f3070bbe316006a7de1bad1093f88d59bfc6c548/coverage-7.11.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:d06f4fc7acf3cabd6d74941d53329e06bab00a8fe10e4df2714f0b134bfc64ef", size = 258114, upload-time = "2025-10-15T15:14:03.907Z" }, + { url = "https://files.pythonhosted.org/packages/0b/8b/918f0e15f0365d50d3986bbd3338ca01178717ac5678301f3f547b6619e6/coverage-7.11.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:6fbcee1a8f056af07ecd344482f711f563a9eb1c2cad192e87df00338ec3cdb0", size = 256723, upload-time = "2025-10-15T15:14:06.324Z" }, + { url = "https://files.pythonhosted.org/packages/44/9e/7776829f82d3cf630878a7965a7d70cc6ca94f22c7d20ec4944f7148cb46/coverage-7.11.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dbbf012be5f32533a490709ad597ad8a8ff80c582a95adc8d62af664e532f9ca", size = 259238, upload-time = "2025-10-15T15:14:08.002Z" }, + { url = "https://files.pythonhosted.org/packages/9a/b8/49cf253e1e7a3bedb85199b201862dd7ca4859f75b6cf25ffa7298aa0760/coverage-7.11.0-cp313-cp313t-win32.whl", hash = "sha256:cee6291bb4fed184f1c2b663606a115c743df98a537c969c3c64b49989da96c2", size = 219180, upload-time = "2025-10-15T15:14:09.786Z" }, + { url = "https://files.pythonhosted.org/packages/ac/e1/1a541703826be7ae2125a0fb7f821af5729d56bb71e946e7b933cc7a89a4/coverage-7.11.0-cp313-cp313t-win_amd64.whl", hash = "sha256:a386c1061bf98e7ea4758e4313c0ab5ecf57af341ef0f43a0bf26c2477b5c268", size = 220241, upload-time = "2025-10-15T15:14:11.471Z" }, + { url = "https://files.pythonhosted.org/packages/d5/d1/5ee0e0a08621140fd418ec4020f595b4d52d7eb429ae6a0c6542b4ba6f14/coverage-7.11.0-cp313-cp313t-win_arm64.whl", hash = "sha256:f9ea02ef40bb83823b2b04964459d281688fe173e20643870bb5d2edf68bc836", size = 218510, upload-time = "2025-10-15T15:14:13.46Z" }, + { url = "https://files.pythonhosted.org/packages/f4/06/e923830c1985ce808e40a3fa3eb46c13350b3224b7da59757d37b6ce12b8/coverage-7.11.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c770885b28fb399aaf2a65bbd1c12bf6f307ffd112d6a76c5231a94276f0c497", size = 216110, upload-time = "2025-10-15T15:14:15.157Z" }, + { url = "https://files.pythonhosted.org/packages/42/82/cdeed03bfead45203fb651ed756dfb5266028f5f939e7f06efac4041dad5/coverage-7.11.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a3d0e2087dba64c86a6b254f43e12d264b636a39e88c5cc0a01a7c71bcfdab7e", size = 216395, upload-time = "2025-10-15T15:14:16.863Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ba/e1c80caffc3199aa699813f73ff097bc2df7b31642bdbc7493600a8f1de5/coverage-7.11.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:73feb83bb41c32811973b8565f3705caf01d928d972b72042b44e97c71fd70d1", size = 247433, upload-time = "2025-10-15T15:14:18.589Z" }, + { url = "https://files.pythonhosted.org/packages/80/c0/5b259b029694ce0a5bbc1548834c7ba3db41d3efd3474489d7efce4ceb18/coverage-7.11.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c6f31f281012235ad08f9a560976cc2fc9c95c17604ff3ab20120fe480169bca", size = 249970, upload-time = "2025-10-15T15:14:20.307Z" }, + { url = "https://files.pythonhosted.org/packages/8c/86/171b2b5e1aac7e2fd9b43f7158b987dbeb95f06d1fbecad54ad8163ae3e8/coverage-7.11.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9570ad567f880ef675673992222746a124b9595506826b210fbe0ce3f0499cd", size = 251324, upload-time = "2025-10-15T15:14:22.419Z" }, + { url = "https://files.pythonhosted.org/packages/1a/7e/7e10414d343385b92024af3932a27a1caf75c6e27ee88ba211221ff1a145/coverage-7.11.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8badf70446042553a773547a61fecaa734b55dc738cacf20c56ab04b77425e43", size = 247445, upload-time = "2025-10-15T15:14:24.205Z" }, + { url = "https://files.pythonhosted.org/packages/c4/3b/e4f966b21f5be8c4bf86ad75ae94efa0de4c99c7bbb8114476323102e345/coverage-7.11.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a09c1211959903a479e389685b7feb8a17f59ec5a4ef9afde7650bd5eabc2777", size = 249324, upload-time = "2025-10-15T15:14:26.234Z" }, + { url = "https://files.pythonhosted.org/packages/00/a2/8479325576dfcd909244d0df215f077f47437ab852ab778cfa2f8bf4d954/coverage-7.11.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:5ef83b107f50db3f9ae40f69e34b3bd9337456c5a7fe3461c7abf8b75dd666a2", size = 247261, upload-time = "2025-10-15T15:14:28.42Z" }, + { url = "https://files.pythonhosted.org/packages/7b/d8/3a9e2db19d94d65771d0f2e21a9ea587d11b831332a73622f901157cc24b/coverage-7.11.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:f91f927a3215b8907e214af77200250bb6aae36eca3f760f89780d13e495388d", size = 247092, upload-time = "2025-10-15T15:14:30.784Z" }, + { url = "https://files.pythonhosted.org/packages/b3/b1/bbca3c472544f9e2ad2d5116b2379732957048be4b93a9c543fcd0207e5f/coverage-7.11.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:cdbcd376716d6b7fbfeedd687a6c4be019c5a5671b35f804ba76a4c0a778cba4", size = 248755, upload-time = "2025-10-15T15:14:32.585Z" }, + { url = "https://files.pythonhosted.org/packages/89/49/638d5a45a6a0f00af53d6b637c87007eb2297042186334e9923a61aa8854/coverage-7.11.0-cp314-cp314-win32.whl", hash = "sha256:bab7ec4bb501743edc63609320aaec8cd9188b396354f482f4de4d40a9d10721", size = 218793, upload-time = "2025-10-15T15:14:34.972Z" }, + { url = "https://files.pythonhosted.org/packages/30/cc/b675a51f2d068adb3cdf3799212c662239b0ca27f4691d1fff81b92ea850/coverage-7.11.0-cp314-cp314-win_amd64.whl", hash = "sha256:3d4ba9a449e9364a936a27322b20d32d8b166553bfe63059bd21527e681e2fad", size = 219587, upload-time = "2025-10-15T15:14:37.047Z" }, + { url = "https://files.pythonhosted.org/packages/93/98/5ac886876026de04f00820e5094fe22166b98dcb8b426bf6827aaf67048c/coverage-7.11.0-cp314-cp314-win_arm64.whl", hash = "sha256:ce37f215223af94ef0f75ac68ea096f9f8e8c8ec7d6e8c346ee45c0d363f0479", size = 218168, upload-time = "2025-10-15T15:14:38.861Z" }, + { url = "https://files.pythonhosted.org/packages/14/d1/b4145d35b3e3ecf4d917e97fc8895bcf027d854879ba401d9ff0f533f997/coverage-7.11.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:f413ce6e07e0d0dc9c433228727b619871532674b45165abafe201f200cc215f", size = 216850, upload-time = "2025-10-15T15:14:40.651Z" }, + { url = "https://files.pythonhosted.org/packages/ca/d1/7f645fc2eccd318369a8a9948acc447bb7c1ade2911e31d3c5620544c22b/coverage-7.11.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:05791e528a18f7072bf5998ba772fe29db4da1234c45c2087866b5ba4dea710e", size = 217071, upload-time = "2025-10-15T15:14:42.755Z" }, + { url = "https://files.pythonhosted.org/packages/54/7d/64d124649db2737ceced1dfcbdcb79898d5868d311730f622f8ecae84250/coverage-7.11.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cacb29f420cfeb9283b803263c3b9a068924474ff19ca126ba9103e1278dfa44", size = 258570, upload-time = "2025-10-15T15:14:44.542Z" }, + { url = "https://files.pythonhosted.org/packages/6c/3f/6f5922f80dc6f2d8b2c6f974835c43f53eb4257a7797727e6ca5b7b2ec1f/coverage-7.11.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:314c24e700d7027ae3ab0d95fbf8d53544fca1f20345fd30cd219b737c6e58d3", size = 260738, upload-time = "2025-10-15T15:14:46.436Z" }, + { url = "https://files.pythonhosted.org/packages/0e/5f/9e883523c4647c860b3812b417a2017e361eca5b635ee658387dc11b13c1/coverage-7.11.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:630d0bd7a293ad2fc8b4b94e5758c8b2536fdf36c05f1681270203e463cbfa9b", size = 262994, upload-time = "2025-10-15T15:14:48.3Z" }, + { url = "https://files.pythonhosted.org/packages/07/bb/43b5a8e94c09c8bf51743ffc65c4c841a4ca5d3ed191d0a6919c379a1b83/coverage-7.11.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e89641f5175d65e2dbb44db15fe4ea48fade5d5bbb9868fdc2b4fce22f4a469d", size = 257282, upload-time = "2025-10-15T15:14:50.236Z" }, + { url = "https://files.pythonhosted.org/packages/aa/e5/0ead8af411411330b928733e1d201384b39251a5f043c1612970310e8283/coverage-7.11.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c9f08ea03114a637dab06cedb2e914da9dc67fa52c6015c018ff43fdde25b9c2", size = 260430, upload-time = "2025-10-15T15:14:52.413Z" }, + { url = "https://files.pythonhosted.org/packages/ae/66/03dd8bb0ba5b971620dcaac145461950f6d8204953e535d2b20c6b65d729/coverage-7.11.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ce9f3bde4e9b031eaf1eb61df95c1401427029ea1bfddb8621c1161dcb0fa02e", size = 258190, upload-time = "2025-10-15T15:14:54.268Z" }, + { url = "https://files.pythonhosted.org/packages/45/ae/28a9cce40bf3174426cb2f7e71ee172d98e7f6446dff936a7ccecee34b14/coverage-7.11.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:e4dc07e95495923d6fd4d6c27bf70769425b71c89053083843fd78f378558996", size = 256658, upload-time = "2025-10-15T15:14:56.436Z" }, + { url = "https://files.pythonhosted.org/packages/5c/7c/3a44234a8599513684bfc8684878fd7b126c2760f79712bb78c56f19efc4/coverage-7.11.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:424538266794db2861db4922b05d729ade0940ee69dcf0591ce8f69784db0e11", size = 259342, upload-time = "2025-10-15T15:14:58.538Z" }, + { url = "https://files.pythonhosted.org/packages/e1/e6/0108519cba871af0351725ebdb8660fd7a0fe2ba3850d56d32490c7d9b4b/coverage-7.11.0-cp314-cp314t-win32.whl", hash = "sha256:4c1eeb3fb8eb9e0190bebafd0462936f75717687117339f708f395fe455acc73", size = 219568, upload-time = "2025-10-15T15:15:00.382Z" }, + { url = "https://files.pythonhosted.org/packages/c9/76/44ba876e0942b4e62fdde23ccb029ddb16d19ba1bef081edd00857ba0b16/coverage-7.11.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b56efee146c98dbf2cf5cffc61b9829d1e94442df4d7398b26892a53992d3547", size = 220687, upload-time = "2025-10-15T15:15:02.322Z" }, + { url = "https://files.pythonhosted.org/packages/b9/0c/0df55ecb20d0d0ed5c322e10a441775e1a3a5d78c60f0c4e1abfe6fcf949/coverage-7.11.0-cp314-cp314t-win_arm64.whl", hash = "sha256:b5c2705afa83f49bd91962a4094b6b082f94aef7626365ab3f8f4bd159c5acf3", size = 218711, upload-time = "2025-10-15T15:15:04.575Z" }, + { url = "https://files.pythonhosted.org/packages/5f/04/642c1d8a448ae5ea1369eac8495740a79eb4e581a9fb0cbdce56bbf56da1/coverage-7.11.0-py3-none-any.whl", hash = "sha256:4b7589765348d78fb4e5fb6ea35d07564e387da2fc5efff62e0222971f155f68", size = 207761, upload-time = "2025-10-15T15:15:06.439Z" }, +] + +[package.optional-dependencies] +toml = [ + { name = "tomli", marker = "python_full_version <= '3.11'" }, +] + +[[package]] +name = "cyclonedx-python-lib" +version = "9.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "license-expression" }, + { name = "packageurl-python" }, + { name = "py-serializable" }, + { name = "sortedcontainers" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/fc/abaad5482f7b59c9a0a9d8f354ce4ce23346d582a0d85730b559562bbeb4/cyclonedx_python_lib-9.1.0.tar.gz", hash = "sha256:86935f2c88a7b47a529b93c724dbd3e903bc573f6f8bd977628a7ca1b5dadea1", size = 1048735, upload-time = "2025-02-27T17:23:40.367Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/53/f1/f3be2e9820a2c26fa77622223e91f9c504e1581830930d477e06146073f4/cyclonedx_python_lib-9.1.0-py3-none-any.whl", hash = "sha256:55693fca8edaecc3363b24af14e82cc6e659eb1e8353e58b587c42652ce0fb52", size = 374968, upload-time = "2025-02-27T17:23:37.766Z" }, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520, upload-time = "2021-03-08T10:59:26.269Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604, upload-time = "2021-03-08T10:59:24.45Z" }, +] + +[[package]] +name = "deprecated" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wrapt" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/49/85/12f0a49a7c4ffb70572b6c2ef13c90c88fd190debda93b23f026b25f9634/deprecated-1.3.1.tar.gz", hash = "sha256:b1b50e0ff0c1fddaa5708a2c6b0a6588bb09b892825ab2b214ac9ea9d92a5223", size = 2932523, upload-time = "2025-10-30T08:19:02.757Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/d0/205d54408c08b13550c733c4b85429e7ead111c7f0014309637425520a9a/deprecated-1.3.1-py2.py3-none-any.whl", hash = "sha256:597bfef186b6f60181535a29fbe44865ce137a5079f295b479886c82729d5f3f", size = 11298, upload-time = "2025-10-30T08:19:00.758Z" }, +] + +[[package]] +name = "distlib" +version = "0.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/96/8e/709914eb2b5749865801041647dc7f4e6d00b549cfe88b65ca192995f07c/distlib-0.4.0.tar.gz", hash = "sha256:feec40075be03a04501a973d81f633735b4b69f98b05450592310c0f401a4e0d", size = 614605, upload-time = "2025-07-17T16:52:00.465Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/6b/e0547afaf41bf2c42e52430072fa5658766e3d65bd4b03a563d1b6336f57/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16", size = 469047, upload-time = "2025-07-17T16:51:58.613Z" }, +] + +[[package]] +name = "docstring-parser-fork" +version = "0.0.14" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/66/bf/27f9cab2f0cd1d17a4420572088bbc19f36d726fbcf165edf226a8926dbc/docstring_parser_fork-0.0.14.tar.gz", hash = "sha256:a2743a63d8d36c09650594f7b4ab5b2758fee8629dcf794d1b221b23179baa5c", size = 34551, upload-time = "2025-09-07T17:27:38.272Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bf/50/98b146aea0f1cd7531d25f12bea69fa9ce8d1662124f93fb30dc4511b65e/docstring_parser_fork-0.0.14-py3-none-any.whl", hash = "sha256:4c544f234ef2cc2749a3df32b70c437d77888b1099143a1ad5454452c574b9af", size = 43063, upload-time = "2025-09-07T17:27:37.012Z" }, +] + +[[package]] +name = "docutils" +version = "0.21.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ae/ed/aefcc8cd0ba62a0560c3c18c33925362d46c6075480bfa4df87b28e169a9/docutils-0.21.2.tar.gz", hash = "sha256:3a6b18732edf182daa3cd12775bbb338cf5691468f91eeeb109deff6ebfa986f", size = 2204444, upload-time = "2024-04-23T18:57:18.24Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/d7/9322c609343d929e75e7e5e6255e614fcc67572cfd083959cdef3b7aad79/docutils-0.21.2-py3-none-any.whl", hash = "sha256:dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2", size = 587408, upload-time = "2024-04-23T18:57:14.835Z" }, +] + +[[package]] +name = "dotty-dict" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6a/ab/88d67f02024700b48cd8232579ad1316aa9df2272c63049c27cc094229d6/dotty_dict-1.3.1.tar.gz", hash = "sha256:4b016e03b8ae265539757a53eba24b9bfda506fb94fbce0bee843c6f05541a15", size = 7699, upload-time = "2022-07-09T18:50:57.727Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1a/91/e0d457ee03ec33d79ee2cd8d212debb1bc21dfb99728ae35efdb5832dc22/dotty_dict-1.3.1-py3-none-any.whl", hash = "sha256:5022d234d9922f13aa711b4950372a06a6d64cb6d6db9ba43d0ba133ebfce31f", size = 7014, upload-time = "2022-07-09T18:50:55.058Z" }, +] + +[[package]] +name = "exceptiongroup" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" }, +] + +[[package]] +name = "execnet" +version = "2.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bb/ff/b4c0dc78fbe20c3e59c0c7334de0c27eb4001a2b2017999af398bf730817/execnet-2.1.1.tar.gz", hash = "sha256:5189b52c6121c24feae288166ab41b32549c7e2348652736540b9e6e7d4e72e3", size = 166524, upload-time = "2024-04-08T09:04:19.245Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/09/2aea36ff60d16dd8879bdb2f5b3ee0ba8d08cbbdcdfe870e695ce3784385/execnet-2.1.1-py3-none-any.whl", hash = "sha256:26dee51f1b80cebd6d0ca8e74dd8745419761d3bef34163928cbebbdc4749fdc", size = 40612, upload-time = "2024-04-08T09:04:17.414Z" }, +] + +[[package]] +name = "filelock" +version = "3.20.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1d/65/ce7f1b70157833bf3cb851b556a37d4547ceafc158aa9b34b36782f23696/filelock-3.20.3.tar.gz", hash = "sha256:18c57ee915c7ec61cff0ecf7f0f869936c7c30191bb0cf406f1341778d0834e1", size = 19485, upload-time = "2026-01-09T17:55:05.421Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b5/36/7fb70f04bf00bc646cd5bb45aa9eddb15e19437a28b8fb2b4a5249fac770/filelock-3.20.3-py3-none-any.whl", hash = "sha256:4b0dda527ee31078689fc205ec4f1c1bf7d56cf88b6dc9426c4f230e46c2dce1", size = 16701, upload-time = "2026-01-09T17:55:04.334Z" }, +] + +[[package]] +name = "furo" +version = "2024.8.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beautifulsoup4" }, + { name = "pygments" }, + { name = "sphinx" }, + { name = "sphinx-basic-ng" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a0/e2/d351d69a9a9e4badb4a5be062c2d0e87bd9e6c23b5e57337fef14bef34c8/furo-2024.8.6.tar.gz", hash = "sha256:b63e4cee8abfc3136d3bc03a3d45a76a850bada4d6374d24c1716b0e01394a01", size = 1661506, upload-time = "2024-08-06T08:07:57.567Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/48/e791a7ed487dbb9729ef32bb5d1af16693d8925f4366befef54119b2e576/furo-2024.8.6-py3-none-any.whl", hash = "sha256:6cd97c58b47813d3619e63e9081169880fbe331f0ca883c871ff1f3f11814f5c", size = 341333, upload-time = "2024-08-06T08:07:54.44Z" }, +] + +[[package]] +name = "gitdb" +version = "4.0.12" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "smmap" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/94/63b0fc47eb32792c7ba1fe1b694daec9a63620db1e313033d18140c2320a/gitdb-4.0.12.tar.gz", hash = "sha256:5ef71f855d191a3326fcfbc0d5da835f26b13fbcba60c32c21091c349ffdb571", size = 394684, upload-time = "2025-01-02T07:20:46.413Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/61/5c78b91c3143ed5c14207f463aecfc8f9dbb5092fb2869baf37c273b2705/gitdb-4.0.12-py3-none-any.whl", hash = "sha256:67073e15955400952c6565cc3e707c554a4eea2e428946f7a4c162fab9bd9bcf", size = 62794, upload-time = "2025-01-02T07:20:43.624Z" }, +] + +[[package]] +name = "gitpython" +version = "3.1.45" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "gitdb" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9a/c8/dd58967d119baab745caec2f9d853297cec1989ec1d63f677d3880632b88/gitpython-3.1.45.tar.gz", hash = "sha256:85b0ee964ceddf211c41b9f27a49086010a190fd8132a24e21f362a4b36a791c", size = 215076, upload-time = "2025-07-24T03:45:54.871Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/61/d4b89fec821f72385526e1b9d9a3a0385dda4a72b206d28049e2c7cd39b8/gitpython-3.1.45-py3-none-any.whl", hash = "sha256:8908cb2e02fb3b93b7eb0f2827125cb699869470432cc885f019b8fd0fccff77", size = 208168, upload-time = "2025-07-24T03:45:52.517Z" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, +] + +[[package]] +name = "identify" +version = "2.6.15" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ff/e7/685de97986c916a6d93b3876139e00eef26ad5bbbd61925d670ae8013449/identify-2.6.15.tar.gz", hash = "sha256:e4f4864b96c6557ef2a1e1c951771838f4edc9df3a72ec7118b338801b11c7bf", size = 99311, upload-time = "2025-10-02T17:43:40.631Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/1c/e5fd8f973d4f375adb21565739498e2e9a1e54c858a97b9a8ccfdc81da9b/identify-2.6.15-py2.py3-none-any.whl", hash = "sha256:1181ef7608e00704db228516541eb83a88a9f94433a8c80bb9b5bd54b1d81757", size = 99183, upload-time = "2025-10-02T17:43:39.137Z" }, +] + +[[package]] +name = "idna" +version = "3.11" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" }, +] + +[[package]] +name = "imagesize" +version = "1.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a7/84/62473fb57d61e31fef6e36d64a179c8781605429fd927b5dd608c997be31/imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a", size = 1280026, upload-time = "2022-07-01T12:21:05.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ff/62/85c4c919272577931d407be5ba5d71c20f0b616d31a0befe0ae45bb79abd/imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b", size = 8769, upload-time = "2022-07-01T12:21:02.467Z" }, +] + +[[package]] +name = "importlib-resources" +version = "6.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cf/8c/f834fbf984f691b4f7ff60f50b514cc3de5cc08abfc3295564dd89c5e2e7/importlib_resources-6.5.2.tar.gz", hash = "sha256:185f87adef5bcc288449d98fb4fba07cea78bc036455dd44c5fc4a2fe78fed2c", size = 44693, upload-time = "2025-01-03T18:51:56.698Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a4/ed/1f1afb2e9e7f38a545d628f864d562a5ae64fe6f7a10e28ffb9b185b4e89/importlib_resources-6.5.2-py3-none-any.whl", hash = "sha256:789cfdc3ed28c78b67a06acb8126751ced69a3d5f79c095a98298cd8a760ccec", size = 37461, upload-time = "2025-01-03T18:51:54.306Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, +] + +[[package]] +name = "license-expression" +version = "30.4.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "boolean-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/40/71/d89bb0e71b1415453980fd32315f2a037aad9f7f70f695c7cec7035feb13/license_expression-30.4.4.tar.gz", hash = "sha256:73448f0aacd8d0808895bdc4b2c8e01a8d67646e4188f887375398c761f340fd", size = 186402, upload-time = "2025-07-22T11:13:32.17Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/40/791891d4c0c4dab4c5e187c17261cedc26285fd41541577f900470a45a4d/license_expression-30.4.4-py3-none-any.whl", hash = "sha256:421788fdcadb41f049d2dc934ce666626265aeccefddd25e162a26f23bcbf8a4", size = 120615, upload-time = "2025-07-22T11:13:31.217Z" }, +] + +[[package]] +name = "linkify-it-py" +version = "2.0.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "uc-micro-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2a/ae/bb56c6828e4797ba5a4821eec7c43b8bf40f69cda4d4f5f8c8a2810ec96a/linkify-it-py-2.0.3.tar.gz", hash = "sha256:68cda27e162e9215c17d786649d1da0021a451bdc436ef9e0fa0ba5234b9b048", size = 27946, upload-time = "2024-02-04T14:48:04.179Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/1e/b832de447dee8b582cac175871d2f6c3d5077cc56d5575cadba1fd1cccfa/linkify_it_py-2.0.3-py3-none-any.whl", hash = "sha256:6bcbc417b0ac14323382aef5c5192c0075bf8a9d6b41820a2b66371eac6b6d79", size = 19820, upload-time = "2024-02-04T14:48:02.496Z" }, +] + +[[package]] +name = "markdown-it-py" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596, upload-time = "2023-06-03T06:41:14.443Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528, upload-time = "2023-06-03T06:41:11.019Z" }, +] + +[[package]] +name = "markupsafe" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/4b/3541d44f3937ba468b75da9eebcae497dcf67adb65caa16760b0a6807ebb/markupsafe-3.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559", size = 11631, upload-time = "2025-09-27T18:36:05.558Z" }, + { url = "https://files.pythonhosted.org/packages/98/1b/fbd8eed11021cabd9226c37342fa6ca4e8a98d8188a8d9b66740494960e4/markupsafe-3.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419", size = 12057, upload-time = "2025-09-27T18:36:07.165Z" }, + { url = "https://files.pythonhosted.org/packages/40/01/e560d658dc0bb8ab762670ece35281dec7b6c1b33f5fbc09ebb57a185519/markupsafe-3.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695", size = 22050, upload-time = "2025-09-27T18:36:08.005Z" }, + { url = "https://files.pythonhosted.org/packages/af/cd/ce6e848bbf2c32314c9b237839119c5a564a59725b53157c856e90937b7a/markupsafe-3.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591", size = 20681, upload-time = "2025-09-27T18:36:08.881Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2a/b5c12c809f1c3045c4d580b035a743d12fcde53cf685dbc44660826308da/markupsafe-3.0.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c", size = 20705, upload-time = "2025-09-27T18:36:10.131Z" }, + { url = "https://files.pythonhosted.org/packages/cf/e3/9427a68c82728d0a88c50f890d0fc072a1484de2f3ac1ad0bfc1a7214fd5/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f", size = 21524, upload-time = "2025-09-27T18:36:11.324Z" }, + { url = "https://files.pythonhosted.org/packages/bc/36/23578f29e9e582a4d0278e009b38081dbe363c5e7165113fad546918a232/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6", size = 20282, upload-time = "2025-09-27T18:36:12.573Z" }, + { url = "https://files.pythonhosted.org/packages/56/21/dca11354e756ebd03e036bd8ad58d6d7168c80ce1fe5e75218e4945cbab7/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1", size = 20745, upload-time = "2025-09-27T18:36:13.504Z" }, + { url = "https://files.pythonhosted.org/packages/87/99/faba9369a7ad6e4d10b6a5fbf71fa2a188fe4a593b15f0963b73859a1bbd/markupsafe-3.0.3-cp310-cp310-win32.whl", hash = "sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa", size = 14571, upload-time = "2025-09-27T18:36:14.779Z" }, + { url = "https://files.pythonhosted.org/packages/d6/25/55dc3ab959917602c96985cb1253efaa4ff42f71194bddeb61eb7278b8be/markupsafe-3.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8", size = 15056, upload-time = "2025-09-27T18:36:16.125Z" }, + { url = "https://files.pythonhosted.org/packages/d0/9e/0a02226640c255d1da0b8d12e24ac2aa6734da68bff14c05dd53b94a0fc3/markupsafe-3.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1", size = 13932, upload-time = "2025-09-27T18:36:17.311Z" }, + { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" }, + { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" }, + { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" }, + { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" }, + { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" }, + { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" }, + { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" }, + { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" }, + { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" }, + { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" }, + { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" }, + { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" }, + { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" }, + { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" }, + { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" }, + { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" }, + { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" }, + { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" }, + { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" }, + { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" }, + { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" }, + { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" }, + { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" }, + { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" }, + { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" }, + { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" }, + { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" }, + { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" }, + { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" }, + { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" }, + { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" }, + { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" }, + { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" }, + { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" }, + { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" }, + { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" }, + { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" }, + { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" }, + { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" }, + { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" }, + { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" }, + { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" }, + { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" }, + { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" }, + { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" }, + { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" }, + { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" }, + { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" }, + { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" }, + { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" }, + { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" }, + { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" }, + { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" }, + { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" }, + { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" }, + { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" }, + { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" }, + { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" }, +] + +[[package]] +name = "mdit-py-plugins" +version = "0.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b2/fd/a756d36c0bfba5f6e39a1cdbdbfdd448dc02692467d83816dff4592a1ebc/mdit_py_plugins-0.5.0.tar.gz", hash = "sha256:f4918cb50119f50446560513a8e311d574ff6aaed72606ddae6d35716fe809c6", size = 44655, upload-time = "2025-08-11T07:25:49.083Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/86/dd6e5db36df29e76c7a7699123569a4a18c1623ce68d826ed96c62643cae/mdit_py_plugins-0.5.0-py3-none-any.whl", hash = "sha256:07a08422fc1936a5d26d146759e9155ea466e842f5ab2f7d2266dd084c8dab1f", size = 57205, upload-time = "2025-08-11T07:25:47.597Z" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, +] + +[[package]] +name = "msgpack" +version = "1.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4d/f2/bfb55a6236ed8725a96b0aa3acbd0ec17588e6a2c3b62a93eb513ed8783f/msgpack-1.1.2.tar.gz", hash = "sha256:3b60763c1373dd60f398488069bcdc703cd08a711477b5d480eecc9f9626f47e", size = 173581, upload-time = "2025-10-08T09:15:56.596Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f5/a2/3b68a9e769db68668b25c6108444a35f9bd163bb848c0650d516761a59c0/msgpack-1.1.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0051fffef5a37ca2cd16978ae4f0aef92f164df86823871b5162812bebecd8e2", size = 81318, upload-time = "2025-10-08T09:14:38.722Z" }, + { url = "https://files.pythonhosted.org/packages/5b/e1/2b720cc341325c00be44e1ed59e7cfeae2678329fbf5aa68f5bda57fe728/msgpack-1.1.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a605409040f2da88676e9c9e5853b3449ba8011973616189ea5ee55ddbc5bc87", size = 83786, upload-time = "2025-10-08T09:14:40.082Z" }, + { url = "https://files.pythonhosted.org/packages/71/e5/c2241de64bfceac456b140737812a2ab310b10538a7b34a1d393b748e095/msgpack-1.1.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b696e83c9f1532b4af884045ba7f3aa741a63b2bc22617293a2c6a7c645f251", size = 398240, upload-time = "2025-10-08T09:14:41.151Z" }, + { url = "https://files.pythonhosted.org/packages/b7/09/2a06956383c0fdebaef5aa9246e2356776f12ea6f2a44bd1368abf0e46c4/msgpack-1.1.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:365c0bbe981a27d8932da71af63ef86acc59ed5c01ad929e09a0b88c6294e28a", size = 406070, upload-time = "2025-10-08T09:14:42.821Z" }, + { url = "https://files.pythonhosted.org/packages/0e/74/2957703f0e1ef20637d6aead4fbb314330c26f39aa046b348c7edcf6ca6b/msgpack-1.1.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:41d1a5d875680166d3ac5c38573896453bbbea7092936d2e107214daf43b1d4f", size = 393403, upload-time = "2025-10-08T09:14:44.38Z" }, + { url = "https://files.pythonhosted.org/packages/a5/09/3bfc12aa90f77b37322fc33e7a8a7c29ba7c8edeadfa27664451801b9860/msgpack-1.1.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:354e81bcdebaab427c3df4281187edc765d5d76bfb3a7c125af9da7a27e8458f", size = 398947, upload-time = "2025-10-08T09:14:45.56Z" }, + { url = "https://files.pythonhosted.org/packages/4b/4f/05fcebd3b4977cb3d840f7ef6b77c51f8582086de5e642f3fefee35c86fc/msgpack-1.1.2-cp310-cp310-win32.whl", hash = "sha256:e64c8d2f5e5d5fda7b842f55dec6133260ea8f53c4257d64494c534f306bf7a9", size = 64769, upload-time = "2025-10-08T09:14:47.334Z" }, + { url = "https://files.pythonhosted.org/packages/d0/3e/b4547e3a34210956382eed1c85935fff7e0f9b98be3106b3745d7dec9c5e/msgpack-1.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:db6192777d943bdaaafb6ba66d44bf65aa0e9c5616fa1d2da9bb08828c6b39aa", size = 71293, upload-time = "2025-10-08T09:14:48.665Z" }, + { url = "https://files.pythonhosted.org/packages/2c/97/560d11202bcd537abca693fd85d81cebe2107ba17301de42b01ac1677b69/msgpack-1.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2e86a607e558d22985d856948c12a3fa7b42efad264dca8a3ebbcfa2735d786c", size = 82271, upload-time = "2025-10-08T09:14:49.967Z" }, + { url = "https://files.pythonhosted.org/packages/83/04/28a41024ccbd67467380b6fb440ae916c1e4f25e2cd4c63abe6835ac566e/msgpack-1.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:283ae72fc89da59aa004ba147e8fc2f766647b1251500182fac0350d8af299c0", size = 84914, upload-time = "2025-10-08T09:14:50.958Z" }, + { url = "https://files.pythonhosted.org/packages/71/46/b817349db6886d79e57a966346cf0902a426375aadc1e8e7a86a75e22f19/msgpack-1.1.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:61c8aa3bd513d87c72ed0b37b53dd5c5a0f58f2ff9f26e1555d3bd7948fb7296", size = 416962, upload-time = "2025-10-08T09:14:51.997Z" }, + { url = "https://files.pythonhosted.org/packages/da/e0/6cc2e852837cd6086fe7d8406af4294e66827a60a4cf60b86575a4a65ca8/msgpack-1.1.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:454e29e186285d2ebe65be34629fa0e8605202c60fbc7c4c650ccd41870896ef", size = 426183, upload-time = "2025-10-08T09:14:53.477Z" }, + { url = "https://files.pythonhosted.org/packages/25/98/6a19f030b3d2ea906696cedd1eb251708e50a5891d0978b012cb6107234c/msgpack-1.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7bc8813f88417599564fafa59fd6f95be417179f76b40325b500b3c98409757c", size = 411454, upload-time = "2025-10-08T09:14:54.648Z" }, + { url = "https://files.pythonhosted.org/packages/b7/cd/9098fcb6adb32187a70b7ecaabf6339da50553351558f37600e53a4a2a23/msgpack-1.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bafca952dc13907bdfdedfc6a5f579bf4f292bdd506fadb38389afa3ac5b208e", size = 422341, upload-time = "2025-10-08T09:14:56.328Z" }, + { url = "https://files.pythonhosted.org/packages/e6/ae/270cecbcf36c1dc85ec086b33a51a4d7d08fc4f404bdbc15b582255d05ff/msgpack-1.1.2-cp311-cp311-win32.whl", hash = "sha256:602b6740e95ffc55bfb078172d279de3773d7b7db1f703b2f1323566b878b90e", size = 64747, upload-time = "2025-10-08T09:14:57.882Z" }, + { url = "https://files.pythonhosted.org/packages/2a/79/309d0e637f6f37e83c711f547308b91af02b72d2326ddd860b966080ef29/msgpack-1.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:d198d275222dc54244bf3327eb8cbe00307d220241d9cec4d306d49a44e85f68", size = 71633, upload-time = "2025-10-08T09:14:59.177Z" }, + { url = "https://files.pythonhosted.org/packages/73/4d/7c4e2b3d9b1106cd0aa6cb56cc57c6267f59fa8bfab7d91df5adc802c847/msgpack-1.1.2-cp311-cp311-win_arm64.whl", hash = "sha256:86f8136dfa5c116365a8a651a7d7484b65b13339731dd6faebb9a0242151c406", size = 64755, upload-time = "2025-10-08T09:15:00.48Z" }, + { url = "https://files.pythonhosted.org/packages/ad/bd/8b0d01c756203fbab65d265859749860682ccd2a59594609aeec3a144efa/msgpack-1.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:70a0dff9d1f8da25179ffcf880e10cf1aad55fdb63cd59c9a49a1b82290062aa", size = 81939, upload-time = "2025-10-08T09:15:01.472Z" }, + { url = "https://files.pythonhosted.org/packages/34/68/ba4f155f793a74c1483d4bdef136e1023f7bcba557f0db4ef3db3c665cf1/msgpack-1.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:446abdd8b94b55c800ac34b102dffd2f6aa0ce643c55dfc017ad89347db3dbdb", size = 85064, upload-time = "2025-10-08T09:15:03.764Z" }, + { url = "https://files.pythonhosted.org/packages/f2/60/a064b0345fc36c4c3d2c743c82d9100c40388d77f0b48b2f04d6041dbec1/msgpack-1.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c63eea553c69ab05b6747901b97d620bb2a690633c77f23feb0c6a947a8a7b8f", size = 417131, upload-time = "2025-10-08T09:15:05.136Z" }, + { url = "https://files.pythonhosted.org/packages/65/92/a5100f7185a800a5d29f8d14041f61475b9de465ffcc0f3b9fba606e4505/msgpack-1.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:372839311ccf6bdaf39b00b61288e0557916c3729529b301c52c2d88842add42", size = 427556, upload-time = "2025-10-08T09:15:06.837Z" }, + { url = "https://files.pythonhosted.org/packages/f5/87/ffe21d1bf7d9991354ad93949286f643b2bb6ddbeab66373922b44c3b8cc/msgpack-1.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2929af52106ca73fcb28576218476ffbb531a036c2adbcf54a3664de124303e9", size = 404920, upload-time = "2025-10-08T09:15:08.179Z" }, + { url = "https://files.pythonhosted.org/packages/ff/41/8543ed2b8604f7c0d89ce066f42007faac1eaa7d79a81555f206a5cdb889/msgpack-1.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:be52a8fc79e45b0364210eef5234a7cf8d330836d0a64dfbb878efa903d84620", size = 415013, upload-time = "2025-10-08T09:15:09.83Z" }, + { url = "https://files.pythonhosted.org/packages/41/0d/2ddfaa8b7e1cee6c490d46cb0a39742b19e2481600a7a0e96537e9c22f43/msgpack-1.1.2-cp312-cp312-win32.whl", hash = "sha256:1fff3d825d7859ac888b0fbda39a42d59193543920eda9d9bea44d958a878029", size = 65096, upload-time = "2025-10-08T09:15:11.11Z" }, + { url = "https://files.pythonhosted.org/packages/8c/ec/d431eb7941fb55a31dd6ca3404d41fbb52d99172df2e7707754488390910/msgpack-1.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:1de460f0403172cff81169a30b9a92b260cb809c4cb7e2fc79ae8d0510c78b6b", size = 72708, upload-time = "2025-10-08T09:15:12.554Z" }, + { url = "https://files.pythonhosted.org/packages/c5/31/5b1a1f70eb0e87d1678e9624908f86317787b536060641d6798e3cf70ace/msgpack-1.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:be5980f3ee0e6bd44f3a9e9dea01054f175b50c3e6cdb692bc9424c0bbb8bf69", size = 64119, upload-time = "2025-10-08T09:15:13.589Z" }, + { url = "https://files.pythonhosted.org/packages/6b/31/b46518ecc604d7edf3a4f94cb3bf021fc62aa301f0cb849936968164ef23/msgpack-1.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4efd7b5979ccb539c221a4c4e16aac1a533efc97f3b759bb5a5ac9f6d10383bf", size = 81212, upload-time = "2025-10-08T09:15:14.552Z" }, + { url = "https://files.pythonhosted.org/packages/92/dc/c385f38f2c2433333345a82926c6bfa5ecfff3ef787201614317b58dd8be/msgpack-1.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:42eefe2c3e2af97ed470eec850facbe1b5ad1d6eacdbadc42ec98e7dcf68b4b7", size = 84315, upload-time = "2025-10-08T09:15:15.543Z" }, + { url = "https://files.pythonhosted.org/packages/d3/68/93180dce57f684a61a88a45ed13047558ded2be46f03acb8dec6d7c513af/msgpack-1.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fdf7d83102bf09e7ce3357de96c59b627395352a4024f6e2458501f158bf999", size = 412721, upload-time = "2025-10-08T09:15:16.567Z" }, + { url = "https://files.pythonhosted.org/packages/5d/ba/459f18c16f2b3fc1a1ca871f72f07d70c07bf768ad0a507a698b8052ac58/msgpack-1.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fac4be746328f90caa3cd4bc67e6fe36ca2bf61d5c6eb6d895b6527e3f05071e", size = 424657, upload-time = "2025-10-08T09:15:17.825Z" }, + { url = "https://files.pythonhosted.org/packages/38/f8/4398c46863b093252fe67368b44edc6c13b17f4e6b0e4929dbf0bdb13f23/msgpack-1.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fffee09044073e69f2bad787071aeec727183e7580443dfeb8556cbf1978d162", size = 402668, upload-time = "2025-10-08T09:15:19.003Z" }, + { url = "https://files.pythonhosted.org/packages/28/ce/698c1eff75626e4124b4d78e21cca0b4cc90043afb80a507626ea354ab52/msgpack-1.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5928604de9b032bc17f5099496417f113c45bc6bc21b5c6920caf34b3c428794", size = 419040, upload-time = "2025-10-08T09:15:20.183Z" }, + { url = "https://files.pythonhosted.org/packages/67/32/f3cd1667028424fa7001d82e10ee35386eea1408b93d399b09fb0aa7875f/msgpack-1.1.2-cp313-cp313-win32.whl", hash = "sha256:a7787d353595c7c7e145e2331abf8b7ff1e6673a6b974ded96e6d4ec09f00c8c", size = 65037, upload-time = "2025-10-08T09:15:21.416Z" }, + { url = "https://files.pythonhosted.org/packages/74/07/1ed8277f8653c40ebc65985180b007879f6a836c525b3885dcc6448ae6cb/msgpack-1.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:a465f0dceb8e13a487e54c07d04ae3ba131c7c5b95e2612596eafde1dccf64a9", size = 72631, upload-time = "2025-10-08T09:15:22.431Z" }, + { url = "https://files.pythonhosted.org/packages/e5/db/0314e4e2db56ebcf450f277904ffd84a7988b9e5da8d0d61ab2d057df2b6/msgpack-1.1.2-cp313-cp313-win_arm64.whl", hash = "sha256:e69b39f8c0aa5ec24b57737ebee40be647035158f14ed4b40e6f150077e21a84", size = 64118, upload-time = "2025-10-08T09:15:23.402Z" }, + { url = "https://files.pythonhosted.org/packages/22/71/201105712d0a2ff07b7873ed3c220292fb2ea5120603c00c4b634bcdafb3/msgpack-1.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e23ce8d5f7aa6ea6d2a2b326b4ba46c985dbb204523759984430db7114f8aa00", size = 81127, upload-time = "2025-10-08T09:15:24.408Z" }, + { url = "https://files.pythonhosted.org/packages/1b/9f/38ff9e57a2eade7bf9dfee5eae17f39fc0e998658050279cbb14d97d36d9/msgpack-1.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6c15b7d74c939ebe620dd8e559384be806204d73b4f9356320632d783d1f7939", size = 84981, upload-time = "2025-10-08T09:15:25.812Z" }, + { url = "https://files.pythonhosted.org/packages/8e/a9/3536e385167b88c2cc8f4424c49e28d49a6fc35206d4a8060f136e71f94c/msgpack-1.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99e2cb7b9031568a2a5c73aa077180f93dd2e95b4f8d3b8e14a73ae94a9e667e", size = 411885, upload-time = "2025-10-08T09:15:27.22Z" }, + { url = "https://files.pythonhosted.org/packages/2f/40/dc34d1a8d5f1e51fc64640b62b191684da52ca469da9cd74e84936ffa4a6/msgpack-1.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:180759d89a057eab503cf62eeec0aa61c4ea1200dee709f3a8e9397dbb3b6931", size = 419658, upload-time = "2025-10-08T09:15:28.4Z" }, + { url = "https://files.pythonhosted.org/packages/3b/ef/2b92e286366500a09a67e03496ee8b8ba00562797a52f3c117aa2b29514b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:04fb995247a6e83830b62f0b07bf36540c213f6eac8e851166d8d86d83cbd014", size = 403290, upload-time = "2025-10-08T09:15:29.764Z" }, + { url = "https://files.pythonhosted.org/packages/78/90/e0ea7990abea5764e4655b8177aa7c63cdfa89945b6e7641055800f6c16b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8e22ab046fa7ede9e36eeb4cfad44d46450f37bb05d5ec482b02868f451c95e2", size = 415234, upload-time = "2025-10-08T09:15:31.022Z" }, + { url = "https://files.pythonhosted.org/packages/72/4e/9390aed5db983a2310818cd7d3ec0aecad45e1f7007e0cda79c79507bb0d/msgpack-1.1.2-cp314-cp314-win32.whl", hash = "sha256:80a0ff7d4abf5fecb995fcf235d4064b9a9a8a40a3ab80999e6ac1e30b702717", size = 66391, upload-time = "2025-10-08T09:15:32.265Z" }, + { url = "https://files.pythonhosted.org/packages/6e/f1/abd09c2ae91228c5f3998dbd7f41353def9eac64253de3c8105efa2082f7/msgpack-1.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:9ade919fac6a3e7260b7f64cea89df6bec59104987cbea34d34a2fa15d74310b", size = 73787, upload-time = "2025-10-08T09:15:33.219Z" }, + { url = "https://files.pythonhosted.org/packages/6a/b0/9d9f667ab48b16ad4115c1935d94023b82b3198064cb84a123e97f7466c1/msgpack-1.1.2-cp314-cp314-win_arm64.whl", hash = "sha256:59415c6076b1e30e563eb732e23b994a61c159cec44deaf584e5cc1dd662f2af", size = 66453, upload-time = "2025-10-08T09:15:34.225Z" }, + { url = "https://files.pythonhosted.org/packages/16/67/93f80545eb1792b61a217fa7f06d5e5cb9e0055bed867f43e2b8e012e137/msgpack-1.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:897c478140877e5307760b0ea66e0932738879e7aa68144d9b78ea4c8302a84a", size = 85264, upload-time = "2025-10-08T09:15:35.61Z" }, + { url = "https://files.pythonhosted.org/packages/87/1c/33c8a24959cf193966ef11a6f6a2995a65eb066bd681fd085afd519a57ce/msgpack-1.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a668204fa43e6d02f89dbe79a30b0d67238d9ec4c5bd8a940fc3a004a47b721b", size = 89076, upload-time = "2025-10-08T09:15:36.619Z" }, + { url = "https://files.pythonhosted.org/packages/fc/6b/62e85ff7193663fbea5c0254ef32f0c77134b4059f8da89b958beb7696f3/msgpack-1.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5559d03930d3aa0f3aacb4c42c776af1a2ace2611871c84a75afe436695e6245", size = 435242, upload-time = "2025-10-08T09:15:37.647Z" }, + { url = "https://files.pythonhosted.org/packages/c1/47/5c74ecb4cc277cf09f64e913947871682ffa82b3b93c8dad68083112f412/msgpack-1.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70c5a7a9fea7f036b716191c29047374c10721c389c21e9ffafad04df8c52c90", size = 432509, upload-time = "2025-10-08T09:15:38.794Z" }, + { url = "https://files.pythonhosted.org/packages/24/a4/e98ccdb56dc4e98c929a3f150de1799831c0a800583cde9fa022fa90602d/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f2cb069d8b981abc72b41aea1c580ce92d57c673ec61af4c500153a626cb9e20", size = 415957, upload-time = "2025-10-08T09:15:40.238Z" }, + { url = "https://files.pythonhosted.org/packages/da/28/6951f7fb67bc0a4e184a6b38ab71a92d9ba58080b27a77d3e2fb0be5998f/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d62ce1f483f355f61adb5433ebfd8868c5f078d1a52d042b0a998682b4fa8c27", size = 422910, upload-time = "2025-10-08T09:15:41.505Z" }, + { url = "https://files.pythonhosted.org/packages/f0/03/42106dcded51f0a0b5284d3ce30a671e7bd3f7318d122b2ead66ad289fed/msgpack-1.1.2-cp314-cp314t-win32.whl", hash = "sha256:1d1418482b1ee984625d88aa9585db570180c286d942da463533b238b98b812b", size = 75197, upload-time = "2025-10-08T09:15:42.954Z" }, + { url = "https://files.pythonhosted.org/packages/15/86/d0071e94987f8db59d4eeb386ddc64d0bb9b10820a8d82bcd3e53eeb2da6/msgpack-1.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:5a46bf7e831d09470ad92dff02b8b1ac92175ca36b087f904a0519857c6be3ff", size = 85772, upload-time = "2025-10-08T09:15:43.954Z" }, + { url = "https://files.pythonhosted.org/packages/81/f2/08ace4142eb281c12701fc3b93a10795e4d4dc7f753911d836675050f886/msgpack-1.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d99ef64f349d5ec3293688e91486c5fdb925ed03807f64d98d205d2713c60b46", size = 70868, upload-time = "2025-10-08T09:15:44.959Z" }, +] + +[[package]] +name = "msgpack-types" +version = "0.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "msgpack" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7f/26/a15707f2af5681333cd598724bedd1948844ac2af45eafc4175af0671a8d/msgpack_types-0.5.0.tar.gz", hash = "sha256:aebd1b8da23f8f9966d66ebb1a43bd261b95751c6a267bd21a124d2ccac84201", size = 6702, upload-time = "2024-09-21T13:55:05.587Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/19/dd/cd9d2b0ef506f6164cd81d4e92e408095041f28523d751b9f7dabdc244eb/msgpack_types-0.5.0-py3-none-any.whl", hash = "sha256:8b633ed75e495a555fa0615843de559a74b1d176828d59bb393d266e51f6bda7", size = 8182, upload-time = "2024-09-21T13:55:04.232Z" }, +] + +[[package]] +name = "mypy" +version = "1.18.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mypy-extensions" }, + { name = "pathspec" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/77/8f0d0001ffad290cef2f7f216f96c814866248a0b92a722365ed54648e7e/mypy-1.18.2.tar.gz", hash = "sha256:06a398102a5f203d7477b2923dda3634c36727fa5c237d8f859ef90c42a9924b", size = 3448846, upload-time = "2025-09-19T00:11:10.519Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/03/6f/657961a0743cff32e6c0611b63ff1c1970a0b482ace35b069203bf705187/mypy-1.18.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c1eab0cf6294dafe397c261a75f96dc2c31bffe3b944faa24db5def4e2b0f77c", size = 12807973, upload-time = "2025-09-19T00:10:35.282Z" }, + { url = "https://files.pythonhosted.org/packages/10/e9/420822d4f661f13ca8900f5fa239b40ee3be8b62b32f3357df9a3045a08b/mypy-1.18.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:7a780ca61fc239e4865968ebc5240bb3bf610ef59ac398de9a7421b54e4a207e", size = 11896527, upload-time = "2025-09-19T00:10:55.791Z" }, + { url = "https://files.pythonhosted.org/packages/aa/73/a05b2bbaa7005f4642fcfe40fb73f2b4fb6bb44229bd585b5878e9a87ef8/mypy-1.18.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:448acd386266989ef11662ce3c8011fd2a7b632e0ec7d61a98edd8e27472225b", size = 12507004, upload-time = "2025-09-19T00:11:05.411Z" }, + { url = "https://files.pythonhosted.org/packages/4f/01/f6e4b9f0d031c11ccbd6f17da26564f3a0f3c4155af344006434b0a05a9d/mypy-1.18.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f9e171c465ad3901dc652643ee4bffa8e9fef4d7d0eece23b428908c77a76a66", size = 13245947, upload-time = "2025-09-19T00:10:46.923Z" }, + { url = "https://files.pythonhosted.org/packages/d7/97/19727e7499bfa1ae0773d06afd30ac66a58ed7437d940c70548634b24185/mypy-1.18.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:592ec214750bc00741af1f80cbf96b5013d81486b7bb24cb052382c19e40b428", size = 13499217, upload-time = "2025-09-19T00:09:39.472Z" }, + { url = "https://files.pythonhosted.org/packages/9f/4f/90dc8c15c1441bf31cf0f9918bb077e452618708199e530f4cbd5cede6ff/mypy-1.18.2-cp310-cp310-win_amd64.whl", hash = "sha256:7fb95f97199ea11769ebe3638c29b550b5221e997c63b14ef93d2e971606ebed", size = 9766753, upload-time = "2025-09-19T00:10:49.161Z" }, + { url = "https://files.pythonhosted.org/packages/88/87/cafd3ae563f88f94eec33f35ff722d043e09832ea8530ef149ec1efbaf08/mypy-1.18.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:807d9315ab9d464125aa9fcf6d84fde6e1dc67da0b6f80e7405506b8ac72bc7f", size = 12731198, upload-time = "2025-09-19T00:09:44.857Z" }, + { url = "https://files.pythonhosted.org/packages/0f/e0/1e96c3d4266a06d4b0197ace5356d67d937d8358e2ee3ffac71faa843724/mypy-1.18.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:776bb00de1778caf4db739c6e83919c1d85a448f71979b6a0edd774ea8399341", size = 11817879, upload-time = "2025-09-19T00:09:47.131Z" }, + { url = "https://files.pythonhosted.org/packages/72/ef/0c9ba89eb03453e76bdac5a78b08260a848c7bfc5d6603634774d9cd9525/mypy-1.18.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1379451880512ffce14505493bd9fe469e0697543717298242574882cf8cdb8d", size = 12427292, upload-time = "2025-09-19T00:10:22.472Z" }, + { url = "https://files.pythonhosted.org/packages/1a/52/ec4a061dd599eb8179d5411d99775bec2a20542505988f40fc2fee781068/mypy-1.18.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1331eb7fd110d60c24999893320967594ff84c38ac6d19e0a76c5fd809a84c86", size = 13163750, upload-time = "2025-09-19T00:09:51.472Z" }, + { url = "https://files.pythonhosted.org/packages/c4/5f/2cf2ceb3b36372d51568f2208c021870fe7834cf3186b653ac6446511839/mypy-1.18.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3ca30b50a51e7ba93b00422e486cbb124f1c56a535e20eff7b2d6ab72b3b2e37", size = 13351827, upload-time = "2025-09-19T00:09:58.311Z" }, + { url = "https://files.pythonhosted.org/packages/c8/7d/2697b930179e7277529eaaec1513f8de622818696857f689e4a5432e5e27/mypy-1.18.2-cp311-cp311-win_amd64.whl", hash = "sha256:664dc726e67fa54e14536f6e1224bcfce1d9e5ac02426d2326e2bb4e081d1ce8", size = 9757983, upload-time = "2025-09-19T00:10:09.071Z" }, + { url = "https://files.pythonhosted.org/packages/07/06/dfdd2bc60c66611dd8335f463818514733bc763e4760dee289dcc33df709/mypy-1.18.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:33eca32dd124b29400c31d7cf784e795b050ace0e1f91b8dc035672725617e34", size = 12908273, upload-time = "2025-09-19T00:10:58.321Z" }, + { url = "https://files.pythonhosted.org/packages/81/14/6a9de6d13a122d5608e1a04130724caf9170333ac5a924e10f670687d3eb/mypy-1.18.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a3c47adf30d65e89b2dcd2fa32f3aeb5e94ca970d2c15fcb25e297871c8e4764", size = 11920910, upload-time = "2025-09-19T00:10:20.043Z" }, + { url = "https://files.pythonhosted.org/packages/5f/a9/b29de53e42f18e8cc547e38daa9dfa132ffdc64f7250e353f5c8cdd44bee/mypy-1.18.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d6c838e831a062f5f29d11c9057c6009f60cb294fea33a98422688181fe2893", size = 12465585, upload-time = "2025-09-19T00:10:33.005Z" }, + { url = "https://files.pythonhosted.org/packages/77/ae/6c3d2c7c61ff21f2bee938c917616c92ebf852f015fb55917fd6e2811db2/mypy-1.18.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01199871b6110a2ce984bde85acd481232d17413868c9807e95c1b0739a58914", size = 13348562, upload-time = "2025-09-19T00:10:11.51Z" }, + { url = "https://files.pythonhosted.org/packages/4d/31/aec68ab3b4aebdf8f36d191b0685d99faa899ab990753ca0fee60fb99511/mypy-1.18.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a2afc0fa0b0e91b4599ddfe0f91e2c26c2b5a5ab263737e998d6817874c5f7c8", size = 13533296, upload-time = "2025-09-19T00:10:06.568Z" }, + { url = "https://files.pythonhosted.org/packages/9f/83/abcb3ad9478fca3ebeb6a5358bb0b22c95ea42b43b7789c7fb1297ca44f4/mypy-1.18.2-cp312-cp312-win_amd64.whl", hash = "sha256:d8068d0afe682c7c4897c0f7ce84ea77f6de953262b12d07038f4d296d547074", size = 9828828, upload-time = "2025-09-19T00:10:28.203Z" }, + { url = "https://files.pythonhosted.org/packages/5f/04/7f462e6fbba87a72bc8097b93f6842499c428a6ff0c81dd46948d175afe8/mypy-1.18.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:07b8b0f580ca6d289e69209ec9d3911b4a26e5abfde32228a288eb79df129fcc", size = 12898728, upload-time = "2025-09-19T00:10:01.33Z" }, + { url = "https://files.pythonhosted.org/packages/99/5b/61ed4efb64f1871b41fd0b82d29a64640f3516078f6c7905b68ab1ad8b13/mypy-1.18.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ed4482847168439651d3feee5833ccedbf6657e964572706a2adb1f7fa4dfe2e", size = 11910758, upload-time = "2025-09-19T00:10:42.607Z" }, + { url = "https://files.pythonhosted.org/packages/3c/46/d297d4b683cc89a6e4108c4250a6a6b717f5fa96e1a30a7944a6da44da35/mypy-1.18.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c3ad2afadd1e9fea5cf99a45a822346971ede8685cc581ed9cd4d42eaf940986", size = 12475342, upload-time = "2025-09-19T00:11:00.371Z" }, + { url = "https://files.pythonhosted.org/packages/83/45/4798f4d00df13eae3bfdf726c9244bcb495ab5bd588c0eed93a2f2dd67f3/mypy-1.18.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a431a6f1ef14cf8c144c6b14793a23ec4eae3db28277c358136e79d7d062f62d", size = 13338709, upload-time = "2025-09-19T00:11:03.358Z" }, + { url = "https://files.pythonhosted.org/packages/d7/09/479f7358d9625172521a87a9271ddd2441e1dab16a09708f056e97007207/mypy-1.18.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7ab28cc197f1dd77a67e1c6f35cd1f8e8b73ed2217e4fc005f9e6a504e46e7ba", size = 13529806, upload-time = "2025-09-19T00:10:26.073Z" }, + { url = "https://files.pythonhosted.org/packages/71/cf/ac0f2c7e9d0ea3c75cd99dff7aec1c9df4a1376537cb90e4c882267ee7e9/mypy-1.18.2-cp313-cp313-win_amd64.whl", hash = "sha256:0e2785a84b34a72ba55fb5daf079a1003a34c05b22238da94fcae2bbe46f3544", size = 9833262, upload-time = "2025-09-19T00:10:40.035Z" }, + { url = "https://files.pythonhosted.org/packages/5a/0c/7d5300883da16f0063ae53996358758b2a2df2a09c72a5061fa79a1f5006/mypy-1.18.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:62f0e1e988ad41c2a110edde6c398383a889d95b36b3e60bcf155f5164c4fdce", size = 12893775, upload-time = "2025-09-19T00:10:03.814Z" }, + { url = "https://files.pythonhosted.org/packages/50/df/2cffbf25737bdb236f60c973edf62e3e7b4ee1c25b6878629e88e2cde967/mypy-1.18.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:8795a039bab805ff0c1dfdb8cd3344642c2b99b8e439d057aba30850b8d3423d", size = 11936852, upload-time = "2025-09-19T00:10:51.631Z" }, + { url = "https://files.pythonhosted.org/packages/be/50/34059de13dd269227fb4a03be1faee6e2a4b04a2051c82ac0a0b5a773c9a/mypy-1.18.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6ca1e64b24a700ab5ce10133f7ccd956a04715463d30498e64ea8715236f9c9c", size = 12480242, upload-time = "2025-09-19T00:11:07.955Z" }, + { url = "https://files.pythonhosted.org/packages/5b/11/040983fad5132d85914c874a2836252bbc57832065548885b5bb5b0d4359/mypy-1.18.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d924eef3795cc89fecf6bedc6ed32b33ac13e8321344f6ddbf8ee89f706c05cb", size = 13326683, upload-time = "2025-09-19T00:09:55.572Z" }, + { url = "https://files.pythonhosted.org/packages/e9/ba/89b2901dd77414dd7a8c8729985832a5735053be15b744c18e4586e506ef/mypy-1.18.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:20c02215a080e3a2be3aa50506c67242df1c151eaba0dcbc1e4e557922a26075", size = 13514749, upload-time = "2025-09-19T00:10:44.827Z" }, + { url = "https://files.pythonhosted.org/packages/25/bc/cc98767cffd6b2928ba680f3e5bc969c4152bf7c2d83f92f5a504b92b0eb/mypy-1.18.2-cp314-cp314-win_amd64.whl", hash = "sha256:749b5f83198f1ca64345603118a6f01a4e99ad4bf9d103ddc5a3200cc4614adf", size = 9982959, upload-time = "2025-09-19T00:10:37.344Z" }, + { url = "https://files.pythonhosted.org/packages/87/e3/be76d87158ebafa0309946c4a73831974d4d6ab4f4ef40c3b53a385a66fd/mypy-1.18.2-py3-none-any.whl", hash = "sha256:22a1748707dd62b58d2ae53562ffc4d7f8bcc727e8ac7cbc69c053ddc874d47e", size = 2352367, upload-time = "2025-09-19T00:10:15.489Z" }, +] + +[[package]] +name = "mypy-extensions" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" }, +] + +[[package]] +name = "myst-parser" +version = "4.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docutils" }, + { name = "jinja2" }, + { name = "markdown-it-py" }, + { name = "mdit-py-plugins" }, + { name = "pyyaml" }, + { name = "sphinx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/a5/9626ba4f73555b3735ad86247a8077d4603aa8628537687c839ab08bfe44/myst_parser-4.0.1.tar.gz", hash = "sha256:5cfea715e4f3574138aecbf7d54132296bfd72bb614d31168f48c477a830a7c4", size = 93985, upload-time = "2025-02-12T10:53:03.833Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5f/df/76d0321c3797b54b60fef9ec3bd6f4cfd124b9e422182156a1dd418722cf/myst_parser-4.0.1-py3-none-any.whl", hash = "sha256:9134e88959ec3b5780aedf8a99680ea242869d012e8821db3126d427edc9c95d", size = 84579, upload-time = "2025-02-12T10:53:02.078Z" }, +] + +[[package]] +name = "nodeenv" +version = "1.9.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/16/fc88b08840de0e0a72a2f9d8c6bae36be573e475a6326ae854bcc549fc45/nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f", size = 47437, upload-time = "2024-06-04T18:44:11.171Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/1d/1b658dbd2b9fa9c4c9f32accbfc0205d532c8c6194dc0f2a4c0428e7128a/nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9", size = 22314, upload-time = "2024-06-04T18:44:08.352Z" }, +] + +[[package]] +name = "oas-generator" +version = "0.1.0" +source = { editable = "api/oas-generator" } +dependencies = [ + { name = "jinja2" }, +] + +[package.metadata] +requires-dist = [{ name = "jinja2", specifier = ">=3.1" }] + +[[package]] +name = "packageurl-python" +version = "0.17.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3a/f0/de0ac00a4484c0d87b71e3d9985518278d89797fa725e90abd3453bccb42/packageurl_python-0.17.5.tar.gz", hash = "sha256:a7be3f3ba70d705f738ace9bf6124f31920245a49fa69d4b416da7037dd2de61", size = 43832, upload-time = "2025-08-06T14:08:20.235Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/be/78/9dbb7d2ef240d20caf6f79c0f66866737c9d0959601fd783ff635d1d019d/packageurl_python-0.17.5-py3-none-any.whl", hash = "sha256:f0e55452ab37b5c192c443de1458e3f3b4d8ac27f747df6e8c48adeab081d321", size = 30544, upload-time = "2025-08-06T14:08:19.055Z" }, +] + +[[package]] +name = "packaging" +version = "25.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" }, +] + +[[package]] +name = "pastel" +version = "0.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/76/f1/4594f5e0fcddb6953e5b8fe00da8c317b8b41b547e2b3ae2da7512943c62/pastel-0.2.1.tar.gz", hash = "sha256:e6581ac04e973cac858828c6202c1e1e81fee1dc7de7683f3e1ffe0bfd8a573d", size = 7555, upload-time = "2020-09-16T19:21:12.43Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/aa/18/a8444036c6dd65ba3624c63b734d3ba95ba63ace513078e1580590075d21/pastel-0.2.1-py2.py3-none-any.whl", hash = "sha256:4349225fcdf6c2bb34d483e523475de5bb04a5c10ef711263452cb37d7dd4364", size = 5955, upload-time = "2020-09-16T19:21:11.409Z" }, +] + +[[package]] +name = "pathspec" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043, upload-time = "2023-12-10T22:30:45Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191, upload-time = "2023-12-10T22:30:43.14Z" }, +] + +[[package]] +name = "pip" +version = "26.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/44/c2/65686a7783a7c27a329706207147e82f23c41221ee9ae33128fc331670a0/pip-26.0.tar.gz", hash = "sha256:3ce220a0a17915972fbf1ab451baae1521c4539e778b28127efa79b974aff0fa", size = 1812654, upload-time = "2026-01-31T01:40:54.361Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/00/5ac7aa77688ec4d34148b423d34dc0c9bc4febe0d872a9a1ad9860b2f6f1/pip-26.0-py3-none-any.whl", hash = "sha256:98436feffb9e31bc9339cf369fd55d3331b1580b6a6f1173bacacddcf9c34754", size = 1787564, upload-time = "2026-01-31T01:40:52.252Z" }, +] + +[[package]] +name = "pip-api" +version = "0.0.34" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pip" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/f1/ee85f8c7e82bccf90a3c7aad22863cc6e20057860a1361083cd2adacb92e/pip_api-0.0.34.tar.gz", hash = "sha256:9b75e958f14c5a2614bae415f2adf7eeb54d50a2cfbe7e24fd4826471bac3625", size = 123017, upload-time = "2024-07-09T20:32:30.641Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/91/f7/ebf5003e1065fd00b4cbef53bf0a65c3d3e1b599b676d5383ccb7a8b88ba/pip_api-0.0.34-py3-none-any.whl", hash = "sha256:8b2d7d7c37f2447373aa2cf8b1f60a2f2b27a84e1e9e0294a3f6ef10eb3ba6bb", size = 120369, upload-time = "2024-07-09T20:32:29.099Z" }, +] + +[[package]] +name = "pip-audit" +version = "2.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cachecontrol", extra = ["filecache"] }, + { name = "cyclonedx-python-lib" }, + { name = "packaging" }, + { name = "pip-api" }, + { name = "pip-requirements-parser" }, + { name = "platformdirs" }, + { name = "requests" }, + { name = "rich" }, + { name = "toml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cc/7f/28fad19a9806f796f13192ab6974c07c4a04d9cbb8e30dd895c3c11ce7ee/pip_audit-2.9.0.tar.gz", hash = "sha256:0b998410b58339d7a231e5aa004326a294e4c7c6295289cdc9d5e1ef07b1f44d", size = 52089, upload-time = "2025-04-07T16:45:23.679Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/9e/f4dfd9d3dadb6d6dc9406f1111062f871e2e248ed7b584cca6020baf2ac1/pip_audit-2.9.0-py3-none-any.whl", hash = "sha256:348b16e60895749a0839875d7cc27ebd692e1584ebe5d5cb145941c8e25a80bd", size = 58634, upload-time = "2025-04-07T16:45:22.056Z" }, +] + +[[package]] +name = "pip-requirements-parser" +version = "32.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, + { name = "pyparsing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5e/2a/63b574101850e7f7b306ddbdb02cb294380d37948140eecd468fae392b54/pip-requirements-parser-32.0.1.tar.gz", hash = "sha256:b4fa3a7a0be38243123cf9d1f3518da10c51bdb165a2b2985566247f9155a7d3", size = 209359, upload-time = "2022-12-21T15:25:22.732Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/d0/d04f1d1e064ac901439699ee097f58688caadea42498ec9c4b4ad2ef84ab/pip_requirements_parser-32.0.1-py3-none-any.whl", hash = "sha256:4659bc2a667783e7a15d190f6fccf8b2486685b6dba4c19c3876314769c57526", size = 35648, upload-time = "2022-12-21T15:25:21.046Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/61/33/9611380c2bdb1225fdef633e2a9610622310fed35ab11dac9620972ee088/platformdirs-4.5.0.tar.gz", hash = "sha256:70ddccdd7c99fc5942e9fc25636a8b34d04c24b335100223152c2803e4063312", size = 21632, upload-time = "2025-10-08T17:44:48.791Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/73/cb/ac7874b3e5d58441674fb70742e6c374b28b0c7cb988d37d991cde47166c/platformdirs-4.5.0-py3-none-any.whl", hash = "sha256:e578a81bb873cbb89a41fcc904c7ef523cc18284b7e3b3ccf06aca1403b7ebd3", size = 18651, upload-time = "2025-10-08T17:44:47.223Z" }, +] + +[[package]] +name = "pluggy" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, +] + +[[package]] +name = "poethepoet" +version = "0.34.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pastel" }, + { name = "pyyaml" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/f2/3853d6a9a0dac08aa680895839eeab8ec0ed63db375e1f782e623c9309b6/poethepoet-0.34.0.tar.gz", hash = "sha256:86203acce555bbfe45cb6ccac61ba8b16a5784264484195874da457ddabf5850", size = 64474, upload-time = "2025-04-21T13:38:20.084Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/d1/61431afe22577083fcb50614bc5e5aa73aa0ab35e3fc2ae49708a59ff70b/poethepoet-0.34.0-py3-none-any.whl", hash = "sha256:c472d6f0fdb341b48d346f4ccd49779840c15b30dfd6bc6347a80d6274b5e34e", size = 85851, upload-time = "2025-04-21T13:38:18.257Z" }, +] + +[[package]] +name = "pre-commit" +version = "3.8.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cfgv" }, + { name = "identify" }, + { name = "nodeenv" }, + { name = "pyyaml" }, + { name = "virtualenv" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/64/10/97ee2fa54dff1e9da9badbc5e35d0bbaef0776271ea5907eccf64140f72f/pre_commit-3.8.0.tar.gz", hash = "sha256:8bb6494d4a20423842e198980c9ecf9f96607a07ea29549e180eef9ae80fe7af", size = 177815, upload-time = "2024-07-28T19:59:01.538Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/92/caae8c86e94681b42c246f0bca35c059a2f0529e5b92619f6aba4cf7e7b6/pre_commit-3.8.0-py2.py3-none-any.whl", hash = "sha256:9a90a53bf82fdd8778d58085faf8d83df56e40dfe18f45b19446e26bf1b3a63f", size = 204643, upload-time = "2024-07-28T19:58:59.335Z" }, +] + +[[package]] +name = "py-serializable" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "defusedxml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/73/21/d250cfca8ff30c2e5a7447bc13861541126ce9bd4426cd5d0c9f08b5547d/py_serializable-2.1.0.tar.gz", hash = "sha256:9d5db56154a867a9b897c0163b33a793c804c80cee984116d02d49e4578fc103", size = 52368, upload-time = "2025-07-21T09:56:48.07Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9b/bf/7595e817906a29453ba4d99394e781b6fabe55d21f3c15d240f85dd06bb1/py_serializable-2.1.0-py3-none-any.whl", hash = "sha256:b56d5d686b5a03ba4f4db5e769dc32336e142fc3bd4d68a8c25579ebb0a67304", size = 23045, upload-time = "2025-07-21T09:56:46.848Z" }, +] + +[[package]] +name = "pycparser" +version = "2.23" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fe/cf/d2d3b9f5699fb1e4615c8e32ff220203e43b248e1dfcc6736ad9057731ca/pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2", size = 173734, upload-time = "2025-09-09T13:23:47.91Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/e3/59cd50310fc9b59512193629e1984c1f95e5c8ae6e5d8c69532ccc65a7fe/pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934", size = 118140, upload-time = "2025-09-09T13:23:46.651Z" }, +] + +[[package]] +name = "pycryptodomex" +version = "3.23.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c9/85/e24bf90972a30b0fcd16c73009add1d7d7cd9140c2498a68252028899e41/pycryptodomex-3.23.0.tar.gz", hash = "sha256:71909758f010c82bc99b0abf4ea12012c98962fbf0583c2164f8b84533c2e4da", size = 4922157, upload-time = "2025-05-17T17:23:41.434Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2e/00/10edb04777069a42490a38c137099d4b17ba6e36a4e6e28bdc7470e9e853/pycryptodomex-3.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:7b37e08e3871efe2187bc1fd9320cc81d87caf19816c648f24443483005ff886", size = 2498764, upload-time = "2025-05-17T17:22:21.453Z" }, + { url = "https://files.pythonhosted.org/packages/6b/3f/2872a9c2d3a27eac094f9ceaa5a8a483b774ae69018040ea3240d5b11154/pycryptodomex-3.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:91979028227543010d7b2ba2471cf1d1e398b3f183cb105ac584df0c36dac28d", size = 1643012, upload-time = "2025-05-17T17:22:23.702Z" }, + { url = "https://files.pythonhosted.org/packages/70/af/774c2e2b4f6570fbf6a4972161adbb183aeeaa1863bde31e8706f123bf92/pycryptodomex-3.23.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b8962204c47464d5c1c4038abeadd4514a133b28748bcd9fa5b6d62e3cec6fa", size = 2187643, upload-time = "2025-05-17T17:22:26.37Z" }, + { url = "https://files.pythonhosted.org/packages/de/a3/71065b24cb889d537954cedc3ae5466af00a2cabcff8e29b73be047e9a19/pycryptodomex-3.23.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a33986a0066860f7fcf7c7bd2bc804fa90e434183645595ae7b33d01f3c91ed8", size = 2273762, upload-time = "2025-05-17T17:22:28.313Z" }, + { url = "https://files.pythonhosted.org/packages/c9/0b/ff6f43b7fbef4d302c8b981fe58467b8871902cdc3eb28896b52421422cc/pycryptodomex-3.23.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c7947ab8d589e3178da3d7cdeabe14f841b391e17046954f2fbcd941705762b5", size = 2313012, upload-time = "2025-05-17T17:22:30.57Z" }, + { url = "https://files.pythonhosted.org/packages/02/de/9d4772c0506ab6da10b41159493657105d3f8bb5c53615d19452afc6b315/pycryptodomex-3.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c25e30a20e1b426e1f0fa00131c516f16e474204eee1139d1603e132acffc314", size = 2186856, upload-time = "2025-05-17T17:22:32.819Z" }, + { url = "https://files.pythonhosted.org/packages/28/ad/8b30efcd6341707a234e5eba5493700a17852ca1ac7a75daa7945fcf6427/pycryptodomex-3.23.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:da4fa650cef02db88c2b98acc5434461e027dce0ae8c22dd5a69013eaf510006", size = 2347523, upload-time = "2025-05-17T17:22:35.386Z" }, + { url = "https://files.pythonhosted.org/packages/0f/02/16868e9f655b7670dbb0ac4f2844145cbc42251f916fc35c414ad2359849/pycryptodomex-3.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:58b851b9effd0d072d4ca2e4542bf2a4abcf13c82a29fd2c93ce27ee2a2e9462", size = 2272825, upload-time = "2025-05-17T17:22:37.632Z" }, + { url = "https://files.pythonhosted.org/packages/ca/18/4ca89ac737230b52ac8ffaca42f9c6f1fd07c81a6cd821e91af79db60632/pycryptodomex-3.23.0-cp313-cp313t-win32.whl", hash = "sha256:a9d446e844f08299236780f2efa9898c818fe7e02f17263866b8550c7d5fb328", size = 1772078, upload-time = "2025-05-17T17:22:40Z" }, + { url = "https://files.pythonhosted.org/packages/73/34/13e01c322db027682e00986873eca803f11c56ade9ba5bbf3225841ea2d4/pycryptodomex-3.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:bc65bdd9fc8de7a35a74cab1c898cab391a4add33a8fe740bda00f5976ca4708", size = 1803656, upload-time = "2025-05-17T17:22:42.139Z" }, + { url = "https://files.pythonhosted.org/packages/54/68/9504c8796b1805d58f4425002bcca20f12880e6fa4dc2fc9a668705c7a08/pycryptodomex-3.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:c885da45e70139464f082018ac527fdaad26f1657a99ee13eecdce0f0ca24ab4", size = 1707172, upload-time = "2025-05-17T17:22:44.704Z" }, + { url = "https://files.pythonhosted.org/packages/dd/9c/1a8f35daa39784ed8adf93a694e7e5dc15c23c741bbda06e1d45f8979e9e/pycryptodomex-3.23.0-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:06698f957fe1ab229a99ba2defeeae1c09af185baa909a31a5d1f9d42b1aaed6", size = 2499240, upload-time = "2025-05-17T17:22:46.953Z" }, + { url = "https://files.pythonhosted.org/packages/7a/62/f5221a191a97157d240cf6643747558759126c76ee92f29a3f4aee3197a5/pycryptodomex-3.23.0-cp37-abi3-macosx_10_9_x86_64.whl", hash = "sha256:b2c2537863eccef2d41061e82a881dcabb04944c5c06c5aa7110b577cc487545", size = 1644042, upload-time = "2025-05-17T17:22:49.098Z" }, + { url = "https://files.pythonhosted.org/packages/8c/fd/5a054543c8988d4ed7b612721d7e78a4b9bf36bc3c5ad45ef45c22d0060e/pycryptodomex-3.23.0-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:43c446e2ba8df8889e0e16f02211c25b4934898384c1ec1ec04d7889c0333587", size = 2186227, upload-time = "2025-05-17T17:22:51.139Z" }, + { url = "https://files.pythonhosted.org/packages/c8/a9/8862616a85cf450d2822dbd4fff1fcaba90877907a6ff5bc2672cafe42f8/pycryptodomex-3.23.0-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f489c4765093fb60e2edafdf223397bc716491b2b69fe74367b70d6999257a5c", size = 2272578, upload-time = "2025-05-17T17:22:53.676Z" }, + { url = "https://files.pythonhosted.org/packages/46/9f/bda9c49a7c1842820de674ab36c79f4fbeeee03f8ff0e4f3546c3889076b/pycryptodomex-3.23.0-cp37-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bdc69d0d3d989a1029df0eed67cc5e8e5d968f3724f4519bd03e0ec68df7543c", size = 2312166, upload-time = "2025-05-17T17:22:56.585Z" }, + { url = "https://files.pythonhosted.org/packages/03/cc/870b9bf8ca92866ca0186534801cf8d20554ad2a76ca959538041b7a7cf4/pycryptodomex-3.23.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:6bbcb1dd0f646484939e142462d9e532482bc74475cecf9c4903d4e1cd21f003", size = 2185467, upload-time = "2025-05-17T17:22:59.237Z" }, + { url = "https://files.pythonhosted.org/packages/96/e3/ce9348236d8e669fea5dd82a90e86be48b9c341210f44e25443162aba187/pycryptodomex-3.23.0-cp37-abi3-musllinux_1_2_i686.whl", hash = "sha256:8a4fcd42ccb04c31268d1efeecfccfd1249612b4de6374205376b8f280321744", size = 2346104, upload-time = "2025-05-17T17:23:02.112Z" }, + { url = "https://files.pythonhosted.org/packages/a5/e9/e869bcee87beb89040263c416a8a50204f7f7a83ac11897646c9e71e0daf/pycryptodomex-3.23.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:55ccbe27f049743a4caf4f4221b166560d3438d0b1e5ab929e07ae1702a4d6fd", size = 2271038, upload-time = "2025-05-17T17:23:04.872Z" }, + { url = "https://files.pythonhosted.org/packages/8d/67/09ee8500dd22614af5fbaa51a4aee6e342b5fa8aecf0a6cb9cbf52fa6d45/pycryptodomex-3.23.0-cp37-abi3-win32.whl", hash = "sha256:189afbc87f0b9f158386bf051f720e20fa6145975f1e76369303d0f31d1a8d7c", size = 1771969, upload-time = "2025-05-17T17:23:07.115Z" }, + { url = "https://files.pythonhosted.org/packages/69/96/11f36f71a865dd6df03716d33bd07a67e9d20f6b8d39820470b766af323c/pycryptodomex-3.23.0-cp37-abi3-win_amd64.whl", hash = "sha256:52e5ca58c3a0b0bd5e100a9fbc8015059b05cffc6c66ce9d98b4b45e023443b9", size = 1803124, upload-time = "2025-05-17T17:23:09.267Z" }, + { url = "https://files.pythonhosted.org/packages/f9/93/45c1cdcbeb182ccd2e144c693eaa097763b08b38cded279f0053ed53c553/pycryptodomex-3.23.0-cp37-abi3-win_arm64.whl", hash = "sha256:02d87b80778c171445d67e23d1caef279bf4b25c3597050ccd2e13970b57fd51", size = 1707161, upload-time = "2025-05-17T17:23:11.414Z" }, + { url = "https://files.pythonhosted.org/packages/f3/b8/3e76d948c3c4ac71335bbe75dac53e154b40b0f8f1f022dfa295257a0c96/pycryptodomex-3.23.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ebfff755c360d674306e5891c564a274a47953562b42fb74a5c25b8fc1fb1cb5", size = 1627695, upload-time = "2025-05-17T17:23:17.38Z" }, + { url = "https://files.pythonhosted.org/packages/6a/cf/80f4297a4820dfdfd1c88cf6c4666a200f204b3488103d027b5edd9176ec/pycryptodomex-3.23.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eca54f4bb349d45afc17e3011ed4264ef1cc9e266699874cdd1349c504e64798", size = 1675772, upload-time = "2025-05-17T17:23:19.202Z" }, + { url = "https://files.pythonhosted.org/packages/d1/42/1e969ee0ad19fe3134b0e1b856c39bd0b70d47a4d0e81c2a8b05727394c9/pycryptodomex-3.23.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f2596e643d4365e14d0879dc5aafe6355616c61c2176009270f3048f6d9a61f", size = 1668083, upload-time = "2025-05-17T17:23:21.867Z" }, + { url = "https://files.pythonhosted.org/packages/6e/c3/1de4f7631fea8a992a44ba632aa40e0008764c0fb9bf2854b0acf78c2cf2/pycryptodomex-3.23.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fdfac7cda115bca3a5abb2f9e43bc2fb66c2b65ab074913643803ca7083a79ea", size = 1706056, upload-time = "2025-05-17T17:23:24.031Z" }, + { url = "https://files.pythonhosted.org/packages/f2/5f/af7da8e6f1e42b52f44a24d08b8e4c726207434e2593732d39e7af5e7256/pycryptodomex-3.23.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:14c37aaece158d0ace436f76a7bb19093db3b4deade9797abfc39ec6cd6cc2fe", size = 1806478, upload-time = "2025-05-17T17:23:26.066Z" }, +] + +[[package]] +name = "pydantic" +version = "2.12.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.41.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c6/90/32c9941e728d564b411d574d8ee0cf09b12ec978cb22b294995bae5549a5/pydantic_core-2.41.5-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:77b63866ca88d804225eaa4af3e664c5faf3568cea95360d21f4725ab6e07146", size = 2107298, upload-time = "2025-11-04T13:39:04.116Z" }, + { url = "https://files.pythonhosted.org/packages/fb/a8/61c96a77fe28993d9a6fb0f4127e05430a267b235a124545d79fea46dd65/pydantic_core-2.41.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dfa8a0c812ac681395907e71e1274819dec685fec28273a28905df579ef137e2", size = 1901475, upload-time = "2025-11-04T13:39:06.055Z" }, + { url = "https://files.pythonhosted.org/packages/5d/b6/338abf60225acc18cdc08b4faef592d0310923d19a87fba1faf05af5346e/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5921a4d3ca3aee735d9fd163808f5e8dd6c6972101e4adbda9a4667908849b97", size = 1918815, upload-time = "2025-11-04T13:39:10.41Z" }, + { url = "https://files.pythonhosted.org/packages/d1/1c/2ed0433e682983d8e8cba9c8d8ef274d4791ec6a6f24c58935b90e780e0a/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e25c479382d26a2a41b7ebea1043564a937db462816ea07afa8a44c0866d52f9", size = 2065567, upload-time = "2025-11-04T13:39:12.244Z" }, + { url = "https://files.pythonhosted.org/packages/b3/24/cf84974ee7d6eae06b9e63289b7b8f6549d416b5c199ca2d7ce13bbcf619/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f547144f2966e1e16ae626d8ce72b4cfa0caedc7fa28052001c94fb2fcaa1c52", size = 2230442, upload-time = "2025-11-04T13:39:13.962Z" }, + { url = "https://files.pythonhosted.org/packages/fd/21/4e287865504b3edc0136c89c9c09431be326168b1eb7841911cbc877a995/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f52298fbd394f9ed112d56f3d11aabd0d5bd27beb3084cc3d8ad069483b8941", size = 2350956, upload-time = "2025-11-04T13:39:15.889Z" }, + { url = "https://files.pythonhosted.org/packages/a8/76/7727ef2ffa4b62fcab916686a68a0426b9b790139720e1934e8ba797e238/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:100baa204bb412b74fe285fb0f3a385256dad1d1879f0a5cb1499ed2e83d132a", size = 2068253, upload-time = "2025-11-04T13:39:17.403Z" }, + { url = "https://files.pythonhosted.org/packages/d5/8c/a4abfc79604bcb4c748e18975c44f94f756f08fb04218d5cb87eb0d3a63e/pydantic_core-2.41.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:05a2c8852530ad2812cb7914dc61a1125dc4e06252ee98e5638a12da6cc6fb6c", size = 2177050, upload-time = "2025-11-04T13:39:19.351Z" }, + { url = "https://files.pythonhosted.org/packages/67/b1/de2e9a9a79b480f9cb0b6e8b6ba4c50b18d4e89852426364c66aa82bb7b3/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:29452c56df2ed968d18d7e21f4ab0ac55e71dc59524872f6fc57dcf4a3249ed2", size = 2147178, upload-time = "2025-11-04T13:39:21Z" }, + { url = "https://files.pythonhosted.org/packages/16/c1/dfb33f837a47b20417500efaa0378adc6635b3c79e8369ff7a03c494b4ac/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:d5160812ea7a8a2ffbe233d8da666880cad0cbaf5d4de74ae15c313213d62556", size = 2341833, upload-time = "2025-11-04T13:39:22.606Z" }, + { url = "https://files.pythonhosted.org/packages/47/36/00f398642a0f4b815a9a558c4f1dca1b4020a7d49562807d7bc9ff279a6c/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:df3959765b553b9440adfd3c795617c352154e497a4eaf3752555cfb5da8fc49", size = 2321156, upload-time = "2025-11-04T13:39:25.843Z" }, + { url = "https://files.pythonhosted.org/packages/7e/70/cad3acd89fde2010807354d978725ae111ddf6d0ea46d1ea1775b5c1bd0c/pydantic_core-2.41.5-cp310-cp310-win32.whl", hash = "sha256:1f8d33a7f4d5a7889e60dc39856d76d09333d8a6ed0f5f1190635cbec70ec4ba", size = 1989378, upload-time = "2025-11-04T13:39:27.92Z" }, + { url = "https://files.pythonhosted.org/packages/76/92/d338652464c6c367e5608e4488201702cd1cbb0f33f7b6a85a60fe5f3720/pydantic_core-2.41.5-cp310-cp310-win_amd64.whl", hash = "sha256:62de39db01b8d593e45871af2af9e497295db8d73b085f6bfd0b18c83c70a8f9", size = 2013622, upload-time = "2025-11-04T13:39:29.848Z" }, + { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" }, + { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" }, + { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" }, + { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" }, + { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" }, + { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" }, + { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" }, + { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" }, + { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" }, + { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" }, + { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" }, + { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" }, + { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" }, + { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" }, + { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" }, + { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" }, + { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" }, + { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" }, + { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" }, + { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" }, + { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" }, + { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" }, + { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" }, + { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" }, + { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" }, + { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" }, + { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" }, + { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" }, + { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" }, + { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" }, + { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" }, + { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" }, + { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" }, + { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" }, + { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" }, + { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" }, + { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" }, + { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" }, + { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" }, + { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" }, + { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" }, + { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" }, + { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" }, + { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" }, + { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" }, + { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" }, + { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" }, + { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" }, + { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" }, + { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" }, + { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" }, + { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" }, + { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" }, + { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" }, + { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" }, + { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" }, + { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" }, + { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" }, + { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" }, + { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" }, + { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" }, + { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" }, + { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" }, + { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" }, + { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" }, + { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" }, + { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" }, + { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" }, + { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" }, + { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" }, + { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" }, + { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" }, + { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" }, + { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" }, + { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" }, + { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" }, + { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" }, + { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" }, + { url = "https://files.pythonhosted.org/packages/e6/b0/1a2aa41e3b5a4ba11420aba2d091b2d17959c8d1519ece3627c371951e73/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b5819cd790dbf0c5eb9f82c73c16b39a65dd6dd4d1439dcdea7816ec9adddab8", size = 2103351, upload-time = "2025-11-04T13:43:02.058Z" }, + { url = "https://files.pythonhosted.org/packages/a4/ee/31b1f0020baaf6d091c87900ae05c6aeae101fa4e188e1613c80e4f1ea31/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5a4e67afbc95fa5c34cf27d9089bca7fcab4e51e57278d710320a70b956d1b9a", size = 1925363, upload-time = "2025-11-04T13:43:05.159Z" }, + { url = "https://files.pythonhosted.org/packages/e1/89/ab8e86208467e467a80deaca4e434adac37b10a9d134cd2f99b28a01e483/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ece5c59f0ce7d001e017643d8d24da587ea1f74f6993467d85ae8a5ef9d4f42b", size = 2135615, upload-time = "2025-11-04T13:43:08.116Z" }, + { url = "https://files.pythonhosted.org/packages/99/0a/99a53d06dd0348b2008f2f30884b34719c323f16c3be4e6cc1203b74a91d/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:16f80f7abe3351f8ea6858914ddc8c77e02578544a0ebc15b4c2e1a0e813b0b2", size = 2175369, upload-time = "2025-11-04T13:43:12.49Z" }, + { url = "https://files.pythonhosted.org/packages/6d/94/30ca3b73c6d485b9bb0bc66e611cff4a7138ff9736b7e66bcf0852151636/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:33cb885e759a705b426baada1fe68cbb0a2e68e34c5d0d0289a364cf01709093", size = 2144218, upload-time = "2025-11-04T13:43:15.431Z" }, + { url = "https://files.pythonhosted.org/packages/87/57/31b4f8e12680b739a91f472b5671294236b82586889ef764b5fbc6669238/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:c8d8b4eb992936023be7dee581270af5c6e0697a8559895f527f5b7105ecd36a", size = 2329951, upload-time = "2025-11-04T13:43:18.062Z" }, + { url = "https://files.pythonhosted.org/packages/7d/73/3c2c8edef77b8f7310e6fb012dbc4b8551386ed575b9eb6fb2506e28a7eb/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:242a206cd0318f95cd21bdacff3fcc3aab23e79bba5cac3db5a841c9ef9c6963", size = 2318428, upload-time = "2025-11-04T13:43:20.679Z" }, + { url = "https://files.pythonhosted.org/packages/2f/02/8559b1f26ee0d502c74f9cca5c0d2fd97e967e083e006bbbb4e97f3a043a/pydantic_core-2.41.5-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d3a978c4f57a597908b7e697229d996d77a6d3c94901e9edee593adada95ce1a", size = 2147009, upload-time = "2025-11-04T13:43:23.286Z" }, + { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" }, + { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" }, + { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" }, + { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" }, + { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" }, + { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" }, + { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" }, +] + +[[package]] +name = "pydoclint" +version = "0.6.11" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "docstring-parser-fork" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7a/38/a588851a1ff97f292b0481e532137953565480be16546b4848e94ab59311/pydoclint-0.6.11.tar.gz", hash = "sha256:89da3d3fc82dedd0e0773e461b8eabc675dfb15060f4f37470c5edce15820ea1", size = 160130, upload-time = "2025-09-01T01:06:32.997Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/74/bd/e40cd5db290a6f0aa0cb8bb545b9e38992a002834346b61efd63f16f3b14/pydoclint-0.6.11-py3-none-any.whl", hash = "sha256:07c003f09075525bd5680d8e72ce53809128c9a4903f282212cd454413d273e7", size = 68351, upload-time = "2025-09-01T01:06:31.795Z" }, +] + +[[package]] +name = "pygments" +version = "2.20.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" }, +] + +[[package]] +name = "pynacl" +version = "1.6.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d9/9a/4019b524b03a13438637b11538c82781a5eda427394380381af8f04f467a/pynacl-1.6.2.tar.gz", hash = "sha256:018494d6d696ae03c7e656e5e74cdfd8ea1326962cc401bcf018f1ed8436811c", size = 3511692, upload-time = "2026-01-01T17:48:10.851Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/79/0e3c34dc3c4671f67d251c07aa8eb100916f250ee470df230b0ab89551b4/pynacl-1.6.2-cp314-cp314t-macosx_10_10_universal2.whl", hash = "sha256:622d7b07cc5c02c666795792931b50c91f3ce3c2649762efb1ef0d5684c81594", size = 390064, upload-time = "2026-01-01T17:31:57.264Z" }, + { url = "https://files.pythonhosted.org/packages/eb/1c/23a26e931736e13b16483795c8a6b2f641bf6a3d5238c22b070a5112722c/pynacl-1.6.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d071c6a9a4c94d79eb665db4ce5cedc537faf74f2355e4d502591d850d3913c0", size = 809370, upload-time = "2026-01-01T17:31:59.198Z" }, + { url = "https://files.pythonhosted.org/packages/87/74/8d4b718f8a22aea9e8dcc8b95deb76d4aae380e2f5b570cc70b5fd0a852d/pynacl-1.6.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fe9847ca47d287af41e82be1dd5e23023d3c31a951da134121ab02e42ac218c9", size = 1408304, upload-time = "2026-01-01T17:32:01.162Z" }, + { url = "https://files.pythonhosted.org/packages/fd/73/be4fdd3a6a87fe8a4553380c2b47fbd1f7f58292eb820902f5c8ac7de7b0/pynacl-1.6.2-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:04316d1fc625d860b6c162fff704eb8426b1a8bcd3abacea11142cbd99a6b574", size = 844871, upload-time = "2026-01-01T17:32:02.824Z" }, + { url = "https://files.pythonhosted.org/packages/55/ad/6efc57ab75ee4422e96b5f2697d51bbcf6cdcc091e66310df91fbdc144a8/pynacl-1.6.2-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:44081faff368d6c5553ccf55322ef2819abb40e25afaec7e740f159f74813634", size = 1446356, upload-time = "2026-01-01T17:32:04.452Z" }, + { url = "https://files.pythonhosted.org/packages/78/b7/928ee9c4779caa0a915844311ab9fb5f99585621c5d6e4574538a17dca07/pynacl-1.6.2-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:a9f9932d8d2811ce1a8ffa79dcbdf3970e7355b5c8eb0c1a881a57e7f7d96e88", size = 826814, upload-time = "2026-01-01T17:32:06.078Z" }, + { url = "https://files.pythonhosted.org/packages/f7/a9/1bdba746a2be20f8809fee75c10e3159d75864ef69c6b0dd168fc60e485d/pynacl-1.6.2-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:bc4a36b28dd72fb4845e5d8f9760610588a96d5a51f01d84d8c6ff9849968c14", size = 1411742, upload-time = "2026-01-01T17:32:07.651Z" }, + { url = "https://files.pythonhosted.org/packages/f3/2f/5e7ea8d85f9f3ea5b6b87db1d8388daa3587eed181bdeb0306816fdbbe79/pynacl-1.6.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3bffb6d0f6becacb6526f8f42adfb5efb26337056ee0831fb9a7044d1a964444", size = 801714, upload-time = "2026-01-01T17:32:09.558Z" }, + { url = "https://files.pythonhosted.org/packages/06/ea/43fe2f7eab5f200e40fb10d305bf6f87ea31b3bbc83443eac37cd34a9e1e/pynacl-1.6.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:2fef529ef3ee487ad8113d287a593fa26f48ee3620d92ecc6f1d09ea38e0709b", size = 1372257, upload-time = "2026-01-01T17:32:11.026Z" }, + { url = "https://files.pythonhosted.org/packages/4d/54/c9ea116412788629b1347e415f72195c25eb2f3809b2d3e7b25f5c79f13a/pynacl-1.6.2-cp314-cp314t-win32.whl", hash = "sha256:a84bf1c20339d06dc0c85d9aea9637a24f718f375d861b2668b2f9f96fa51145", size = 231319, upload-time = "2026-01-01T17:32:12.46Z" }, + { url = "https://files.pythonhosted.org/packages/ce/04/64e9d76646abac2dccf904fccba352a86e7d172647557f35b9fe2a5ee4a1/pynacl-1.6.2-cp314-cp314t-win_amd64.whl", hash = "sha256:320ef68a41c87547c91a8b58903c9caa641ab01e8512ce291085b5fe2fcb7590", size = 244044, upload-time = "2026-01-01T17:32:13.781Z" }, + { url = "https://files.pythonhosted.org/packages/33/33/7873dc161c6a06f43cda13dec67b6fe152cb2f982581151956fa5e5cdb47/pynacl-1.6.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d29bfe37e20e015a7d8b23cfc8bd6aa7909c92a1b8f41ee416bbb3e79ef182b2", size = 188740, upload-time = "2026-01-01T17:32:15.083Z" }, + { url = "https://files.pythonhosted.org/packages/be/7b/4845bbf88e94586ec47a432da4e9107e3fc3ce37eb412b1398630a37f7dd/pynacl-1.6.2-cp38-abi3-macosx_10_10_universal2.whl", hash = "sha256:c949ea47e4206af7c8f604b8278093b674f7c79ed0d4719cc836902bf4517465", size = 388458, upload-time = "2026-01-01T17:32:16.829Z" }, + { url = "https://files.pythonhosted.org/packages/1e/b4/e927e0653ba63b02a4ca5b4d852a8d1d678afbf69b3dbf9c4d0785ac905c/pynacl-1.6.2-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8845c0631c0be43abdd865511c41eab235e0be69c81dc66a50911594198679b0", size = 800020, upload-time = "2026-01-01T17:32:18.34Z" }, + { url = "https://files.pythonhosted.org/packages/7f/81/d60984052df5c97b1d24365bc1e30024379b42c4edcd79d2436b1b9806f2/pynacl-1.6.2-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:22de65bb9010a725b0dac248f353bb072969c94fa8d6b1f34b87d7953cf7bbe4", size = 1399174, upload-time = "2026-01-01T17:32:20.239Z" }, + { url = "https://files.pythonhosted.org/packages/68/f7/322f2f9915c4ef27d140101dd0ed26b479f7e6f5f183590fd32dfc48c4d3/pynacl-1.6.2-cp38-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:46065496ab748469cdd999246d17e301b2c24ae2fdf739132e580a0e94c94a87", size = 835085, upload-time = "2026-01-01T17:32:22.24Z" }, + { url = "https://files.pythonhosted.org/packages/3e/d0/f301f83ac8dbe53442c5a43f6a39016f94f754d7a9815a875b65e218a307/pynacl-1.6.2-cp38-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a66d6fb6ae7661c58995f9c6435bda2b1e68b54b598a6a10247bfcdadac996c", size = 1437614, upload-time = "2026-01-01T17:32:23.766Z" }, + { url = "https://files.pythonhosted.org/packages/c4/58/fc6e649762b029315325ace1a8c6be66125e42f67416d3dbd47b69563d61/pynacl-1.6.2-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:26bfcd00dcf2cf160f122186af731ae30ab120c18e8375684ec2670dccd28130", size = 818251, upload-time = "2026-01-01T17:32:25.69Z" }, + { url = "https://files.pythonhosted.org/packages/c9/a8/b917096b1accc9acd878819a49d3d84875731a41eb665f6ebc826b1af99e/pynacl-1.6.2-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:c8a231e36ec2cab018c4ad4358c386e36eede0319a0c41fed24f840b1dac59f6", size = 1402859, upload-time = "2026-01-01T17:32:27.215Z" }, + { url = "https://files.pythonhosted.org/packages/85/42/fe60b5f4473e12c72f977548e4028156f4d340b884c635ec6b063fe7e9a5/pynacl-1.6.2-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:68be3a09455743ff9505491220b64440ced8973fe930f270c8e07ccfa25b1f9e", size = 791926, upload-time = "2026-01-01T17:32:29.314Z" }, + { url = "https://files.pythonhosted.org/packages/fa/f9/e40e318c604259301cc091a2a63f237d9e7b424c4851cafaea4ea7c4834e/pynacl-1.6.2-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:8b097553b380236d51ed11356c953bf8ce36a29a3e596e934ecabe76c985a577", size = 1363101, upload-time = "2026-01-01T17:32:31.263Z" }, + { url = "https://files.pythonhosted.org/packages/48/47/e761c254f410c023a469284a9bc210933e18588ca87706ae93002c05114c/pynacl-1.6.2-cp38-abi3-win32.whl", hash = "sha256:5811c72b473b2f38f7e2a3dc4f8642e3a3e9b5e7317266e4ced1fba85cae41aa", size = 227421, upload-time = "2026-01-01T17:32:33.076Z" }, + { url = "https://files.pythonhosted.org/packages/41/ad/334600e8cacc7d86587fe5f565480fde569dfb487389c8e1be56ac21d8ac/pynacl-1.6.2-cp38-abi3-win_amd64.whl", hash = "sha256:62985f233210dee6548c223301b6c25440852e13d59a8b81490203c3227c5ba0", size = 239754, upload-time = "2026-01-01T17:32:34.557Z" }, + { url = "https://files.pythonhosted.org/packages/29/7d/5945b5af29534641820d3bd7b00962abbbdfee84ec7e19f0d5b3175f9a31/pynacl-1.6.2-cp38-abi3-win_arm64.whl", hash = "sha256:834a43af110f743a754448463e8fd61259cd4ab5bbedcf70f9dabad1d28a394c", size = 184801, upload-time = "2026-01-01T17:32:36.309Z" }, +] + +[[package]] +name = "pyparsing" +version = "3.2.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f2/a5/181488fc2b9d093e3972d2a472855aae8a03f000592dbfce716a512b3359/pyparsing-3.2.5.tar.gz", hash = "sha256:2df8d5b7b2802ef88e8d016a2eb9c7aeaa923529cd251ed0fe4608275d4105b6", size = 1099274, upload-time = "2025-09-21T04:11:06.277Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/5e/1aa9a93198c6b64513c9d7752de7422c06402de6600a8767da1524f9570b/pyparsing-3.2.5-py3-none-any.whl", hash = "sha256:e38a4f02064cf41fe6593d328d0512495ad1f3d8a91c4f73fc401b3079a59a5e", size = 113890, upload-time = "2025-09-21T04:11:04.117Z" }, +] + +[[package]] +name = "pytest" +version = "9.0.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" }, +] + +[[package]] +name = "pytest-cov" +version = "6.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "coverage", extra = ["toml"] }, + { name = "pluggy" }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/30/4c/f883ab8f0daad69f47efdf95f55a66b51a8b939c430dadce0611508d9e99/pytest_cov-6.3.0.tar.gz", hash = "sha256:35c580e7800f87ce892e687461166e1ac2bcb8fb9e13aea79032518d6e503ff2", size = 70398, upload-time = "2025-09-06T15:40:14.361Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/80/b4/bb7263e12aade3842b938bc5c6958cae79c5ee18992f9b9349019579da0f/pytest_cov-6.3.0-py3-none-any.whl", hash = "sha256:440db28156d2468cafc0415b4f8e50856a0d11faefa38f30906048fe490f1749", size = 25115, upload-time = "2025-09-06T15:40:12.44Z" }, +] + +[[package]] +name = "pytest-httpx" +version = "0.36.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "httpx" }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4e/42/f53c58570e80d503ade9dd42ce57f2915d14bcbe25f6308138143950d1d6/pytest_httpx-0.36.2.tar.gz", hash = "sha256:05a56527484f7f4e8c856419ea379b8dc359c36801c4992fdb330f294c690356", size = 57683, upload-time = "2026-04-09T13:57:19.837Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/55/1fa65f8e4fceb19dd6daa867c162ad845d547f6058cd92b4b02384a44777/pytest_httpx-0.36.2-py3-none-any.whl", hash = "sha256:d42ebd5679442dc7bfb0c48e0767b6562e9bc4534d805127b0084171886a5e22", size = 20315, upload-time = "2026-04-09T13:57:18.587Z" }, +] + +[[package]] +name = "pytest-mock" +version = "3.15.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/68/14/eb014d26be205d38ad5ad20d9a80f7d201472e08167f0bb4361e251084a9/pytest_mock-3.15.1.tar.gz", hash = "sha256:1849a238f6f396da19762269de72cb1814ab44416fa73a8686deac10b0d87a0f", size = 34036, upload-time = "2025-09-16T16:37:27.081Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/cc/06253936f4a7fa2e0f48dfe6d851d9c56df896a9ab09ac019d70b760619c/pytest_mock-3.15.1-py3-none-any.whl", hash = "sha256:0a25e2eb88fe5168d535041d09a4529a188176ae608a6d249ee65abc0949630d", size = 10095, upload-time = "2025-09-16T16:37:25.734Z" }, +] + +[[package]] +name = "pytest-sugar" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytest" }, + { name = "termcolor" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0b/4e/60fed105549297ba1a700e1ea7b828044842ea27d72c898990510b79b0e2/pytest-sugar-1.1.1.tar.gz", hash = "sha256:73b8b65163ebf10f9f671efab9eed3d56f20d2ca68bda83fa64740a92c08f65d", size = 16533, upload-time = "2025-08-23T12:19:35.737Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/87/d5/81d38a91c1fdafb6711f053f5a9b92ff788013b19821257c2c38c1e132df/pytest_sugar-1.1.1-py3-none-any.whl", hash = "sha256:2f8319b907548d5b9d03a171515c1d43d2e38e32bd8182a1781eb20b43344cc8", size = 11440, upload-time = "2025-08-23T12:19:34.894Z" }, +] + +[[package]] +name = "pytest-xdist" +version = "3.8.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "execnet" }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/78/b4/439b179d1ff526791eb921115fca8e44e596a13efeda518b9d845a619450/pytest_xdist-3.8.0.tar.gz", hash = "sha256:7e578125ec9bc6050861aa93f2d59f1d8d085595d6551c2c90b6f4fad8d3a9f1", size = 88069, upload-time = "2025-07-01T13:30:59.346Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ca/31/d4e37e9e550c2b92a9cbc2e4d0b7420a27224968580b5a447f420847c975/pytest_xdist-3.8.0-py3-none-any.whl", hash = "sha256:202ca578cfeb7370784a8c33d6d05bc6e13b4f25b5053c30a152269fd10f0b88", size = 46396, upload-time = "2025-07-01T13:30:56.632Z" }, +] + +[[package]] +name = "python-dotenv" +version = "1.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f0/26/19cadc79a718c5edbec86fd4919a6b6d3f681039a2f6d66d14be94e75fb9/python_dotenv-1.2.1.tar.gz", hash = "sha256:42667e897e16ab0d66954af0e60a9caa94f0fd4ecf3aaf6d2d260eec1aa36ad6", size = 44221, upload-time = "2025-10-26T15:12:10.434Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/1b/a298b06749107c305e1fe0f814c6c74aea7b2f1e10989cb30f544a1b3253/python_dotenv-1.2.1-py3-none-any.whl", hash = "sha256:b81ee9561e9ca4004139c6cbba3a238c32b03e4894671e181b671e8cb8425d61", size = 21230, upload-time = "2025-10-26T15:12:09.109Z" }, +] + +[[package]] +name = "python-gitlab" +version = "6.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "requests" }, + { name = "requests-toolbelt" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9a/bd/b30f1d3b303cb5d3c72e2d57a847d699e8573cbdfd67ece5f1795e49da1c/python_gitlab-6.5.0.tar.gz", hash = "sha256:97553652d94b02de343e9ca92782239aa2b5f6594c5482331a9490d9d5e8737d", size = 400591, upload-time = "2025-10-17T21:40:02.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/bd/b0d440685fbcafee462bed793a74aea88541887c4c30556a55ac64914b8d/python_gitlab-6.5.0-py3-none-any.whl", hash = "sha256:494e1e8e5edd15286eaf7c286f3a06652688f1ee20a49e2a0218ddc5cc475e32", size = 144419, upload-time = "2025-10-17T21:40:01.233Z" }, +] + +[[package]] +name = "python-semantic-release" +version = "10.5.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "click-option-group" }, + { name = "deprecated" }, + { name = "dotty-dict" }, + { name = "gitpython" }, + { name = "importlib-resources" }, + { name = "jinja2" }, + { name = "pydantic" }, + { name = "python-gitlab" }, + { name = "requests" }, + { name = "rich" }, + { name = "shellingham" }, + { name = "tomlkit" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/3a/7332b822825ed0e902c6e950e0d1e90e8f666fd12eb27855d1c8b6677eff/python_semantic_release-10.5.3.tar.gz", hash = "sha256:de4da78635fa666e5774caaca2be32063cae72431eb75e2ac23b9f2dfd190785", size = 618034, upload-time = "2025-12-14T22:37:29.782Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6b/01/ada29a1215df601bded0a2efd3b6d53864a0a9e0a9ea52aeaebe14fd03fd/python_semantic_release-10.5.3-py3-none-any.whl", hash = "sha256:1be0e07c36fa1f1ec9da4f438c1f6bbd7bc10eb0d6ac0089b0643103708c2823", size = 152716, upload-time = "2025-12-14T22:37:28.089Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" }, + { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" }, + { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" }, + { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" }, + { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" }, + { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" }, + { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" }, + { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" }, + { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" }, + { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" }, + { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" }, + { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" }, + { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" }, + { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" }, + { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" }, + { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" }, + { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" }, + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, +] + +[[package]] +name = "requests" +version = "2.33.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", hash = "sha256:18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517", size = 134120, upload-time = "2026-03-30T16:09:15.531Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", hash = "sha256:4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a", size = 64947, upload-time = "2026-03-30T16:09:13.83Z" }, +] + +[[package]] +name = "requests-toolbelt" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f3/61/d7545dafb7ac2230c70d38d31cbfe4cc64f7144dc41f6e4e4b78ecd9f5bb/requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6", size = 206888, upload-time = "2023-05-01T04:11:33.229Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481, upload-time = "2023-05-01T04:11:28.427Z" }, +] + +[[package]] +name = "rich" +version = "14.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fb/d2/8920e102050a0de7bfabeb4c4614a49248cf8d5d7a8d01885fbb24dc767a/rich-14.2.0.tar.gz", hash = "sha256:73ff50c7c0c1c77c8243079283f4edb376f0f6442433aecb8ce7e6d0b92d1fe4", size = 219990, upload-time = "2025-10-09T14:16:53.064Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/7a/b0178788f8dc6cafce37a212c99565fa1fe7872c70c6c9c1e1a372d9d88f/rich-14.2.0-py3-none-any.whl", hash = "sha256:76bc51fe2e57d2b1be1f96c524b890b816e334ab4c1e45888799bfaab0021edd", size = 243393, upload-time = "2025-10-09T14:16:51.245Z" }, +] + +[[package]] +name = "ruff" +version = "0.11.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/52/f6/adcf73711f31c9f5393862b4281c875a462d9f639f4ccdf69dc368311c20/ruff-0.11.8.tar.gz", hash = "sha256:6d742d10626f9004b781f4558154bb226620a7242080e11caeffab1a40e99df8", size = 4086399, upload-time = "2025-05-01T14:53:24.459Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9f/60/c6aa9062fa518a9f86cb0b85248245cddcd892a125ca00441df77d79ef88/ruff-0.11.8-py3-none-linux_armv6l.whl", hash = "sha256:896a37516c594805e34020c4a7546c8f8a234b679a7716a3f08197f38913e1a3", size = 10272473, upload-time = "2025-05-01T14:52:37.252Z" }, + { url = "https://files.pythonhosted.org/packages/a0/e4/0325e50d106dc87c00695f7bcd5044c6d252ed5120ebf423773e00270f50/ruff-0.11.8-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ab86d22d3d721a40dd3ecbb5e86ab03b2e053bc93c700dc68d1c3346b36ce835", size = 11040862, upload-time = "2025-05-01T14:52:41.022Z" }, + { url = "https://files.pythonhosted.org/packages/e6/27/b87ea1a7be37fef0adbc7fd987abbf90b6607d96aa3fc67e2c5b858e1e53/ruff-0.11.8-py3-none-macosx_11_0_arm64.whl", hash = "sha256:258f3585057508d317610e8a412788cf726efeefa2fec4dba4001d9e6f90d46c", size = 10385273, upload-time = "2025-05-01T14:52:43.551Z" }, + { url = "https://files.pythonhosted.org/packages/d3/f7/3346161570d789045ed47a86110183f6ac3af0e94e7fd682772d89f7f1a1/ruff-0.11.8-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:727d01702f7c30baed3fc3a34901a640001a2828c793525043c29f7614994a8c", size = 10578330, upload-time = "2025-05-01T14:52:45.48Z" }, + { url = "https://files.pythonhosted.org/packages/c6/c3/327fb950b4763c7b3784f91d3038ef10c13b2d42322d4ade5ce13a2f9edb/ruff-0.11.8-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3dca977cc4fc8f66e89900fa415ffe4dbc2e969da9d7a54bfca81a128c5ac219", size = 10122223, upload-time = "2025-05-01T14:52:47.675Z" }, + { url = "https://files.pythonhosted.org/packages/de/c7/ba686bce9adfeb6c61cb1bbadc17d58110fe1d602f199d79d4c880170f19/ruff-0.11.8-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c657fa987d60b104d2be8b052d66da0a2a88f9bd1d66b2254333e84ea2720c7f", size = 11697353, upload-time = "2025-05-01T14:52:50.264Z" }, + { url = "https://files.pythonhosted.org/packages/53/8e/a4fb4a1ddde3c59e73996bb3ac51844ff93384d533629434b1def7a336b0/ruff-0.11.8-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:f2e74b021d0de5eceb8bd32919f6ff8a9b40ee62ed97becd44993ae5b9949474", size = 12375936, upload-time = "2025-05-01T14:52:52.394Z" }, + { url = "https://files.pythonhosted.org/packages/ad/a1/9529cb1e2936e2479a51aeb011307e7229225df9ac64ae064d91ead54571/ruff-0.11.8-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f9b5ef39820abc0f2c62111f7045009e46b275f5b99d5e59dda113c39b7f4f38", size = 11850083, upload-time = "2025-05-01T14:52:55.424Z" }, + { url = "https://files.pythonhosted.org/packages/3e/94/8f7eac4c612673ae15a4ad2bc0ee62e03c68a2d4f458daae3de0e47c67ba/ruff-0.11.8-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c1dba3135ca503727aa4648152c0fa67c3b1385d3dc81c75cd8a229c4b2a1458", size = 14005834, upload-time = "2025-05-01T14:52:58.056Z" }, + { url = "https://files.pythonhosted.org/packages/1e/7c/6f63b46b2be870cbf3f54c9c4154d13fac4b8827f22fa05ac835c10835b2/ruff-0.11.8-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f024d32e62faad0f76b2d6afd141b8c171515e4fb91ce9fd6464335c81244e5", size = 11503713, upload-time = "2025-05-01T14:53:01.244Z" }, + { url = "https://files.pythonhosted.org/packages/3a/91/57de411b544b5fe072779678986a021d87c3ee5b89551f2ca41200c5d643/ruff-0.11.8-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:d365618d3ad747432e1ae50d61775b78c055fee5936d77fb4d92c6f559741948", size = 10457182, upload-time = "2025-05-01T14:53:03.726Z" }, + { url = "https://files.pythonhosted.org/packages/01/49/cfe73e0ce5ecdd3e6f1137bf1f1be03dcc819d1bfe5cff33deb40c5926db/ruff-0.11.8-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:4d9aaa91035bdf612c8ee7266153bcf16005c7c7e2f5878406911c92a31633cb", size = 10101027, upload-time = "2025-05-01T14:53:06.555Z" }, + { url = "https://files.pythonhosted.org/packages/56/21/a5cfe47c62b3531675795f38a0ef1c52ff8de62eaddf370d46634391a3fb/ruff-0.11.8-py3-none-musllinux_1_2_i686.whl", hash = "sha256:0eba551324733efc76116d9f3a0d52946bc2751f0cd30661564117d6fd60897c", size = 11111298, upload-time = "2025-05-01T14:53:08.825Z" }, + { url = "https://files.pythonhosted.org/packages/36/98/f76225f87e88f7cb669ae92c062b11c0a1e91f32705f829bd426f8e48b7b/ruff-0.11.8-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:161eb4cff5cfefdb6c9b8b3671d09f7def2f960cee33481dd898caf2bcd02304", size = 11566884, upload-time = "2025-05-01T14:53:11.626Z" }, + { url = "https://files.pythonhosted.org/packages/de/7e/fff70b02e57852fda17bd43f99dda37b9bcf3e1af3d97c5834ff48d04715/ruff-0.11.8-py3-none-win32.whl", hash = "sha256:5b18caa297a786465cc511d7f8be19226acf9c0a1127e06e736cd4e1878c3ea2", size = 10451102, upload-time = "2025-05-01T14:53:14.303Z" }, + { url = "https://files.pythonhosted.org/packages/7b/a9/eaa571eb70648c9bde3120a1d5892597de57766e376b831b06e7c1e43945/ruff-0.11.8-py3-none-win_amd64.whl", hash = "sha256:6e70d11043bef637c5617297bdedec9632af15d53ac1e1ba29c448da9341b0c4", size = 11597410, upload-time = "2025-05-01T14:53:16.571Z" }, + { url = "https://files.pythonhosted.org/packages/cd/be/f6b790d6ae98f1f32c645f8540d5c96248b72343b0a56fab3a07f2941897/ruff-0.11.8-py3-none-win_arm64.whl", hash = "sha256:304432e4c4a792e3da85b7699feb3426a0908ab98bf29df22a31b0cdd098fac2", size = 10713129, upload-time = "2025-05-01T14:53:22.27Z" }, +] + +[[package]] +name = "setuptools" +version = "80.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/5d/3bf57dcd21979b887f014ea83c24ae194cfcd12b9e0fda66b957c69d1fca/setuptools-80.9.0.tar.gz", hash = "sha256:f36b47402ecde768dbfafc46e8e4207b4360c654f1f3bb84475f0a28628fb19c", size = 1319958, upload-time = "2025-05-27T00:56:51.443Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/dc/17031897dae0efacfea57dfd3a82fdd2a2aeb58e0ff71b77b87e44edc772/setuptools-80.9.0-py3-none-any.whl", hash = "sha256:062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922", size = 1201486, upload-time = "2025-05-27T00:56:49.664Z" }, +] + +[[package]] +name = "shellingham" +version = "1.5.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" }, +] + +[[package]] +name = "smmap" +version = "5.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/44/cd/a040c4b3119bbe532e5b0732286f805445375489fceaec1f48306068ee3b/smmap-5.0.2.tar.gz", hash = "sha256:26ea65a03958fa0c8a1c7e8c7a58fdc77221b8910f6be2131affade476898ad5", size = 22329, upload-time = "2025-01-02T07:14:40.909Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/be/d09147ad1ec7934636ad912901c5fd7667e1c858e19d355237db0d0cd5e4/smmap-5.0.2-py3-none-any.whl", hash = "sha256:b30115f0def7d7531d22a0fb6502488d879e75b260a9db4d0819cfb25403af5e", size = 24303, upload-time = "2025-01-02T07:14:38.724Z" }, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" }, +] + +[[package]] +name = "snowballstemmer" +version = "3.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/75/a7/9810d872919697c9d01295633f5d574fb416d47e535f258272ca1f01f447/snowballstemmer-3.0.1.tar.gz", hash = "sha256:6d5eeeec8e9f84d4d56b847692bacf79bc2c8e90c7f80ca4444ff8b6f2e52895", size = 105575, upload-time = "2025-05-09T16:34:51.843Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/78/3565d011c61f5a43488987ee32b6f3f656e7f107ac2782dd57bdd7d91d9a/snowballstemmer-3.0.1-py3-none-any.whl", hash = "sha256:6cd7b3897da8d6c9ffb968a6781fa6532dce9c3618a4b127d920dab764a19064", size = 103274, upload-time = "2025-05-09T16:34:50.371Z" }, +] + +[[package]] +name = "sortedcontainers" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594, upload-time = "2021-05-16T22:03:42.897Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575, upload-time = "2021-05-16T22:03:41.177Z" }, +] + +[[package]] +name = "soupsieve" +version = "2.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6d/e6/21ccce3262dd4889aa3332e5a119a3491a95e8f60939870a3a035aabac0d/soupsieve-2.8.tar.gz", hash = "sha256:e2dd4a40a628cb5f28f6d4b0db8800b8f581b65bb380b97de22ba5ca8d72572f", size = 103472, upload-time = "2025-08-27T15:39:51.78Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/a0/bb38d3b76b8cae341dad93a2dd83ab7462e6dbcdd84d43f54ee60a8dc167/soupsieve-2.8-py3-none-any.whl", hash = "sha256:0cc76456a30e20f5d7f2e14a98a4ae2ee4e5abdc7c5ea0aafe795f344bc7984c", size = 36679, upload-time = "2025-08-27T15:39:50.179Z" }, +] + +[[package]] +name = "sphinx" +version = "8.1.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "alabaster" }, + { name = "babel" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "docutils" }, + { name = "imagesize" }, + { name = "jinja2" }, + { name = "packaging" }, + { name = "pygments" }, + { name = "requests" }, + { name = "snowballstemmer" }, + { name = "sphinxcontrib-applehelp" }, + { name = "sphinxcontrib-devhelp" }, + { name = "sphinxcontrib-htmlhelp" }, + { name = "sphinxcontrib-jsmath" }, + { name = "sphinxcontrib-qthelp" }, + { name = "sphinxcontrib-serializinghtml" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/be0b61178fe2cdcb67e2a92fc9ebb488e3c51c4f74a36a7824c0adf23425/sphinx-8.1.3.tar.gz", hash = "sha256:43c1911eecb0d3e161ad78611bc905d1ad0e523e4ddc202a58a821773dc4c927", size = 8184611, upload-time = "2024-10-13T20:27:13.93Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/60/1ddff83a56d33aaf6f10ec8ce84b4c007d9368b21008876fceda7e7381ef/sphinx-8.1.3-py3-none-any.whl", hash = "sha256:09719015511837b76bf6e03e42eb7595ac8c2e41eeb9c29c5b755c6b677992a2", size = 3487125, upload-time = "2024-10-13T20:27:10.448Z" }, +] + +[[package]] +name = "sphinx-autoapi" +version = "3.6.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "astroid", version = "3.3.11", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, + { name = "astroid", version = "4.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "jinja2" }, + { name = "pyyaml" }, + { name = "sphinx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/ad/c627976d5f4d812b203ef1136108bbd81ef9bbbfd3f700f1295c322c22e6/sphinx_autoapi-3.6.1.tar.gz", hash = "sha256:1ff2992b7d5e39ccf92413098a376e0f91e7b4ca532c4f3e71298dbc8a4a9900", size = 55456, upload-time = "2025-10-06T16:21:22.888Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ca/89/aea2f346fcdb44eb72464842e106b6291b2687feec2dd8b2de920ab89f28/sphinx_autoapi-3.6.1-py3-none-any.whl", hash = "sha256:6b7af0d5650f6eac1f4b85c1eb9f9a4911160ec7138bdc4451c77a5e94d5832c", size = 35334, upload-time = "2025-10-06T16:21:21.33Z" }, +] + +[[package]] +name = "sphinx-basic-ng" +version = "1.0.0b2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "sphinx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/98/0b/a866924ded68efec7a1759587a4e478aec7559d8165fac8b2ad1c0e774d6/sphinx_basic_ng-1.0.0b2.tar.gz", hash = "sha256:9ec55a47c90c8c002b5960c57492ec3021f5193cb26cebc2dc4ea226848651c9", size = 20736, upload-time = "2023-07-08T18:40:54.166Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3c/dd/018ce05c532a22007ac58d4f45232514cd9d6dd0ee1dc374e309db830983/sphinx_basic_ng-1.0.0b2-py3-none-any.whl", hash = "sha256:eb09aedbabfb650607e9b4b68c9d240b90b1e1be221d6ad71d61c52e29f7932b", size = 22496, upload-time = "2023-07-08T18:40:52.659Z" }, +] + +[[package]] +name = "sphinx-markdown-builder" +version = "0.6.8" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docutils" }, + { name = "sphinx" }, + { name = "tabulate" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/74/36/f4a2efb804e2b89a6a29338bd1e9895af806e465c4a13ca59271f9d40dfd/sphinx_markdown_builder-0.6.8.tar.gz", hash = "sha256:6141b566bf18dd1cd515a0a90efd91c6c4d10fc638554fab2fd19cba66543dd7", size = 22007, upload-time = "2025-01-19T01:58:20.497Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/31/98/7e8e11d4edce0947d89c5d00ed43d925a5254dc9733579382b04f77e5ff2/sphinx_markdown_builder-0.6.8-py3-none-any.whl", hash = "sha256:f04ab42d52449363228b9104569c56b778534f9c41a168af8cfc721a1e0e3edc", size = 17270, upload-time = "2025-01-19T01:58:19.296Z" }, +] + +[[package]] +name = "sphinxcontrib-applehelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/6e/b837e84a1a704953c62ef8776d45c3e8d759876b4a84fe14eba2859106fe/sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1", size = 20053, upload-time = "2024-07-29T01:09:00.465Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", size = 119300, upload-time = "2024-07-29T01:08:58.99Z" }, +] + +[[package]] +name = "sphinxcontrib-devhelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/d2/5beee64d3e4e747f316bae86b55943f51e82bb86ecd325883ef65741e7da/sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad", size = 12967, upload-time = "2024-07-29T01:09:23.417Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", size = 82530, upload-time = "2024-07-29T01:09:21.945Z" }, +] + +[[package]] +name = "sphinxcontrib-htmlhelp" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/93/983afd9aa001e5201eab16b5a444ed5b9b0a7a010541e0ddfbbfd0b2470c/sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9", size = 22617, upload-time = "2024-07-29T01:09:37.889Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", size = 98705, upload-time = "2024-07-29T01:09:36.407Z" }, +] + +[[package]] +name = "sphinxcontrib-jsmath" +version = "1.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/e8/9ed3830aeed71f17c026a07a5097edcf44b692850ef215b161b8ad875729/sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8", size = 5787, upload-time = "2019-01-21T16:10:16.347Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", size = 5071, upload-time = "2019-01-21T16:10:14.333Z" }, +] + +[[package]] +name = "sphinxcontrib-qthelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/68/bc/9104308fc285eb3e0b31b67688235db556cd5b0ef31d96f30e45f2e51cae/sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab", size = 17165, upload-time = "2024-07-29T01:09:56.435Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", size = 88743, upload-time = "2024-07-29T01:09:54.885Z" }, +] + +[[package]] +name = "sphinxcontrib-serializinghtml" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3b/44/6716b257b0aa6bfd51a1b31665d1c205fb12cb5ad56de752dfa15657de2f/sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d", size = 16080, upload-time = "2024-07-29T01:10:09.332Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072, upload-time = "2024-07-29T01:10:08.203Z" }, +] + +[[package]] +name = "syrupy" +version = "5.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c1/90/1a442d21527009d4b40f37fe50b606ebb68a6407142c2b5cc508c34b696b/syrupy-5.0.0.tar.gz", hash = "sha256:3282fe963fa5d4d3e47231b16d1d4d0f4523705e8199eeb99a22a1bc9f5942f2", size = 48881, upload-time = "2025-09-28T21:15:12.783Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9d/9a/6c68aad2ccfce6e2eeebbf5bb709d0240592eb51ff142ec4c8fbf3c2460a/syrupy-5.0.0-py3-none-any.whl", hash = "sha256:c848e1a980ca52a28715cd2d2b4d434db424699c05653bd1158fb31cf56e9546", size = 49087, upload-time = "2025-09-28T21:15:11.639Z" }, +] + +[[package]] +name = "tabulate" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ec/fe/802052aecb21e3797b8f7902564ab6ea0d60ff8ca23952079064155d1ae1/tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c", size = 81090, upload-time = "2022-10-06T17:21:48.54Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/44/4a5f08c96eb108af5cb50b41f76142f0afa346dfa99d5296fe7202a11854/tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f", size = 35252, upload-time = "2022-10-06T17:21:44.262Z" }, +] + +[[package]] +name = "termcolor" +version = "3.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/87/56/ab275c2b56a5e2342568838f0d5e3e66a32354adcc159b495e374cda43f5/termcolor-3.2.0.tar.gz", hash = "sha256:610e6456feec42c4bcd28934a8c87a06c3fa28b01561d46aa09a9881b8622c58", size = 14423, upload-time = "2025-10-25T19:11:42.586Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/d5/141f53d7c1eb2a80e6d3e9a390228c3222c27705cbe7f048d3623053f3ca/termcolor-3.2.0-py3-none-any.whl", hash = "sha256:a10343879eba4da819353c55cb8049b0933890c2ebf9ad5d3ecd2bb32ea96ea6", size = 7698, upload-time = "2025-10-25T19:11:41.536Z" }, +] + +[[package]] +name = "toml" +version = "0.10.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/be/ba/1f744cdc819428fc6b5084ec34d9b30660f6f9daaf70eead706e3203ec3c/toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f", size = 22253, upload-time = "2020-11-01T01:40:22.204Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/44/6f/7120676b6d73228c96e17f1f794d8ab046fc910d781c8d151120c3f1569e/toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b", size = 16588, upload-time = "2020-11-01T01:40:20.672Z" }, +] + +[[package]] +name = "tomli" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/52/ed/3f73f72945444548f33eba9a87fc7a6e969915e7b1acc8260b30e1f76a2f/tomli-2.3.0.tar.gz", hash = "sha256:64be704a875d2a59753d80ee8a533c3fe183e3f06807ff7dc2232938ccb01549", size = 17392, upload-time = "2025-10-08T22:01:47.119Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/2e/299f62b401438d5fe1624119c723f5d877acc86a4c2492da405626665f12/tomli-2.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:88bd15eb972f3664f5ed4b57c1634a97153b4bac4479dcb6a495f41921eb7f45", size = 153236, upload-time = "2025-10-08T22:01:00.137Z" }, + { url = "https://files.pythonhosted.org/packages/86/7f/d8fffe6a7aefdb61bced88fcb5e280cfd71e08939da5894161bd71bea022/tomli-2.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:883b1c0d6398a6a9d29b508c331fa56adbcdff647f6ace4dfca0f50e90dfd0ba", size = 148084, upload-time = "2025-10-08T22:01:01.63Z" }, + { url = "https://files.pythonhosted.org/packages/47/5c/24935fb6a2ee63e86d80e4d3b58b222dafaf438c416752c8b58537c8b89a/tomli-2.3.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d1381caf13ab9f300e30dd8feadb3de072aeb86f1d34a8569453ff32a7dea4bf", size = 234832, upload-time = "2025-10-08T22:01:02.543Z" }, + { url = "https://files.pythonhosted.org/packages/89/da/75dfd804fc11e6612846758a23f13271b76d577e299592b4371a4ca4cd09/tomli-2.3.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a0e285d2649b78c0d9027570d4da3425bdb49830a6156121360b3f8511ea3441", size = 242052, upload-time = "2025-10-08T22:01:03.836Z" }, + { url = "https://files.pythonhosted.org/packages/70/8c/f48ac899f7b3ca7eb13af73bacbc93aec37f9c954df3c08ad96991c8c373/tomli-2.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a154a9ae14bfcf5d8917a59b51ffd5a3ac1fd149b71b47a3a104ca4edcfa845", size = 239555, upload-time = "2025-10-08T22:01:04.834Z" }, + { url = "https://files.pythonhosted.org/packages/ba/28/72f8afd73f1d0e7829bfc093f4cb98ce0a40ffc0cc997009ee1ed94ba705/tomli-2.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:74bf8464ff93e413514fefd2be591c3b0b23231a77f901db1eb30d6f712fc42c", size = 245128, upload-time = "2025-10-08T22:01:05.84Z" }, + { url = "https://files.pythonhosted.org/packages/b6/eb/a7679c8ac85208706d27436e8d421dfa39d4c914dcf5fa8083a9305f58d9/tomli-2.3.0-cp311-cp311-win32.whl", hash = "sha256:00b5f5d95bbfc7d12f91ad8c593a1659b6387b43f054104cda404be6bda62456", size = 96445, upload-time = "2025-10-08T22:01:06.896Z" }, + { url = "https://files.pythonhosted.org/packages/0a/fe/3d3420c4cb1ad9cb462fb52967080575f15898da97e21cb6f1361d505383/tomli-2.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:4dc4ce8483a5d429ab602f111a93a6ab1ed425eae3122032db7e9acf449451be", size = 107165, upload-time = "2025-10-08T22:01:08.107Z" }, + { url = "https://files.pythonhosted.org/packages/ff/b7/40f36368fcabc518bb11c8f06379a0fd631985046c038aca08c6d6a43c6e/tomli-2.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d7d86942e56ded512a594786a5ba0a5e521d02529b3826e7761a05138341a2ac", size = 154891, upload-time = "2025-10-08T22:01:09.082Z" }, + { url = "https://files.pythonhosted.org/packages/f9/3f/d9dd692199e3b3aab2e4e4dd948abd0f790d9ded8cd10cbaae276a898434/tomli-2.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:73ee0b47d4dad1c5e996e3cd33b8a76a50167ae5f96a2607cbe8cc773506ab22", size = 148796, upload-time = "2025-10-08T22:01:10.266Z" }, + { url = "https://files.pythonhosted.org/packages/60/83/59bff4996c2cf9f9387a0f5a3394629c7efa5ef16142076a23a90f1955fa/tomli-2.3.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:792262b94d5d0a466afb5bc63c7daa9d75520110971ee269152083270998316f", size = 242121, upload-time = "2025-10-08T22:01:11.332Z" }, + { url = "https://files.pythonhosted.org/packages/45/e5/7c5119ff39de8693d6baab6c0b6dcb556d192c165596e9fc231ea1052041/tomli-2.3.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4f195fe57ecceac95a66a75ac24d9d5fbc98ef0962e09b2eddec5d39375aae52", size = 250070, upload-time = "2025-10-08T22:01:12.498Z" }, + { url = "https://files.pythonhosted.org/packages/45/12/ad5126d3a278f27e6701abde51d342aa78d06e27ce2bb596a01f7709a5a2/tomli-2.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e31d432427dcbf4d86958c184b9bfd1e96b5b71f8eb17e6d02531f434fd335b8", size = 245859, upload-time = "2025-10-08T22:01:13.551Z" }, + { url = "https://files.pythonhosted.org/packages/fb/a1/4d6865da6a71c603cfe6ad0e6556c73c76548557a8d658f9e3b142df245f/tomli-2.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7b0882799624980785240ab732537fcfc372601015c00f7fc367c55308c186f6", size = 250296, upload-time = "2025-10-08T22:01:14.614Z" }, + { url = "https://files.pythonhosted.org/packages/a0/b7/a7a7042715d55c9ba6e8b196d65d2cb662578b4d8cd17d882d45322b0d78/tomli-2.3.0-cp312-cp312-win32.whl", hash = "sha256:ff72b71b5d10d22ecb084d345fc26f42b5143c5533db5e2eaba7d2d335358876", size = 97124, upload-time = "2025-10-08T22:01:15.629Z" }, + { url = "https://files.pythonhosted.org/packages/06/1e/f22f100db15a68b520664eb3328fb0ae4e90530887928558112c8d1f4515/tomli-2.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:1cb4ed918939151a03f33d4242ccd0aa5f11b3547d0cf30f7c74a408a5b99878", size = 107698, upload-time = "2025-10-08T22:01:16.51Z" }, + { url = "https://files.pythonhosted.org/packages/89/48/06ee6eabe4fdd9ecd48bf488f4ac783844fd777f547b8d1b61c11939974e/tomli-2.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5192f562738228945d7b13d4930baffda67b69425a7f0da96d360b0a3888136b", size = 154819, upload-time = "2025-10-08T22:01:17.964Z" }, + { url = "https://files.pythonhosted.org/packages/f1/01/88793757d54d8937015c75dcdfb673c65471945f6be98e6a0410fba167ed/tomli-2.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:be71c93a63d738597996be9528f4abe628d1adf5e6eb11607bc8fe1a510b5dae", size = 148766, upload-time = "2025-10-08T22:01:18.959Z" }, + { url = "https://files.pythonhosted.org/packages/42/17/5e2c956f0144b812e7e107f94f1cc54af734eb17b5191c0bbfb72de5e93e/tomli-2.3.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4665508bcbac83a31ff8ab08f424b665200c0e1e645d2bd9ab3d3e557b6185b", size = 240771, upload-time = "2025-10-08T22:01:20.106Z" }, + { url = "https://files.pythonhosted.org/packages/d5/f4/0fbd014909748706c01d16824eadb0307115f9562a15cbb012cd9b3512c5/tomli-2.3.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4021923f97266babc6ccab9f5068642a0095faa0a51a246a6a02fccbb3514eaf", size = 248586, upload-time = "2025-10-08T22:01:21.164Z" }, + { url = "https://files.pythonhosted.org/packages/30/77/fed85e114bde5e81ecf9bc5da0cc69f2914b38f4708c80ae67d0c10180c5/tomli-2.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4ea38c40145a357d513bffad0ed869f13c1773716cf71ccaa83b0fa0cc4e42f", size = 244792, upload-time = "2025-10-08T22:01:22.417Z" }, + { url = "https://files.pythonhosted.org/packages/55/92/afed3d497f7c186dc71e6ee6d4fcb0acfa5f7d0a1a2878f8beae379ae0cc/tomli-2.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ad805ea85eda330dbad64c7ea7a4556259665bdf9d2672f5dccc740eb9d3ca05", size = 248909, upload-time = "2025-10-08T22:01:23.859Z" }, + { url = "https://files.pythonhosted.org/packages/f8/84/ef50c51b5a9472e7265ce1ffc7f24cd4023d289e109f669bdb1553f6a7c2/tomli-2.3.0-cp313-cp313-win32.whl", hash = "sha256:97d5eec30149fd3294270e889b4234023f2c69747e555a27bd708828353ab606", size = 96946, upload-time = "2025-10-08T22:01:24.893Z" }, + { url = "https://files.pythonhosted.org/packages/b2/b7/718cd1da0884f281f95ccfa3a6cc572d30053cba64603f79d431d3c9b61b/tomli-2.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:0c95ca56fbe89e065c6ead5b593ee64b84a26fca063b5d71a1122bf26e533999", size = 107705, upload-time = "2025-10-08T22:01:26.153Z" }, + { url = "https://files.pythonhosted.org/packages/19/94/aeafa14a52e16163008060506fcb6aa1949d13548d13752171a755c65611/tomli-2.3.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:cebc6fe843e0733ee827a282aca4999b596241195f43b4cc371d64fc6639da9e", size = 154244, upload-time = "2025-10-08T22:01:27.06Z" }, + { url = "https://files.pythonhosted.org/packages/db/e4/1e58409aa78eefa47ccd19779fc6f36787edbe7d4cd330eeeedb33a4515b/tomli-2.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4c2ef0244c75aba9355561272009d934953817c49f47d768070c3c94355c2aa3", size = 148637, upload-time = "2025-10-08T22:01:28.059Z" }, + { url = "https://files.pythonhosted.org/packages/26/b6/d1eccb62f665e44359226811064596dd6a366ea1f985839c566cd61525ae/tomli-2.3.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c22a8bf253bacc0cf11f35ad9808b6cb75ada2631c2d97c971122583b129afbc", size = 241925, upload-time = "2025-10-08T22:01:29.066Z" }, + { url = "https://files.pythonhosted.org/packages/70/91/7cdab9a03e6d3d2bb11beae108da5bdc1c34bdeb06e21163482544ddcc90/tomli-2.3.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0eea8cc5c5e9f89c9b90c4896a8deefc74f518db5927d0e0e8d4a80953d774d0", size = 249045, upload-time = "2025-10-08T22:01:31.98Z" }, + { url = "https://files.pythonhosted.org/packages/15/1b/8c26874ed1f6e4f1fcfeb868db8a794cbe9f227299402db58cfcc858766c/tomli-2.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b74a0e59ec5d15127acdabd75ea17726ac4c5178ae51b85bfe39c4f8a278e879", size = 245835, upload-time = "2025-10-08T22:01:32.989Z" }, + { url = "https://files.pythonhosted.org/packages/fd/42/8e3c6a9a4b1a1360c1a2a39f0b972cef2cc9ebd56025168c4137192a9321/tomli-2.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b5870b50c9db823c595983571d1296a6ff3e1b88f734a4c8f6fc6188397de005", size = 253109, upload-time = "2025-10-08T22:01:34.052Z" }, + { url = "https://files.pythonhosted.org/packages/22/0c/b4da635000a71b5f80130937eeac12e686eefb376b8dee113b4a582bba42/tomli-2.3.0-cp314-cp314-win32.whl", hash = "sha256:feb0dacc61170ed7ab602d3d972a58f14ee3ee60494292d384649a3dc38ef463", size = 97930, upload-time = "2025-10-08T22:01:35.082Z" }, + { url = "https://files.pythonhosted.org/packages/b9/74/cb1abc870a418ae99cd5c9547d6bce30701a954e0e721821df483ef7223c/tomli-2.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:b273fcbd7fc64dc3600c098e39136522650c49bca95df2d11cf3b626422392c8", size = 107964, upload-time = "2025-10-08T22:01:36.057Z" }, + { url = "https://files.pythonhosted.org/packages/54/78/5c46fff6432a712af9f792944f4fcd7067d8823157949f4e40c56b8b3c83/tomli-2.3.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:940d56ee0410fa17ee1f12b817b37a4d4e4dc4d27340863cc67236c74f582e77", size = 163065, upload-time = "2025-10-08T22:01:37.27Z" }, + { url = "https://files.pythonhosted.org/packages/39/67/f85d9bd23182f45eca8939cd2bc7050e1f90c41f4a2ecbbd5963a1d1c486/tomli-2.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f85209946d1fe94416debbb88d00eb92ce9cd5266775424ff81bc959e001acaf", size = 159088, upload-time = "2025-10-08T22:01:38.235Z" }, + { url = "https://files.pythonhosted.org/packages/26/5a/4b546a0405b9cc0659b399f12b6adb750757baf04250b148d3c5059fc4eb/tomli-2.3.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a56212bdcce682e56b0aaf79e869ba5d15a6163f88d5451cbde388d48b13f530", size = 268193, upload-time = "2025-10-08T22:01:39.712Z" }, + { url = "https://files.pythonhosted.org/packages/42/4f/2c12a72ae22cf7b59a7fe75b3465b7aba40ea9145d026ba41cb382075b0e/tomli-2.3.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c5f3ffd1e098dfc032d4d3af5c0ac64f6d286d98bc148698356847b80fa4de1b", size = 275488, upload-time = "2025-10-08T22:01:40.773Z" }, + { url = "https://files.pythonhosted.org/packages/92/04/a038d65dbe160c3aa5a624e93ad98111090f6804027d474ba9c37c8ae186/tomli-2.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5e01decd096b1530d97d5d85cb4dff4af2d8347bd35686654a004f8dea20fc67", size = 272669, upload-time = "2025-10-08T22:01:41.824Z" }, + { url = "https://files.pythonhosted.org/packages/be/2f/8b7c60a9d1612a7cbc39ffcca4f21a73bf368a80fc25bccf8253e2563267/tomli-2.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:8a35dd0e643bb2610f156cca8db95d213a90015c11fee76c946aa62b7ae7e02f", size = 279709, upload-time = "2025-10-08T22:01:43.177Z" }, + { url = "https://files.pythonhosted.org/packages/7e/46/cc36c679f09f27ded940281c38607716c86cf8ba4a518d524e349c8b4874/tomli-2.3.0-cp314-cp314t-win32.whl", hash = "sha256:a1f7f282fe248311650081faafa5f4732bdbfef5d45fe3f2e702fbc6f2d496e0", size = 107563, upload-time = "2025-10-08T22:01:44.233Z" }, + { url = "https://files.pythonhosted.org/packages/84/ff/426ca8683cf7b753614480484f6437f568fd2fda2edbdf57a2d3d8b27a0b/tomli-2.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:70a251f8d4ba2d9ac2542eecf008b3c8a9fc5c3f9f02c56a9d7952612be2fdba", size = 119756, upload-time = "2025-10-08T22:01:45.234Z" }, + { url = "https://files.pythonhosted.org/packages/77/b8/0135fadc89e73be292b473cb820b4f5a08197779206b33191e801feeae40/tomli-2.3.0-py3-none-any.whl", hash = "sha256:e95b1af3c5b07d9e643909b5abbec77cd9f1217e6d0bca72b0234736b9fb1f1b", size = 14408, upload-time = "2025-10-08T22:01:46.04Z" }, +] + +[[package]] +name = "tomlkit" +version = "0.13.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/18/0bbf3884e9eaa38819ebe46a7bd25dcd56b67434402b66a58c4b8e552575/tomlkit-0.13.3.tar.gz", hash = "sha256:430cf247ee57df2b94ee3fbe588e71d362a941ebb545dec29b53961d61add2a1", size = 185207, upload-time = "2025-06-05T07:13:44.947Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/75/8539d011f6be8e29f339c42e633aae3cb73bffa95dd0f9adec09b9c58e85/tomlkit-0.13.3-py3-none-any.whl", hash = "sha256:c89c649d79ee40629a9fda55f8ace8c6a1b42deb912b2a8fd8d942ddadb606b0", size = 38901, upload-time = "2025-06-05T07:13:43.546Z" }, +] + +[[package]] +name = "types-cffi" +version = "1.17.0.20260307" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "types-setuptools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/cf/f727256b5b17e8d54a08e3c40877b3c49fdb35e7f683f9ee295bd4df51e1/types_cffi-1.17.0.20260307.tar.gz", hash = "sha256:1a4f1168d43ed8cd2b0ed40a3eb870cda685a154d98478b0a65862084f190a02", size = 17437, upload-time = "2026-03-07T03:49:26.106Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/15/4564f173d031f64bf56964d192b6b705e679fc23c02704b84ccbcb809396/types_cffi-1.17.0.20260307-py3-none-any.whl", hash = "sha256:89b5b2c798d32fc6e3304903ed99af93fd608b741483ce7d57fa69eda40430e5", size = 20115, upload-time = "2026-03-07T03:49:25.031Z" }, +] + +[[package]] +name = "types-deprecated" +version = "1.2.15.20250304" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0e/67/eeefaaabb03b288aad85483d410452c8bbcbf8b2bd876b0e467ebd97415b/types_deprecated-1.2.15.20250304.tar.gz", hash = "sha256:c329030553029de5cc6cb30f269c11f4e00e598c4241290179f63cda7d33f719", size = 8015, upload-time = "2025-03-04T02:48:17.894Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4d/e3/c18aa72ab84e0bc127a3a94e93be1a6ac2cb281371d3a45376ab7cfdd31c/types_deprecated-1.2.15.20250304-py3-none-any.whl", hash = "sha256:86a65aa550ea8acf49f27e226b8953288cd851de887970fbbdf2239c116c3107", size = 8553, upload-time = "2025-03-04T02:48:16.666Z" }, +] + +[[package]] +name = "types-setuptools" +version = "82.0.0.20260210" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4b/90/796ac8c774a7f535084aacbaa6b7053d16fff5c630eff87c3ecff7896c37/types_setuptools-82.0.0.20260210.tar.gz", hash = "sha256:d9719fbbeb185254480ade1f25327c4654f8c00efda3fec36823379cebcdee58", size = 44768, upload-time = "2026-02-10T04:22:02.107Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3e/54/3489432b1d9bc713c9d8aa810296b8f5b0088403662959fb63a8acdbd4fc/types_setuptools-82.0.0.20260210-py3-none-any.whl", hash = "sha256:5124a7daf67f195c6054e0f00f1d97c69caad12fdcf9113eba33eff0bce8cd2b", size = 68433, upload-time = "2026-02-10T04:22:00.876Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, +] + +[[package]] +name = "typing-inspection" +version = "0.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" }, +] + +[[package]] +name = "uc-micro-py" +version = "1.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/91/7a/146a99696aee0609e3712f2b44c6274566bc368dfe8375191278045186b8/uc-micro-py-1.0.3.tar.gz", hash = "sha256:d321b92cff673ec58027c04015fcaa8bb1e005478643ff4a500882eaab88c48a", size = 6043, upload-time = "2024-02-09T16:52:01.654Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/37/87/1f677586e8ac487e29672e4b17455758fce261de06a0d086167bb760361a/uc_micro_py-1.0.3-py3-none-any.whl", hash = "sha256:db1dffff340817673d7b466ec86114a9dc0e9d4d9b5ba229d9d60e5c12600cd5", size = 6229, upload-time = "2024-02-09T16:52:00.371Z" }, +] + +[[package]] +name = "urllib3" +version = "2.6.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" }, +] + +[[package]] +name = "virtualenv" +version = "20.36.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "distlib" }, + { name = "filelock" }, + { name = "platformdirs" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/aa/a3/4d310fa5f00863544e1d0f4de93bddec248499ccf97d4791bc3122c9d4f3/virtualenv-20.36.1.tar.gz", hash = "sha256:8befb5c81842c641f8ee658481e42641c68b5eab3521d8e092d18320902466ba", size = 6032239, upload-time = "2026-01-09T18:21:01.296Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/2a/dc2228b2888f51192c7dc766106cd475f1b768c10caaf9727659726f7391/virtualenv-20.36.1-py3-none-any.whl", hash = "sha256:575a8d6b124ef88f6f51d56d656132389f961062a9177016a50e4f507bbcc19f", size = 6008258, upload-time = "2026-01-09T18:20:59.425Z" }, +] + +[[package]] +name = "wrapt" +version = "2.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/2a/6de8a50cb435b7f42c46126cf1a54b2aab81784e74c8595c8e025e8f36d3/wrapt-2.0.1.tar.gz", hash = "sha256:9c9c635e78497cacb81e84f8b11b23e0aacac7a136e73b8e5b2109a1d9fc468f", size = 82040, upload-time = "2025-11-07T00:45:33.312Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/61/0d/12d8c803ed2ce4e5e7d5b9f5f602721f9dfef82c95959f3ce97fa584bb5c/wrapt-2.0.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:64b103acdaa53b7caf409e8d45d39a8442fe6dcfec6ba3f3d141e0cc2b5b4dbd", size = 77481, upload-time = "2025-11-07T00:43:11.103Z" }, + { url = "https://files.pythonhosted.org/packages/05/3e/4364ebe221ebf2a44d9fc8695a19324692f7dd2795e64bd59090856ebf12/wrapt-2.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:91bcc576260a274b169c3098e9a3519fb01f2989f6d3d386ef9cbf8653de1374", size = 60692, upload-time = "2025-11-07T00:43:13.697Z" }, + { url = "https://files.pythonhosted.org/packages/1f/ff/ae2a210022b521f86a8ddcdd6058d137c051003812b0388a5e9a03d3fe10/wrapt-2.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ab594f346517010050126fcd822697b25a7031d815bb4fbc238ccbe568216489", size = 61574, upload-time = "2025-11-07T00:43:14.967Z" }, + { url = "https://files.pythonhosted.org/packages/c6/93/5cf92edd99617095592af919cb81d4bff61c5dbbb70d3c92099425a8ec34/wrapt-2.0.1-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:36982b26f190f4d737f04a492a68accbfc6fa042c3f42326fdfbb6c5b7a20a31", size = 113688, upload-time = "2025-11-07T00:43:18.275Z" }, + { url = "https://files.pythonhosted.org/packages/a0/0a/e38fc0cee1f146c9fb266d8ef96ca39fb14a9eef165383004019aa53f88a/wrapt-2.0.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:23097ed8bc4c93b7bf36fa2113c6c733c976316ce0ee2c816f64ca06102034ef", size = 115698, upload-time = "2025-11-07T00:43:19.407Z" }, + { url = "https://files.pythonhosted.org/packages/b0/85/bef44ea018b3925fb0bcbe9112715f665e4d5309bd945191da814c314fd1/wrapt-2.0.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8bacfe6e001749a3b64db47bcf0341da757c95959f592823a93931a422395013", size = 112096, upload-time = "2025-11-07T00:43:16.5Z" }, + { url = "https://files.pythonhosted.org/packages/7c/0b/733a2376e413117e497aa1a5b1b78e8f3a28c0e9537d26569f67d724c7c5/wrapt-2.0.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:8ec3303e8a81932171f455f792f8df500fc1a09f20069e5c16bd7049ab4e8e38", size = 114878, upload-time = "2025-11-07T00:43:20.81Z" }, + { url = "https://files.pythonhosted.org/packages/da/03/d81dcb21bbf678fcda656495792b059f9d56677d119ca022169a12542bd0/wrapt-2.0.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:3f373a4ab5dbc528a94334f9fe444395b23c2f5332adab9ff4ea82f5a9e33bc1", size = 111298, upload-time = "2025-11-07T00:43:22.229Z" }, + { url = "https://files.pythonhosted.org/packages/c9/d5/5e623040e8056e1108b787020d56b9be93dbbf083bf2324d42cde80f3a19/wrapt-2.0.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f49027b0b9503bf6c8cdc297ca55006b80c2f5dd36cecc72c6835ab6e10e8a25", size = 113361, upload-time = "2025-11-07T00:43:24.301Z" }, + { url = "https://files.pythonhosted.org/packages/a1/f3/de535ccecede6960e28c7b722e5744846258111d6c9f071aa7578ea37ad3/wrapt-2.0.1-cp310-cp310-win32.whl", hash = "sha256:8330b42d769965e96e01fa14034b28a2a7600fbf7e8f0cc90ebb36d492c993e4", size = 58035, upload-time = "2025-11-07T00:43:28.96Z" }, + { url = "https://files.pythonhosted.org/packages/21/15/39d3ca5428a70032c2ec8b1f1c9d24c32e497e7ed81aed887a4998905fcc/wrapt-2.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:1218573502a8235bb8a7ecaed12736213b22dcde9feab115fa2989d42b5ded45", size = 60383, upload-time = "2025-11-07T00:43:25.804Z" }, + { url = "https://files.pythonhosted.org/packages/43/c2/dfd23754b7f7a4dce07e08f4309c4e10a40046a83e9ae1800f2e6b18d7c1/wrapt-2.0.1-cp310-cp310-win_arm64.whl", hash = "sha256:eda8e4ecd662d48c28bb86be9e837c13e45c58b8300e43ba3c9b4fa9900302f7", size = 58894, upload-time = "2025-11-07T00:43:27.074Z" }, + { url = "https://files.pythonhosted.org/packages/98/60/553997acf3939079dab022e37b67b1904b5b0cc235503226898ba573b10c/wrapt-2.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0e17283f533a0d24d6e5429a7d11f250a58d28b4ae5186f8f47853e3e70d2590", size = 77480, upload-time = "2025-11-07T00:43:30.573Z" }, + { url = "https://files.pythonhosted.org/packages/2d/50/e5b3d30895d77c52105c6d5cbf94d5b38e2a3dd4a53d22d246670da98f7c/wrapt-2.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:85df8d92158cb8f3965aecc27cf821461bb5f40b450b03facc5d9f0d4d6ddec6", size = 60690, upload-time = "2025-11-07T00:43:31.594Z" }, + { url = "https://files.pythonhosted.org/packages/f0/40/660b2898703e5cbbb43db10cdefcc294274458c3ca4c68637c2b99371507/wrapt-2.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c1be685ac7700c966b8610ccc63c3187a72e33cab53526a27b2a285a662cd4f7", size = 61578, upload-time = "2025-11-07T00:43:32.918Z" }, + { url = "https://files.pythonhosted.org/packages/5b/36/825b44c8a10556957bc0c1d84c7b29a40e05fcf1873b6c40aa9dbe0bd972/wrapt-2.0.1-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:df0b6d3b95932809c5b3fecc18fda0f1e07452d05e2662a0b35548985f256e28", size = 114115, upload-time = "2025-11-07T00:43:35.605Z" }, + { url = "https://files.pythonhosted.org/packages/83/73/0a5d14bb1599677304d3c613a55457d34c344e9b60eda8a737c2ead7619e/wrapt-2.0.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4da7384b0e5d4cae05c97cd6f94faaf78cc8b0f791fc63af43436d98c4ab37bb", size = 116157, upload-time = "2025-11-07T00:43:37.058Z" }, + { url = "https://files.pythonhosted.org/packages/01/22/1c158fe763dbf0a119f985d945711d288994fe5514c0646ebe0eb18b016d/wrapt-2.0.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ec65a78fbd9d6f083a15d7613b2800d5663dbb6bb96003899c834beaa68b242c", size = 112535, upload-time = "2025-11-07T00:43:34.138Z" }, + { url = "https://files.pythonhosted.org/packages/5c/28/4f16861af67d6de4eae9927799b559c20ebdd4fe432e89ea7fe6fcd9d709/wrapt-2.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7de3cc939be0e1174969f943f3b44e0d79b6f9a82198133a5b7fc6cc92882f16", size = 115404, upload-time = "2025-11-07T00:43:39.214Z" }, + { url = "https://files.pythonhosted.org/packages/a0/8b/7960122e625fad908f189b59c4aae2d50916eb4098b0fb2819c5a177414f/wrapt-2.0.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:fb1a5b72cbd751813adc02ef01ada0b0d05d3dcbc32976ce189a1279d80ad4a2", size = 111802, upload-time = "2025-11-07T00:43:40.476Z" }, + { url = "https://files.pythonhosted.org/packages/3e/73/7881eee5ac31132a713ab19a22c9e5f1f7365c8b1df50abba5d45b781312/wrapt-2.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3fa272ca34332581e00bf7773e993d4f632594eb2d1b0b162a9038df0fd971dd", size = 113837, upload-time = "2025-11-07T00:43:42.921Z" }, + { url = "https://files.pythonhosted.org/packages/45/00/9499a3d14e636d1f7089339f96c4409bbc7544d0889f12264efa25502ae8/wrapt-2.0.1-cp311-cp311-win32.whl", hash = "sha256:fc007fdf480c77301ab1afdbb6ab22a5deee8885f3b1ed7afcb7e5e84a0e27be", size = 58028, upload-time = "2025-11-07T00:43:47.369Z" }, + { url = "https://files.pythonhosted.org/packages/70/5d/8f3d7eea52f22638748f74b102e38fdf88cb57d08ddeb7827c476a20b01b/wrapt-2.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:47434236c396d04875180171ee1f3815ca1eada05e24a1ee99546320d54d1d1b", size = 60385, upload-time = "2025-11-07T00:43:44.34Z" }, + { url = "https://files.pythonhosted.org/packages/14/e2/32195e57a8209003587bbbad44d5922f13e0ced2a493bb46ca882c5b123d/wrapt-2.0.1-cp311-cp311-win_arm64.whl", hash = "sha256:837e31620e06b16030b1d126ed78e9383815cbac914693f54926d816d35d8edf", size = 58893, upload-time = "2025-11-07T00:43:46.161Z" }, + { url = "https://files.pythonhosted.org/packages/cb/73/8cb252858dc8254baa0ce58ce382858e3a1cf616acebc497cb13374c95c6/wrapt-2.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1fdbb34da15450f2b1d735a0e969c24bdb8d8924892380126e2a293d9902078c", size = 78129, upload-time = "2025-11-07T00:43:48.852Z" }, + { url = "https://files.pythonhosted.org/packages/19/42/44a0db2108526ee6e17a5ab72478061158f34b08b793df251d9fbb9a7eb4/wrapt-2.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3d32794fe940b7000f0519904e247f902f0149edbe6316c710a8562fb6738841", size = 61205, upload-time = "2025-11-07T00:43:50.402Z" }, + { url = "https://files.pythonhosted.org/packages/4d/8a/5b4b1e44b791c22046e90d9b175f9a7581a8cc7a0debbb930f81e6ae8e25/wrapt-2.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:386fb54d9cd903ee0012c09291336469eb7b244f7183d40dc3e86a16a4bace62", size = 61692, upload-time = "2025-11-07T00:43:51.678Z" }, + { url = "https://files.pythonhosted.org/packages/11/53/3e794346c39f462bcf1f58ac0487ff9bdad02f9b6d5ee2dc84c72e0243b2/wrapt-2.0.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7b219cb2182f230676308cdcacd428fa837987b89e4b7c5c9025088b8a6c9faf", size = 121492, upload-time = "2025-11-07T00:43:55.017Z" }, + { url = "https://files.pythonhosted.org/packages/c6/7e/10b7b0e8841e684c8ca76b462a9091c45d62e8f2de9c4b1390b690eadf16/wrapt-2.0.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:641e94e789b5f6b4822bb8d8ebbdfc10f4e4eae7756d648b717d980f657a9eb9", size = 123064, upload-time = "2025-11-07T00:43:56.323Z" }, + { url = "https://files.pythonhosted.org/packages/0e/d1/3c1e4321fc2f5ee7fd866b2d822aa89b84495f28676fd976c47327c5b6aa/wrapt-2.0.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fe21b118b9f58859b5ebaa4b130dee18669df4bd111daad082b7beb8799ad16b", size = 117403, upload-time = "2025-11-07T00:43:53.258Z" }, + { url = "https://files.pythonhosted.org/packages/a4/b0/d2f0a413cf201c8c2466de08414a15420a25aa83f53e647b7255cc2fab5d/wrapt-2.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:17fb85fa4abc26a5184d93b3efd2dcc14deb4b09edcdb3535a536ad34f0b4dba", size = 121500, upload-time = "2025-11-07T00:43:57.468Z" }, + { url = "https://files.pythonhosted.org/packages/bd/45/bddb11d28ca39970a41ed48a26d210505120f925918592283369219f83cc/wrapt-2.0.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:b89ef9223d665ab255ae42cc282d27d69704d94be0deffc8b9d919179a609684", size = 116299, upload-time = "2025-11-07T00:43:58.877Z" }, + { url = "https://files.pythonhosted.org/packages/81/af/34ba6dd570ef7a534e7eec0c25e2615c355602c52aba59413411c025a0cb/wrapt-2.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a453257f19c31b31ba593c30d997d6e5be39e3b5ad9148c2af5a7314061c63eb", size = 120622, upload-time = "2025-11-07T00:43:59.962Z" }, + { url = "https://files.pythonhosted.org/packages/e2/3e/693a13b4146646fb03254636f8bafd20c621955d27d65b15de07ab886187/wrapt-2.0.1-cp312-cp312-win32.whl", hash = "sha256:3e271346f01e9c8b1130a6a3b0e11908049fe5be2d365a5f402778049147e7e9", size = 58246, upload-time = "2025-11-07T00:44:03.169Z" }, + { url = "https://files.pythonhosted.org/packages/a7/36/715ec5076f925a6be95f37917b66ebbeaa1372d1862c2ccd7a751574b068/wrapt-2.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:2da620b31a90cdefa9cd0c2b661882329e2e19d1d7b9b920189956b76c564d75", size = 60492, upload-time = "2025-11-07T00:44:01.027Z" }, + { url = "https://files.pythonhosted.org/packages/ef/3e/62451cd7d80f65cc125f2b426b25fbb6c514bf6f7011a0c3904fc8c8df90/wrapt-2.0.1-cp312-cp312-win_arm64.whl", hash = "sha256:aea9c7224c302bc8bfc892b908537f56c430802560e827b75ecbde81b604598b", size = 58987, upload-time = "2025-11-07T00:44:02.095Z" }, + { url = "https://files.pythonhosted.org/packages/ad/fe/41af4c46b5e498c90fc87981ab2972fbd9f0bccda597adb99d3d3441b94b/wrapt-2.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:47b0f8bafe90f7736151f61482c583c86b0693d80f075a58701dd1549b0010a9", size = 78132, upload-time = "2025-11-07T00:44:04.628Z" }, + { url = "https://files.pythonhosted.org/packages/1c/92/d68895a984a5ebbbfb175512b0c0aad872354a4a2484fbd5552e9f275316/wrapt-2.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:cbeb0971e13b4bd81d34169ed57a6dda017328d1a22b62fda45e1d21dd06148f", size = 61211, upload-time = "2025-11-07T00:44:05.626Z" }, + { url = "https://files.pythonhosted.org/packages/e8/26/ba83dc5ae7cf5aa2b02364a3d9cf74374b86169906a1f3ade9a2d03cf21c/wrapt-2.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb7cffe572ad0a141a7886a1d2efa5bef0bf7fe021deeea76b3ab334d2c38218", size = 61689, upload-time = "2025-11-07T00:44:06.719Z" }, + { url = "https://files.pythonhosted.org/packages/cf/67/d7a7c276d874e5d26738c22444d466a3a64ed541f6ef35f740dbd865bab4/wrapt-2.0.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c8d60527d1ecfc131426b10d93ab5d53e08a09c5fa0175f6b21b3252080c70a9", size = 121502, upload-time = "2025-11-07T00:44:09.557Z" }, + { url = "https://files.pythonhosted.org/packages/0f/6b/806dbf6dd9579556aab22fc92908a876636e250f063f71548a8660382184/wrapt-2.0.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c654eafb01afac55246053d67a4b9a984a3567c3808bb7df2f8de1c1caba2e1c", size = 123110, upload-time = "2025-11-07T00:44:10.64Z" }, + { url = "https://files.pythonhosted.org/packages/e5/08/cdbb965fbe4c02c5233d185d070cabed2ecc1f1e47662854f95d77613f57/wrapt-2.0.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:98d873ed6c8b4ee2418f7afce666751854d6d03e3c0ec2a399bb039cd2ae89db", size = 117434, upload-time = "2025-11-07T00:44:08.138Z" }, + { url = "https://files.pythonhosted.org/packages/2d/d1/6aae2ce39db4cb5216302fa2e9577ad74424dfbe315bd6669725569e048c/wrapt-2.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c9e850f5b7fc67af856ff054c71690d54fa940c3ef74209ad9f935b4f66a0233", size = 121533, upload-time = "2025-11-07T00:44:12.142Z" }, + { url = "https://files.pythonhosted.org/packages/79/35/565abf57559fbe0a9155c29879ff43ce8bd28d2ca61033a3a3dd67b70794/wrapt-2.0.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e505629359cb5f751e16e30cf3f91a1d3ddb4552480c205947da415d597f7ac2", size = 116324, upload-time = "2025-11-07T00:44:13.28Z" }, + { url = "https://files.pythonhosted.org/packages/e1/e0/53ff5e76587822ee33e560ad55876d858e384158272cd9947abdd4ad42ca/wrapt-2.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2879af909312d0baf35f08edeea918ee3af7ab57c37fe47cb6a373c9f2749c7b", size = 120627, upload-time = "2025-11-07T00:44:14.431Z" }, + { url = "https://files.pythonhosted.org/packages/7c/7b/38df30fd629fbd7612c407643c63e80e1c60bcc982e30ceeae163a9800e7/wrapt-2.0.1-cp313-cp313-win32.whl", hash = "sha256:d67956c676be5a24102c7407a71f4126d30de2a569a1c7871c9f3cabc94225d7", size = 58252, upload-time = "2025-11-07T00:44:17.814Z" }, + { url = "https://files.pythonhosted.org/packages/85/64/d3954e836ea67c4d3ad5285e5c8fd9d362fd0a189a2db622df457b0f4f6a/wrapt-2.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:9ca66b38dd642bf90c59b6738af8070747b610115a39af2498535f62b5cdc1c3", size = 60500, upload-time = "2025-11-07T00:44:15.561Z" }, + { url = "https://files.pythonhosted.org/packages/89/4e/3c8b99ac93527cfab7f116089db120fef16aac96e5f6cdb724ddf286086d/wrapt-2.0.1-cp313-cp313-win_arm64.whl", hash = "sha256:5a4939eae35db6b6cec8e7aa0e833dcca0acad8231672c26c2a9ab7a0f8ac9c8", size = 58993, upload-time = "2025-11-07T00:44:16.65Z" }, + { url = "https://files.pythonhosted.org/packages/f9/f4/eff2b7d711cae20d220780b9300faa05558660afb93f2ff5db61fe725b9a/wrapt-2.0.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a52f93d95c8d38fed0669da2ebdb0b0376e895d84596a976c15a9eb45e3eccb3", size = 82028, upload-time = "2025-11-07T00:44:18.944Z" }, + { url = "https://files.pythonhosted.org/packages/0c/67/cb945563f66fd0f61a999339460d950f4735c69f18f0a87ca586319b1778/wrapt-2.0.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4e54bbf554ee29fcceee24fa41c4d091398b911da6e7f5d7bffda963c9aed2e1", size = 62949, upload-time = "2025-11-07T00:44:20.074Z" }, + { url = "https://files.pythonhosted.org/packages/ec/ca/f63e177f0bbe1e5cf5e8d9b74a286537cd709724384ff20860f8f6065904/wrapt-2.0.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:908f8c6c71557f4deaa280f55d0728c3bca0960e8c3dd5ceeeafb3c19942719d", size = 63681, upload-time = "2025-11-07T00:44:21.345Z" }, + { url = "https://files.pythonhosted.org/packages/39/a1/1b88fcd21fd835dca48b556daef750952e917a2794fa20c025489e2e1f0f/wrapt-2.0.1-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e2f84e9af2060e3904a32cea9bb6db23ce3f91cfd90c6b426757cf7cc01c45c7", size = 152696, upload-time = "2025-11-07T00:44:24.318Z" }, + { url = "https://files.pythonhosted.org/packages/62/1c/d9185500c1960d9f5f77b9c0b890b7fc62282b53af7ad1b6bd779157f714/wrapt-2.0.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e3612dc06b436968dfb9142c62e5dfa9eb5924f91120b3c8ff501ad878f90eb3", size = 158859, upload-time = "2025-11-07T00:44:25.494Z" }, + { url = "https://files.pythonhosted.org/packages/91/60/5d796ed0f481ec003220c7878a1d6894652efe089853a208ea0838c13086/wrapt-2.0.1-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6d2d947d266d99a1477cd005b23cbd09465276e302515e122df56bb9511aca1b", size = 146068, upload-time = "2025-11-07T00:44:22.81Z" }, + { url = "https://files.pythonhosted.org/packages/04/f8/75282dd72f102ddbfba137e1e15ecba47b40acff32c08ae97edbf53f469e/wrapt-2.0.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:7d539241e87b650cbc4c3ac9f32c8d1ac8a54e510f6dca3f6ab60dcfd48c9b10", size = 155724, upload-time = "2025-11-07T00:44:26.634Z" }, + { url = "https://files.pythonhosted.org/packages/5a/27/fe39c51d1b344caebb4a6a9372157bdb8d25b194b3561b52c8ffc40ac7d1/wrapt-2.0.1-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:4811e15d88ee62dbf5c77f2c3ff3932b1e3ac92323ba3912f51fc4016ce81ecf", size = 144413, upload-time = "2025-11-07T00:44:27.939Z" }, + { url = "https://files.pythonhosted.org/packages/83/2b/9f6b643fe39d4505c7bf926d7c2595b7cb4b607c8c6b500e56c6b36ac238/wrapt-2.0.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c1c91405fcf1d501fa5d55df21e58ea49e6b879ae829f1039faaf7e5e509b41e", size = 150325, upload-time = "2025-11-07T00:44:29.29Z" }, + { url = "https://files.pythonhosted.org/packages/bb/b6/20ffcf2558596a7f58a2e69c89597128781f0b88e124bf5a4cadc05b8139/wrapt-2.0.1-cp313-cp313t-win32.whl", hash = "sha256:e76e3f91f864e89db8b8d2a8311d57df93f01ad6bb1e9b9976d1f2e83e18315c", size = 59943, upload-time = "2025-11-07T00:44:33.211Z" }, + { url = "https://files.pythonhosted.org/packages/87/6a/0e56111cbb3320151eed5d3821ee1373be13e05b376ea0870711f18810c3/wrapt-2.0.1-cp313-cp313t-win_amd64.whl", hash = "sha256:83ce30937f0ba0d28818807b303a412440c4b63e39d3d8fc036a94764b728c92", size = 63240, upload-time = "2025-11-07T00:44:30.935Z" }, + { url = "https://files.pythonhosted.org/packages/1d/54/5ab4c53ea1f7f7e5c3e7c1095db92932cc32fd62359d285486d00c2884c3/wrapt-2.0.1-cp313-cp313t-win_arm64.whl", hash = "sha256:4b55cacc57e1dc2d0991dbe74c6419ffd415fb66474a02335cb10efd1aa3f84f", size = 60416, upload-time = "2025-11-07T00:44:32.002Z" }, + { url = "https://files.pythonhosted.org/packages/73/81/d08d83c102709258e7730d3cd25befd114c60e43ef3891d7e6877971c514/wrapt-2.0.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:5e53b428f65ece6d9dad23cb87e64506392b720a0b45076c05354d27a13351a1", size = 78290, upload-time = "2025-11-07T00:44:34.691Z" }, + { url = "https://files.pythonhosted.org/packages/f6/14/393afba2abb65677f313aa680ff0981e829626fed39b6a7e3ec807487790/wrapt-2.0.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ad3ee9d0f254851c71780966eb417ef8e72117155cff04821ab9b60549694a55", size = 61255, upload-time = "2025-11-07T00:44:35.762Z" }, + { url = "https://files.pythonhosted.org/packages/c4/10/a4a1f2fba205a9462e36e708ba37e5ac95f4987a0f1f8fd23f0bf1fc3b0f/wrapt-2.0.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d7b822c61ed04ee6ad64bc90d13368ad6eb094db54883b5dde2182f67a7f22c0", size = 61797, upload-time = "2025-11-07T00:44:37.22Z" }, + { url = "https://files.pythonhosted.org/packages/12/db/99ba5c37cf1c4fad35349174f1e38bd8d992340afc1ff27f526729b98986/wrapt-2.0.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7164a55f5e83a9a0b031d3ffab4d4e36bbec42e7025db560f225489fa929e509", size = 120470, upload-time = "2025-11-07T00:44:39.425Z" }, + { url = "https://files.pythonhosted.org/packages/30/3f/a1c8d2411eb826d695fc3395a431757331582907a0ec59afce8fe8712473/wrapt-2.0.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e60690ba71a57424c8d9ff28f8d006b7ad7772c22a4af432188572cd7fa004a1", size = 122851, upload-time = "2025-11-07T00:44:40.582Z" }, + { url = "https://files.pythonhosted.org/packages/b3/8d/72c74a63f201768d6a04a8845c7976f86be6f5ff4d74996c272cefc8dafc/wrapt-2.0.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3cd1a4bd9a7a619922a8557e1318232e7269b5fb69d4ba97b04d20450a6bf970", size = 117433, upload-time = "2025-11-07T00:44:38.313Z" }, + { url = "https://files.pythonhosted.org/packages/c7/5a/df37cf4042cb13b08256f8e27023e2f9b3d471d553376616591bb99bcb31/wrapt-2.0.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b4c2e3d777e38e913b8ce3a6257af72fb608f86a1df471cb1d4339755d0a807c", size = 121280, upload-time = "2025-11-07T00:44:41.69Z" }, + { url = "https://files.pythonhosted.org/packages/54/34/40d6bc89349f9931e1186ceb3e5fbd61d307fef814f09fbbac98ada6a0c8/wrapt-2.0.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3d366aa598d69416b5afedf1faa539fac40c1d80a42f6b236c88c73a3c8f2d41", size = 116343, upload-time = "2025-11-07T00:44:43.013Z" }, + { url = "https://files.pythonhosted.org/packages/70/66/81c3461adece09d20781dee17c2366fdf0cb8754738b521d221ca056d596/wrapt-2.0.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c235095d6d090aa903f1db61f892fffb779c1eaeb2a50e566b52001f7a0f66ed", size = 119650, upload-time = "2025-11-07T00:44:44.523Z" }, + { url = "https://files.pythonhosted.org/packages/46/3a/d0146db8be8761a9e388cc9cc1c312b36d583950ec91696f19bbbb44af5a/wrapt-2.0.1-cp314-cp314-win32.whl", hash = "sha256:bfb5539005259f8127ea9c885bdc231978c06b7a980e63a8a61c8c4c979719d0", size = 58701, upload-time = "2025-11-07T00:44:48.277Z" }, + { url = "https://files.pythonhosted.org/packages/1a/38/5359da9af7d64554be63e9046164bd4d8ff289a2dd365677d25ba3342c08/wrapt-2.0.1-cp314-cp314-win_amd64.whl", hash = "sha256:4ae879acc449caa9ed43fc36ba08392b9412ee67941748d31d94e3cedb36628c", size = 60947, upload-time = "2025-11-07T00:44:46.086Z" }, + { url = "https://files.pythonhosted.org/packages/aa/3f/96db0619276a833842bf36343685fa04f987dd6e3037f314531a1e00492b/wrapt-2.0.1-cp314-cp314-win_arm64.whl", hash = "sha256:8639b843c9efd84675f1e100ed9e99538ebea7297b62c4b45a7042edb84db03e", size = 59359, upload-time = "2025-11-07T00:44:47.164Z" }, + { url = "https://files.pythonhosted.org/packages/71/49/5f5d1e867bf2064bf3933bc6cf36ade23505f3902390e175e392173d36a2/wrapt-2.0.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:9219a1d946a9b32bb23ccae66bdb61e35c62773ce7ca6509ceea70f344656b7b", size = 82031, upload-time = "2025-11-07T00:44:49.4Z" }, + { url = "https://files.pythonhosted.org/packages/2b/89/0009a218d88db66ceb83921e5685e820e2c61b59bbbb1324ba65342668bc/wrapt-2.0.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:fa4184e74197af3adad3c889a1af95b53bb0466bced92ea99a0c014e48323eec", size = 62952, upload-time = "2025-11-07T00:44:50.74Z" }, + { url = "https://files.pythonhosted.org/packages/ae/18/9b968e920dd05d6e44bcc918a046d02afea0fb31b2f1c80ee4020f377cbe/wrapt-2.0.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c5ef2f2b8a53b7caee2f797ef166a390fef73979b15778a4a153e4b5fedce8fa", size = 63688, upload-time = "2025-11-07T00:44:52.248Z" }, + { url = "https://files.pythonhosted.org/packages/a6/7d/78bdcb75826725885d9ea26c49a03071b10c4c92da93edda612910f150e4/wrapt-2.0.1-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e042d653a4745be832d5aa190ff80ee4f02c34b21f4b785745eceacd0907b815", size = 152706, upload-time = "2025-11-07T00:44:54.613Z" }, + { url = "https://files.pythonhosted.org/packages/dd/77/cac1d46f47d32084a703df0d2d29d47e7eb2a7d19fa5cbca0e529ef57659/wrapt-2.0.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2afa23318136709c4b23d87d543b425c399887b4057936cd20386d5b1422b6fa", size = 158866, upload-time = "2025-11-07T00:44:55.79Z" }, + { url = "https://files.pythonhosted.org/packages/8a/11/b521406daa2421508903bf8d5e8b929216ec2af04839db31c0a2c525eee0/wrapt-2.0.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6c72328f668cf4c503ffcf9434c2b71fdd624345ced7941bc6693e61bbe36bef", size = 146148, upload-time = "2025-11-07T00:44:53.388Z" }, + { url = "https://files.pythonhosted.org/packages/0c/c0/340b272bed297baa7c9ce0c98ef7017d9c035a17a6a71dce3184b8382da2/wrapt-2.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3793ac154afb0e5b45d1233cb94d354ef7a983708cc3bb12563853b1d8d53747", size = 155737, upload-time = "2025-11-07T00:44:56.971Z" }, + { url = "https://files.pythonhosted.org/packages/f3/93/bfcb1fb2bdf186e9c2883a4d1ab45ab099c79cbf8f4e70ea453811fa3ea7/wrapt-2.0.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:fec0d993ecba3991645b4857837277469c8cc4c554a7e24d064d1ca291cfb81f", size = 144451, upload-time = "2025-11-07T00:44:58.515Z" }, + { url = "https://files.pythonhosted.org/packages/d2/6b/dca504fb18d971139d232652656180e3bd57120e1193d9a5899c3c0b7cdd/wrapt-2.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:949520bccc1fa227274da7d03bf238be15389cd94e32e4297b92337df9b7a349", size = 150353, upload-time = "2025-11-07T00:44:59.753Z" }, + { url = "https://files.pythonhosted.org/packages/1d/f6/a1de4bd3653afdf91d250ca5c721ee51195df2b61a4603d4b373aa804d1d/wrapt-2.0.1-cp314-cp314t-win32.whl", hash = "sha256:be9e84e91d6497ba62594158d3d31ec0486c60055c49179edc51ee43d095f79c", size = 60609, upload-time = "2025-11-07T00:45:03.315Z" }, + { url = "https://files.pythonhosted.org/packages/01/3a/07cd60a9d26fe73efead61c7830af975dfdba8537632d410462672e4432b/wrapt-2.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:61c4956171c7434634401db448371277d07032a81cc21c599c22953374781395", size = 64038, upload-time = "2025-11-07T00:45:00.948Z" }, + { url = "https://files.pythonhosted.org/packages/41/99/8a06b8e17dddbf321325ae4eb12465804120f699cd1b8a355718300c62da/wrapt-2.0.1-cp314-cp314t-win_arm64.whl", hash = "sha256:35cdbd478607036fee40273be8ed54a451f5f23121bd9d4be515158f9498f7ad", size = 60634, upload-time = "2025-11-07T00:45:02.087Z" }, + { url = "https://files.pythonhosted.org/packages/15/d1/b51471c11592ff9c012bd3e2f7334a6ff2f42a7aed2caffcf0bdddc9cb89/wrapt-2.0.1-py3-none-any.whl", hash = "sha256:4d2ce1bf1a48c5277d7969259232b57645aae5686dba1eaeade39442277afbca", size = 44046, upload-time = "2025-11-07T00:45:32.116Z" }, +] + +[[package]] +name = "xhd-wallet-api" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, + { name = "types-cffi" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/fb/a50dbe3ec6ed5b7257894735e46306bd11c0daee09e971441b2fadeeb05c/xhd_wallet_api-1.0.0-py3-none-macosx_10_9_x86_64.whl", hash = "sha256:e37dbb3f434d9baf28f49decf09d52a8ab64a58f926d50f49eab124a961a3a7e", size = 378250, upload-time = "2026-03-27T15:51:37.789Z" }, + { url = "https://files.pythonhosted.org/packages/f0/46/32d7fdbc321a89ba5cedbf772a328badd76c3ff0e04c61d574f93801032e/xhd_wallet_api-1.0.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:915a89efacc1174f64af07c52672b026a355aee4374ab04d92721fc2b0930db9", size = 363100, upload-time = "2026-03-27T15:51:39.447Z" }, + { url = "https://files.pythonhosted.org/packages/64/df/51a32ee17ed10723239215a6dc6a3eda81308ed9f29a10598de61d5fa25f/xhd_wallet_api-1.0.0-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:092b079f244e5d88c254d8af3630181b4c049269374e4e25ed764baf417fdd3d", size = 386354, upload-time = "2026-03-27T15:51:40.729Z" }, + { url = "https://files.pythonhosted.org/packages/53/5a/5da7ef4c70ede3b1bfbbe445a78857de99019b66169a0f9d75ebe0563e2f/xhd_wallet_api-1.0.0-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:38b4843464cdf2398ca635bc4cb6ba37ef7fbd2191c6b9053743bcc66a4784be", size = 395015, upload-time = "2026-03-27T15:51:41.964Z" }, + { url = "https://files.pythonhosted.org/packages/d2/f8/6052412d8b360240fa4958319dc257a01517e864a1539accda639a7836cc/xhd_wallet_api-1.0.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:71d6aa0291fea0f0ecc22f7eda8a0f61482dc92e19345c0a354dd8a4f1bdb72a", size = 450127, upload-time = "2026-03-27T15:51:43.178Z" }, + { url = "https://files.pythonhosted.org/packages/f8/38/9f3d3849e1bdff900f405dc4a636c872c189e0f4d3202bdfa969e3206825/xhd_wallet_api-1.0.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:a956ca70a155de9a0afc528a3bf216f9408172bc54afc5b8103c5425c5f9f912", size = 474598, upload-time = "2026-03-27T15:51:44.47Z" }, + { url = "https://files.pythonhosted.org/packages/b1/78/5477067a40347a88af0b57b9dabf0f1dc3e5796f785073c2dd157434f56b/xhd_wallet_api-1.0.0-py3-none-win_amd64.whl", hash = "sha256:d4a633e0cdb8095e941b9ce84e05e96904ef273f7b655abd81f13f265bf195a9", size = 267934, upload-time = "2026-03-27T15:51:45.654Z" }, +]