├── tests
    ├── __init__.py
    ├── functional
    │   ├── __init__.py
    │   ├── test_chain.py
    │   ├── test_explorer.py
    │   ├── test_ecosystem.py
    │   ├── test_tokens.py
    │   ├── test_receipt.py
    │   ├── test_networks.py
    │   ├── test_provider.py
    │   ├── test_utils.py
    │   ├── test_accounts.py
    │   └── test_contract.py
    ├── integration
    │   ├── __init__.py
    │   ├── test_misc.py
    │   ├── test_testnet.py
    │   ├── test_console.py
    │   ├── conftest.py
    │   └── test_accounts.py
    ├── projects
    │   ├── token
    │   │   ├── ape-config.yaml
    │   │   └── contracts
    │   │   │   ├── IFireEvents.cairo
    │   │   │   ├── UseToken.cairo
    │   │   │   ├── myeventlib
    │   │   │       └── library.cairo
    │   │   │   └── TestToken.cairo
    │   ├── project
    │   │   ├── ape-config.yaml
    │   │   └── contracts
    │   │   │   ├── EthContract.vy
    │   │   │   ├── ContractFactory.cairo
    │   │   │   └── MyContract.cairo
    │   └── proxy
    │   │   └── contracts
    │   │       ├── Proxy.cairo
    │   │       └── library.cairo
    └── data
    │   └── traces-testnet-block-243810_results.json
├── ape_starknet
    ├── py.typed
    ├── _cli.py
    ├── exceptions.py
    ├── config.py
    ├── types.py
    ├── conversion.py
    ├── __init__.py
    ├── explorer.py
    ├── udc.py
    ├── utils
    │   ├── basemodel.py
    │   └── __init__.py
    └── accounts
    │   └── _cli.py
├── .mdformat.toml
├── docs
    ├── userguides
    │   ├── quickstart.md
    │   ├── testing.md
    │   ├── contracts.md
    │   └── accounts.md
    ├── logo.gif
    ├── favicon.ico
    ├── methoddocs
    │   ├── tokens.md
    │   ├── accounts.md
    │   ├── explorer.md
    │   ├── provider.md
    │   ├── conversion.md
    │   ├── ecosystems.md
    │   ├── exceptions.md
    │   ├── transactions.md
    │   ├── types.md
    │   ├── udc.md
    │   └── utils.md
    ├── commands
    │   └── accounts.rst
    ├── index.md
    ├── _static
    │   ├── custom.js
    │   └── custom.css
    ├── conf.py
    └── _templates
    │   └── layout.html
├── setup.cfg
├── .github
    ├── workflows
    │   ├── draft.yaml
    │   ├── prtitle.yaml
    │   ├── publish.yaml
    │   ├── codeql.yml
    │   ├── stale-prs.yml
    │   ├── commitlint.yaml
    │   ├── docs.yaml
    │   └── test.yaml
    ├── PULL_REQUEST_TEMPLATE.md
    ├── ISSUE_TEMPLATE
    │   ├── feature.md
    │   ├── bug.md
    │   └── work-item.md
    └── release-drafter.yml
├── .pre-commit-config.yaml
├── pyproject.toml
├── .gitignore
├── CONTRIBUTING.md
├── README.md
├── setup.py
└── LICENSE


/tests/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/ape_starknet/py.typed:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/tests/functional/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/.mdformat.toml:
--------------------------------------------------------------------------------
1 | number = true
2 | 


--------------------------------------------------------------------------------
/tests/integration/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/docs/userguides/quickstart.md:
--------------------------------------------------------------------------------
1 | ```{include} ../../README.md
2 | ```
3 | 


--------------------------------------------------------------------------------
/docs/logo.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ApeWorX/archive-ape-starknet/HEAD/docs/logo.gif


--------------------------------------------------------------------------------
/docs/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ApeWorX/archive-ape-starknet/HEAD/docs/favicon.ico


--------------------------------------------------------------------------------
/setup.cfg:
--------------------------------------------------------------------------------
1 | [flake8]
2 | max-line-length = 100
3 | exclude =
4 | 	venv*
5 | 	.eggs
6 | 	docs
7 | 	build
8 | 	.git
9 | 


--------------------------------------------------------------------------------
/docs/methoddocs/tokens.md:
--------------------------------------------------------------------------------
1 | # Tokens
2 | 
3 | ```{eval-rst}
4 | .. automodule:: ape_starknet.tokens
5 |    :members:
6 | ```
7 | 


--------------------------------------------------------------------------------
/docs/methoddocs/accounts.md:
--------------------------------------------------------------------------------
1 | # Accounts
2 | 
3 | ```{eval-rst}
4 | .. automodule:: ape_starknet.accounts
5 |    :members:
6 | ```
7 | 


--------------------------------------------------------------------------------
/docs/methoddocs/explorer.md:
--------------------------------------------------------------------------------
1 | # Explorer
2 | 
3 | ```{eval-rst}
4 | .. automodule:: ape_starknet.explorer
5 |    :members:
6 | ```
7 | 


--------------------------------------------------------------------------------
/docs/methoddocs/provider.md:
--------------------------------------------------------------------------------
1 | # Provider
2 | 
3 | ```{eval-rst}
4 | .. automodule:: ape_starknet.provider
5 |    :members:
6 | ```
7 | 


--------------------------------------------------------------------------------
/docs/methoddocs/conversion.md:
--------------------------------------------------------------------------------
1 | # Conversion
2 | 
3 | ```{eval-rst}
4 | .. automodule:: ape_starknet.conversion
5 |    :members:
6 | ```
7 | 


--------------------------------------------------------------------------------
/docs/methoddocs/ecosystems.md:
--------------------------------------------------------------------------------
1 | # Ecosystems
2 | 
3 | ```{eval-rst}
4 | .. automodule:: ape_starknet.ecosystems
5 |    :members:
6 | ```
7 | 


--------------------------------------------------------------------------------
/docs/methoddocs/exceptions.md:
--------------------------------------------------------------------------------
1 | # Exceptions
2 | 
3 | ```{eval-rst}
4 | .. automodule:: ape_starknet.exceptions
5 |    :members:
6 | ```
7 | 


--------------------------------------------------------------------------------
/docs/commands/accounts.rst:
--------------------------------------------------------------------------------
1 | accounts
2 | ********
3 | 
4 | .. click:: ape_starknet.accounts._cli:accounts
5 |   :prog: accounts
6 |   :nested: full


--------------------------------------------------------------------------------
/docs/methoddocs/transactions.md:
--------------------------------------------------------------------------------
1 | # Transactions
2 | 
3 | ```{eval-rst}
4 | .. automodule:: ape_starknet.transactions
5 |    :members:
6 | ```
7 | 


--------------------------------------------------------------------------------
/docs/methoddocs/types.md:
--------------------------------------------------------------------------------
1 | # Types
2 | 
3 | ```{eval-rst}
4 | .. automodule:: ape_starknet.types
5 |    :members:
6 |    :show-inheritance:
7 | ```
8 | 


--------------------------------------------------------------------------------
/docs/methoddocs/udc.md:
--------------------------------------------------------------------------------
1 | # Universal Deployer Contract
2 | 
3 | ```{eval-rst}
4 | .. automodule:: ape_starknet.udc
5 |    :members:
6 |    :show-inheritance:
7 | ```
8 | 


--------------------------------------------------------------------------------
/tests/functional/test_chain.py:
--------------------------------------------------------------------------------
1 | def test_get_contract_instance(contract, chain):
2 |     actual = chain.contracts.instance_at(contract.address)
3 |     assert actual.address == contract.address
4 | 


--------------------------------------------------------------------------------
/ape_starknet/_cli.py:
--------------------------------------------------------------------------------
 1 | import click
 2 | 
 3 | from ape_starknet.accounts._cli import accounts
 4 | 
 5 | 
 6 | @click.group()
 7 | def cli():
 8 |     """Starknet ecosystem commands"""
 9 | 
10 | 
11 | cli.add_command(accounts)
12 | 


--------------------------------------------------------------------------------
/docs/methoddocs/utils.md:
--------------------------------------------------------------------------------
 1 | # Utils
 2 | 
 3 | ```{eval-rst}
 4 | .. automodule:: ape_starknet.utils
 5 |    :members:
 6 | ```
 7 | 
 8 | ```{eval-rst}
 9 | .. automodule:: ape_starknet.utils.basemodel
10 |     :members:
11 |     :show-inheritance:
12 | ```
13 | 


--------------------------------------------------------------------------------
/tests/integration/test_misc.py:
--------------------------------------------------------------------------------
1 | from .conftest import ApeStarknetCliRunner
2 | 
3 | 
4 | def test_plugin_loads(ape_cli):
5 |     runner = ApeStarknetCliRunner(ape_cli, ["starknet"])
6 |     output = runner.invoke("--help")
7 |     assert "ERROR" not in runner.invoke("--help"), output
8 | 


--------------------------------------------------------------------------------
/tests/projects/token/ape-config.yaml:
--------------------------------------------------------------------------------
 1 | default_ecosystem: starknet
 2 | 
 3 | dependencies:
 4 |   - name: OpenZeppelinCairo
 5 |     github: OpenZeppelin/cairo-contracts
 6 |     version: 0.5.0
 7 |     contracts_folder: src
 8 | 
 9 | cairo:
10 |   dependencies:
11 |     - OpenZeppelinCairo@0.5.0
12 | 


--------------------------------------------------------------------------------
/tests/projects/token/contracts/IFireEvents.cairo:
--------------------------------------------------------------------------------
 1 | %lang starknet
 2 | 
 3 | from starkware.cairo.common.uint256 import Uint256
 4 | 
 5 | 
 6 | @contract_interface
 7 | namespace IFireEvents {
 8 |     func fire_events(recipient: felt, amount0: Uint256, amount1: Uint256) -> () {
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/integration/test_testnet.py:
--------------------------------------------------------------------------------
1 | def test_can_connect_to_testnet(networks):
2 |     with networks.parse_network_choice("starknet:testnet") as provider:
3 |         eth_contract = provider.tokens["eth"]
4 |         address = "0x348ef2b95e31269b4a1c019428723e3a33cd964f92ad866741f189b88be3bc0"
5 |         assert eth_contract.balanceOf(address) is not None
6 | 


--------------------------------------------------------------------------------
/tests/projects/project/ape-config.yaml:
--------------------------------------------------------------------------------
 1 | default_ecosystem: starknet
 2 | 
 3 | # This contract was deployed to the live testnet
 4 | # to facilitate comparisons because local starknet-devnet
 5 | # and the live Goerli testnet response data.
 6 | deployments:
 7 |   starknet:
 8 |     testnet:
 9 |       - address: "0x106F49F2e7Fa56de62b110749312FED81656199E757a0645AF101BBB3EfCEc6"
10 |         contract_type: MyContract
11 | 


--------------------------------------------------------------------------------
/.github/workflows/draft.yaml:
--------------------------------------------------------------------------------
 1 | name: Release Drafter
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - main
 7 | 
 8 | jobs:
 9 |   update-draft:
10 |     runs-on: ubuntu-latest
11 |     steps:
12 |       # Drafts your next Release notes as Pull Requests are merged into "main"
13 |       - uses: release-drafter/release-drafter@v5
14 |         with:
15 |           disable-autolabeler: true
16 |         env:
17 |           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
18 | 


--------------------------------------------------------------------------------
/tests/projects/token/contracts/UseToken.cairo:
--------------------------------------------------------------------------------
 1 | %lang starknet
 2 | 
 3 | from starkware.cairo.common.cairo_builtins import HashBuiltin
 4 | from starkware.cairo.common.uint256 import Uint256
 5 | from IFireEvents import IFireEvents
 6 | 
 7 | 
 8 | @external
 9 | func fireTokenEvent{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(token: felt) {
10 |     IFireEvents.fire_events(token, 10000000, Uint256(100, 0), Uint256(200, 0));
11 |     return ();
12 | }
13 | 


--------------------------------------------------------------------------------
/tests/projects/token/contracts/myeventlib/library.cairo:
--------------------------------------------------------------------------------
 1 | // SPDX-License-Identifier: MIT
 2 | 
 3 | %lang starknet
 4 | 
 5 | from starkware.cairo.common.cairo_builtins import HashBuiltin
 6 | 
 7 | // Event for testing that it shows up in downstream contract
 8 | @event
 9 | func MyEventLib_ParentEvent(favorite_account: felt) {
10 | }
11 | 
12 | namespace MyEventLib {
13 |     func fire_event{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(person: felt) -> () {
14 |         MyEventLib_ParentEvent.emit(person);
15 |         return ();
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/.github/PULL_REQUEST_TEMPLATE.md:
--------------------------------------------------------------------------------
 1 | ### What I did
 2 | 
 3 | <!-- The `fixes:` field denotes an issue that will be marked resolved by merging this PR -->
 4 | 
 5 | fixes: #
 6 | 
 7 | ### How I did it
 8 | 
 9 | ### How to verify it
10 | 
11 | ### Checklist
12 | 
13 | - [ ] Passes all linting checks (pre-commit and CI jobs)
14 | - [ ] New test cases have been added and are passing
15 | - [ ] Documentation has been updated
16 | - [ ] PR title follows [Conventional Commit](https://www.conventionalcommits.org/en/v1.0.0/) standard (will be automatically included in the changelog)
17 | 


--------------------------------------------------------------------------------
/tests/projects/project/contracts/EthContract.vy:
--------------------------------------------------------------------------------
 1 | # @version 0.3.3
 2 | 
 3 | event NumberChange:
 4 |     prevNum: uint256
 5 |     newNum: indexed(uint256)
 6 | 
 7 | owner: public(address)
 8 | myNumber: public(uint256)
 9 | prevNumber: public(uint256)
10 | 
11 | @external
12 | def __init__():
13 |     self.owner = msg.sender
14 | 
15 | @external
16 | def setNumber(num: uint256):
17 |     assert msg.sender == self.owner, "!authorized"
18 |     assert num != 5
19 |     self.prevNumber = self.myNumber
20 |     self.myNumber = num
21 |     log NumberChange(self.prevNumber, num)
22 | 


--------------------------------------------------------------------------------
/.github/workflows/prtitle.yaml:
--------------------------------------------------------------------------------
 1 | name: PR Title
 2 | 
 3 | on:
 4 |   pull_request_target:
 5 |     types:
 6 |       - opened
 7 |       - edited
 8 |       - synchronize
 9 | 
10 | jobs:
11 |     check:
12 |         runs-on: ubuntu-latest
13 | 
14 |         steps:
15 |         - uses: actions/checkout@v3
16 | 
17 |         - name: Setup Python
18 |           uses: actions/setup-python@v4
19 |           with:
20 |               python-version: 3.9
21 | 
22 |         - name: Install Dependencies
23 |           run: pip install commitizen
24 | 
25 |         - name: Check PR Title
26 |           env:
27 |               TITLE: ${{ github.event.pull_request.title }}
28 |           run: cz check --message "$TITLE"
29 | 


--------------------------------------------------------------------------------
/tests/integration/test_console.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | from ape.api.networks import LOCAL_NETWORK_NAME
 3 | 
 4 | from .conftest import ApeStarknetCliRunner
 5 | 
 6 | 
 7 | @pytest.fixture(scope="session")
 8 | def console_runner(ape_cli):
 9 |     return ApeStarknetCliRunner(
10 |         ape_cli, ["console", "--network", f"ethereum:{LOCAL_NETWORK_NAME}:test"]
11 |     )
12 | 
13 | 
14 | def test_console_accounts_object(ape_cli, console_runner, key_file_account, networks):
15 |     # NOTE: This console connects to Eth-Tester and makes sure we can still _read_
16 |     # starknet accounts.
17 |     output = console_runner.invoke(
18 |         input=["accounts", f"accounts['{key_file_account.address}']", "exit"]
19 |     )
20 |     assert key_file_account.address in output, output
21 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/feature.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Feature request
 3 | about: Request a new feature, or an improvement to existing functionality.
 4 | labels: enhancement
 5 | ---
 6 | 
 7 | ### Overview
 8 | 
 9 | Provide a simple overview of what you wish to see added. Please include:
10 | 
11 | - What you are trying to do
12 | - Why Ape's current functionality is inadequate to address your goal
13 | 
14 | ### Specification
15 | 
16 | Describe the syntax and semantics of how you would like to see this feature implemented. The more detailed the better!
17 | 
18 | Remember, your feature is much more likely to be included if it does not involve any breaking changes.
19 | 
20 | ### Dependencies
21 | 
22 | Include links to any open issues that must be resolved before this feature can be implemented.
23 | 


--------------------------------------------------------------------------------
/.github/workflows/publish.yaml:
--------------------------------------------------------------------------------
 1 | name: Release
 2 | 
 3 | on:
 4 |   release:
 5 |     types: [released]
 6 | 
 7 | jobs:
 8 |   deploy:
 9 | 
10 |     runs-on: ubuntu-latest
11 | 
12 |     steps:
13 |     - uses: actions/checkout@v3
14 | 
15 |     - name: Set up Python
16 |       uses: actions/setup-python@v4
17 |       with:
18 |         python-version: 3.9
19 | 
20 |     - name: Install dependencies
21 |       run: |
22 |         python -m pip install --upgrade pip
23 |         pip install -e .[release]
24 |         
25 |     - name: Build
26 |       run: python setup.py sdist bdist_wheel
27 | 
28 |     - name: Publish
29 |       env:
30 |         TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
31 |         TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
32 |       run: twine upload dist/* --verbose
33 | 


--------------------------------------------------------------------------------
/.github/workflows/codeql.yml:
--------------------------------------------------------------------------------
 1 | name: "CodeQL"
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ "main" ]
 6 |   pull_request:
 7 |     branches: [ "main" ]
 8 | 
 9 | jobs:
10 |   analyze:
11 |     name: Analyze
12 |     runs-on: ubuntu-latest
13 |     permissions:
14 |       actions: read
15 |       contents: read
16 |       security-events: write
17 | 
18 |     strategy:
19 |       fail-fast: false
20 | 
21 |     steps:
22 |     - name: Checkout repository
23 |       uses: actions/checkout@v3
24 | 
25 |     - name: Initialize CodeQL
26 |       uses: github/codeql-action/init@v2
27 |       with:
28 |         languages: python
29 | 
30 |     - name: Autobuild
31 |       uses: github/codeql-action/autobuild@v2
32 | 
33 |     - name: Perform CodeQL Analysis
34 |       uses: github/codeql-action/analyze@v2
35 | 


--------------------------------------------------------------------------------
/.github/workflows/stale-prs.yml:
--------------------------------------------------------------------------------
 1 | name: "Close stale PRs"
 2 | on:
 3 |   schedule:
 4 |     - cron: '30 1 * * *'
 5 | 
 6 | jobs:
 7 |   stale:
 8 |     runs-on: ubuntu-latest
 9 |     permissions:
10 |       pull-requests: write
11 |     steps:
12 |       - uses: actions/stale@v6
13 |         with:
14 |           stale-pr-message: 'This pull request is considered stale because it has been open 30 days with no activity. Remove stale label, add a comment, or make a new commit, otherwise this PR will be closed in 5 days.'
15 |           close-pr-message: 'This PR was closed because it has been inactive for 35 days.'
16 |           stale-pr-label: "stale"
17 |           close-pr-label: "inactive"
18 |           days-before-pr-stale: 30
19 |           days-before-pr-close: 5
20 |           repo-token: ${{ secrets.GITHUB_TOKEN }}
21 | 


--------------------------------------------------------------------------------
/.github/workflows/commitlint.yaml:
--------------------------------------------------------------------------------
 1 | on: push
 2 | 
 3 | name: Commit Message
 4 | 
 5 | # NOTE: Skip check on PR so as not to confuse contributors
 6 | # NOTE: Also install a PR title checker so we don't mess up merges
 7 | jobs:
 8 |     check:
 9 |         runs-on: ubuntu-latest
10 | 
11 |         steps:
12 |         - uses: actions/checkout@v3
13 |           with:
14 |               fetch-depth: 0
15 | 
16 |         - name: Setup Python
17 |           uses: actions/setup-python@v4
18 |           with:
19 |               python-version: 3.9
20 | 
21 |         - name: Install Dependencies
22 |           run: |
23 |             python -m pip install --upgrade pip
24 |             pip install commitizen
25 | 
26 |         - name: Check commit history
27 |           run: cz check --rev-range $(git rev-list --all --reverse | head -1)..HEAD
28 | 


--------------------------------------------------------------------------------
/.github/release-drafter.yml:
--------------------------------------------------------------------------------
 1 | name-template: '$RESOLVED_VERSION'
 2 | tag-template: 'v$RESOLVED_VERSION'
 3 | 
 4 | categories:
 5 |   - title: 'Features'
 6 |     labels:
 7 |       - 'feat'
 8 |   - title: 'Bug Fixes'
 9 |     labels:
10 |       - 'fix'
11 |   - title: 'Other updates'
12 |     labels:
13 |       - 'refactor'
14 |       - 'chore'
15 |       - 'docs'
16 | 
17 | change-template: '- $TITLE @$AUTHOR (#$NUMBER)'
18 | change-title-escapes: '\<*_&' # You can add # and @ to disable mentions, and add ` to disable code blocks.
19 | 
20 | version-resolver:
21 |   major:
22 |     labels:
23 |       - 'major'
24 |   minor:
25 |     labels:
26 |       - 'minor'
27 |   patch:
28 |     labels:
29 |       - 'patch'
30 |   default: patch
31 | 
32 | template: |
33 |   ## Changes
34 |   
35 |   $CHANGES
36 |   
37 |   Special thanks to: $CONTRIBUTORS
38 | 


--------------------------------------------------------------------------------
/docs/index.md:
--------------------------------------------------------------------------------
 1 | # Ape-Starknet Documentation
 2 | 
 3 | ```{eval-rst}
 4 | .. toctree::
 5 |    :caption: User Guides
 6 |    :maxdepth: 1
 7 |    
 8 |    userguides/quickstart
 9 |    userguides/accounts
10 |    userguides/contracts
11 |    userguides/testing
12 | ```
13 | 
14 | ```{eval-rst}
15 | .. toctree::
16 |    :caption: CLI Reference
17 |    :maxdepth: 1
18 | 
19 |    commands/accounts.rst
20 | ```
21 | 
22 | ```{eval-rst}
23 | .. toctree::
24 |    :caption: Python Reference
25 |    :maxdepth: 1
26 |    
27 |    methoddocs/accounts.md
28 |    methoddocs/conversion.md
29 |    methoddocs/ecosystems.md
30 |    methoddocs/exceptions.md
31 |    methoddocs/explorer.md
32 |    methoddocs/provider.md
33 |    methoddocs/tokens.md
34 |    methoddocs/transactions.md
35 |    methoddocs/types.md
36 |    methoddocs/udc.md
37 |    methoddocs/utils.md
38 | ```
39 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Bug report
 3 | about: Report an error that you've encountered.
 4 | labels: bug
 5 | ---
 6 | 
 7 | ### Environment information
 8 | 
 9 | - `ape` and plugin versions:
10 | 
11 | ```
12 | $ ape --version
13 | # ...copy and paste result of above command here...
14 | 
15 | $ ape plugins list
16 | # ...copy and paste result of above command here...
17 | ```
18 | 
19 | - Python Version: x.x.x
20 | - OS: macOS/linux/win
21 | 
22 | ### What went wrong?
23 | 
24 | Please include information like:
25 | 
26 | - what command you ran
27 | - the code that caused the failure (see [this link](https://help.github.com/articles/basic-writing-and-formatting-syntax/) for help with formatting code)
28 | - full output of the error you received
29 | 
30 | ### How can it be fixed?
31 | 
32 | Fill this in if you have ideas on how the bug could be fixed.
33 | 


--------------------------------------------------------------------------------
/tests/functional/test_explorer.py:
--------------------------------------------------------------------------------
 1 | from ape_starknet.accounts import OPEN_ZEPPELIN_ACCOUNT_CONTRACT_TYPE
 2 | 
 3 | 
 4 | def test_get_contract_type_tokens(tokens, explorer):
 5 |     actual = explorer.get_contract_type(tokens.token_address_map["eth"]["local"])
 6 |     expected = tokens.contract_type
 7 |     assert actual == expected
 8 | 
 9 | 
10 | def test_get_contract_type_accounts(account, second_account, explorer):
11 |     actual_0 = explorer.get_contract_type(account.address)
12 |     actual_1 = explorer.get_contract_type(second_account.address)
13 |     assert actual_0 == OPEN_ZEPPELIN_ACCOUNT_CONTRACT_TYPE
14 |     assert actual_1 == OPEN_ZEPPELIN_ACCOUNT_CONTRACT_TYPE
15 | 
16 | 
17 | def test_get_contract_type_after_deploy(contract, explorer):
18 |     actual = explorer.get_contract_type(contract.address)
19 |     expected = contract.contract_type
20 |     assert actual.abi == expected.abi
21 | 


--------------------------------------------------------------------------------
/ape_starknet/exceptions.py:
--------------------------------------------------------------------------------
 1 | from ape.exceptions import AccountsError, ApeException, ProviderError
 2 | from ape.types import AddressType
 3 | 
 4 | 
 5 | class StarknetEcosystemError(ApeException):
 6 |     """
 7 |     A general Starknet ecosystem error.
 8 |     """
 9 | 
10 | 
11 | class StarknetProviderError(ProviderError):
12 |     """
13 |     An error raised by the Starknet provider.
14 |     """
15 | 
16 | 
17 | class StarknetTokensError(ApeException):
18 |     """
19 |     An error raised by the Starknet tokens manager.
20 |     """
21 | 
22 | 
23 | class StarknetAccountsError(AccountsError):
24 |     """
25 |     An error raised by a Starknet account.
26 |     """
27 | 
28 | 
29 | class ContractTypeNotFoundError(StarknetEcosystemError):
30 |     """
31 |     An error raised when unable to locate a contract type.
32 |     """
33 | 
34 |     def __init__(self, address: AddressType):
35 |         super().__init__(f"Failed to find contract type for '{address}'")
36 | 


--------------------------------------------------------------------------------
/.pre-commit-config.yaml:
--------------------------------------------------------------------------------
 1 | repos:
 2 | -   repo: https://github.com/pre-commit/pre-commit-hooks
 3 |     rev: v4.2.0
 4 |     hooks:
 5 |     -   id: check-yaml
 6 | 
 7 | -   repo: https://github.com/pre-commit/mirrors-isort
 8 |     rev: v5.10.1
 9 |     hooks:
10 |       - id: isort
11 | 
12 | -   repo: https://github.com/psf/black
13 |     rev: 22.12.0
14 |     hooks:
15 |       - id: black
16 |         name: black
17 | 
18 | -   repo: https://github.com/pycqa/flake8
19 |     rev: 5.0.4
20 |     hooks:
21 |     -   id: flake8
22 | 
23 | -   repo: https://github.com/pre-commit/mirrors-mypy
24 |     rev: v0.991
25 |     hooks:
26 |     -   id: mypy
27 |         additional_dependencies: [types-PyYAML, types-requests, types-setuptools, pydantic==1.10.4]
28 | 
29 | -   repo: https://github.com/executablebooks/mdformat
30 |     rev: 0.7.14
31 |     hooks:
32 |     -   id: mdformat
33 |         additional_dependencies: [mdformat-gfm, mdformat-frontmatter]
34 | 
35 | 
36 | default_language_version:
37 |     python: python3
38 | 


--------------------------------------------------------------------------------
/docs/userguides/testing.md:
--------------------------------------------------------------------------------
 1 | # Testing
 2 | 
 3 | You can learn more about testing from the ApeWorX documentation on [testing](https://docs.apeworx.io/ape/stable/userguides/testing.html).
 4 | 
 5 | ## Accounts
 6 | 
 7 | You can use `starknet-devnet` accounts in your tests.
 8 | 
 9 | ```python
10 | import pytest
11 | import ape
12 | 
13 | 
14 | @pytest.fixture
15 | def devnet_accounts():
16 |     return ape.accounts.containers["starknet"].test_accounts
17 | 
18 | 
19 | @pytest.fixture
20 | def owner(devnet_accounts):
21 |     return devnet_accounts[0]
22 | ```
23 | 
24 | Additionally, any accounts deployed in the local network are **not** saved to disk and are ephemeral.
25 | 
26 | ```python
27 | import pytest
28 | import ape
29 | 
30 | 
31 | @pytest.fixture(scope="session")
32 | def ephemeral_account():
33 |     accounts = ape.accounts.containers["starknet"]
34 |     accounts.deploy_account("ALIAS")
35 | 
36 |     # This account only exists in the devnet and is not a key-file account.
37 |     return accounts.load("ALIAS")
38 | ```
39 | 


--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
 1 | [build-system]
 2 | requires = ["setuptools>=51.1.1", "wheel", "setuptools_scm[toml]>=5.0"]
 3 | 
 4 | [tool.mypy]
 5 | exclude = "build/"
 6 | ignore_missing_imports = true
 7 | check_untyped_defs = true
 8 | plugins = ["pydantic.mypy"]
 9 | 
10 | 
11 | [tool.setuptools_scm]
12 | write_to = "ape_starknet/version.py"
13 | 
14 | # NOTE: you have to use single-quoted strings in TOML for regular expressions.
15 | # It's the equivalent of r-strings in Python.  Multiline strings are treated as
16 | # verbose regular expressions by Black.  Use [ ] to denote a significant space
17 | # character.
18 | 
19 | [tool.black]
20 | line-length = 100
21 | target-version = ['py38', 'py39', 'py310']
22 | include = '\.pyi?$'
23 | 
24 | [tool.pytest.ini_options]
25 | addopts = """
26 |     -p no:ape_test
27 |     --cov-branch
28 |     --cov-report term
29 |     --cov-report html
30 |     --cov-report xml
31 |     --cov=ape_starknet
32 | """
33 | python_files = "test_*.py"
34 | testpaths = "tests"
35 | markers = "fuzzing: Run Hypothesis fuzz test suite"
36 | asyncio_mode = "auto"
37 | 
38 | [tool.isort]
39 | line_length = 100
40 | force_grid_wrap = 0
41 | include_trailing_comma = true
42 | multi_line_output = 3
43 | use_parentheses = true
44 | 


--------------------------------------------------------------------------------
/ape_starknet/config.py:
--------------------------------------------------------------------------------
 1 | from ape.api import PluginConfig
 2 | from ape.api.networks import LOCAL_NETWORK_NAME
 3 | from ape.utils import DEFAULT_NUMBER_OF_TEST_ACCOUNTS
 4 | 
 5 | from ape_starknet.utils import DEFAULT_ACCOUNT_SEED
 6 | 
 7 | DEFAULT_PORT = 8545
 8 | 
 9 | 
10 | class NetworkConfig(PluginConfig):
11 |     required_confirmations: int = 0
12 |     block_time: int = 0
13 |     default_provider: str = "starknet"
14 | 
15 | 
16 | class ProviderConfig(PluginConfig):
17 |     mainnet: dict = {"uri": "https://alpha-mainnet.starknet.io"}
18 |     testnet: dict = {"uri": "https://alpha4.starknet.io"}
19 |     testnet2: dict = {"uri": "https://alpha4-2.starknet.io"}
20 |     local: dict = {
21 |         "uri": f"http://127.0.0.1:{DEFAULT_PORT}",
22 |         "seed": DEFAULT_ACCOUNT_SEED,
23 |         "number_of_accounts": DEFAULT_NUMBER_OF_TEST_ACCOUNTS,
24 |     }
25 | 
26 | 
27 | class StarknetConfig(PluginConfig):
28 |     mainnet: NetworkConfig = NetworkConfig(required_confirmations=7, block_time=13)
29 |     testnet: NetworkConfig = NetworkConfig(required_confirmations=2, block_time=15)
30 |     local: NetworkConfig = NetworkConfig()
31 |     default_network: str = LOCAL_NETWORK_NAME
32 |     provider: ProviderConfig = ProviderConfig()
33 | 


--------------------------------------------------------------------------------
/docs/_static/custom.js:
--------------------------------------------------------------------------------
 1 | function getSelectedDocsVersion(pathname) {
 2 |     if (!pathname) {
 3 |         pathname = document.location.pathname
 4 |     }
 5 |     let parts = pathname.split('/').filter(item => item !== "");
 6 |     if (parts.length === 1) {
 7 |         if (parts[0] === PROJECT) {
 8 |             // '/ape-starknet/' (return 'stable')
 9 |             return "stable";
10 |         } else {
11 |             // '/latest/' (return 'latest')
12 |             return parts[0];
13 |         }
14 |     } else if (parts[0] === PROJECT) {
15 |         // '/ape-starknet/latest/more' (return 'latest')
16 |         return parts[1];
17 |     } else {
18 |         // '/latest/more' (return 'latest')
19 |         return parts[0]
20 |     }
21 | }
22 | 
23 | $(document).ready(function () {
24 |     // Version picker logic
25 |     let current = getSelectedDocsVersion();
26 |     $("option[value='" + current + "']").attr("selected", "selected");
27 |     $("select").change(function () {
28 |         if (this.value === "") {
29 |             return false;
30 |         }
31 |         let current = getSelectedDocsVersion();
32 |         let selected = $(this).val();
33 |         $("option[value='" + selected + "']").attr("selected", "selected");
34 |         window.location = document.URL.replace(current, selected);
35 |     });
36 | });
37 | 


--------------------------------------------------------------------------------
/tests/projects/project/contracts/ContractFactory.cairo:
--------------------------------------------------------------------------------
 1 | %lang starknet
 2 | 
 3 | from starkware.cairo.common.alloc import alloc
 4 | from starkware.starknet.common.syscalls import deploy
 5 | from starkware.cairo.common.cairo_builtins import HashBuiltin
 6 | from starkware.cairo.common.bool import FALSE, TRUE
 7 | 
 8 | @storage_var
 9 | func class_hash() -> (class_hash: felt) {
10 | }
11 | 
12 | @storage_var
13 | func salt() -> (value: felt) {
14 | }
15 | 
16 | @event
17 | func contract_deployed(contract_address: felt) {
18 | }
19 | 
20 | @constructor
21 | func constructor{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(cls_hash: felt) {
22 |     class_hash.write(value=cls_hash);
23 |     return ();
24 | }
25 | 
26 | @external
27 | func create_my_contract{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() {
28 |     let (cls_hash) = class_hash.read();
29 |     let (current_salt) = salt.read();
30 |     let (ctor_calldata) = alloc();
31 |     let (contract_addr) = deploy(
32 |         class_hash=cls_hash,
33 |         contract_address_salt=current_salt,
34 |         constructor_calldata_size=0,
35 |         constructor_calldata=ctor_calldata,
36 |         deploy_from_zero=FALSE,
37 |     );
38 |     salt.write(value=current_salt + 1);
39 |     contract_deployed.emit(contract_address=contract_addr);
40 |     return ();
41 | }
42 | 


--------------------------------------------------------------------------------
/tests/integration/conftest.py:
--------------------------------------------------------------------------------
 1 | from typing import List, Optional, Union
 2 | 
 3 | import pytest
 4 | from ape._cli import cli
 5 | from click.testing import CliRunner
 6 | 
 7 | 
 8 | @pytest.fixture(scope="session")
 9 | def ape_cli():
10 |     yield cli
11 | 
12 | 
13 | class ApeStarknetCliRunner:
14 |     runner = CliRunner()
15 | 
16 |     def __init__(self, cli, base_cmd: List[str]):
17 |         self._cli = cli
18 |         self.base_cmd = base_cmd
19 | 
20 |     def invoke(
21 |         self, *cmd, input: Optional[Union[str, List[str]]] = None, ensure_successful: bool = True
22 |     ):
23 |         if isinstance(input, (list, tuple)):
24 |             input_str = "\n".join([str(i) for i in input])
25 |         else:
26 |             input_str = input or "\n"
27 | 
28 |         if not input_str.endswith("\n"):
29 |             input_str = f"{input_str}\n"
30 | 
31 |         ape_cmd = self._get_cmd(*cmd)
32 |         catch_exceptions = not ensure_successful
33 |         result = self.runner.invoke(
34 |             self._cli, ape_cmd, catch_exceptions=catch_exceptions, input=input_str
35 |         )
36 | 
37 |         if ensure_successful:
38 |             cmd_str = " ".join(ape_cmd)
39 |             msg = f"CMD '{cmd_str}' failed with output '{result.output}'"
40 |             assert result.exit_code == 0, msg
41 | 
42 |         return result.output
43 | 
44 |     def _get_cmd(self, *args) -> List[str]:
45 |         return [*self.base_cmd, *[str(a) for a in args]]
46 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/work-item.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Work item
 3 | about: New work item for Ape team
 4 | labels: backlog
 5 | ---
 6 | 
 7 | ### Elevator pitch
 8 | 
 9 | <!-- 1-2 line summary of the scope of this work item -->
10 | 
11 | ### Value
12 | 
13 | <!--
14 |   Who is this for?
15 |   Persona or group of people whom will derive value from the scenario.
16 |   What benefits will be achieved or business metrics improved?
17 | -->
18 | 
19 | ### Dependencies
20 | 
21 | <!-- Call out key people, teams, tech dependencies, or assumptions. -->
22 | 
23 | ### Design approach
24 | 
25 | <!--
26 |   Free text / diagram / whiteboard picture / etc. that clearly shows your approach and considerations to build the task list.
27 |   Existing code patterns in production code base that you will base your work off of.
28 | -->
29 | 
30 | ### Task list
31 | 
32 | <!-- Bulleted list describing the exit criteria, desired end state and any documentation, monitors, work for DRI, etc. that will need to be added to make sure someone else can support once it's live. -->
33 | 
34 | - [ ] Tasks go here
35 | 
36 | ### Estimated completion date
37 | 
38 | ### Design review
39 | 
40 | <!-- 1-2 people needed for signoff -->
41 | 
42 | Do not signoff unless:
43 | 
44 | - 1. agreed the tasks and design approach will achieve acceptance, and
45 | - 2. the work can be completed by one person within the SLA.
46 |      Design reviewers should consider simpler approaches to achieve goals.
47 | 
48 | (Please leave a comment to sign off)
49 | 


--------------------------------------------------------------------------------
/ape_starknet/types.py:
--------------------------------------------------------------------------------
 1 | from functools import reduce
 2 | from typing import Any, List, Optional
 3 | 
 4 | from ape.api import TransactionAPI
 5 | from pydantic import BaseModel
 6 | from starkware.crypto.signature.signature import pedersen_hash
 7 | 
 8 | from ape_starknet.utils import to_int
 9 | 
10 | 
11 | def _prepare_message(message: Any) -> List[int]:
12 |     if not isinstance(message, (list, tuple)):
13 |         message = [message]
14 | 
15 |     converted: List[int] = []
16 |     for value in message:
17 |         if isinstance(value, StarknetSignableMessage):
18 |             converted.extend(_prepare_message(value.message))
19 |         elif isinstance(value, (list, tuple)):
20 |             converted.extend(_prepare_message(value))
21 |         elif isinstance(value, TransactionAPI):
22 |             converted.append(to_int(value.txn_hash))
23 |         else:
24 |             converted.append(to_int(value))
25 | 
26 |     return converted
27 | 
28 | 
29 | class StarknetSignableMessage(BaseModel):
30 |     """
31 |     Starknet Signable Message
32 |     """
33 | 
34 |     message: Optional[Any]
35 | 
36 |     @property
37 |     def message_ints(self) -> List[int]:
38 |         return _prepare_message(self.message)
39 | 
40 |     @property
41 |     def hash(self) -> int:
42 |         return reduce(lambda x, y: pedersen_hash(y, x), self.message_ints, 0)
43 | 
44 |     def __str__(self) -> str:
45 |         return str(self.message)
46 | 
47 |     def __repr__(self) -> str:
48 |         return f"<message={self.message}>"
49 | 


--------------------------------------------------------------------------------
/ape_starknet/conversion.py:
--------------------------------------------------------------------------------
 1 | from typing import Any
 2 | 
 3 | from ape.api import ConverterAPI
 4 | from ape.types import AddressType
 5 | from eth_typing import HexAddress, HexStr
 6 | 
 7 | from ape_starknet.accounts import BaseStarknetAccount
 8 | from ape_starknet.utils import PLUGIN_NAME, is_checksum_address, is_hex_address, to_checksum_address
 9 | 
10 | 
11 | # NOTE: This utility converter ensures that all bytes args can accept hex too
12 | class StarknetAddressConverter(ConverterAPI):
13 |     """
14 |     A converter that converts ``str`` to ``AddressType``.
15 |     """
16 | 
17 |     def is_convertible(self, value: Any) -> bool:
18 |         provider = self.network_manager.active_provider
19 |         return (provider is not None and provider.network.ecosystem.name == PLUGIN_NAME) and (
20 |             (isinstance(value, str) and is_hex_address(value)) or isinstance(value, int)
21 |         )
22 | 
23 |     def convert(self, value: str) -> AddressType:
24 |         """
25 |         Convert the given value to a ``AddressType``.
26 | 
27 |         Args:
28 |             value (str): The address ``str`` to convert.
29 | 
30 |         Returns:
31 |             ``AddressType``
32 |         """
33 | 
34 |         if is_checksum_address(value):
35 |             return AddressType(HexAddress(HexStr(value)))
36 | 
37 |         return to_checksum_address(value)
38 | 
39 | 
40 | class StarknetAccountConverter(ConverterAPI):
41 |     """
42 |     A converter that converts accounts to address integers.
43 |     """
44 | 
45 |     def is_convertible(self, value: Any) -> bool:
46 |         return isinstance(value, BaseStarknetAccount)
47 | 
48 |     def convert(self, value: BaseStarknetAccount) -> int:
49 |         return value.address_int
50 | 


--------------------------------------------------------------------------------
/tests/projects/proxy/contracts/Proxy.cairo:
--------------------------------------------------------------------------------
 1 | // SPDX-License-Identifier: MIT
 2 | // OpenZeppelin Contracts for Cairo v0.2.0 (upgrades/Proxy.cairo)
 3 | 
 4 | %lang starknet
 5 | // %builtins pedersen range_check bitwise
 6 | 
 7 | from starkware.cairo.common.cairo_builtins import HashBuiltin
 8 | from starkware.starknet.common.syscalls import library_call, library_call_l1_handler
 9 | from library import Proxy
10 | 
11 | //
12 | // Constructor
13 | //
14 | 
15 | @constructor
16 | func constructor{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
17 |     implementation_hash: felt
18 | ) {
19 |     Proxy._set_implementation_hash(implementation_hash);
20 |     return ();
21 | }
22 | 
23 | //
24 | // Fallback functions
25 | //
26 | 
27 | @external
28 | @raw_input
29 | @raw_output
30 | func __default__{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
31 |     selector: felt, calldata_size: felt, calldata: felt*
32 | ) -> (retdata_size: felt, retdata: felt*) {
33 |     let (class_hash) = Proxy.get_implementation_hash();
34 | 
35 |     let (retdata_size: felt, retdata: felt*) = library_call(
36 |         class_hash=class_hash,
37 |         function_selector=selector,
38 |         calldata_size=calldata_size,
39 |         calldata=calldata,
40 |     );
41 |     return (retdata_size=retdata_size, retdata=retdata);
42 | }
43 | 
44 | @l1_handler
45 | @raw_input
46 | func __l1_default__{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
47 |     selector: felt, calldata_size: felt, calldata: felt*
48 | ) {
49 |     let (class_hash) = Proxy.get_implementation_hash();
50 | 
51 |     library_call_l1_handler(
52 |         class_hash=class_hash,
53 |         function_selector=selector,
54 |         calldata_size=calldata_size,
55 |         calldata=calldata,
56 |     );
57 |     return ();
58 | }
59 | 


--------------------------------------------------------------------------------
/tests/functional/test_ecosystem.py:
--------------------------------------------------------------------------------
 1 | from typing import Literal
 2 | 
 3 | import pytest
 4 | from ape.types import AddressType
 5 | from eth_typing import HexAddress, HexStr
 6 | from ethpm_types.abi import MethodABI
 7 | from hexbytes import HexBytes
 8 | from starkware.starknet.public.abi import get_selector_from_name
 9 | 
10 | INT_ADDRESS = 269168490721327376227480949634158339134330130662514218728945045982440529971
11 | STR_ADDRESS = "0x0098580E36aB1485C66F0Dc95c2c923E734B7aF44d04Dd2B5B9d0809Aa672033"
12 | HEXBYTES_ADDRESS = HexBytes(STR_ADDRESS)
13 | EVENT_NAME = "balance_increased"
14 | 
15 | 
16 | class CustomABI(MethodABI):
17 |     name: str = "Custom"
18 |     type: Literal["function"] = "function"
19 | 
20 | 
21 | @pytest.fixture(scope="module")
22 | def raw_logs():
23 |     return [
24 |         {
25 |             "data": ["4321"],
26 |             "from_address": "0x14acf3b7e92f97adee4d5359a7de3d673582f0ce03d33879cdbdbf03ec7fa5d",
27 |             "keys": [get_selector_from_name(EVENT_NAME)],
28 |             "transaction_hash": "0x7ccac756aafe0df416ee4f4ca74b42cdd7399ebae5aa31d92132dfbee445370",
29 |             "block_number": 5,
30 |             "block_hash": "0x7032c67f8741c6ce547175c2101d5ccdf468ca6ea0642bafccea04080726a06",
31 |         }
32 |     ]
33 | 
34 | 
35 | @pytest.fixture
36 | def event_abi(contract):
37 |     return contract.balance_increased.abi
38 | 
39 | 
40 | @pytest.mark.parametrize("value", (INT_ADDRESS, STR_ADDRESS, HEXBYTES_ADDRESS))
41 | def test_encode_and_decode_address(value, starknet):
42 |     decoded_address = starknet.decode_address(value)
43 |     expected = AddressType(HexAddress(HexStr(STR_ADDRESS)))
44 |     assert decoded_address == expected
45 | 
46 |     # The values should _always_ encode back to the INT_ADDRESS.
47 |     re_encoded_address = starknet.encode_address(decoded_address)
48 |     assert re_encoded_address == INT_ADDRESS
49 | 
50 | 
51 | def test_decode_logs(starknet, event_abi, raw_logs):
52 |     actual = list(starknet.decode_logs(raw_logs, event_abi))
53 |     assert len(actual) == 1
54 |     assert actual[0].amount == "4321"
55 | 


--------------------------------------------------------------------------------
/ape_starknet/__init__.py:
--------------------------------------------------------------------------------
 1 | from ape import plugins
 2 | from ape.api.networks import LOCAL_NETWORK_NAME, NetworkAPI, create_network_type
 3 | from ape.types import AddressType
 4 | 
 5 | from ape_starknet.accounts import StarknetAccountContainer, StarknetKeyfileAccount
 6 | from ape_starknet.config import StarknetConfig
 7 | from ape_starknet.conversion import StarknetAccountConverter, StarknetAddressConverter
 8 | from ape_starknet.ecosystems import Starknet
 9 | from ape_starknet.explorer import StarknetExplorer
10 | from ape_starknet.provider import StarknetDevnetProvider, StarknetProvider
11 | from ape_starknet.tokens import tokens
12 | from ape_starknet.utils import NETWORKS, PLUGIN_NAME
13 | 
14 | network_names = [LOCAL_NETWORK_NAME] + list(NETWORKS.keys())
15 | 
16 | 
17 | @plugins.register(plugins.ConversionPlugin)
18 | def converters():
19 |     yield AddressType, StarknetAddressConverter
20 |     yield int, StarknetAccountConverter
21 | 
22 | 
23 | @plugins.register(plugins.Config)
24 | def config_class():
25 |     return StarknetConfig
26 | 
27 | 
28 | @plugins.register(plugins.EcosystemPlugin)
29 | def ecosystems():
30 |     yield Starknet
31 | 
32 | 
33 | @plugins.register(plugins.NetworkPlugin)
34 | def networks():
35 |     for network_name, network_params in NETWORKS.items():
36 |         yield PLUGIN_NAME, network_name, create_network_type(*network_params)
37 | 
38 |     # NOTE: This works for development providers, as they get chain_id from themselves
39 |     yield PLUGIN_NAME, LOCAL_NETWORK_NAME, NetworkAPI
40 | 
41 | 
42 | @plugins.register(plugins.ProviderPlugin)
43 | def providers():
44 |     for network_name in list(NETWORKS.keys()):
45 |         yield PLUGIN_NAME, network_name, StarknetProvider
46 | 
47 |     yield PLUGIN_NAME, LOCAL_NETWORK_NAME, StarknetDevnetProvider
48 | 
49 | 
50 | @plugins.register(plugins.AccountPlugin)
51 | def account_types():
52 |     return StarknetAccountContainer, StarknetKeyfileAccount
53 | 
54 | 
55 | @plugins.register(plugins.ExplorerPlugin)
56 | def explorers():
57 |     for network_name in network_names:
58 |         yield PLUGIN_NAME, network_name, StarknetExplorer
59 | 
60 | 
61 | __all__ = [
62 |     "tokens",
63 | ]
64 | 


--------------------------------------------------------------------------------
/.github/workflows/docs.yaml:
--------------------------------------------------------------------------------
 1 | name: Docs
 2 | 
 3 | on:
 4 |     push:
 5 |         branches: [main]
 6 |     release:
 7 |         types: [released]
 8 |     pull_request:
 9 |         types: [opened, synchronize]
10 | 
11 | jobs:
12 |     docs:
13 |         runs-on: ubuntu-latest
14 | 
15 |         steps:
16 |         - uses: actions/checkout@v3
17 | 
18 |         - name: Setup Python
19 |           uses: actions/setup-python@v4
20 |           with:
21 |               python-version: 3.8
22 | 
23 |         - name: Install Dependencies
24 |           run: |
25 |             python -m pip install --upgrade pip
26 | 
27 |             # TODO: Remove once we have re-added Myst-Parser to setup.py (post sphinx 6 support)
28 |             pip install git+https://github.com/executablebooks/MyST-Parser.git
29 | 
30 |             pip install .[docs]
31 |         - name: Build HTML artifact
32 |           run: python build_docs.py
33 | 
34 |         - name: Upload HTML artifact
35 |           uses: actions/upload-artifact@v1
36 |           with:
37 |               name: DocumentationHTML
38 |               path: docs/_build/ape-starknet
39 | 
40 |         - name: Commit and publish documentation changes to gh-pages branch
41 |           run: |
42 |               if [[ "${GITHUB_EVENT_NAME}" =~ "pull_request" ]]; then
43 |                 echo "skipping 'git commit' step for PR"
44 |               else
45 |                 git clone https://github.com/${GITHUB_REPOSITORY} --branch gh-pages --single-branch gh-pages
46 |                 cp -r docs/_build/ape-starknet/* gh-pages/
47 |                 cd gh-pages
48 |                 touch .nojekyll
49 |                 git config --local user.email "action@github.com"
50 |                 git config --local user.name "GitHub Action"
51 |                 git add .
52 |                 git commit -m "Update documentation" -a || true
53 |               fi
54 |         - name: Push changes
55 |           uses: ad-m/github-push-action@master
56 |           if: ${{ github.event_name != 'pull_request' }}
57 |           with:
58 |               branch: gh-pages
59 |               directory: gh-pages
60 |               github_token: ${{ secrets.GITHUB_TOKEN }}
61 | 


--------------------------------------------------------------------------------
/tests/functional/test_tokens.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | 
 3 | all_tokens = pytest.mark.parametrize(
 4 |     "token",
 5 |     (
 6 |         "eth",
 7 |         "test_token",
 8 |         # "proxy_token",  # TODO: Fix local proxies
 9 |     ),
10 | )
11 | 
12 | 
13 | @pytest.fixture(scope="module", autouse=True)
14 | def ensure_token_deployed(token_contract):
15 |     _ = token_contract
16 | 
17 | 
18 | @all_tokens
19 | def test_get_balance(tokens, account, token_initial_supply, token):
20 |     if token == "eth":
21 |         # Likely spent fees
22 |         assert tokens.get_balance(account)
23 |     else:
24 |         assert tokens.get_balance(account, token=token) == token_initial_supply
25 | 
26 | 
27 | @all_tokens
28 | def test_transfer(tokens, account, second_account, token):
29 |     initial_balance = tokens.get_balance(second_account.address, token=token)
30 |     tokens.transfer(account.address, second_account.address, 10, token=token)
31 |     actual = tokens.get_balance(second_account.address, token=token)
32 |     expected = initial_balance + 10
33 |     assert actual == expected
34 | 
35 | 
36 | @all_tokens
37 | def test_transfer_providing_a_struct(tokens, account, second_account, token):
38 |     amount = {"low": 10, "high": 0}  # == Uint256(10, 0) == 10
39 |     initial_balance = tokens.get_balance(second_account, token=token)
40 |     tokens.transfer(account, second_account, amount, token=token)
41 |     assert tokens.get_balance(second_account, token=token) == initial_balance + 10
42 | 
43 | 
44 | def test_large_transfer(tokens, account, second_account):
45 |     initial_balance = tokens.get_balance(second_account.address, token="test_token")
46 | 
47 |     # Value large enough to properly test Uint256 logic
48 |     balance_to_transfer = 2**128 + 1
49 |     tokens.transfer(
50 |         account.address, second_account.address, balance_to_transfer, token="test_token"
51 |     )
52 |     actual = tokens.get_balance(second_account.address, token="test_token")
53 |     expected = initial_balance + balance_to_transfer
54 |     assert actual == expected
55 | 
56 | 
57 | @all_tokens
58 | def test_is_token(tokens, token):
59 |     # Ensure it's recognized as a token
60 |     assert tokens.is_token(tokens[token])
61 | 
62 | 
63 | def test_is_not_token(contract, tokens):
64 |     assert not tokens.is_token(contract.address)
65 | 


--------------------------------------------------------------------------------
/.github/workflows/test.yaml:
--------------------------------------------------------------------------------
 1 | on: ["push", "pull_request"]
 2 | 
 3 | name: Test
 4 | 
 5 | concurrency:
 6 |   # Cancel older, in-progress jobs from the same PR, same workflow.
 7 |   # use run_id if the job is triggered by a push to ensure
 8 |   # push-triggered jobs to not get canceled.
 9 |   group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
10 |   cancel-in-progress: true
11 | 
12 | jobs:
13 |     linting:
14 |         runs-on: ubuntu-latest
15 | 
16 |         steps:
17 |         - uses: actions/checkout@v3
18 | 
19 |         - name: Setup Python
20 |           uses: actions/setup-python@v4
21 |           with:
22 |               python-version: 3.9
23 | 
24 |         - name: Install Dependencies
25 |           run: |
26 |             python -m pip install --upgrade pip
27 |             pip install .[lint]
28 | 
29 |         - name: Run Black
30 |           run: black --check .
31 | 
32 |         - name: Run isort
33 |           run: isort --check-only .
34 | 
35 |         - name: Run flake8
36 |           run: flake8 .
37 | 
38 |         - name: Run mdformat
39 |           run: mdformat . --check
40 | 
41 |     type-check:
42 |         runs-on: ubuntu-latest
43 | 
44 |         steps:
45 |         - uses: actions/checkout@v3
46 | 
47 |         - name: Setup Python
48 |           uses: actions/setup-python@v4
49 |           with:
50 |               python-version: 3.9
51 | 
52 |         - name: Install Dependencies
53 |           run: |
54 |             python -m pip install --upgrade pip
55 |             pip install .[lint,test]
56 | 
57 |         - name: Run MyPy
58 |           run: mypy .
59 | 
60 |     functional:
61 |         runs-on: ${{ matrix.os }}
62 | 
63 |         strategy:
64 |             matrix:
65 |                 os: [ubuntu-latest, macos-latest]   # eventually add `windows-latest`
66 |                 python-version: [3.8, 3.9]
67 | 
68 |         env:
69 |           GITHUB_ACCESS_TOKEN: ${{ secrets.GITHUB_TOKEN }}
70 | 
71 |         steps:
72 |         - uses: actions/checkout@v3
73 | 
74 |         - name: Setup Python
75 |           uses: actions/setup-python@v4
76 |           with:
77 |               python-version: ${{ matrix.python-version }}
78 | 
79 |         - name: Install Dependencies
80 |           run: |
81 |             python -m pip install --upgrade pip
82 |             pip install .[test]
83 | 
84 |         - name: Run Tests
85 |           run: |
86 |             pytest -m "not fuzzing" -n 0 -s --cov
87 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | # Byte-compiled / optimized / DLL files
  2 | __pycache__/
  3 | *.py[cod]
  4 | *$py.class
  5 | 
  6 | # C extensions
  7 | *.so
  8 | 
  9 | # Distribution / packaging
 10 | .Python
 11 | build/
 12 | develop-eggs/
 13 | dist/
 14 | downloads/
 15 | eggs/
 16 | .eggs/
 17 | lib/
 18 | lib64/
 19 | parts/
 20 | sdist/
 21 | var/
 22 | wheels/
 23 | pip-wheel-metadata/
 24 | share/python-wheels/
 25 | *.egg-info/
 26 | .installed.cfg
 27 | *.egg
 28 | MANIFEST
 29 | 
 30 | # PyInstaller
 31 | #  Usually these files are written by a python script from a template
 32 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 33 | *.manifest
 34 | *.spec
 35 | 
 36 | # Installer logs
 37 | pip-log.txt
 38 | pip-delete-this-directory.txt
 39 | 
 40 | # Unit test / coverage reports
 41 | htmlcov/
 42 | .tox/
 43 | .nox/
 44 | .coverage
 45 | .coverage.*
 46 | .cache
 47 | nosetests.xml
 48 | coverage.xml
 49 | *.cover
 50 | *.py,cover
 51 | .hypothesis/
 52 | .pytest_cache/
 53 | 
 54 | # Translations
 55 | *.mo
 56 | *.pot
 57 | 
 58 | # Django stuff:
 59 | *.log
 60 | local_settings.py
 61 | db.sqlite3
 62 | db.sqlite3-journal
 63 | 
 64 | # Flask stuff:
 65 | instance/
 66 | .webassets-cache
 67 | 
 68 | # Scrapy stuff:
 69 | .scrapy
 70 | # Sphinx documentation
 71 | docs/_build/
 72 | 
 73 | # PyBuilder
 74 | target/
 75 | 
 76 | # Jupyter Notebook
 77 | .ipynb_checkpoints
 78 | 
 79 | # IPython
 80 | profile_default/
 81 | ipython_config.py
 82 | 
 83 | # pyenv
 84 | .python-version
 85 | 
 86 | # pipenv
 87 | #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
 88 | #   However, in case of collaboration, if having platform-specific dependencies or dependencies
 89 | #   having no cross-platform support, pipenv may install dependencies that don't work, or not
 90 | #   install all needed dependencies.
 91 | #Pipfile.lock
 92 | 
 93 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow
 94 | __pypackages__/
 95 | 
 96 | # Celery stuff
 97 | celerybeat-schedule
 98 | celerybeat.pid
 99 | 
100 | # Environments
101 | .env
102 | .venv
103 | env/
104 | venv/
105 | ENV/
106 | env.bak/
107 | venv.bak/
108 | 
109 | # mkdocs documentation
110 | /site
111 | 
112 | # mypy
113 | .mypy_cache/
114 | .dmypy.json
115 | dmypy.json
116 | 
117 | # setuptools-scm
118 | version.py
119 | 
120 | # Ape stuff
121 | .build/
122 | 
123 | # IDEs stuff
124 | .vscode
125 | 
126 | **/.DS_Store
127 | *.swp
128 | *.swo
129 | 


--------------------------------------------------------------------------------
/tests/functional/test_receipt.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | 
 3 | AMOUNT_0 = 10
 4 | AMOUNT_1 = 2**128 + 42
 5 | 
 6 | 
 7 | @pytest.fixture(scope="module")
 8 | def receipt(token_contract, second_account, account):
 9 |     return token_contract.fire_events(second_account, AMOUNT_0, AMOUNT_1, sender=account)
10 | 
11 | 
12 | def test_decode_logs(receipt, token_contract, account, second_account):
13 |     expected_sender = int(account.address, 16)
14 |     expected_receiver = int(second_account.address, 16)
15 |     transfer_logs = list(receipt.decode_logs(token_contract.Transfer))
16 | 
17 |     # TODO: Figure out why 1 extra strange Transfer event shows up (as of 0.5)
18 | 
19 |     assert transfer_logs
20 | 
21 |     mint_logs = list(receipt.decode_logs(token_contract.Mint))
22 |     assert len(mint_logs) == 1
23 |     log = mint_logs[-1]
24 |     assert log.sender == expected_sender
25 |     assert log.amount0 == AMOUNT_0
26 |     assert log.amount1 == AMOUNT_1
27 |     assert log.to == expected_receiver
28 | 
29 |     # Verify events emitted from imported function call show up in receipt.
30 |     lib_event = token_contract.contract_type.events["MyEventLib_ParentEvent"]
31 |     lib_logs = list(receipt.decode_logs(lib_event))
32 |     assert len(lib_logs) == 1
33 |     assert lib_logs[0].favorite_account == expected_receiver
34 | 
35 | 
36 | def test_decode_logs_when_logs_from_other_contract(token_contract, token_user_contract, account):
37 |     receipt = token_user_contract.fireTokenEvent(token_contract.address, sender=account)
38 |     transfer_logs = list(receipt.decode_logs(token_contract.Transfer))
39 |     mint_logs = list(receipt.decode_logs(token_contract.Mint))
40 | 
41 |     assert transfer_logs
42 |     assert len(mint_logs) == 1
43 |     assert mint_logs[-1].amount0 == 100
44 |     assert mint_logs[-1].amount1 == 200
45 | 
46 |     # The caller address is the user token
47 |     assert mint_logs[-1].sender == int(token_user_contract.address, 16)
48 | 
49 |     # Verify events emitted from imported function call show up in receipt.
50 |     lib_event = token_contract.contract_type.events["MyEventLib_ParentEvent"]
51 |     lib_logs = list(receipt.decode_logs(lib_event))
52 |     assert len(lib_logs) == 1
53 | 
54 | 
55 | def test_decode_logs_no_specify_abi(receipt, account, second_account):
56 |     logs = list(receipt.decode_logs())
57 |     expected_from = int(account.address, 16)
58 |     expected_to = int(second_account.address, 16)
59 |     assert len(logs) >= 2
60 |     transfer_log = [
61 |         x
62 |         for x in logs
63 |         if x.event_name == "Transfer" and x.from_ == expected_from and x.to == expected_to
64 |     ][-1]
65 |     assert transfer_log.value == AMOUNT_0
66 | 
67 |     mint_log = [x for x in logs if x.event_name == "Mint"][-1]
68 |     assert mint_log.sender == expected_from
69 |     assert mint_log.amount0 == AMOUNT_0
70 |     assert mint_log.amount1 == AMOUNT_1
71 |     assert mint_log.to == expected_to
72 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # Development
 2 | 
 3 | To get started with working on the codebase, use the following steps prepare your local environment:
 4 | 
 5 | ```bash
 6 | # clone the github repo and navigate into the folder
 7 | git clone https://github.com/ApeWorX/ape-starknet.git
 8 | cd ape-starknet
 9 | 
10 | # create and load a virtual environment
11 | python3 -m venv venv
12 | source venv/bin/activate
13 | 
14 | # install ape-starknet into the virtual environment
15 | python setup.py install
16 | 
17 | # install the developer dependencies (-e is interactive mode)
18 | pip install -e .'[dev]'
19 | ```
20 | 
21 | ## Pre-Commit Hooks
22 | 
23 | We use [`pre-commit`](https://pre-commit.com/) hooks to simplify linting and ensure consistent formatting among contributors.
24 | Use of `pre-commit` is not a requirement, but is highly recommended.
25 | 
26 | Install `pre-commit` locally from the root folder:
27 | 
28 | ```bash
29 | pip install pre-commit
30 | pre-commit install
31 | ```
32 | 
33 | Committing will now automatically run the local hooks and ensure that your commit passes all lint checks.
34 | 
35 | ## Github Access Token
36 | 
37 | If you are a member of ApeWorX and would like to install private plugins,
38 | [create a Github access token](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token).
39 | 
40 | Once you have your token, export it to your terminal session:
41 | 
42 | ```bash
43 | export GITHUB_ACCESS_TOKEN=<your-token>
44 | ```
45 | 
46 | ## Running the docs locally
47 | 
48 | First, make sure you have the docs-related tooling installed:
49 | 
50 | ```bash
51 | pip install -e .'[docs]'
52 | ```
53 | 
54 | Then, run the following from the root project directory:
55 | 
56 | ```bash
57 | python build_docs.py
58 | ```
59 | 
60 | For the best viewing experience, use a local server:
61 | 
62 | ```bash
63 | python -m http.server --directory "docs/_build/" --bind 127.0.0.1 1337
64 | ```
65 | 
66 | Then, open your browser to `127.0.0.1:1337` and click the `ape` directory link.
67 | NOTE: Serving from `"docs/_build/"` rather than `"docs/_build/ape-starknet"` is necessary to make routing work.
68 | 
69 | ## Pull Requests
70 | 
71 | Pull requests are welcomed! Please adhere to the following:
72 | 
73 | - Ensure your pull request passes our linting checks
74 | - Include test cases for any new functionality
75 | - Include any relevant documentation updates
76 | 
77 | It's a good idea to make pull requests early on.
78 | A pull request represents the start of a discussion, and doesn't necessarily need to be the final, finished submission.
79 | 
80 | If you are opening a work-in-progress pull request to verify that it passes CI tests, please consider
81 | [marking it as a draft](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-requests#draft-pull-requests).
82 | 
83 | Join the Ethereum Python [Discord](https://discord.gg/PcEJ54yX) if you have any questions.
84 | 


--------------------------------------------------------------------------------
/tests/functional/test_networks.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | from ape.contracts import ContractContainer, ContractInstance
 3 | 
 4 | 
 5 | @pytest.fixture
 6 | def in_ethereum(use_local_ethereum):
 7 |     with use_local_ethereum:
 8 |         yield
 9 | 
10 | 
11 | @pytest.fixture
12 | def in_starknet(use_local_starknet):
13 |     with use_local_starknet:
14 |         yield
15 | 
16 | 
17 | @pytest.fixture(scope="module")
18 | def eth_contract_container(eth_contract_type):
19 |     return ContractContainer(eth_contract_type)
20 | 
21 | 
22 | @pytest.fixture(scope="module", autouse=True)
23 | def deploy_eth_contract(use_local_ethereum, eth_account, eth_contract_container):
24 |     with use_local_ethereum:
25 |         return eth_account.deploy(eth_contract_container, sender=eth_account)
26 | 
27 | 
28 | @pytest.fixture
29 | def eth_contract(in_ethereum, eth_contract_container):
30 |     return eth_contract_container.deployments[-1]
31 | 
32 | 
33 | @pytest.fixture(scope="module")
34 | def stark_contract(use_local_starknet, config, project_path):
35 |     with use_local_starknet:
36 |         with config.using_project(project_path) as project:
37 |             yield project.MyContract.deployments[-1]
38 | 
39 | 
40 | def test_use_eth_network_from_fixture(eth_contract, eth_account, in_ethereum):
41 |     # Shows that we can write Ethereum-only tests within a multi-chain test module
42 |     # (NOTE: 'starknet' is the default ecosystem for this project)
43 |     eth_contract.setNumber(123, sender=eth_account)
44 |     assert eth_contract.myNumber() == 123
45 | 
46 | 
47 | def test_use_starknet_network_from_fixture(account, stark_contract, in_starknet):
48 |     # Shows that we can write Starknet-only tests within a multi-chain test module
49 |     receipt = stark_contract.increase_balance(account.address, 123, sender=account)
50 |     assert not receipt.failed
51 | 
52 | 
53 | def test_switch_to_ethereum_mid_test(
54 |     provider,
55 |     eth_account,
56 |     eth_contract_container,
57 |     stark_contract,
58 |     account,
59 |     in_starknet,
60 |     use_local_ethereum,
61 | ):
62 |     receipt = stark_contract.increase_balance(account.address, 123, sender=account)
63 |     assert not receipt.failed
64 | 
65 |     # Shows that we can change to Ethereum within an individual test
66 |     starknet_chain_id = provider.chain_id
67 | 
68 |     with use_local_ethereum as eth_provider:
69 |         # Verify the chain changed
70 |         assert eth_provider.chain_id != starknet_chain_id
71 | 
72 |         # Deploy and interact with a contract on Ethereum
73 |         eth_contract = eth_contract_container.deploy(sender=eth_account)
74 |         receipt = eth_contract.setNumber(123, sender=eth_account)
75 |         assert not receipt.failed
76 |         assert isinstance(eth_contract, ContractInstance)
77 |         assert eth_contract.myNumber() == 123
78 | 
79 |     # Switch back to Starknet
80 |     receipt = stark_contract.increase_balance(account.address, 123, sender=account)
81 |     assert not receipt.failed
82 | 


--------------------------------------------------------------------------------
/ape_starknet/explorer.py:
--------------------------------------------------------------------------------
 1 | from typing import Iterator, Optional, Union, cast
 2 | 
 3 | from ape.api import ExplorerAPI, ReceiptAPI
 4 | from ape.types import AddressType
 5 | from ape.utils import raises_not_implemented
 6 | from ethpm_types import ContractType, HexBytes
 7 | 
 8 | from ape_starknet.accounts import BaseStarknetAccount
 9 | from ape_starknet.utils import EXECUTE_METHOD_NAME, pad_hex_str
10 | from ape_starknet.utils.basemodel import StarknetBase
11 | 
12 | 
13 | class StarknetExplorer(ExplorerAPI, StarknetBase):
14 |     BASE_URIS = {
15 |         "testnet": "https://goerli.voyager.online",
16 |         "testnet2": "https://goerli-2.voyager.online",
17 |         "mainnet": "https://voyager.online",
18 |     }
19 | 
20 |     @property
21 |     def base_uri(self) -> str:
22 |         network_name = self.provider.network.name
23 |         return self.BASE_URIS.get(network_name, "")
24 | 
25 |     def get_address_url(self, address: AddressType) -> str:
26 |         base_uri = self.base_uri
27 |         return f"{base_uri}/contract/{address}" if base_uri else ""
28 | 
29 |     def get_transaction_url(self, transaction_hash: str) -> str:
30 |         base_uri = self.base_uri
31 |         return f"{base_uri}/tx/{transaction_hash}" if base_uri else ""
32 | 
33 |     def get_contract_type(self, address: Union[AddressType, int]) -> Optional[ContractType]:
34 |         if self.tokens.is_token(address):
35 |             return self.tokens.contract_type
36 | 
37 |         elif address in self.account_container:
38 |             starknet_account = cast(BaseStarknetAccount, self.account_container[address])
39 |             return starknet_account.contract_type
40 | 
41 |         return self.get_contract_type_from_provider(address)
42 | 
43 |     def get_contract_type_from_provider(self, address: Union[int, AddressType]):
44 |         """
45 |         Get contract type from provider for a given address.
46 | 
47 |         Args:
48 |             address(Union[int, ``AddressType``]): The contract address.
49 |         """
50 |         code_and_abi = self.provider.get_code_and_abi(address)
51 | 
52 |         # Convert list of ints to bytes
53 |         bytecode_str_list = [HexBytes(x).hex() for x in code_and_abi.bytecode]
54 |         if not bytecode_str_list:
55 |             return None
56 | 
57 |         longest_str = min(len(max(bytecode_str_list, key=len)) - 2, 0)
58 |         code_parts = [
59 |             pad_hex_str(x, to_length=longest_str).replace("0x", "") for x in bytecode_str_list
60 |         ]
61 | 
62 |         contract_type_dict = {
63 |             "abi": code_and_abi.abi,
64 |             "deploymentBytecode": {"bytecode": f"0x{''.join(code_parts)}"},
65 |         }
66 | 
67 |         if EXECUTE_METHOD_NAME in [a["name"] for a in code_and_abi.abi]:
68 |             contract_type_dict["contractName"] = "Account"
69 | 
70 |         return ContractType(**contract_type_dict)
71 | 
72 |     @raises_not_implemented
73 |     def get_account_transactions(  # type: ignore[empty-body]
74 |         self, address: AddressType
75 |     ) -> Iterator[ReceiptAPI]:
76 |         # TODO
77 |         pass
78 | 
79 |     @raises_not_implemented
80 |     def publish_contract(self, address: AddressType):
81 |         # TODO
82 |         pass
83 | 


--------------------------------------------------------------------------------
/tests/projects/proxy/contracts/library.cairo:
--------------------------------------------------------------------------------
  1 | // SPDX-License-Identifier: MIT
  2 | // OpenZeppelin Contracts for Cairo v0.2.0 (upgrades/library.cairo)
  3 | 
  4 | %lang starknet
  5 | 
  6 | from starkware.starknet.common.syscalls import get_caller_address
  7 | from starkware.cairo.common.cairo_builtins import HashBuiltin
  8 | from starkware.cairo.common.bool import TRUE, FALSE
  9 | from starkware.cairo.common.math import assert_not_zero
 10 | 
 11 | //
 12 | // Events
 13 | //
 14 | 
 15 | @event
 16 | func Upgraded(implementation: felt) {
 17 | }
 18 | 
 19 | @event
 20 | func AdminChanged(previousAdmin: felt, newAdmin: felt) {
 21 | }
 22 | 
 23 | //
 24 | // Storage variables
 25 | //
 26 | 
 27 | @storage_var
 28 | func Proxy_implementation_hash() -> (class_hash: felt) {
 29 | }
 30 | 
 31 | @storage_var
 32 | func Proxy_admin() -> (proxy_admin: felt) {
 33 | }
 34 | 
 35 | @storage_var
 36 | func Proxy_initialized() -> (initialized: felt) {
 37 | }
 38 | 
 39 | namespace Proxy {
 40 |     //
 41 |     // Initializer
 42 |     //
 43 | 
 44 |     func initializer{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
 45 |         proxy_admin: felt
 46 |     ) {
 47 |         let (initialized) = Proxy_initialized.read();
 48 |         with_attr error_message("Proxy: contract already initialized") {
 49 |             assert initialized = FALSE;
 50 |         }
 51 | 
 52 |         Proxy_initialized.write(TRUE);
 53 |         _set_admin(proxy_admin);
 54 |         return ();
 55 |     }
 56 | 
 57 |     //
 58 |     // Guards
 59 |     //
 60 | 
 61 |     func assert_only_admin{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() {
 62 |         let (caller) = get_caller_address();
 63 |         let (admin) = Proxy_admin.read();
 64 |         with_attr error_message("Proxy: caller is not admin") {
 65 |             assert admin = caller;
 66 |         }
 67 |         return ();
 68 |     }
 69 | 
 70 |     //
 71 |     // Getters
 72 |     //
 73 | 
 74 |     func get_implementation_hash{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
 75 |         ) -> (implementation: felt) {
 76 |         let (implementation) = Proxy_implementation_hash.read();
 77 |         return (implementation,);
 78 |     }
 79 | 
 80 |     func get_admin{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() -> (
 81 |         admin: felt
 82 |     ) {
 83 |         let (admin) = Proxy_admin.read();
 84 |         return (admin,);
 85 |     }
 86 | 
 87 |     //
 88 |     // Unprotected
 89 |     //
 90 | 
 91 |     func _set_admin{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
 92 |         new_admin: felt
 93 |     ) {
 94 |         let (previous_admin) = get_admin();
 95 |         Proxy_admin.write(new_admin);
 96 |         AdminChanged.emit(previous_admin, new_admin);
 97 |         return ();
 98 |     }
 99 | 
100 |     //
101 |     // Upgrade
102 |     //
103 | 
104 |     func _set_implementation_hash{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
105 |         new_implementation: felt
106 |     ) {
107 |         with_attr error_message("Proxy: implementation hash cannot be zero") {
108 |             Proxy_implementation_hash.write(new_implementation);
109 |         }
110 |         Upgraded.emit(new_implementation);
111 |         return ();
112 |     }
113 | }
114 | 


--------------------------------------------------------------------------------
/docs/conf.py:
--------------------------------------------------------------------------------
  1 | #
  2 | # Configuration file for the Sphinx documentation builder.
  3 | #
  4 | # This file does only contain a selection of the most common options. For a
  5 | # full list see the documentation:
  6 | # https://www.sphinx-doc.org/en/master/config
  7 | # -- Path setup --------------------------------------------------------------
  8 | # If extensions (or modules to document with autodoc) are in another directory,
  9 | # add these directories to sys.path here. If the directory is relative to the
 10 | # documentation root, use os.path.abspath to make it absolute, like shown here.
 11 | #
 12 | import os
 13 | import sys
 14 | from pathlib import Path
 15 | from typing import List
 16 | 
 17 | sys.path.insert(0, os.path.abspath(".."))
 18 | 
 19 | # -- Project information -----------------------------------------------------
 20 | 
 21 | project = "ape-starknet"
 22 | copyright = "2021, ApeWorX LTD"
 23 | author = "ApeWorX Team"
 24 | extensions = [
 25 |     "myst_parser",
 26 |     "sphinx_click",
 27 |     "sphinx.ext.autodoc",
 28 |     "sphinx.ext.autosummary",
 29 |     "sphinx.ext.napoleon",
 30 |     "sphinx_rtd_theme",
 31 | ]
 32 | autosummary_generate = True
 33 | 
 34 | # Add any paths that contain templates here, relative to this directory.
 35 | templates_path = ["_templates"]
 36 | 
 37 | # List of patterns, relative to source directory, that match files and
 38 | # directories to ignore when looking for source files.
 39 | # This pattern also affects html_static_path and html_extra_path.
 40 | exclude_patterns: List[str] = ["_build", ".DS_Store"]
 41 | 
 42 | 
 43 | # The suffix(es) of source filenames.
 44 | # You can specify multiple suffix as a list of string:
 45 | source_suffix = [".rst", ".md"]
 46 | 
 47 | # The master toctree document.
 48 | master_doc = "index"
 49 | 
 50 | 
 51 | # -- Options for HTML output -------------------------------------------------
 52 | 
 53 | # The theme to use for HTML and HTML Help pages.  See the documentation for
 54 | # a list of builtin themes.
 55 | #
 56 | html_theme = "sphinx_rtd_theme"
 57 | html_favicon = "favicon.ico"
 58 | html_logo = "logo.gif"
 59 | html_baseurl = f"/{project}/"
 60 | 
 61 | # Add any paths that contain custom static files (such as style sheets) here,
 62 | # relative to this directory. They are copied after the builtin static files,
 63 | # so a file named "default.css" will overwrite the builtin "default.css".
 64 | html_static_path = ["_static"]
 65 | 
 66 | # These paths are either relative to html_static_path
 67 | # or fully qualified paths (eg. https://...)
 68 | html_css_files = ["custom.css"]
 69 | 
 70 | # Currently required for how we handle method docs links in the Myst parser
 71 | # since not all links are available in the markdown files pre-build.
 72 | myst_all_links_external = True
 73 | 
 74 | 
 75 | def fixpath(path: str) -> str:
 76 |     """
 77 |     Change paths to reference the resources from 'latest/' to save room.
 78 |     """
 79 |     suffix = path.split("_static")[1]
 80 |     new = f"/{project}/latest/_static"
 81 | 
 82 |     if suffix:
 83 |         new = str(Path(new) / suffix.lstrip("/"))
 84 | 
 85 |     return new
 86 | 
 87 | 
 88 | def get_versions() -> List[str]:
 89 |     build_dir = Path(__file__).parent / "_build" / project
 90 |     if not build_dir.exists():
 91 |         return []
 92 | 
 93 |     versions = [d.name for d in build_dir.iterdir()]
 94 | 
 95 |     return versions
 96 | 
 97 | 
 98 | html_context = {
 99 |     "fixpath": fixpath,
100 |     "get_versions": get_versions,
101 | }
102 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Quick Start
  2 | 
  3 | Plugins for the [Starknet Ethereum L2 networks](https://starkware.co/starknet/).
  4 | 
  5 | ## Dependencies
  6 | 
  7 | - [python3](https://www.python.org/downloads) version 3.8 or greater, python3-dev
  8 | 
  9 | ## Installation
 10 | 
 11 | ### via `pip`
 12 | 
 13 | You can install the latest release via [`pip`](https://pypi.org/project/pip/):
 14 | 
 15 | ```bash
 16 | pip install ape-starknet
 17 | ```
 18 | 
 19 | ### via `setuptools`
 20 | 
 21 | You can clone the repository and use [`setuptools`](https://github.com/pypa/setuptools) for the most up-to-date version:
 22 | 
 23 | ```bash
 24 | git clone https://github.com/ApeWorX/ape-starknet.git
 25 | cd ape-starknet
 26 | python3 setup.py install
 27 | ```
 28 | 
 29 | ## Quick Usage
 30 | 
 31 | ### Account Management
 32 | 
 33 | Accounts are used to execute transactions and sign call data.
 34 | Accounts are smart contracts in Starknet.
 35 | 
 36 | You can access accounts using
 37 | 
 38 | ```
 39 | ape starknet accounts
 40 | ```
 41 | 
 42 | Learn more about accounts by following the [accounts guide](https://docs.apeworx.io/ape-starknet/stable/userguides/accounts.html).
 43 | 
 44 | ### Testing
 45 | 
 46 | Out of the box, `ape-starknet` comes with development accounts.
 47 | Access them like this:
 48 | 
 49 | ```python
 50 | from ape import accounts
 51 | 
 52 | container = accounts.containers["starknet"]
 53 | owner = container.test_accounts[0]
 54 | ```
 55 | 
 56 | See the guide about [Testing](https://docs.apeworx.io/ape-starknet/stable/userguides/testing.html) to learn more about test accounts and testing with the Starknet plugin.
 57 | 
 58 | ### Contracts
 59 | 
 60 | In Starknet, you can declare contract types by publishing them to the chain.
 61 | This allows other contracts to create instances of them using the [deploy system call](https://www.cairo-lang.org/docs/hello_starknet/deploying_from_contracts.html).
 62 | 
 63 | Learn more about contracts by following the [contracts guide](https://docs.apeworx.io/ape/stable/userguides/contracts.html).
 64 | 
 65 | ### Paying Fees
 66 | 
 67 | Starknet fees are currently paid in ETH, which is an ERC-20 on the Starknet chain.
 68 | To check your account balance (in ETH), use the `balance` property on the account:
 69 | 
 70 | ```python
 71 | from ape import accounts
 72 | 
 73 | acct = accounts.load("Alias")
 74 | print(acct.balance)
 75 | ```
 76 | 
 77 | If your account has a positive balance, you can begin paying fees!
 78 | 
 79 | To pay fees, you can manually set the `max_fee` kwarg on an invoke-transaction:
 80 | 
 81 | ```python
 82 | receipt = contract.my_mutable_method(123, max_fee=2900000000000)
 83 | ```
 84 | 
 85 | **NOTE**: If `max_fee` is not set, it will default to the value returned from the provider's `estimate_gas_cost()` call.
 86 | You do **not** need to call `estimate_gas_cost()` explicitly.
 87 | 
 88 | ### Mainnet Alpha Whitelist Deployment Token
 89 | 
 90 | Currently, to deploy to Alpha-Mainnet, your contract needs to be whitelisted.
 91 | You can provide your WL token in a variety of ways.
 92 | 
 93 | Via Python code:
 94 | 
 95 | ```python
 96 | from ape import project
 97 | 
 98 | my_contract = project.MyContract.deploy(token="MY_TOKEN")
 99 | ```
100 | 
101 | Via an Environment Variable:
102 | 
103 | ```bash
104 | export ALPHA_MAINNET_WL_DEPLOY_TOKEN="MY_TOKEN"
105 | ```
106 | 
107 | ## Development
108 | 
109 | This project is in development and should be considered a beta.
110 | Things might not be in their final state and breaking changes may occur.
111 | Comments, questions, criticisms and pull requests are welcomed.
112 | 


--------------------------------------------------------------------------------
/ape_starknet/udc.py:
--------------------------------------------------------------------------------
 1 | from typing import Any, Dict, List, Optional, cast
 2 | 
 3 | from ape.types import AddressType
 4 | from ape.utils import cached_property
 5 | from ethpm_types import ContractType
 6 | from ethpm_types.abi import MethodABI
 7 | from starkware.starknet.definitions.fields import ContractAddressSalt
 8 | 
 9 | from ape_starknet.transactions import InvokeFunctionTransaction
10 | from ape_starknet.utils.basemodel import StarknetBase
11 | 
12 | DEFAULT_UDC_ADDRESS: AddressType = cast(
13 |     AddressType, "0x041A78e741e5aF2fec34B695679bc6891742439F7Afb8484ecd7766661aD02bF"
14 | )
15 | DEFAULT_UDC_ABI: List[Dict] = [
16 |     {
17 |         "type": "event",
18 |         "name": "ContractDeployed",
19 |         "inputs": [
20 |             {"name": "address", "type": "felt", "indexed": False},
21 |             {"name": "deployer", "type": "felt", "indexed": False},
22 |             {"name": "unique", "type": "felt", "indexed": False},
23 |             {"name": "classHash", "type": "felt", "indexed": False},
24 |             {"name": "calldata_len", "type": "felt", "indexed": False},
25 |             {"name": "calldata", "type": "felt*", "indexed": False},
26 |             {"name": "salt", "type": "felt", "indexed": False},
27 |         ],
28 |         "anonymous": False,
29 |     },
30 |     {
31 |         "type": "function",
32 |         "name": "deployContract",
33 |         "stateMutability": "nonpayable",
34 |         "inputs": [
35 |             {"name": "classHash", "type": "felt"},
36 |             {"name": "salt", "type": "felt"},
37 |             {"name": "unique", "type": "felt"},
38 |             {"name": "calldata_len", "type": "felt"},
39 |             {"name": "calldata", "type": "felt*"},
40 |         ],
41 |         "outputs": [{"name": "address", "type": "felt"}],
42 |     },
43 | ]
44 | 
45 | 
46 | class UniversalDeployer(StarknetBase):
47 |     @cached_property
48 |     def contract_type(self) -> ContractType:
49 |         return ContractType(
50 |             contractName="openzeppelin.utils.presets.UniversalDeployer",
51 |             sourceId="openzeppelin/utils/presets/UniversalDeployer.cairo",
52 |             abi=self.abi,
53 |             # NOTE: code is not necessary for its use-cases (use like an interface)
54 |             deploymentBytecode={},
55 |             runtimeBytecode={},
56 |         )
57 | 
58 |     def __init__(
59 |         self, address: AddressType = DEFAULT_UDC_ADDRESS, abi: Optional[List[Dict]] = None
60 |     ):
61 |         self.address = address
62 |         self.abi = abi or DEFAULT_UDC_ABI
63 |         self._cache_self()
64 |         super().__init__()
65 | 
66 |     @cached_property
67 |     def deploy_function(self) -> MethodABI:
68 |         method = self.contract_type.mutable_methods["deployContract"]
69 |         method.contract_type = self.contract_type
70 |         return method
71 | 
72 |     def create_deploy(
73 |         self,
74 |         class_hash: int,
75 |         constructor_arguments: List[Any],
76 |         salt: Optional[int] = None,
77 |         unique: bool = True,
78 |         **kwargs,
79 |     ) -> InvokeFunctionTransaction:
80 |         """
81 |         Deploy a contract using the Starknet public Universal Deployer Contract.
82 |         """
83 |         salt = salt or ContractAddressSalt.get_random_value()
84 |         txn = self.starknet.encode_transaction(
85 |             self.address,
86 |             self.deploy_function,
87 |             class_hash,
88 |             salt,
89 |             unique,
90 |             len(constructor_arguments),
91 |             constructor_arguments,
92 |             **kwargs,
93 |         )
94 |         return cast(InvokeFunctionTransaction, txn)
95 | 
96 |     def _cache_self(self):
97 |         self.chain_manager.contracts[self.address] = self.contract_type
98 | 


--------------------------------------------------------------------------------
/docs/userguides/contracts.md:
--------------------------------------------------------------------------------
  1 | # Contracts
  2 | 
  3 | You can learn more about interacting with contracts from the ApeWorX documentation about [contracts](https://docs.apeworx.io/ape/stable/userguides/contracts.html#contracts).
  4 | 
  5 | ## Declare and Deploy Contracts
  6 | 
  7 | To declare a contract using `ape-starknet`, do the following (in a script or console):
  8 | 
  9 | ```python
 10 | from ape import accounts, project
 11 | 
 12 | account = accounts.load("<MY_STARK_ACCOUNT>")
 13 | declaration = account.declare(project.MyContract)
 14 | print(declaration.class_hash)
 15 | ```
 16 | 
 17 | Then, you can use the `deploy` method to deploy the contracts.
 18 | **NOTE**: The `deploy` method in `ape-starknet` makes an invoke-function call against the Starknet public UDC contract.
 19 | Learn more about UDC contracts [here](https://community.starknet.io/t/universal-deployer-contract-proposal/1864).
 20 | 
 21 | ```python
 22 | from ape import accounts, project
 23 | 
 24 | # This only works if `project.MyContract` was declared previously.
 25 | # The class hash is not necessary as an argument. Ape will look it up.
 26 | account = accounts.load("<MY_STARK_ACCOUNT>")
 27 | account.deploy(project.MyContact)
 28 | ```
 29 | 
 30 | You can also deploy contracts by doing:
 31 | 
 32 | ```python
 33 | from ape import accounts, project
 34 | 
 35 | account = accounts.load("<MY_STARK_ACCOUNT>")
 36 | my_contract = project.MyContract.deploy(sender=account)
 37 | ```
 38 | 
 39 | ### Factory Contracts
 40 | 
 41 | Alternatively, you can use the class hash in a `deploy()` system call in a local factory contract.
 42 | Let's say for example I have the following Cairo factory contract:
 43 | 
 44 | ```
 45 | from starkware.cairo.common.alloc import alloc
 46 | from starkware.starknet.common.syscalls import deploy
 47 | from starkware.cairo.common.cairo_builtins import HashBuiltin
 48 | 
 49 | @storage_var
 50 | func class_hash() -> (class_hash: felt) {
 51 | }
 52 | 
 53 | @storage_var
 54 | func salt() -> (value: felt) {
 55 | }
 56 | 
 57 | @constructor
 58 | func constructor{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(cls_hash: felt) {
 59 |     class_hash.write(value=cls_hash);
 60 |     return ();
 61 | }
 62 | 
 63 | @external
 64 | func deploy_my_contract{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() {
 65 |     let (cls_hash) = class_hash.read();
 66 |     let (current_salt) = salt.read();
 67 |     let (ctor_calldata) = alloc();
 68 |     let (contract_addr) = deploy(
 69 |         class_hash=cls_hash,
 70 |         contract_address_salt=current_salt,
 71 |         constructor_calldata_size=0,
 72 |         constructor_calldata=ctor_calldata,
 73 |         deploy_from_zero=FALSE,
 74 |     );
 75 |     salt.write(value=current_salt + 1);
 76 |     return ();
 77 | }
 78 | ```
 79 | 
 80 | This contract accepts a class hash of a declared contract and deploys it.
 81 | The following example shows how to use this factory class to deploy other contracts:
 82 | 
 83 | ```python
 84 | from ape import Contract, accounts, networks, project
 85 | 
 86 | account = accounts.load("<MY_STARK_ACCOUNT>")
 87 | declaration = account.declare(project.MyContract)
 88 | 
 89 | # NOTE: Assuming you have a contract named 'ContractFactory'.
 90 | factory = project.ContractFactory.deploy(declaration.class_hash, sender=account)
 91 | 
 92 | call_result = factory.deploy_my_contract()
 93 | contract_address = networks.starknet.decode_address(call_result)
 94 | contract = Contract(contract_address, contract_type=project.MyContract.contract_type)
 95 | ```
 96 | 
 97 | ## Contract Interaction
 98 | 
 99 | You can learn more about contract interaction from the ApeWorX documentation about [contracts](https://docs.apeworx.io/ape/stable/userguides/contracts.html).
100 | 
101 | **NOTE**: Currently, to pass in arrays as arguments, you have to also include the array size beforehand:
102 | 
103 | ```python
104 | receipt = contract.store_my_list(3, [1, 2, 3])
105 | ```
106 | 


--------------------------------------------------------------------------------
/tests/data/traces-testnet-block-243810_results.json:
--------------------------------------------------------------------------------
  1 | {
  2 |     "0x59949c78d504055e1937626115e7e83e25db677b5067129fb032e2eceb45d9": [
  3 |         "0x0"
  4 |     ],
  5 |     "0x1b50749bd19e94c64fb71771c4c92c779fdeac0c281f3305e0b5b5214697b8c": [],
  6 |     "0x408daf26b562ab9a890b9e2ca39b645ca5af4809463c9dda2a92934d575a73b": [
  7 |         "0x1"
  8 |     ],
  9 |     "0x6606fd04124b3264bf6295580bda96455efb7713c2ef9d701f6d5b8c65d409a": [
 10 |         "0x1"
 11 |     ],
 12 |     "0x291ffe912a6d06785b29c28b493b2a5bbf50736f8c2116ed9d083d10bfd61e6": [
 13 |         "0x1",
 14 |         "0x78294edbfb5e2fc4d",
 15 |         "0x0"
 16 |     ],
 17 |     "0x4a94a65efa1af680e65b7b4d46850deecc493e5c4c3a7de17b25d1bec6ea7c": [
 18 |         "0x1",
 19 |         "0x1",
 20 |         "0xad781b168878b922d",
 21 |         "0x0",
 22 |         "0xc705a3",
 23 |         "0x0",
 24 |         "0x2e0bb9e8e52c",
 25 |         "0x0"
 26 |     ],
 27 |     "0x357787f7ff27bb9cff4bcf1953826f99ac00e5ab1da5b595854c39e35a664d4": [],
 28 |     "0x75a828662d76bacaba069a75ccc892c65bcabb15a4214a22f156ec1b46887a8": [
 29 |         "0x0"
 30 |     ],
 31 |     "0x3f9404e5fef5ddf80c5c012b3bd1b9afef61b57e08c40912cef861ff8e2676": [],
 32 |     "0x763b470debd148744fa6aa3eadd385870bfc6f645374c4f55c8d26ef242d0e": [
 33 |         "0x0"
 34 |     ],
 35 |     "0x1b62451ef233a58120dfc6757f90ec86221379ec9b7e57260c55432ba7e30a4": [],
 36 |     "0xe28d927a92a11eaa0d68062cc63a35c7cf75b730e9d52a27822e08ced4798c": [
 37 |         "0x0"
 38 |     ],
 39 |     "0x6ea17c1188070efe7504c288969424e5c750fd667e5074819daef14f2f98051": [
 40 |         "0x1",
 41 |         "0x1109e5157d1a9f8d0",
 42 |         "0x0",
 43 |         "0x363d05301b3fadc74b",
 44 |         "0x0"
 45 |     ],
 46 |     "0x552334e3dfb31d87d62eb9c1483551c30f03c91e5aa7af376df030646c21123": [
 47 |         "0x3",
 48 |         "0x1",
 49 |         "0x2",
 50 |         "0x3"
 51 |     ],
 52 |     "0x6d279fe1c9cfb0540d527dec02a0c2b6f1417e91f00084b34e9c63bca0b28a8": [
 53 |         "0x1"
 54 |     ],
 55 |     "0xbd418c0c10dcd5502df78d79b4d268831354f8b4b4dc7eee88b961323dffff": [],
 56 |     "0x3f094122db852d07214fa15f38ec2bdd57452dc6f35091cc249cad3a661c5e4": [
 57 |         "0x1",
 58 |         "0x2",
 59 |         "0x6c6b935b8bbd400000",
 60 |         "0x0",
 61 |         "0x7c0487c",
 62 |         "0x0"
 63 |     ],
 64 |     "0x5c3f43c0c65b3bcd663a2999a9fbb6550fa3aa78c6d92d2f30cee072a02b72b": [],
 65 |     "0x311b496d373b0776b1f12cd500138f228af8f45664530116bc501a6e2f4b40f": [],
 66 |     "0x3e83a229f544b538f9bf4b79860edcabfe3a2de02b5cb7ff11a8c76666c0fa7": [],
 67 |     "0x1d808749d0a008d6cea1d48197251ab4194df154984c20b39e638af78aa2a1b": [
 68 |         "0x35ab060f27e60e175e",
 69 |         "0x0"
 70 |     ],
 71 |     "0xb67cc869b35e043c07a74612c531afd7827ce4fb4f3d9d1c8e25b934feb991": [
 72 |         "0x0"
 73 |     ],
 74 |     "0x2da9cad86f76f406a10f2b4878b108a02f49e0d749abdadec030d42bc8c2f54": [
 75 |         "0x1"
 76 |     ],
 77 |     "0x577e8a98102dbe78e744dcff17cae0d9832a25f4daf7485c2a070741e2fb9c": [
 78 |         "0x1",
 79 |         "0x1",
 80 |         "0x1270e6723177cdc84",
 81 |         "0x0"
 82 |     ],
 83 |     "0x6775350096f21c08fafa84ac75170ea98a8c1fdb6548ca8ad951ff9a5abb923": [
 84 |         "0x0"
 85 |     ],
 86 |     "0x53787fbf6680150741163cf2406c2a1710de4cc6c6079d978081ff94156002b": [],
 87 |     "0x525325372496ebb75b1e29f05c3bc150914864737a804b17dbd6495990c2edb": [
 88 |         "0x0"
 89 |     ],
 90 |     "0x64911c96a1ef58d401346a0286b88354f4aad57c50b513e547ac7dc6e1805c2": [
 91 |         "0x1",
 92 |         "0x1"
 93 |     ],
 94 |     "0x10e8a6010980156daaebe32efbc5588f028e7b1576c8f8c57a0ded21c8927a3": [],
 95 |     "0x477173a0d6cca55990b35dbd721093dbd132e5b8bdfcaa0298a8b61cc015ad": [
 96 |         "0x1",
 97 |         "0x72e3a95de9b26371",
 98 |         "0x0",
 99 |         "0x14b66ddf",
100 |         "0x0"
101 |     ],
102 |     "0x4d73269f4251b2dc0a421a86a2c8c8d04a97a5046fbfe2d8fa037c954b6b2dd": [
103 |         "0x3",
104 |         "0x1",
105 |         "0x2",
106 |         "0x3"
107 |     ]
108 | }
109 | 


--------------------------------------------------------------------------------
/ape_starknet/utils/basemodel.py:
--------------------------------------------------------------------------------
  1 | from functools import cached_property
  2 | from typing import TYPE_CHECKING, Optional, Union, cast
  3 | 
  4 | from ape.types import AddressType
  5 | from ape.utils import ManagerAccessMixin
  6 | from eth_utils import is_0x_prefixed
  7 | from ethpm_types import ContractType
  8 | from hexbytes import HexBytes
  9 | from starknet_py.net.client_models import ContractClass
 10 | from starkware.starknet.core.os.class_hash import compute_class_hash
 11 | from starkware.starknet.testing.contract_utils import get_contract_class
 12 | 
 13 | if TYPE_CHECKING:
 14 |     from ape_starknet.accounts import StarknetAccountContainer
 15 |     from ape_starknet.config import StarknetConfig
 16 |     from ape_starknet.ecosystems import Starknet
 17 |     from ape_starknet.explorer import StarknetExplorer
 18 |     from ape_starknet.provider import StarknetProvider
 19 |     from ape_starknet.tokens import TokenManager
 20 |     from ape_starknet.udc import UniversalDeployer
 21 | 
 22 | 
 23 | class StarknetBase(ManagerAccessMixin):
 24 |     """
 25 |     Starknet Base Model
 26 |     """
 27 | 
 28 |     @property
 29 |     def starknet_config(self) -> "StarknetConfig":
 30 |         return cast("StarknetConfig", self.config_manager.get_config("starknet"))
 31 | 
 32 |     @property
 33 |     def starknet(self) -> "Starknet":
 34 |         return cast("Starknet", self.network_manager.starknet)
 35 | 
 36 |     @property
 37 |     def starknet_explorer(self) -> "StarknetExplorer":
 38 |         explorer = self.provider.network.explorer
 39 |         assert explorer  # For mypy
 40 |         return cast("StarknetExplorer", explorer)
 41 | 
 42 |     @property
 43 |     def provider(self) -> "StarknetProvider":
 44 |         return cast("StarknetProvider", super().provider)
 45 | 
 46 |     @property
 47 |     def account_container(self) -> "StarknetAccountContainer":
 48 |         return cast("StarknetAccountContainer", self.account_manager.containers["starknet"])
 49 | 
 50 |     @property
 51 |     def tokens(self) -> "TokenManager":
 52 |         from ape_starknet.tokens import tokens
 53 | 
 54 |         return tokens
 55 | 
 56 |     @cached_property
 57 |     def universal_deployer(self) -> "UniversalDeployer":
 58 |         from ape_starknet.udc import UniversalDeployer
 59 | 
 60 |         return UniversalDeployer()
 61 | 
 62 |     def get_contract_type(self, address: AddressType) -> Optional[ContractType]:
 63 |         # Force explorer in Local networks since Ape turns it off by default
 64 |         return self.chain_manager.contracts.get(
 65 |             address
 66 |         ) or self.starknet_explorer.get_contract_type(address)
 67 | 
 68 |     def get_local_contract_type(self, class_hash: int) -> Optional[ContractType]:
 69 |         for contract_name, contract_type in self.project_manager.contracts.items():
 70 |             if not contract_type.source_id or not contract_type.source_id.endswith(".cairo"):
 71 |                 continue
 72 | 
 73 |             program = contract_type.deployment_bytecode
 74 |             if not program:
 75 |                 continue
 76 | 
 77 |             code = program.bytecode
 78 |             if not code:
 79 |                 continue
 80 | 
 81 |             try:
 82 |                 contract_class = create_contract_class(code)
 83 |             except UnicodeDecodeError:
 84 |                 continue
 85 | 
 86 |             contract_cls = get_contract_class(contract_class=contract_class)
 87 |             computed_class_hash = compute_class_hash(contract_cls)
 88 |             if computed_class_hash == class_hash:
 89 |                 return contract_type
 90 | 
 91 |         return None
 92 | 
 93 | 
 94 | def create_contract_class(code: Union[str, bytes]) -> ContractClass:
 95 |     if isinstance(code, str) and is_0x_prefixed(code):
 96 |         return ContractClass.deserialize(HexBytes(code))
 97 | 
 98 |     elif isinstance(code, str):
 99 |         return ContractClass.loads(code)
100 | 
101 |     elif isinstance(code, bytes):
102 |         return ContractClass.deserialize(code)
103 | 
104 |     else:
105 |         raise TypeError(f"Unhandled bytecode type '{code}'.")
106 | 


--------------------------------------------------------------------------------
/tests/projects/token/contracts/TestToken.cairo:
--------------------------------------------------------------------------------
  1 | %lang starknet
  2 | 
  3 | from starkware.cairo.common.cairo_builtins import HashBuiltin
  4 | from starkware.cairo.common.uint256 import Uint256
  5 | from starkware.starknet.common.syscalls import get_caller_address
  6 | 
  7 | from openzeppelin.token.erc20.library import ERC20, Transfer
  8 | from openzeppelin.access.ownable.library import Ownable
  9 | from myeventlib.library import MyEventLib
 10 | 
 11 | @constructor
 12 | func constructor{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
 13 |     name: felt, symbol: felt, decimals: felt, initial_supply: Uint256, recipient: felt
 14 | ) {
 15 |     ERC20.initializer(name, symbol, decimals);
 16 |     ERC20._mint(recipient, initial_supply);
 17 |     Ownable.initializer(recipient);
 18 |     return ();
 19 | }
 20 | 
 21 | //
 22 | // Events
 23 | //
 24 | 
 25 | @event
 26 | func Mint(sender: felt, amount0: Uint256, amount1: Uint256, to: felt) {
 27 | }
 28 | 
 29 | //
 30 | // Getters
 31 | //
 32 | 
 33 | @view
 34 | func name{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() -> (name: felt) {
 35 |     let (name) = ERC20.name();
 36 |     return (name,);
 37 | }
 38 | 
 39 | @view
 40 | func symbol{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() -> (symbol: felt) {
 41 |     let (symbol) = ERC20.symbol();
 42 |     return (symbol,);
 43 | }
 44 | 
 45 | @view
 46 | func totalSupply{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() -> (
 47 |     totalSupply: Uint256
 48 | ) {
 49 |     let (totalSupply: Uint256) = ERC20.total_supply();
 50 |     return (totalSupply,);
 51 | }
 52 | 
 53 | @view
 54 | func decimals{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() -> (
 55 |     decimals: felt
 56 | ) {
 57 |     let (decimals) = ERC20.decimals();
 58 |     return (decimals,);
 59 | }
 60 | 
 61 | @view
 62 | func balanceOf{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(account: felt) -> (
 63 |     balance: Uint256
 64 | ) {
 65 |     let (balance: Uint256) = ERC20.balance_of(account);
 66 |     return (balance,);
 67 | }
 68 | 
 69 | @view
 70 | func allowance{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
 71 |     owner: felt, spender: felt
 72 | ) -> (remaining: Uint256) {
 73 |     let (remaining: Uint256) = ERC20.allowance(owner, spender);
 74 |     return (remaining,);
 75 | }
 76 | 
 77 | //
 78 | // Externals
 79 | //
 80 | 
 81 | @external
 82 | func approve{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
 83 |     spender: felt, amount: Uint256
 84 | ) -> (success: felt) {
 85 |     ERC20.approve(spender, amount);
 86 |     // Cairo equivalent to 'return (true)'
 87 |     return (1,);
 88 | }
 89 | 
 90 | @external
 91 | func increaseAllowance{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
 92 |     spender: felt, added_value: Uint256
 93 | ) -> (success: felt) {
 94 |     ERC20.increase_allowance(spender, added_value);
 95 |     // Cairo equivalent to 'return (true)'
 96 |     return (1,);
 97 | }
 98 | 
 99 | @external
100 | func decreaseAllowance{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
101 |     spender: felt, subtracted_value: Uint256
102 | ) -> (success: felt) {
103 |     ERC20.decrease_allowance(spender, subtracted_value);
104 |     // Cairo equivalent to 'return (true)'
105 |     return (1,);
106 | }
107 | 
108 | @external
109 | func transfer{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
110 |     recipient: felt, amount: Uint256
111 | ) -> (success: felt) {
112 |     ERC20.transfer(recipient, amount);
113 |     // Cairo equivalent to 'return (true)'
114 |     MyEventLib.fire_event(recipient);
115 |     return (1,);
116 | }
117 | 
118 | @external
119 | func fire_events{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
120 |     recipient: felt, amount0: Uint256, amount1: Uint256
121 | ) -> () {
122 |     MyEventLib.fire_event(recipient);
123 |     let (sender) = get_caller_address();
124 |     Transfer.emit(sender, recipient, amount0);
125 |     Mint.emit(sender, amount0, amount1, recipient);
126 |     return ();
127 | }
128 | 


--------------------------------------------------------------------------------
/tests/functional/test_provider.py:
--------------------------------------------------------------------------------
  1 | import time
  2 | 
  3 | import pytest
  4 | from starkware.starknet.public.abi import get_selector_from_name
  5 | 
  6 | from ape_starknet.exceptions import StarknetProviderError
  7 | from ape_starknet.utils import EXECUTE_ABI, is_checksum_address
  8 | 
  9 | 
 10 | def test_get_nonce(provider, account, contract):
 11 |     initial_nonce = provider.get_nonce(account.address)
 12 | 
 13 |     # Transact to increase nonce
 14 |     contract.increase_balance(account.address, 123, sender=account)
 15 | 
 16 |     actual = provider.get_nonce(account.address)
 17 |     assert actual == initial_nonce + 1
 18 | 
 19 | 
 20 | def test_get_block(provider, contract):
 21 |     _ = contract  # Contract fixture used to increase blocks (since deploys happen)
 22 |     latest_block_0 = provider.get_block("latest")
 23 |     latest_block_1 = provider.get_block(-1)
 24 |     latest_block_2 = provider.get_block(latest_block_0.number)
 25 |     assert latest_block_0.hash == latest_block_1.hash == latest_block_2.hash
 26 | 
 27 | 
 28 | def test_get_negative_block_number(account, provider, contract):
 29 |     start_block = provider.get_block("latest").number
 30 |     for _ in range(3):
 31 |         # Mine 3 blocks
 32 |         contract.increase_balance(account.address, 12, sender=account)
 33 | 
 34 |     block = provider.get_block(-2)
 35 |     assert block.number == start_block + 2
 36 | 
 37 | 
 38 | def test_get_negative_block_number_out_of_range(provider, contract):
 39 |     _ = contract  # We have blocks because the contract was deployed.
 40 | 
 41 |     # Also tests against bug where every error was considered a `VirtualMachineError`.
 42 |     with pytest.raises(StarknetProviderError, match=r"Block with number '-\d*' not found."):
 43 |         provider.get_block(-46346)
 44 | 
 45 | 
 46 | def test_get_transactions_by_block(provider, account, contract):
 47 |     # Transact to create data.
 48 |     expected_value = 123
 49 |     contract.increase_balance(account, expected_value, sender=account)
 50 | 
 51 |     transactions = [t for t in provider.get_transactions_by_block("latest")]
 52 | 
 53 |     expected_chain_id = provider.chain_id
 54 |     expected_abi = EXECUTE_ABI
 55 |     expected_nonce = account.nonce - 1
 56 |     assert len(transactions) == 1
 57 |     assert transactions[0].chain_id == expected_chain_id
 58 |     assert transactions[0].method_abi == expected_abi
 59 |     assert transactions[0].nonce == expected_nonce
 60 |     assert transactions[0].receiver == account.address
 61 |     assert transactions[0].value == 0
 62 |     assert is_checksum_address(transactions[0].receiver)
 63 |     expected_data = [
 64 |         1,
 65 |         provider.starknet.encode_address(contract.address),
 66 |         get_selector_from_name("increase_balance"),
 67 |         0,
 68 |         2,
 69 |         2,
 70 |         provider.starknet.encode_address(account.address),
 71 |         expected_value,
 72 |     ]
 73 |     assert transactions[0].data == expected_data
 74 |     assert transactions[0].total_transfer_value == transactions[0].max_fee + transactions[0].value
 75 | 
 76 | 
 77 | def test_set_timestamp(provider, account, contract):
 78 |     start_time = provider.get_block("pending").timestamp
 79 |     provider.set_timestamp(start_time + 8600)
 80 |     provider.mine()
 81 |     curr_time = time.time()
 82 |     assert pytest.approx(curr_time + 8600) == provider.get_block("latest").timestamp
 83 | 
 84 | 
 85 | def test_mine(provider):
 86 |     block_num = provider.get_block("latest").number
 87 |     provider.mine()
 88 |     next_block_num = provider.get_block("latest").number
 89 | 
 90 |     # NOTE: Uses >= in case of x-dist
 91 |     assert next_block_num >= block_num + 1
 92 | 
 93 | 
 94 | def test_set_balance(provider, account, tokens):
 95 |     current_balance = account.balance
 96 | 
 97 |     del tokens.balance_cache[account.address_int]["eth"]
 98 |     assert account.balance == current_balance
 99 | 
100 |     new_balance = current_balance + 23400000000
101 |     provider.set_balance(account, new_balance)
102 |     assert account.balance == new_balance
103 | 
104 |     # Clear cache to ensure recognized on chain
105 |     del tokens.balance_cache[account.address_int]["eth"]
106 |     assert account.balance == new_balance
107 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | # -*- coding: utf-8 -*-
  3 | from setuptools import find_packages, setup
  4 | 
  5 | extras_require = {
  6 |     "test": [  # `test` GitHub Action jobs uses this
  7 |         "pytest>=6.0",  # Core testing package
  8 |         "pytest-asyncio",  # For 'ape test' integration
  9 |         "pytest-xdist",  # multi-process runner
 10 |         "pytest-cov",  # Coverage analyzer plugin
 11 |         "hypothesis>=6.2.0,<7.0",  # Strategy-based fuzzer
 12 |         "ape-cairo",  # For compiling contracts in tests
 13 |     ],
 14 |     "lint": [
 15 |         "black>=22.12",  # auto-formatter and linter
 16 |         "mypy>=0.991,<1.0",  # Static type analyzer
 17 |         "types-requests",  # Needed due to mypy typeshed
 18 |         "types-setuptools",  # Needed due to mypy typeshed
 19 |         "types-PyYAML",  # Needed due to mypy typeshed
 20 |         "flake8>=5.0.4",  # Style linter
 21 |         "isort>=5.10.1",  # Import sorting linter
 22 |         "mdformat>=0.7.16",  # Auto-formatter for markdown
 23 |         "mdformat-gfm>=0.3.5",  # Needed for formatting GitHub-flavored markdown
 24 |         "mdformat-frontmatter>=0.4.1",  # Needed for frontmatters-style headers in issue templates
 25 |         "types-pkg-resources>=0.1.3,<0.2",
 26 |     ],
 27 |     "docs": [
 28 |         # Tools for parsing markdown files in the docs
 29 |         # "myst-parser",  # TODO: Uncomment/re-pin once Sphinx 6 support is released
 30 |         "sphinx-click>=4.4.0,<5.0",  # For documenting CLI
 31 |         "Sphinx>=6.1.3,<7.0",  # Documentation generator
 32 |         "sphinx_rtd_theme>=1.2.0rc3,<2",  # Readthedocs.org theme
 33 |         "sphinxcontrib-napoleon>=0.7",  # Allow Google-style documentation
 34 |     ],
 35 |     "release": [  # `release` GitHub Action job uses this
 36 |         "setuptools",  # Installation tool
 37 |         "wheel",  # Packaging tool
 38 |         "twine",  # Package upload tool
 39 |     ],
 40 |     "dev": [
 41 |         "commitizen",  # Manage commits and publishing releases
 42 |         "pre-commit",  # Ensure that linters are run prior to committing
 43 |         "pytest-watch",  # `ptw` test watcher/runner
 44 |         "IPython",  # Console for interacting
 45 |         "ipdb",  # Debugger (Must use `export PYTHONBREAKPOINT=ipdb.set_trace`)
 46 |     ],
 47 | }
 48 | 
 49 | # NOTE: `pip install -e .[dev]` to install package
 50 | extras_require["dev"] = (
 51 |     extras_require["test"]
 52 |     + extras_require["lint"]
 53 |     + extras_require["release"]
 54 |     + extras_require["dev"]
 55 | )
 56 | 
 57 | with open("./README.md") as readme:
 58 |     long_description = readme.read()
 59 | 
 60 | 
 61 | setup(
 62 |     name="ape-starknet",
 63 |     use_scm_version=True,
 64 |     setup_requires=["setuptools_scm"],
 65 |     description="""ape-starknet: An ape plugin for the StarkNet networks""",
 66 |     long_description=long_description,
 67 |     long_description_content_type="text/markdown",
 68 |     author="ApeWorX Ltd.",
 69 |     author_email="admin@apeworx.io",
 70 |     url="https://github.com/ApeWorX/ape-starknet",
 71 |     include_package_data=True,
 72 |     install_requires=[
 73 |         "click",  # Use same version as eth-ape
 74 |         "hexbytes",  # Use same version as eth-ape
 75 |         "pydantic",  # Use same version as eth-ape
 76 |         # ** ApeWorX maintained **
 77 |         "eth-ape>=0.6.3,<0.7",
 78 |         "ethpm-types",  # Use same version as eth-ape
 79 |         # ** Starknet Ecosystem **
 80 |         "cairo-lang>=0.10.3,<0.11",
 81 |         "starknet_py>=0.14.0a0,<0.15",
 82 |         "starknet-devnet>=0.4.4,<0.5",
 83 |     ],
 84 |     entry_points={"ape_cli_subcommands": ["ape_starknet=ape_starknet._cli:cli"]},
 85 |     python_requires=">=3.8,<3.11",
 86 |     extras_require=extras_require,
 87 |     py_modules=["ape_starknet"],
 88 |     license="Apache-2.0",
 89 |     zip_safe=False,
 90 |     keywords="ethereum starknet",
 91 |     packages=find_packages(exclude=["tests", "tests.*"]),
 92 |     package_data={"ape_starknet": ["py.typed"]},
 93 |     classifiers=[
 94 |         "Development Status :: 4 - Beta",
 95 |         "Intended Audience :: Developers",
 96 |         "License :: OSI Approved :: Apache Software License",
 97 |         "Natural Language :: English",
 98 |         "Operating System :: MacOS",
 99 |         "Operating System :: POSIX",
100 |         "Programming Language :: Python :: 3",
101 |         "Programming Language :: Python :: 3.8",
102 |         "Programming Language :: Python :: 3.9",
103 |         "Programming Language :: Python :: 3.10",
104 |     ],
105 | )
106 | 


--------------------------------------------------------------------------------
/docs/userguides/accounts.md:
--------------------------------------------------------------------------------
  1 | # Accounts
  2 | 
  3 | When using a live network, you will have to import or create an account first.
  4 | 
  5 | ## Importing an Account
  6 | 
  7 | To import an account, use the `import` command:
  8 | 
  9 | ```bash
 10 | ape starknet accounts import <ALIAS> \
 11 |     --network testnet,testnet2 \
 12 |     --address 0x6b7111AA4111e5B2229c3332B66696888164440A773333143333B383333a183 \
 13 |     --class-hash "0x025ec026985a3bf9d0cc1fe17326b245dfdc3ff89b8fde106542a3ea56c5a918"
 14 |     --salt 123
 15 | ```
 16 | 
 17 | The command above is using a network value of `testnet,testnet2`, meaning both Starknet's Goerli testnet and Goerli testnet2 networks.
 18 | You can run the import command more than once to add more networks at a later time.
 19 | To add all networks at once, you can also use a `--network` value of `starknet`.
 20 | 
 21 | If the account is already added, you can omit the `--address` flag and use the calculated one instead.
 22 | If you know the salt the account used to calculate its address, you can provide that with the `--salt` flag.
 23 | This will allow future deployments to use the same address.
 24 | 
 25 | Importing accounts is complex.
 26 | A common use-case is to import your Argent-X wallet.
 27 | To do this, you can use the following command:
 28 | 
 29 | ```bash
 30 | ape starknet accounts import <ArgentX-Alias> \
 31 |     --network starknet \
 32 |     --address 0x6b7111AA4111e5B2229c3332B66696888164440A773333143333B383333a183 \
 33 |     --class-hash argentx
 34 | ```
 35 | 
 36 | And then export your Argent-X private key from the app and paste it in the CLI prompt.
 37 | Now, you can use your argent-x account to fund and create other accounts!
 38 | 
 39 | ## Creating an Account
 40 | 
 41 | To create a new account, you can use the `create` command:
 42 | 
 43 | ```bash
 44 | ape starknet accounts create <NEW-ALIAS>
 45 | ```
 46 | 
 47 | By default, new accounts use the Open Zeppelin account contract implementation.
 48 | However, if you want to change the class, use the `--class-hash` option:
 49 | 
 50 | ```bash
 51 | CLASS_HASH="0x1a7820094feaf82d53f53f214b81292d717e7bb9a92bb2488092cd306f3993f"
 52 | ape starknet accounts create <NEW-ALIAS> --class-hash "${CLASS_HASH}"
 53 | ```
 54 | 
 55 | **NOTE**: You may also need to change the constructor calldata using the `--constructor-calldata` flag when using a different account contract type.
 56 | 
 57 | The `create` command will first generate the public and private key combination and store a local keyfile for the account.
 58 | However, it does not deploy the account.
 59 | The reason it does not deploy is that the account needs funding to pay for its deployment and there are several ways to achieve this.
 60 | See [this section](https://starknet.io/docs/hello_starknet/account_setup.html#transferring-goerli-eth-to-the-account) of the Starknet official guides for more information.
 61 | 
 62 | ## Deploying an Account
 63 | 
 64 | To deploy the new account, use the `deploy` command:
 65 | 
 66 | ```bash
 67 | ape starknet accounts deploy <NEW-ALIAS> --network testnet
 68 | ```
 69 | 
 70 | This only works if the account has been funded.
 71 | For convenience purposes, if you have another account with funds, you can use that account to fund the deployment of this one using the `--funder` option:
 72 | 
 73 | ```bash
 74 | ape starknet accounts deploy <NEW-ALIAS> --network testnet --funder <EXISTING-FUNDED-ALIAS>
 75 | ```
 76 | 
 77 | **NOTE**: You cannot use an Ethereum account to send funds to a Starknet account directly.
 78 | You must use the [Starknet L2 bridge](https://goerli.starkgate.starknet.io/) to transfer existing Goerli L1 ETH to and from the L2 account.
 79 | 
 80 | ## Listing Accounts
 81 | 
 82 | See your accounts and all of their deployment addresses:
 83 | 
 84 | ```bash
 85 | ape starknet accounts list
 86 | ```
 87 | 
 88 | shows:
 89 | 
 90 | ```bash
 91 | Alias                      - <ALIAS>
 92 | Public key                 - 0x123444444d716666dd88882bE2e99991555DE1c7
 93 | Class hash                 - 0x25ec026985a3bf9d0cc1fe17326b245dfdc3ff89b8fde106542a3ea56c5a918
 94 | Contract address (testnet) - 0x6b7111AA4111e5B2229c3332B66696888164440A773333143333B383333a183
 95 | Contract address (mainnet) - 0x7873113A4111e5B2229c3332B66696388163440A373333143333B3833332122
 96 | ```
 97 | 
 98 | ## Deleting an Account
 99 | 
100 | You can also delete accounts:
101 | 
102 | ```bash
103 | ape starknet accounts delete <ALIAS> --network testnet,testnet2
104 | ```
105 | 
106 | The `delete` command differs based on its values of `--network` and `--address`:
107 | 
108 | - To delete all deployments on a given network, use the `--network` option without `--address`.
109 | - To delete all deployments matching an address (regardless of network), use the `--address` option without `--network`.
110 | - To delete a deployment on a network with a particular address, use both `--network` and `--address`.
111 | - Exclude both options to delete the whole account.
112 | 
113 | Note you can also specify multiple networks, the same as `import`.
114 | 
115 | ## Auto-Sign Message
116 | 
117 | While generally bad practice, sometimes it is necessary to have unlocked keyfile accounts auto-signing messages.
118 | An example would be during testnet automated deployments.
119 | To achieve this, use the `set_autosign()` method available on the keyfile accounts:
120 | 
121 | ```python
122 | import keyring
123 | from ape import accounts
124 | 
125 | # Use keyring package to store secrets
126 | password = keyring.get_password("starknet-testnet-automations", "ci-shared-account")
127 | testnet_account = accounts.load("starknet-testnet-account")
128 | testnet_account.set_autosign(True, passphrase=password)
129 | 
130 | # Won't prompt for signing or unlocking
131 | testnet_account.sign_message([123])
132 | ```
133 | 


--------------------------------------------------------------------------------
/tests/functional/test_utils.py:
--------------------------------------------------------------------------------
  1 | import pytest
  2 | from ape.exceptions import (
  3 |     ApeException,
  4 |     ContractError,
  5 |     ContractLogicError,
  6 |     OutOfGasError,
  7 |     SignatureError,
  8 | )
  9 | from hexbytes import HexBytes
 10 | from starknet_py.net.client_errors import ClientError, ContractNotFoundError
 11 | from starknet_py.net.client_models import BlockSingleTransactionTrace
 12 | from starknet_py.transaction_exceptions import TransactionRejectedError
 13 | 
 14 | from ape_starknet.exceptions import StarknetProviderError
 15 | from ape_starknet.utils import (
 16 |     extract_trace_data,
 17 |     get_random_private_key,
 18 |     handle_client_error,
 19 |     is_checksum_address,
 20 |     to_checksum_address,
 21 |     to_int,
 22 | )
 23 | 
 24 | TEST_ADDRESS = 852629284295565304522725188288313475155928521990240236795402253191102056828
 25 | 
 26 | 
 27 | @pytest.mark.parametrize("iteration", range(10))
 28 | def test_get_random_private_key(iteration):
 29 |     pkey = get_random_private_key()
 30 |     assert len(pkey) == 66
 31 |     pkey_int = int(pkey, 16)
 32 |     pkey_back_to_str = HexBytes(pkey_int).hex()
 33 |     assert pkey_back_to_str.replace("0x", "") in pkey
 34 | 
 35 | 
 36 | def test_is_checksum_address(account):
 37 |     assert is_checksum_address(account.address)
 38 | 
 39 | 
 40 | def test_to_checksum_address(account):
 41 |     # Value from Starknet.js result
 42 |     expected = "0x02F4F57e5948B113Bf3D807B9ABB900EfC689b5b7a8500EBb79F670B3e08AE24"
 43 |     actual = to_checksum_address(expected.lower())
 44 |     assert actual == expected
 45 | 
 46 | 
 47 | @pytest.mark.parametrize(
 48 |     "exception, expected",
 49 |     [
 50 |         (ApeException("Foo!"), ApeException("Foo!")),
 51 |         (
 52 |             ClientError(
 53 |                 message=(
 54 |                     '{"message":"Error at pc=0:91:\nGot an exception '
 55 |                     "while executing a hint.\nCairo traceback (most r"
 56 |                     "ecent call last):\nUnknown location (pc=0:739)\n"
 57 |                     "Unknown location (pc=0:682)\nUnknown location (p"
 58 |                     "c=0:358)\nUnknown location (pc=0:400)\nUnknown l"
 59 |                     "ocation (pc=0:423)\n\nError in the called contra"
 60 |                     "ct (0x123):\nError at pc=0:41:\nGot an exception"
 61 |                     " while executing a hint.\nCairo traceback (most "
 62 |                     "recent call last):\nUnknown location (pc=0:7453)"
 63 |                     "\nUnknown location (pc=0:7437)\nUnknown location"
 64 |                     " (pc=0:4491)\nError message: Strings: exceeding "
 65 |                     "max felt string length (31)\nUnknown location (p"
 66 |                     "c=0:3219)\nUnknown location (pc=0:47)\n\nTraceba"
 67 |                     'ck (most recent call last):\n  File "<hint6>", l'
 68 |                     "ine 3, in <module>\nAssertionError: a = 36185027"
 69 |                     "886661312136973227830950701056231072153315966999"
 70 |                     '20561358720 is out of range.","status_code":500}'
 71 |                 ),
 72 |             ),
 73 |             ContractLogicError(revert_message="Strings: exceeding max felt string length (31)"),
 74 |         ),
 75 |         (
 76 |             ClientError(
 77 |                 message=(
 78 |                     '{"message":"An InvokeFunction transaction '
 79 |                     '(version != 0) must have a nonce.","status_code":500}\n'
 80 |                 )
 81 |             ),
 82 |             StarknetProviderError(
 83 |                 "An InvokeFunction transaction (version != 0) must have a nonce."
 84 |             ),
 85 |         ),
 86 |         (
 87 |             ContractNotFoundError(
 88 |                 address=TEST_ADDRESS,
 89 |                 block_hash="pending",
 90 |             ),
 91 |             StarknetProviderError(
 92 |                 f"No contract with address {TEST_ADDRESS} found for block with block_hash: pending."
 93 |             ),
 94 |         ),
 95 |         (
 96 |             TransactionRejectedError(message="Actual fee exceeded max fee.\n999800000000000 > 1"),
 97 |             OutOfGasError(),
 98 |         ),
 99 |         (
100 |             TransactionRejectedError(
101 |                 message="Error at pc=0:330: An ASSERT_EQ instruction failed: 0 != 1."
102 |             ),
103 |             ContractLogicError(
104 |                 revert_message="Error at pc=0:330: An ASSERT_EQ instruction failed: 0 != 1."
105 |             ),
106 |         ),
107 |         (ValueError("Foo!"), ValueError("Foo!")),
108 |         (
109 |             ClientError(
110 |                 "Client failed with code 500: "
111 |                 '{"code": "StarknetErrorCode.TRANSACTION_FAILED", '
112 |                 '"message": "Error at pc=0:166:\\nSignature '
113 |                 "(3043690392760996823501689233597619912806801642077770433986032017604167509951, "
114 |                 "140932343948720055880187056217327835615175238698469767628052057966817353503), "
115 |                 "is invalid, with respect to the public key "
116 |                 "6835981319243216192375995835136133760276036836, "
117 |                 "and the message hash "
118 |                 "2506859578009568926921040670359334110481328447009243612404313172189339494201."
119 |                 "\\nCairo traceback (most recent call last):\\nUnknown "
120 |                 "location (pc=0:413)\\nUnknown location (pc=0:400)"
121 |                 '\\nUnknown location (pc=0:320)"}.'
122 |             ),
123 |             SignatureError(
124 |                 "Invalid signature with respect to public key "
125 |                 "0x13289378ec83a20385758c7ec489853213cfce4."
126 |             ),
127 |         ),
128 |         (
129 |             ClientError(
130 |                 "Client failed with code 500: "
131 |                 '{{"code":"StarknetErrorCode.UNINITIALIZED_CONTRACT",'
132 |                 f'"message":"Requested contract address {TEST_ADDRESS} is not deployed."}}\n.'
133 |             ),
134 |             ContractError(f"Contract at address '{TEST_ADDRESS}' not deployed."),
135 |         ),
136 |     ],
137 | )
138 | def test_handle_client_error(exception, expected):
139 |     error = handle_client_error(exception)
140 |     assert str(error) == str(expected)
141 | 
142 | 
143 | def test_extract_trace_data(traces_testnet_243810, traces_testnet_243810_results):
144 |     for trace in traces_testnet_243810:
145 |         trace_object = BlockSingleTransactionTrace(**trace)
146 |         trace_data = extract_trace_data(trace_object)
147 |         assert isinstance(trace_data, dict)
148 | 
149 |         expected_result = traces_testnet_243810_results[trace_object.transaction_hash]
150 |         assert trace_data["result"] == expected_result
151 | 
152 | 
153 | @pytest.mark.parametrize(
154 |     "val", (1952805748, "1952805748", b"test", "test", HexBytes(1952805748), "0x74657374")
155 | )
156 | def test_to_int(val):
157 |     assert to_int(val) == 1952805748
158 | 


--------------------------------------------------------------------------------
/tests/functional/test_accounts.py:
--------------------------------------------------------------------------------
  1 | import pytest
  2 | from ape.api.networks import LOCAL_NETWORK_NAME
  3 | from click.testing import CliRunner
  4 | from hexbytes import HexBytes
  5 | 
  6 | from ape_starknet.accounts import DEVNET_CONTRACT_SALT, StarknetAccountDeployment
  7 | from ape_starknet.utils import OPEN_ZEPPELIN_ACCOUNT_CLASS_HASH, is_hex_address
  8 | 
  9 | 
 10 | @pytest.fixture
 11 | def give_input():
 12 |     def fn(msg):
 13 |         return CliRunner().isolation(input=msg)
 14 | 
 15 |     return fn
 16 | 
 17 | 
 18 | @pytest.fixture
 19 | def devnet_keyfile_account(account_container, account, password, give_input):
 20 |     deployments = [
 21 |         StarknetAccountDeployment(
 22 |             contract_address=account.address, network_name="testnet", salt=DEVNET_CONTRACT_SALT
 23 |         )
 24 |     ]
 25 | 
 26 |     with give_input(f"{password}\n{password}\n"):
 27 |         return account_container.import_account(
 28 |             "__DEV_AS_KEYFILE_ACCOUNT__",
 29 |             OPEN_ZEPPELIN_ACCOUNT_CLASS_HASH,
 30 |             account.private_key,
 31 |             deployments=deployments,
 32 |             salt=DEVNET_CONTRACT_SALT,
 33 |         )
 34 | 
 35 | 
 36 | @pytest.fixture
 37 | def txn(devnet_keyfile_account):
 38 |     return devnet_keyfile_account.get_deploy_account_txn()
 39 | 
 40 | 
 41 | def test_public_key(key_file_account, public_key):
 42 |     actual = key_file_account.public_key
 43 |     assert int(actual, 16) == public_key
 44 | 
 45 | 
 46 | def test_address(account):
 47 |     assert is_hex_address(account.address)
 48 | 
 49 | 
 50 | def test_account_container_contains(account, second_account, key_file_account, account_container):
 51 |     assert account.address in account_container
 52 |     assert second_account.address in account_container
 53 |     assert key_file_account.address in account_container
 54 | 
 55 | 
 56 | CASE_NAME_TO_LAMBDA = {
 57 |     "address_str": lambda a, _: a.address,
 58 |     "address_int": lambda a, e: e.encode_address(a.address),
 59 |     "public_key_str": lambda a, _: a.public_key,
 60 |     "public_key_int": lambda a, e: e.encode_address(a.public_key),
 61 | }
 62 | 
 63 | 
 64 | @pytest.mark.parametrize("case", [x for x in CASE_NAME_TO_LAMBDA.keys()])
 65 | def test_access_account_by_str_address(account, account_container, starknet, case):
 66 |     get_address = CASE_NAME_TO_LAMBDA[case]
 67 |     address = get_address(account, starknet)
 68 |     assert account_container[address] == account
 69 |     assert address in account_container
 70 | 
 71 | 
 72 | def test_balance(account, ephemeral_account, tokens):
 73 |     balance = account.balance
 74 |     assert isinstance(balance, int)
 75 |     assert balance > 0
 76 | 
 77 |     balance = ephemeral_account.balance
 78 |     assert isinstance(balance, int)
 79 |     assert balance > 0
 80 | 
 81 |     # Clear caches and make sure still works (uses RPC)
 82 |     del tokens.balance_cache[account.address_int]
 83 |     del tokens.balance_cache[ephemeral_account.address_int]
 84 | 
 85 |     balance = account.balance
 86 |     assert isinstance(balance, int)
 87 |     assert balance > 0
 88 | 
 89 |     balance = ephemeral_account.balance
 90 |     assert isinstance(balance, int)
 91 |     assert balance > 0
 92 | 
 93 | 
 94 | def test_can_access_devnet_accounts(account, second_account, chain):
 95 |     assert chain.contracts[account.address] == account.contract_type
 96 |     assert chain.contracts[second_account.address] == second_account.contract_type
 97 | 
 98 | 
 99 | def test_import_with_passphrase(account_container, account, give_input):
100 |     alias = "__TEST_IMPORT_WITH_PASSPHRASE__"
101 |     deployment = StarknetAccountDeployment(
102 |         contract_address=account.address, network_name=LOCAL_NETWORK_NAME, salt=DEVNET_CONTRACT_SALT
103 |     )
104 | 
105 |     with give_input("p@55W0rd\np@55W0rd\n"):
106 |         account_container.import_account(
107 |             alias,
108 |             OPEN_ZEPPELIN_ACCOUNT_CLASS_HASH,
109 |             account.private_key,
110 |             deployments=[deployment],
111 |         )
112 |     new_account = account_container.load(alias)
113 |     assert new_account.address == account.address
114 | 
115 | 
116 | def test_transfer(account, second_account):
117 |     initial_account_balance = account.balance
118 |     initial_second_account_balance = second_account.balance
119 |     receipt = account.transfer(second_account, 10)
120 |     total_cost = receipt.total_fees_paid + 10
121 |     assert second_account.balance == initial_second_account_balance + 10
122 |     assert account.balance == initial_account_balance - total_cost
123 | 
124 | 
125 | @pytest.mark.parametrize("msg", (5, [5, 6], b"5", HexBytes(122)))
126 | def test_sign_message(msg, key_file_account, password):
127 |     key_file_account.set_autosign(True, passphrase=password)
128 |     assert key_file_account.sign_message(msg)
129 |     key_file_account.set_autosign(False)
130 | 
131 | 
132 | def test_unlock_with_passphrase_and_sign_message(
133 |     in_starknet_testnet, give_input, devnet_keyfile_account, password
134 | ):
135 |     devnet_keyfile_account.unlock(passphrase=password)
136 |     with give_input("y\n"):
137 |         devnet_keyfile_account.sign_message([1, 2, 3])
138 | 
139 | 
140 | def test_unlock_from_prompt_and_sign_message(
141 |     in_starknet_testnet, give_input, devnet_keyfile_account, password
142 | ):
143 |     with give_input(f"{password}\n"):
144 |         devnet_keyfile_account.unlock()
145 | 
146 |     with give_input("y\n"):
147 |         devnet_keyfile_account.sign_message([1, 2, 3])
148 | 
149 | 
150 | def test_unlock_with_passphrase_and_sign_transaction(
151 |     in_starknet_testnet, give_input, devnet_keyfile_account, password, txn
152 | ):
153 |     devnet_keyfile_account.unlock(passphrase=password)
154 |     with give_input("y\n"):
155 |         devnet_keyfile_account.sign_transaction(txn)
156 | 
157 | 
158 | def test_unlock_from_prompt_and_sign_transaction(
159 |     in_starknet_testnet, give_input, devnet_keyfile_account, password, txn
160 | ):
161 |     with give_input(f"{password}\n"):
162 |         devnet_keyfile_account.unlock()
163 | 
164 |     with give_input("y\n"):
165 |         devnet_keyfile_account.sign_transaction(txn)
166 | 
167 | 
168 | def test_set_autosign(in_starknet_testnet, give_input, devnet_keyfile_account, password, txn):
169 |     with give_input(f"{password}\n"):
170 |         devnet_keyfile_account.set_autosign(True)
171 | 
172 |     devnet_keyfile_account.sign_transaction(txn)
173 | 
174 |     # Disable and verify we have to sign again
175 |     devnet_keyfile_account.set_autosign(False)
176 |     with give_input(f"y\n{password}\n"):
177 |         devnet_keyfile_account.sign_transaction(txn)
178 | 
179 | 
180 | def test_set_autosign_and_provide_passphrase(
181 |     in_starknet_testnet, give_input, devnet_keyfile_account, password, txn
182 | ):
183 |     devnet_keyfile_account.set_autosign(True, passphrase=password)
184 |     devnet_keyfile_account.sign_transaction(txn)
185 | 
186 |     # Disable and verify we have to sign again
187 |     devnet_keyfile_account.set_autosign(False)
188 |     with give_input(f"y\n{password}\n"):
189 |         devnet_keyfile_account.sign_transaction(txn)
190 | 
191 | 
192 | def test_accounts_devnet_accounts_are_still_available_on_ethereum(account_container, networks):
193 |     assert account_container.test_accounts
194 | 
195 |     with networks.ethereum.local.use_provider("test"):
196 |         # Accounts are still found even though devnet is not the active provider.
197 |         assert account_container.test_accounts
198 | 
199 |     assert account_container.test_accounts
200 | 


--------------------------------------------------------------------------------
/docs/_static/custom.css:
--------------------------------------------------------------------------------
  1 | @import url("https://fonts.cdnfonts.com/css/barlow");
  2 | 
  3 | html {
  4 |     font-weight: 400;
  5 |     font-family: "Barlow", sans-serif;
  6 |     min-height: 100%;
  7 |     background: rgb(244, 244, 244);
  8 |     font-size: 17px;
  9 | }
 10 | 
 11 | #version-picker-label {
 12 |     color: #000000;
 13 |     display: inline;
 14 |     font-size: 16px;
 15 | 
 16 |     font-family: "Barlow", sans-serif;
 17 |     font-weight: 600;
 18 |     width: 100%;
 19 | }
 20 | 
 21 | body {
 22 |     font-weight: 400;
 23 |     font-family: "Barlow", sans-serif;
 24 |     min-height: 100%;
 25 |     background: rgb(244, 244, 244);
 26 |     font-size: 17px;
 27 | }
 28 | 
 29 | p {
 30 |     font-weight: 400;
 31 |     font-family: "Barlow", sans-serif;
 32 |     font-size: 18px;
 33 | }
 34 | 
 35 | h1 {
 36 |     font-size: 60px;
 37 |     line-height: 54px;
 38 |     font-weight: 600;
 39 |     font-family: "Barlow", sans-serif;
 40 |     text-transform: uppercase;
 41 |     letter-spacing: -0.05em;
 42 |     color: #000000;
 43 |     padding: 0px !important;
 44 | }
 45 | 
 46 | h2 {
 47 |     font-size: 32px;
 48 |     line-height: 32px;
 49 |     font-family: "Barlow", sans-serif;
 50 |     letter-spacing: -0.02em;
 51 |     padding: 0px;
 52 |     color: #000000;
 53 | }
 54 | 
 55 | h3 {
 56 |     font-size: 24px;
 57 |     line-height: 24px;
 58 |     font-family: "Barlow", sans-serif;
 59 |     letter-spacing: -0.05em;
 60 |     font-weight: 300;
 61 |     color: #000000;
 62 | }
 63 | 
 64 | .wy-nav-content-wrap {
 65 |     margin-left: 300px;
 66 |     background: #fff;
 67 |     min-height: 100%;
 68 |     padding: 20px;
 69 | }
 70 | 
 71 | .wy-side-scroll {
 72 |     width: 320px;
 73 |     background-color: #ffffff;
 74 |     position: relative;
 75 |     overflow-x: hidden;
 76 |     overflow-y: scroll;
 77 |     height: 100%;
 78 |     padding: 20px;
 79 | }
 80 | 
 81 | .wy-nav-top {
 82 |     display: block;
 83 |     background-color: rgb(255, 255, 255);
 84 |     padding: 0.4045em 0.809em;
 85 |     position: relative;
 86 |     line-height: 50px;
 87 |     text-align: center;
 88 |     font-size: 100%;
 89 |     font-family: "Barlow", sans-serif;
 90 |     color: black;
 91 | }
 92 | 
 93 | .wy-side-nav-search {
 94 |     display: block;
 95 |     width: 300px;
 96 |     /*padding: 0.809em;
 97 |   margin-bottom: 0.809em;*/
 98 |     z-index: 200;
 99 |     background-color: #000000;
100 |     text-align: center;
101 |     color: #fafafa;
102 | }
103 | 
104 | .wy-menu-vertical header,
105 | .wy-menu-vertical p.caption {
106 |     color: #000000;
107 |     font-family: "Barlow", sans-serif;
108 |     height: 32px;
109 |     line-height: 32px;
110 |     display: block;
111 |     font-weight: 700;
112 |     text-transform: uppercase;
113 |     font-size: 20px;
114 |     white-space: nowrap;
115 |     background-color: rgb(255, 255, 255);
116 | }
117 | 
118 | .wy-menu-vertical a {
119 |     line-height: 18px;
120 |     padding: 0.4045em 1.618em;
121 |     display: block;
122 |     position: relative;
123 |     font-size: 90%;
124 |     color: #000000;
125 | }
126 | 
127 | .rst-content code.literal,
128 | .rst-content tt.literal {
129 |     color: #000000;
130 | }
131 | 
132 | footer {
133 |     color: rgb(0, 0, 0);
134 |     display: none;
135 | }
136 | 
137 | .wy-nav-top {
138 |     display: none;
139 |     background: #ffffff;
140 |     color: rgb(0, 0, 0);
141 |     padding: 0.4045em 0.809em;
142 |     position: relative;
143 |     line-height: 50px;
144 |     text-align: center;
145 |     font-size: 100%;
146 | }
147 | 
148 | .wy-nav-side {
149 |     position: fixed;
150 |     top: 0;
151 |     bottom: 0;
152 |     left: 0;
153 |     padding-bottom: 2em;
154 |     width: 300px;
155 |     overflow-x: hidden;
156 |     overflow-y: hidden;
157 |     min-height: 100%;
158 |     background-color: #ffffff;
159 |     z-index: 200;
160 | }
161 | 
162 | @media only screen and (min-device-width: 320px) and (max-device-width: 480px) {
163 |     .wy-nav-side {
164 |         display: none;
165 |     }
166 | 
167 |     .wy-nav-side.shift {
168 |         display: block;
169 |     }
170 | 
171 |     .wy-nav-content-wrap {
172 |         margin-left: 0;
173 |         background-color: #f2f3f8;
174 |         min-height: 100%;
175 |     }
176 | 
177 |     .wy-nav-top {
178 |         display: block;
179 |         color: #fff;
180 |         padding: 0.4045em 0.809em;
181 |         position: relative;
182 |         line-height: 50px;
183 |         text-align: center;
184 |         font-size: 100%;
185 |     }
186 | 
187 |     .wy-side-nav-search {
188 |         display: block;
189 |         width: 300px;
190 |         /*padding: 0.809em;*/
191 |         margin-bottom: 0.809em;
192 |         z-index: 200;
193 |         background-color: #000000;
194 |         text-align: center;
195 |         color: #fafafa;
196 |     }
197 | 
198 |     h1 {
199 |         font-size: 32px;
200 |         line-height: 32px;
201 |         font-family: "Barlow", sans-serif;
202 |         text-transform: uppercase;
203 |         letter-spacing: -0.05em;
204 |         color: #000000;
205 |     }
206 | 
207 |     h2 {
208 |         font-size: 34px;
209 |         line-height: 34px;
210 |         font-family: "Barlow", sans-serif;
211 |         letter-spacing: -0.05em;
212 |     }
213 | }
214 | 
215 | a {
216 |     color: rgb(93, 0, 255);
217 |     cursor: pointer;
218 | }
219 | 
220 | @media only screen and (min-device-width: 320px) and (max-device-width: 480px) {
221 |     a {
222 |         color: rgb(93, 0, 255);
223 |         cursor: pointer;
224 |     }
225 | }
226 | 
227 | .toctree-l3 {
228 |     color: red;
229 | }
230 | 
231 | .caption-text {
232 |     color: black;
233 |     margin: -10px;
234 |     font-family: "Barlow", sans-serif;
235 |     font-weight: 600;
236 |     font-size: 24px;
237 |     padding: 0px !important;
238 | }
239 | 
240 | .reference {
241 |     color: rgb(93, 0, 255);
242 | }
243 | 
244 | .wy-menu-vertical li.current a {
245 |     background: #ff969600;
246 | }
247 | 
248 | .wy-menu-vertical a {
249 |     line-height: 28px;
250 |     font-size: 18px;
251 |     font-weight: 400;
252 |     font-family: "Barlow", sans-serif;
253 |     padding: 0.4045em 1.618em;
254 |     display: block;
255 |     position: relative;
256 |     font-size: 100%;
257 |     color: #000000;
258 | }
259 | 
260 | .wy-menu-vertical a:hover {
261 |     line-height: 28px;
262 |     font-size: 18px;
263 |     font-weight: 400;
264 |     font-family: "Barlow", sans-serif;
265 |     display: block;
266 |     position: relative;
267 |     font-size: 100%;
268 |     color: #000000;
269 |     background-color: rgba(247, 247, 247, 0.961);
270 |     cursor: pointer;
271 | }
272 | 
273 | .logo {
274 |     filter: invert(0.85);
275 |     width: 250px !important;
276 |     height: auto;
277 |     position: relative;
278 |     top: 20 !important;
279 |     left: 20 !important;
280 |     margin-left: -10px;
281 |     z-index: 240;
282 | }
283 | 
284 | .wy-side-nav-search {
285 |     display: block;
286 |     width: 300px;
287 | 
288 |     z-index: 200;
289 |     background-color: transparent;
290 |     text-align: center;
291 |     color: #fafafa;
292 | }
293 | 
294 | .wy-side-nav-search input[type="text"] {
295 |     width: 80%;
296 |     border-radius: 25px;
297 |     padding: 6px 12px;
298 |     border-color: #000000;
299 |     border: width 1.5em;
300 | }
301 | 
302 | .wy-menu-vertical li.current a {
303 |     background: #ffffff;
304 |     border-style: none;
305 | }
306 | 
307 | .wy-menu-vertical li.current a:hover {
308 |     background-color: rgba(247, 247, 247, 0.961);
309 |     border-style: none;
310 | }
311 | 
312 | .wy-menu-vertical li.toctree-l2 button.toctree-expand {
313 |     display: none;
314 | }
315 | 
316 | .icon icon-home {
317 |     display: none;
318 | }


--------------------------------------------------------------------------------
/tests/functional/test_contract.py:
--------------------------------------------------------------------------------
  1 | import pytest
  2 | from ape import Contract
  3 | from ape.exceptions import ContractLogicError, OutOfGasError
  4 | 
  5 | from ape_starknet.exceptions import StarknetProviderError
  6 | from ape_starknet.utils import EXECUTE_METHOD_NAME
  7 | 
  8 | 
  9 | def test_declare_then_deploy(account, chain, project, provider):
 10 |     """
 11 |     This test shows a realistic flow.
 12 | 
 13 |     1. Declare a contract.
 14 |     2. Declare a factory contract.
 15 |     3. Use the universal deployer contract to deploy factory contract
 16 |        (with other class hash as argument).
 17 |     4. Use the factory contract to deploy the other contract.
 18 |     """
 19 | 
 20 |     # Declare the contracts
 21 |     balance_before = account.balance  # Tracked to make sure Declares cost money.
 22 |     declaration = account.declare(project.MyContract)
 23 |     factory_declaration = account.declare(project.ContractFactory)
 24 |     assert declaration.class_hash
 25 |     assert factory_declaration.class_hash
 26 | 
 27 |     # Ensure the Declares cost money
 28 |     actual_balance = account.balance
 29 |     total_fees = declaration.total_fees_paid + factory_declaration.total_fees_paid
 30 |     expected_balance = balance_before - total_fees
 31 |     assert actual_balance == expected_balance
 32 | 
 33 |     # Deploy the factory contract. It takes the class hash of the other contract as its
 34 |     # argument so it can create instances of it.
 35 |     # NOTE: We would not be able to deploy the factory if we did not declare it above.
 36 |     #  and we don't need to tell ape the factory's class-hash - it can configure it out.
 37 |     factory = project.ContractFactory.deploy(declaration.class_hash, sender=account)
 38 |     assert factory.address
 39 |     assert factory.create_my_contract
 40 | 
 41 |     # Use custom factory method to create a new contract.
 42 |     balance_before = account.balance
 43 |     receipt = factory.create_my_contract(sender=account)
 44 |     actual_balance = account.balance
 45 |     expected_balance = balance_before - receipt.total_fees_paid
 46 |     assert actual_balance == expected_balance
 47 | 
 48 |     # Grab the new contract address from the receipt's logs.
 49 |     logs = list(receipt.decode_logs(factory.contract_deployed))
 50 |     new_contract_address = provider.starknet.decode_address(logs[0]["contract_address"])
 51 | 
 52 |     # Interact with deployed contract from 'class_hash'.
 53 |     new_contract_instance = Contract(
 54 |         new_contract_address, contract_type=project.MyContract.contract_type
 55 |     )
 56 |     assert new_contract_instance
 57 |     new_contract_instance.initialize(sender=account)
 58 |     balance_pre_call = new_contract_instance.get_balance(account)
 59 |     new_contract_instance.increase_balance(account, 9, sender=account)
 60 |     assert new_contract_instance.get_balance(account) == balance_pre_call + 9
 61 | 
 62 | 
 63 | def test_get_caller_address(contract, account, provider):
 64 |     expected = provider.starknet.encode_address(account.address)
 65 |     assert contract.get_caller(sender=account).return_value == expected
 66 | 
 67 | 
 68 | def test_validate_signature_on_chain(contract, account, initial_balance):
 69 |     # NOTE: This test validates the account signature but the transaction
 70 |     # is not directly sent from the account.
 71 |     increase_amount = 42 * 2**152
 72 | 
 73 |     signature = account.sign_message(increase_amount)
 74 |     contract.increase_balance_signed(
 75 |         account.public_key, account.address, increase_amount, signature, sender=account
 76 |     )
 77 | 
 78 |     actual = contract.get_balance(account)
 79 |     expected = initial_balance + increase_amount
 80 |     assert actual == expected
 81 | 
 82 | 
 83 | def test_transact_from_account(contract, account, initial_balance):
 84 |     increase_amount = 123456
 85 |     receipt = contract.increase_balance(account, increase_amount, sender=account)
 86 |     actual_from_receipt = receipt.return_value
 87 |     actual_from_call = contract.get_balance(account)
 88 |     expected = initial_balance + increase_amount
 89 |     assert actual_from_receipt == actual_from_call == expected
 90 | 
 91 | 
 92 | def test_contracts_as_arguments(contract, account):
 93 |     initial_balance = contract.get_balance(contract)
 94 |     increase_amount = 123456
 95 |     receipt = contract.increase_balance(contract, increase_amount, sender=account)
 96 |     actual_from_receipt = receipt.return_value
 97 |     actual_from_call = contract.get_balance(contract)
 98 |     expected = initial_balance + increase_amount
 99 |     assert actual_from_receipt == actual_from_call == expected
100 | 
101 | 
102 | def test_unsigned_contract_transaction(contract, account, initial_balance):
103 |     increase_amount = 123456
104 | 
105 |     with pytest.raises(
106 |         StarknetProviderError,
107 |         match=f"Can only send invoke transaction to an account {EXECUTE_METHOD_NAME} method.",
108 |     ):
109 |         contract.increase_balance(account.address, increase_amount)
110 | 
111 | 
112 | def test_decode_logs(contract, account, starknet):
113 |     increase_amount = 9933
114 |     receipt = contract.increase_balance(account.address, increase_amount, sender=account)
115 |     logs = list(receipt.decode_logs(contract.balance_increased))
116 |     assert len(logs) == 1
117 |     assert logs[0].amount == increase_amount
118 | 
119 |     from_address = receipt.logs[0]["from_address"]
120 |     log_sender_address = starknet.decode_address(from_address)
121 |     assert log_sender_address == contract.address
122 | 
123 | 
124 | def test_revert_message(contract, account):
125 |     reason = "Already initialized"
126 |     with pytest.raises(ContractLogicError, match=reason):
127 |         # Already initialized from fixture
128 |         contract.initialize(sender=account)
129 | 
130 | 
131 | def test_revert_no_message(contract, account):
132 |     contract.reset(sender=account)
133 |     reason = "An ASSERT_EQ instruction failed.*"
134 |     with pytest.raises(ContractLogicError, match=reason):
135 |         contract.increase_balance(account.address, 123, sender=account)
136 | 
137 |     # Re-initialize (re-store state)
138 |     contract.initialize(sender=account)
139 | 
140 | 
141 | def test_unable_to_afford_transaction(contract, account, provider):
142 |     with pytest.raises(OutOfGasError):
143 |         contract.increase_balance(account.address, 1, sender=account, max_fee=1)
144 | 
145 | 
146 | def test_array_inputs(contract, account):
147 |     # This test makes sure we can pass python lists as arguments
148 |     # to Cairo methods that accept arrays.
149 |     # NOTE: Due to a limitation in ape, we have to include the array length argument.
150 |     contract.store_sum(3, [1, 2, 3], sender=account)
151 |     assert contract.get_last_sum() == 6
152 | 
153 | 
154 | def test_complex_struct_argument(contract, account):
155 |     complex_struct = {
156 |         "timestamp": 42,
157 |         "value0": 123,  # == Uint256(123, 0)
158 |         "value1": {
159 |             "low": 0,
160 |             "high": 123,
161 |         },  # == Uint256(0, 123) == 41854731131275431005995076714107490009088
162 |     }
163 |     receipt = contract.store_complex_struct(complex_struct, sender=account)
164 |     assert receipt.return_value == {
165 |         "timestamp": 42,
166 |         "value0": 123,
167 |         "value1": 41854731131275431005995076714107490009088,
168 |     }
169 | 
170 | 
171 | #
172 | # Test external, and view, methods
173 | #
174 | 
175 | 
176 | @pytest.mark.parametrize(
177 |     "method, returndata_expected, return_value_expected",
178 |     [
179 |         ("array", ["0x3", "0x1", "0x2", "0x3"], [1, 2, 3]),
180 |         (
181 |             "array_complex_struct",
182 |             [
183 |                 "0x3",
184 |                 "0x0",
185 |                 "0x7b",
186 |                 "0x0",
187 |                 "0x0",
188 |                 "0x7b",
189 |                 "0x1",
190 |                 "0x0",
191 |                 "0x7b",
192 |                 "0x7b",
193 |                 "0x0",
194 |                 "0x2",
195 |                 "0x0",
196 |                 "0x0",
197 |                 "0x0",
198 |                 "0x0",
199 |             ],
200 |             [
201 |                 {
202 |                     "timestamp": 0,
203 |                     "value0": 123,
204 |                     "value1": 41854731131275431005995076714107490009088,
205 |                 },
206 |                 {
207 |                     "timestamp": 1,
208 |                     "value0": 41854731131275431005995076714107490009088,
209 |                     "value1": 123,
210 |                 },
211 |                 {"timestamp": 2, "value0": 0, "value1": 0},
212 |             ],
213 |         ),
214 |         (
215 |             "array_uint256",
216 |             ["0x3", "0x7b", "0x0", "0x0", "0x7b", "0x0", "0x0"],
217 |             [
218 |                 123,
219 |                 41854731131275431005995076714107490009088,
220 |                 0,
221 |             ],
222 |         ),
223 |         (
224 |             "complex_struct",
225 |             ["0x4d2", "0x7b", "0x0", "0x0", "0x7b"],
226 |             {
227 |                 "timestamp": 1234,
228 |                 "value0": 123,
229 |                 "value1": 41854731131275431005995076714107490009088,
230 |             },
231 |         ),
232 |         ("felt", ["0x2"], 2),
233 |         (
234 |             "mix",
235 |             [
236 |                 "0x1",
237 |                 "0x2",
238 |                 "0x3",
239 |                 "0x4",
240 |                 "0x7b",
241 |                 "0x0",
242 |                 "0x3",
243 |                 "0x8",
244 |                 "0x9",
245 |                 "0xa",
246 |                 "0xb",
247 |                 "0x0",
248 |                 "0x7b",
249 |             ],
250 |             (
251 |                 1,
252 |                 [3, 4],
253 |                 123,
254 |                 [8, 9, 10],
255 |                 11,
256 |                 41854731131275431005995076714107490009088,
257 |             ),
258 |         ),
259 |         ("uint256", ["0x1", "0x0"], 1),
260 |         (
261 |             "uint256s",
262 |             ["0x7b", "0x0", "0x0", "0x7b", "0x0", "0x0"],
263 |             (
264 |                 123,
265 |                 41854731131275431005995076714107490009088,
266 |                 0,
267 |             ),
268 |         ),
269 |     ],
270 | )
271 | def test_external_and_view_method_outputs(
272 |     method, returndata_expected, return_value_expected, contract, account
273 | ):
274 |     # Check the view method
275 |     return_value = getattr(contract, f"{method}_view")()
276 |     assert return_value == return_value_expected
277 | 
278 |     # Check the external method
279 |     receipt = getattr(contract, f"{method}_external")(sender=account)
280 |     assert receipt.returndata == returndata_expected
281 |     assert receipt.return_value == return_value
282 | 
283 | 
284 | def test_estimate_gas_cost_external_method(contract, account, provider):
285 |     estimated_fee = contract.increase_balance.estimate_gas_cost(account.address, 1, sender=account)
286 |     assert estimated_fee > 100_000_000_000_000
287 | 
288 |     receipt = contract.increase_balance(account.address, 1, sender=account)
289 |     assert receipt.gas_used == estimated_fee
290 |     assert receipt.max_fee > estimated_fee
291 |     assert receipt.total_fees_paid == receipt.gas_used
292 |     assert not receipt.ran_out_of_gas
293 |     assert provider.gas_price >= 100_000_000_000
294 | 
295 | 
296 | def test_estimate_gas_cost_view_method(contract, account, provider):
297 |     estimated_fee = contract.get_balance.estimate_gas_cost(account.address, sender=account)
298 |     assert estimated_fee > 100_000_000_000_000
299 |     assert provider.gas_price >= 100_000_000_000
300 | 
301 | 
302 | def test_estimate_gas_cost_view_method_2(contract, account):
303 |     estimated_fee = contract.get_balance.estimate_gas_cost(account, sender=account)
304 |     assert estimated_fee > 100_000_000_000_000
305 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "[]"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright 2021 ApeWorX Ltd.
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 


--------------------------------------------------------------------------------
/docs/_templates/layout.html:
--------------------------------------------------------------------------------
  1 | {# TEMPLATE VAR SETTINGS #}
  2 | {%- set url_root = pathto('', 1) %}
  3 | {%- if url_root == '#' %}{% set url_root = '' %}{% endif %}
  4 | {%- if not embedded and docstitle %}
  5 | {%- set titlesuffix = " &mdash; "|safe + docstitle|e %}
  6 | {%- else %}
  7 | {%- set titlesuffix = "" %}
  8 | {%- endif %}
  9 | {%- set lang_attr = 'en' if language == None else (language | replace('_', '-')) %}
 10 | {%- set sphinx_writer = 'writer-html5' if html5_doctype else 'writer-html4' -%}
 11 | 
 12 | {# Build sphinx_version_info tuple from sphinx_version string in pure Jinja #}
 13 | {%- set (_ver_major, _ver_minor) = (sphinx_version.split('.') | list)[:2] | map('int') -%}
 14 | {%- set sphinx_version_info = (_ver_major, _ver_minor, -1) -%}
 15 | 
 16 | <!DOCTYPE html>
 17 | <html class="{{ sphinx_writer }}" lang="{{ lang_attr }}">
 18 | 
 19 | <head>
 20 |     <meta charset="utf-8" />
 21 |     {{- metatags }}
 22 |     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 23 |     {%- block htmltitle %}
 24 |     <title>{{ title|striptags|e }}{{ titlesuffix }}</title>
 25 |     {%- endblock -%}
 26 | 
 27 |     {#- CSS #}
 28 |     {%- for css in css_files %}
 29 |     {%- if css|attr("rel") %}
 30 |     <link rel="{{ css.rel }}" href="{{ fixpath(pathto(css.filename, 1)) }}" type="text/css" {% if css.title is not none
 31 |         %} title="{{ css.title }}" {% endif %} />
 32 |     {%- else %}
 33 |     <link rel="stylesheet" href="{{ fixpath(pathto(css, 1)) }}" type="text/css" />
 34 |     {%- endif %}
 35 |     {%- endfor %}
 36 | 
 37 |     {%- for cssfile in extra_css_files %}
 38 |     <link rel="stylesheet" href="{{ fixpath(pathto(cssfile, 1)) }}" type="text/css" />
 39 |     {%- endfor -%}
 40 | 
 41 |     {#- FAVICON
 42 |     favicon_url is the only context var necessary since Sphinx 4.
 43 |     In Sphinx
 44 |     <4, we use favicon but need to prepend path info. #} {%- set _favicon_url=favicon_url | default(pathto('_static/' +
 45 |         (favicon or "" ), 1)) %} {%- if favicon_url or favicon %} <link rel="shortcut icon" href="{{ _favicon_url }}" />
 46 |     {%- endif %}
 47 | 
 48 |     {#- CANONICAL URL (deprecated) #}
 49 |     {%- if theme_canonical_url and not pageurl %}
 50 |     <link rel="canonical" href="{{ theme_canonical_url }}{{ pagename }}.html" />
 51 |     {%- endif -%}
 52 | 
 53 |     {#- CANONICAL URL #}
 54 |     {%- if pageurl %}
 55 |     <link rel="canonical" href="{{ pageurl|e }}" />
 56 |     {%- endif -%}
 57 | 
 58 |     {#- JAVASCRIPTS #}
 59 |     {%- block scripts %}
 60 |     <!--[if lt IE 9]>
 61 |     <script src="{{ pathto('_static/js/html5shiv.min.js', 1) }}"></script>
 62 |   <![endif]-->
 63 |     {%- if not embedded %}
 64 |     {# XXX Sphinx 1.8.0 made this an external js-file, quick fix until we refactor the template to inherert more blocks
 65 |     directly from sphinx #}
 66 |     {%- if sphinx_version_info >= (1, 8) -%}
 67 |     {%- for scriptfile in script_files %}
 68 |     {{ js_tag(scriptfile) }}
 69 |     {%- endfor %}
 70 |     {%- else %}
 71 |     <script>
 72 |         var DOCUMENTATION_OPTIONS = {
 73 |             URL_ROOT: '{{ url_root }}',
 74 |             VERSION: '{{ release|e }}',
 75 |             LANGUAGE: '{{ language }}',
 76 |             COLLAPSE_INDEX: false,
 77 |             FILE_SUFFIX: '{{ '' if no_search_suffix else file_suffix }}',
 78 |             HAS_SOURCE: {{ has_source| lower }},
 79 |         SOURCELINK_SUFFIX: '{{ sourcelink_suffix }}'
 80 |           };
 81 |     </script>
 82 |     {%- for scriptfile in script_files %}
 83 |     <script src="{{ pathto(scriptfile, 1) }}"></script>
 84 |     {%- endfor %}
 85 |     {%- endif %}
 86 |     <script src="{{ pathto('_static/js/theme.js', 1) }}"></script>
 87 |     <script src="{{ pathto('_static/custom.js', 1) }}"></script>
 88 | 
 89 |     {#- OPENSEARCH #}
 90 |     {%- if use_opensearch %}
 91 |     <link rel="search" type="application/opensearchdescription+xml"
 92 |         title="{% trans docstitle=docstitle|e %}Search within {{ docstitle }}{% endtrans %}"
 93 |         href="{{ pathto('_static/opensearch.xml', 1) }}" />
 94 |     {%- endif %}
 95 |     {%- endif %}
 96 |     <script>
 97 |         var PROJECT = "{{ project }}";
 98 |     </script>
 99 |     {%- endblock %}
100 | 
101 |     {%- block linktags %}
102 |     {%- if hasdoc('about') %}
103 |     <link rel="author" title="{{ _('About these documents') }}" href="{{ pathto('about') }}" />
104 |     {%- endif %}
105 |     {%- if hasdoc('genindex') %}
106 |     <link rel="index" title="{{ _('Index') }}" href="{{ pathto('genindex') }}" />
107 |     {%- endif %}
108 |     {%- if hasdoc('search') %}
109 |     <link rel="search" title="{{ _('Search') }}" href="{{ pathto('search') }}" />
110 |     {%- endif %}
111 |     {%- if hasdoc('copyright') %}
112 |     <link rel="copyright" title="{{ _('Copyright') }}" href="{{ pathto('copyright') }}" />
113 |     {%- endif %}
114 |     {%- if next %}
115 |     <link rel="next" title="{{ next.title|striptags|e }}" href="{{ next.link|e }}" />
116 |     {%- endif %}
117 |     {%- if prev %}
118 |     <link rel="prev" title="{{ prev.title|striptags|e }}" href="{{ prev.link|e }}" />
119 |     {%- endif %}
120 |     {%- endblock %}
121 |     {%- block extrahead %} {% endblock %}
122 | </head>
123 | 
124 | <body class="wy-body-for-nav">
125 | 
126 |     {%- block extrabody %} {% endblock %}
127 |     <div class="wy-grid-for-nav">
128 |         {#- SIDE NAV, TOGGLES ON MOBILE #}
129 |         <nav data-toggle="wy-nav-shift" class="wy-nav-side">
130 |             <div class="wy-side-scroll">
131 |                 <div class="wy-side-nav-search" {% if theme_style_nav_header_background %}
132 |                     style="background: {{theme_style_nav_header_background}}" {% endif %}>
133 |                     {%- block sidebartitle %}
134 | 
135 |                     {# the logo helper function was removed in Sphinx 6 and deprecated since Sphinx 4 #}
136 |                     {# the master_doc variable was renamed to root_doc in Sphinx 4 (master_doc still exists in later
137 |                     Sphinx versions) #}
138 |                     {%- set _logo_url = logo_url|default(pathto('_static/' + (logo or ""), 1)) %}
139 |                     {%- set _root_doc = root_doc|default(master_doc) %}
140 |                     <a href="{{ pathto(_root_doc) }}" {% if not theme_logo_only %} class="icon icon-home" {% endif %}>
141 |                         {% if not theme_logo_only %}{{ project }}{% endif %}
142 |                         {%- if logo or logo_url %}
143 |                         <img src="{{ _logo_url }}" class="logo" alt="{{ _('Logo') }}" />
144 |                         {%- endif %}
145 |                     </a>
146 | 
147 |                     {%- if theme_display_version %}
148 |                     {%- set nav_version = version %}
149 |                     {%- if READTHEDOCS and current_version %}
150 |                     {%- set nav_version = current_version %}
151 |                     {%- endif %}
152 |                     {%- if nav_version %}
153 |                     <div class="version">
154 |                         {{ nav_version }}
155 |                     </div>
156 |                     {%- endif %}
157 |                     {%- endif %}
158 | 
159 |                     <div class="version">
160 |                         <label for="version-picker" id="version-picker-label">Version:</label>
161 |                         <select id="version-picker">
162 |                             <option value="">Select version...</option>
163 |                             <option value="latest">latest</option>
164 |                             <option value="stable">stable</option>
165 |                             {%- for tag in get_versions() %}
166 |                             <option value="{{ tag }}">{{ tag }}</option>
167 |                             {%- endfor %}
168 |                         </select>
169 |                     </div>
170 | 
171 |                     {%- include "searchbox.html" %}
172 | 
173 |                     {%- endblock %}
174 |                 </div>
175 | 
176 |                 {%- block navigation %}
177 |                 {#- Translators: This is an ARIA section label for the main navigation menu -#}
178 |                 <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation"
179 |                     aria-label="{{ _('Navigation menu') }}">
180 |                     {%- block menu %}
181 |                     {%- set toctree = toctree(maxdepth=theme_navigation_depth|int,
182 |                     collapse=theme_collapse_navigation|tobool,
183 |                     includehidden=theme_includehidden|tobool,
184 |                     titles_only=theme_titles_only|tobool) %}
185 |                     {%- if toctree %}
186 |                     {{ toctree }}
187 |                     {%- else %}
188 |                     <!-- Local TOC -->
189 |                     <div class="local-toc">{{ toc }}</div>
190 |                     {%- endif %}
191 |                     {%- endblock %}
192 |                 </div>
193 |                 {%- endblock %}
194 |             </div>
195 |         </nav>
196 | 
197 |         <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
198 | 
199 |             {#- MOBILE NAV, TRIGGLES SIDE NAV ON TOGGLE #}
200 |             {#- Translators: This is an ARIA section label for the navigation menu that is visible when viewing the page
201 |             on mobile devices -#}
202 |             <nav class="wy-nav-top" aria-label="{{ _('Mobile navigation menu') }}" {% if
203 |                 theme_style_nav_header_background %} style="background: {{theme_style_nav_header_background}}" {% endif
204 |                 %}>
205 |                 {%- block mobile_nav %}
206 |                 <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
207 |                 <a href="{{ pathto(master_doc) }}">{{ project }}</a>
208 |                 {%- endblock %}
209 |             </nav>
210 | 
211 |             <div class="wy-nav-content">
212 |                 {%- block content %}
213 |                 {%- if theme_style_external_links|tobool %}
214 |                 <div class="rst-content style-external-links">
215 |                     {%- else %}
216 |                     <div class="rst-content">
217 |                         {%- endif %}
218 |                         {% include "breadcrumbs.html" %}
219 |                         <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
220 |                             {%- block document %}
221 |                             <div itemprop="articleBody">
222 |                                 {% block body %}{% endblock %}
223 |                             </div>
224 |                             {%- if self.comments()|trim %}
225 |                             <div class="articleComments">
226 |                                 {%- block comments %}{% endblock %}
227 |                             </div>
228 |                             {%- endif%}
229 |                         </div>
230 |                         {%- endblock %}
231 |                         {% include "footer.html" %}
232 |                     </div>
233 |                     {%- endblock %}
234 |                 </div>
235 |         </section>
236 |     </div>
237 |     {% include "versions.html" -%}
238 | 
239 |     <script>
240 |         jQuery(function () {
241 |             SphinxRtdTheme.Navigation.enable({{ 'true' if theme_sticky_navigation | tobool else 'false' }});
242 |       });
243 |     </script>
244 | 
245 |     {#- Do not conflict with RTD insertion of analytics script #}
246 |     {%- if not READTHEDOCS %}
247 |     {%- if theme_analytics_id %}
248 |     <!-- Theme Analytics -->
249 |     <script async src="https://www.googletagmanager.com/gtag/js?id={{ theme_analytics_id }}"></script>
250 |     <script>
251 |         window.dataLayer = window.dataLayer || [];
252 |         function gtag() { dataLayer.push(arguments); }
253 |         gtag('js', new Date());
254 | 
255 |         gtag('config', '{{ theme_analytics_id }}', {
256 |             'anonymize_ip': {{ 'true' if theme_analytics_anonymize_ip | tobool else 'false' }},
257 |       });
258 |     </script>
259 | 
260 |     {%- endif %}
261 |     {%- endif %}
262 | 
263 |     {%- block footer %} {% endblock %}
264 | 
265 | </body>
266 | 
267 | </html>


--------------------------------------------------------------------------------
/tests/projects/project/contracts/MyContract.cairo:
--------------------------------------------------------------------------------
  1 | %lang starknet
  2 | 
  3 | from starkware.cairo.common.alloc import alloc
  4 | from starkware.cairo.common.cairo_builtins import HashBuiltin, SignatureBuiltin
  5 | from starkware.cairo.common.hash import hash2
  6 | from starkware.cairo.common.signature import verify_ecdsa_signature
  7 | from starkware.cairo.common.bool import TRUE, FALSE
  8 | from starkware.cairo.common.uint256 import Uint256
  9 | from starkware.starknet.common.syscalls import get_caller_address
 10 | 
 11 | struct ComplexStruct {
 12 |     timestamp: felt,
 13 |     value0: Uint256,
 14 |     value1: Uint256,
 15 | }
 16 | 
 17 | @storage_var
 18 | func balance(user : felt) -> (res : felt) {
 19 | }
 20 | 
 21 | @storage_var
 22 | func last_sum() -> (sum : felt) {
 23 | }
 24 | 
 25 | @storage_var
 26 | func is_initialized() -> (initialized : felt) {
 27 | }
 28 | 
 29 | @storage_var
 30 | func array_get_counter() -> (res : felt) {
 31 | }
 32 | 
 33 | @event
 34 | func balance_increased(amount : felt) {
 35 | }
 36 | 
 37 | @storage_var
 38 | func complex_structs(index : felt) -> (res : ComplexStruct) {
 39 | }
 40 | 
 41 | @external
 42 | func initialize{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() {
 43 |     let (initialized) = is_initialized.read();
 44 |     with_attr error_message("Already initialized") {
 45 |         assert initialized = FALSE;
 46 |     }
 47 | 
 48 |     is_initialized.write(TRUE);
 49 |     return ();
 50 | }
 51 | 
 52 | @external
 53 | func reset{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() {
 54 |     is_initialized.write(FALSE);
 55 |     return ();
 56 | }
 57 | 
 58 | // Increases the balance by the given amount.
 59 | @external
 60 | func increase_balance{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
 61 |     user : felt, amount : felt
 62 | ) -> (balance: felt) {
 63 |     let (initialized) = is_initialized.read();
 64 |     assert initialized = TRUE;
 65 | 
 66 |     let (current_balance) = balance.read(user=user);
 67 |     balance.write(user, current_balance + amount);
 68 |     balance_increased.emit(amount);
 69 |     let (new_balance) = balance.read(user=user);
 70 |     return (balance=new_balance);
 71 | }
 72 | 
 73 | // Increases the balance of the given user by the given amount.
 74 | @external
 75 | func increase_balance_signed{
 76 |     syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr, ecdsa_ptr : SignatureBuiltin*
 77 | }(public_key : felt, user : felt, amount : felt, sig : (felt, felt)) {
 78 |     // Compute the hash of the message.
 79 |     // The hash of (x, 0) is equivalent to the hash of (x).
 80 |     let (amount_hash) = hash2{hash_ptr=pedersen_ptr}(amount, 0);
 81 | 
 82 |     // Verify the user's signature.
 83 |     verify_ecdsa_signature(
 84 |         message=amount_hash, public_key=public_key, signature_r=sig[0], signature_s=sig[1]
 85 |     );
 86 | 
 87 |     let (res) = balance.read(user=user);
 88 |     balance.write(user, res + amount);
 89 |     return ();
 90 | }
 91 | 
 92 | // Returns the current balance.
 93 | @view
 94 | func get_balance{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
 95 |     user : felt
 96 | ) -> (res : felt) {
 97 |     let (res) = balance.read(user=user);
 98 |     return (res=res);
 99 | }
100 | 
101 | @external
102 | func store_sum{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
103 |     arr_len : felt, arr : felt*
104 | ) -> (sum: felt) {
105 |     let (calc) = array_sum(arr_len, arr);
106 |     last_sum.write(calc);
107 |     return (sum=calc);
108 | }
109 | 
110 | @external
111 | func get_caller{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (caller: felt) {
112 |     let (caller) = get_caller_address();
113 |     return (caller=caller);
114 | }
115 | 
116 | func array_sum(arr_len : felt, arr : felt*) -> (felt) {
117 |     if (arr_len == 0) {
118 |         return (sum=0);
119 |     }
120 | 
121 |     // size is not zero.
122 |     let (sum_of_rest) = array_sum(arr_len=arr_len - 1, arr=arr + 1);
123 |     return (sum=[arr] + sum_of_rest);
124 | }
125 | 
126 | @view
127 | func get_last_sum{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (
128 |     res : felt
129 | ) {
130 |     let (res) = last_sum.read();
131 |     return (res=res);
132 | }
133 | 
134 | @external
135 | func store_complex_struct{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
136 |     complex_struct : ComplexStruct
137 | ) -> (res : ComplexStruct) {
138 |     complex_structs.write(0, complex_struct);
139 |     let (stored_complex_struct : ComplexStruct) = complex_structs.read(0);
140 |     return (res=stored_complex_struct);
141 | }
142 | 
143 | //
144 | // Methods for returndata, and return_value, tests.
145 | // Should always define 2 methods:
146 | //   - the external one: my_method_external()
147 | //   - the view one: my_method_view()
148 | //
149 | // Note: keep them alphabetically sorted.
150 | //
151 | 
152 | @external
153 | func array_external{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (
154 |     arr_len : felt, arr : felt*
155 | ) {
156 |     const ARRAY_SIZE = 3;
157 |     let (ptr) = alloc();
158 |     assert [ptr] = 1;
159 |     assert [ptr + 1] = 2;
160 |     assert [ptr + 2] = 3;
161 |     let (current_count) = array_get_counter.read();
162 |     array_get_counter.write(current_count + 1);
163 |     return (ARRAY_SIZE, ptr);
164 | }
165 | 
166 | @view
167 | func array_view{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (
168 |     arr_len : felt, arr : felt*
169 | ) {
170 |     const ARRAY_SIZE = 3;
171 |     let (ptr) = alloc();
172 |     assert [ptr] = 1;
173 |     assert [ptr + 1] = 2;
174 |     assert [ptr + 2] = 3;
175 |     let (current_count) = array_get_counter.read();
176 |     array_get_counter.write(current_count + 1);
177 |     return (ARRAY_SIZE, ptr);
178 | }
179 | 
180 | @external
181 | func array_complex_struct_external{
182 |     syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr
183 | }() -> (complex_structs_len : felt, complex_structs : ComplexStruct*) {
184 |     let value0 = Uint256(123, 0);
185 |     let value1 = Uint256(0, 123);
186 |     let zero = Uint256(0, 0);
187 |     let my_struct0 = ComplexStruct(0, value0, value1);
188 |     let my_struct1 = ComplexStruct(1, value1, value0);
189 |     let my_struct2 = ComplexStruct(2, zero, zero);
190 | 
191 |     alloc_locals;
192 |     let (local complex_structs : ComplexStruct*) = alloc();
193 |     assert complex_structs[0] = my_struct0;
194 |     assert complex_structs[1] = my_struct1;
195 |     assert complex_structs[2] = my_struct2;
196 |     return (complex_structs_len=3, complex_structs=complex_structs);
197 | }
198 | 
199 | @view
200 | func array_complex_struct_view{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
201 |     ) -> (complex_structs_len : felt, complex_structs : ComplexStruct*) {
202 |     let value0 = Uint256(123, 0);
203 |     let value1 = Uint256(0, 123);
204 |     let zero = Uint256(0, 0);
205 |     let my_struct0 = ComplexStruct(0, value0, value1);
206 |     let my_struct1 = ComplexStruct(1, value1, value0);
207 |     let my_struct2 = ComplexStruct(2, zero, zero);
208 | 
209 |     alloc_locals;
210 |     let (local complex_structs : ComplexStruct*) = alloc();
211 |     assert complex_structs[0] = my_struct0;
212 |     assert complex_structs[1] = my_struct1;
213 |     assert complex_structs[2] = my_struct2;
214 |     return (complex_structs_len=3, complex_structs=complex_structs);
215 | }
216 | 
217 | @external
218 | func array_uint256_external{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
219 |     ) -> (amounts_len : felt, amounts : Uint256*) {
220 |     alloc_locals;
221 |     let (local amounts : Uint256*) = alloc();
222 |     assert amounts[0] = Uint256(123, 0);
223 |     assert amounts[1] = Uint256(0, 123);
224 |     assert amounts[2] = Uint256(0, 0);
225 |     return (amounts_len=3, amounts=amounts);
226 | }
227 | 
228 | @view
229 | func array_uint256_view{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (
230 |     amounts_len : felt, amounts : Uint256*
231 | ) {
232 |     alloc_locals;
233 |     let (local amounts : Uint256*) = alloc();
234 |     assert amounts[0] = Uint256(123, 0);
235 |     assert amounts[1] = Uint256(0, 123);
236 |     assert amounts[2] = Uint256(0, 0);
237 |     return (amounts_len=3, amounts=amounts);
238 | }
239 | 
240 | @external
241 | func complex_struct_external() -> (res : ComplexStruct) {
242 |     let value0 = Uint256(123, 0);
243 |     let value1 = Uint256(0, 123);
244 |     let res = ComplexStruct(1234, value0, value1);
245 |     return (res=res);
246 | }
247 | 
248 | @view
249 | func complex_struct_view() -> (res : ComplexStruct) {
250 |     let value0 = Uint256(123, 0);
251 |     let value1 = Uint256(0, 123);
252 |     let res = ComplexStruct(1234, value0, value1);
253 |     return (res=res);
254 | }
255 | 
256 | @external
257 | func felt_external{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (
258 |     res : felt
259 | ) {
260 |     return (res=2);
261 | }
262 | 
263 | @view
264 | func felt_view{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (res : felt) {
265 |     return (res=2);
266 | }
267 | 
268 | @external
269 | func mix_external{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (
270 |     start : felt,
271 |     arr_len : felt,
272 |     arr : felt*,
273 |     some_uint256 : Uint256,
274 |     arr2_len : felt,
275 |     arr2 : felt*,
276 |     suffix : felt,
277 |     last_uint256 : Uint256,
278 | ) {
279 |     alloc_locals;
280 | 
281 |     let (local arr : felt*) = alloc();
282 |     assert arr[0] = 3;
283 |     assert arr[1] = 4;
284 | 
285 |     let some_uint256 = Uint256(123, 0);
286 | 
287 |     let (local arr2 : felt*) = alloc();
288 |     assert arr2[0] = 8;
289 |     assert arr2[1] = 9;
290 |     assert arr2[2] = 10;
291 | 
292 |     let last_uint256 = Uint256(0, 123);
293 | 
294 |     return (
295 |         start=1,
296 |         arr_len=2,
297 |         arr=arr,
298 |         some_uint256=some_uint256,
299 |         arr2_len=3,
300 |         arr2=arr2,
301 |         suffix=11,
302 |         last_uint256=last_uint256,
303 |     );
304 | }
305 | 
306 | @view
307 | func mix_view{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (
308 |     start : felt,
309 |     arr_len : felt,
310 |     arr : felt*,
311 |     some_uint256 : Uint256,
312 |     arr2_len : felt,
313 |     arr2 : felt*,
314 |     suffix : felt,
315 |     last_uint256 : Uint256,
316 | ) {
317 |     alloc_locals;
318 | 
319 |     let (local arr : felt*) = alloc();
320 |     assert arr[0] = 3;
321 |     assert arr[1] = 4;
322 | 
323 |     let some_uint256 = Uint256(123, 0);
324 | 
325 |     let (local arr2 : felt*) = alloc();
326 |     assert arr2[0] = 8;
327 |     assert arr2[1] = 9;
328 |     assert arr2[2] = 10;
329 | 
330 |     let last_uint256 = Uint256(0, 123);
331 | 
332 |     return (
333 |         start=1,
334 |         arr_len=2,
335 |         arr=arr,
336 |         some_uint256=some_uint256,
337 |         arr2_len=3,
338 |         arr2=arr2,
339 |         suffix=11,
340 |         last_uint256=last_uint256,
341 |     );
342 | }
343 | 
344 | @external
345 | func uint256_external{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (
346 |     res : Uint256
347 | ) {
348 |     let res = Uint256(1, 0);
349 |     return (res=res);
350 | }
351 | 
352 | @view
353 | func uint256_view{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (
354 |     res : Uint256
355 | ) {
356 |     let res = Uint256(1, 0);
357 |     return (res=res);
358 | }
359 | 
360 | @external
361 | func uint256s_external{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (
362 |     res1 : Uint256, res2 : Uint256, res3 : Uint256
363 | ) {
364 |     let res1 = Uint256(123, 0);
365 |     let res2 = Uint256(0, 123);
366 |     let res3 = Uint256(0, 0);
367 |     return (res1=res1, res2=res2, res3=res3);
368 | }
369 | 
370 | @view
371 | func uint256s_view{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (
372 |     res1 : Uint256, res2 : Uint256, res3 : Uint256
373 | ) {
374 |     let res1 = Uint256(123, 0);
375 |     let res2 = Uint256(0, 123);
376 |     let res3 = Uint256(0, 0);
377 |     return (res1=res1, res2=res2, res3=res3);
378 | }
379 | 


--------------------------------------------------------------------------------
/ape_starknet/accounts/_cli.py:
--------------------------------------------------------------------------------
  1 | import json
  2 | from typing import List, Optional, Union, cast
  3 | 
  4 | import click
  5 | from ape.api.networks import LOCAL_NETWORK_NAME
  6 | from ape.cli import ape_cli_context, existing_alias_argument, non_existing_alias_argument
  7 | from ape.cli.options import ApeCliContextObject
  8 | from ape.logging import logger
  9 | from ape.utils import add_padding_to_strings
 10 | from eth_keyfile import decode_keyfile_json
 11 | from eth_utils import is_hex, text_if_str, to_bytes, to_hex
 12 | from hexbytes import HexBytes
 13 | from starkware.crypto.signature.signature import EC_ORDER
 14 | from starkware.starknet.definitions.fields import ContractAddressSalt
 15 | 
 16 | from ape_starknet.accounts import (
 17 |     BaseStarknetAccount,
 18 |     StarknetAccountContainer,
 19 |     StarknetAccountDeployment,
 20 |     StarknetKeyfileAccount,
 21 | )
 22 | from ape_starknet.ecosystems import NETWORKS
 23 | from ape_starknet.utils import (
 24 |     ARGENTX_ACCOUNT_CLASS_HASH,
 25 |     OPEN_ZEPPELIN_ACCOUNT_CLASS_HASH,
 26 |     PLUGIN_NAME,
 27 |     to_int,
 28 | )
 29 | 
 30 | 
 31 | def _get_container(cli_ctx: ApeCliContextObject) -> StarknetAccountContainer:
 32 |     return cast(StarknetAccountContainer, cli_ctx.account_manager.containers[PLUGIN_NAME])
 33 | 
 34 | 
 35 | def class_hash_option(default: Optional[Union[str, int]] = None, required: bool = False):
 36 |     def callback(ctx, param, value) -> Optional[int]:
 37 |         if value is None:
 38 |             return None
 39 | 
 40 |         elif isinstance(value, int):
 41 |             return int(value)
 42 | 
 43 |         elif value.lower() == "openzeppelin":
 44 |             return OPEN_ZEPPELIN_ACCOUNT_CLASS_HASH
 45 | 
 46 |         elif value.lower() in ("argentx", "argent-x"):
 47 |             return ARGENTX_ACCOUNT_CLASS_HASH
 48 | 
 49 |         return to_int(value)
 50 | 
 51 |     return click.option(
 52 |         "--class-hash",
 53 |         help="The class hash of the account contract.",
 54 |         required=required,
 55 |         callback=callback,
 56 |         default=default,
 57 |         type=str,
 58 |     )
 59 | 
 60 | 
 61 | def address_option():
 62 |     return click.option(
 63 |         "--address",
 64 |         help="The contract address of the account",
 65 |         callback=lambda ctx, param, value: ctx.obj.network_manager.starknet.decode_address(value)
 66 |         if value
 67 |         else None,
 68 |     )
 69 | 
 70 | 
 71 | def constructor_calldata_option():
 72 |     return click.option(
 73 |         "--constructor-calldata",
 74 |         help="Comma separated list of calldata, default uses keyfile or known inputs.",
 75 |     )
 76 | 
 77 | 
 78 | def _network_callback(ctx, param, value, single: bool = False):
 79 |     parse = ctx.obj.network_manager.parse_network_choice
 80 | 
 81 |     if single and value == "starknet":
 82 |         raise click.BadOptionUsage("--network", "Must use single network.")
 83 | 
 84 |     elif value == "starknet":
 85 |         # Use all live networks.
 86 |         return [_validate_network(parse, n) for n in NETWORKS]
 87 | 
 88 |     if single and value is not None:
 89 |         return _validate_network(parse, value)
 90 | 
 91 |     elif single:
 92 |         return value
 93 | 
 94 |     elif value is not None:
 95 |         return [_validate_network(parse, n.strip()) for n in value.split(",")]
 96 | 
 97 |     return []
 98 | 
 99 | 
100 | def network_option(required: bool = False, default: Optional[str] = None, single: bool = False):
101 |     def callback(ctx, param, value):
102 |         return _network_callback(ctx, param, value, single=single)
103 | 
104 |     return click.option(
105 |         "--network",
106 |         default=default,
107 |         required=required,
108 |         callback=callback,
109 |     )
110 | 
111 | 
112 | @click.group("accounts")
113 | def accounts():
114 |     """Manage Starknet accounts"""
115 | 
116 | 
117 | def _salt_callback(ctx, param, value):
118 |     return value or ContractAddressSalt.get_random_value()
119 | 
120 | 
121 | @accounts.command()
122 | @ape_cli_context()
123 | @non_existing_alias_argument()
124 | @class_hash_option(default=OPEN_ZEPPELIN_ACCOUNT_CLASS_HASH)
125 | @constructor_calldata_option()
126 | @click.option(
127 |     "--salt", help="The default address salt to use when deploying.", callback=_salt_callback
128 | )
129 | def create(cli_ctx, alias, class_hash, constructor_calldata, salt):
130 |     """Create an account keypair"""
131 |     starknet = cli_ctx.provider.starknet
132 |     calldata = (
133 |         [starknet.decode_primitive_value(x) for x in constructor_calldata.split(",")]
134 |         if constructor_calldata is not None
135 |         else None
136 |     )
137 |     _get_container(cli_ctx).create_account(
138 |         alias,
139 |         class_hash=class_hash,
140 |         constructor_calldata=calldata,
141 |         salt=salt,
142 |         allow_local_file_store=True,
143 |     )
144 |     cli_ctx.logger.success(f"Created account key-pair for alias '{alias}'.")
145 | 
146 | 
147 | def _funder_callback(ctx, param, value):
148 |     container = _get_container(ctx.obj)
149 |     if not value:
150 |         return None
151 | 
152 |     if value.isnumeric():
153 |         # Useful for testing / local but not realistic.
154 |         return container._genesis_test_accounts[int(value)]
155 | 
156 |     return container.load(value)
157 | 
158 | 
159 | @accounts.command()
160 | @ape_cli_context()
161 | @click.argument("alias")
162 | @network_option(default=LOCAL_NETWORK_NAME, single=True)
163 | @click.option("--funder", help="Use another an account to help fund", callback=_funder_callback)
164 | @constructor_calldata_option()
165 | def deploy(cli_ctx, network, alias, funder, constructor_calldata):
166 |     """Deploy an account"""
167 |     with cli_ctx.network_manager.parse_network_choice(network):
168 |         logger.info(f"Deploying account '{alias}' to network '{network}'.")
169 |         container = _get_container(cli_ctx)
170 |         account = container.load(alias)
171 |         uses_keyfile = isinstance(account, StarknetKeyfileAccount)
172 | 
173 |         if uses_keyfile:
174 |             account.unlock("Enter passphrase to deploy account")  # type: ignore[attr-defined]
175 | 
176 |         try:
177 |             starknet = cli_ctx.provider.starknet
178 |             calldata = (
179 |                 [starknet.decode_primitive_value(x) for x in constructor_calldata.split(",")]
180 |                 if constructor_calldata is not None
181 |                 else None
182 |             )
183 |             receipt = account.deploy_account(funder=funder, calldata=calldata)
184 |             contract_address_styled = click.style(receipt.contract_address, bold=True)
185 |             logger.success(f"Account successfully deployed to '{contract_address_styled}'.")
186 |         finally:
187 |             if uses_keyfile:
188 |                 account.lock()  # type: ignore[attr-defined]
189 | 
190 | 
191 | @accounts.command("list")
192 | @ape_cli_context()
193 | def _list(cli_ctx):
194 |     """List your Starknet accounts"""
195 | 
196 |     starknet_accounts: List[StarknetKeyfileAccount] = [
197 |         x for x in _get_container(cli_ctx).accounts if isinstance(x, StarknetKeyfileAccount)
198 |     ]
199 | 
200 |     if len(starknet_accounts) == 0:
201 |         cli_ctx.logger.info("No accounts found.")
202 |         return
203 | 
204 |     num_accounts = len(starknet_accounts)
205 |     header = f"Found {num_accounts} account"
206 |     header += "s" if num_accounts > 1 else ""
207 |     click.echo(f"{header}\n")
208 | 
209 |     for index in range(num_accounts):
210 |         account = starknet_accounts[index]
211 |         output_dict = {
212 |             "Alias": account.alias,
213 |             "Public key": account.public_key,
214 |             "Class hash": to_hex(account.class_hash),
215 |         }
216 |         if not account.deployments:
217 |             output_dict["Contract address (not deployed)"] = account.address
218 | 
219 |         else:
220 |             for deployment in account.deployments:
221 |                 key = f"Contract address ({deployment.network_name})"
222 |                 output_dict[key] = deployment.contract_address
223 | 
224 |         output_keys = add_padding_to_strings(list(output_dict.keys()))
225 |         output_dict = {k: output_dict[k.rstrip()] for k in output_keys}
226 | 
227 |         for k, v in output_dict.items():
228 |             click.echo(f"{k} - {v}")
229 | 
230 |         if index < num_accounts - 1:
231 |             click.echo()
232 | 
233 | 
234 | def _validate_network(parse, network: str) -> str:
235 |     # Temporarily connect to extract network name and validate network.
236 |     live_nets = list(NETWORKS.keys())
237 |     options = [*live_nets, LOCAL_NETWORK_NAME]
238 | 
239 |     if network.startswith("starknet:"):
240 |         network = network.replace("starknet:", "")
241 | 
242 |     if network not in options:
243 |         options_str = ",".join(options)
244 |         raise click.BadOptionUsage("--network", f"Network '{network}' not one of '{options_str}'.")
245 | 
246 |     return f"starknet:{network}"
247 | 
248 | 
249 | @accounts.command(name="import")
250 | @ape_cli_context()
251 | @click.argument("alias")
252 | @network_option(required=True)
253 | @address_option()
254 | @class_hash_option()
255 | @click.option("--salt", help="The contract address salt used when deploying the contract.")
256 | def _import(cli_ctx, alias, network, address, class_hash, salt):
257 |     """Add an existing, deployed account"""
258 | 
259 |     container = _get_container(cli_ctx)
260 |     if alias in container.aliases:
261 |         # Since the alias exists, try to import as a new deployment.
262 | 
263 |         existing_account = container.load(alias)
264 |         if not isinstance(existing_account, StarknetKeyfileAccount):
265 |             cli_ctx.abort(
266 |                 "Unable to use default ape-starknet CLI to add "
267 |                 "deployments to accounts from other plugins. "
268 |                 f"Try using plugin with account type {type(existing_account).__name__}."
269 |             )
270 | 
271 |         else:
272 |             # Assume calculated address if not given anything.
273 |             address = address or existing_account.address
274 |             if not salt and address == existing_account.address:
275 |                 # It must have used the same salt since the addresses are the same.
276 |                 salt = existing_account.salt
277 | 
278 |             networks_str = ", ".join(network)
279 |             click.echo(f"Importing existing account on network(s) '{networks_str}'.")
280 |             for network_name in network:
281 |                 existing_account.add_deployment(network_name, address, salt, leave_unlocked=False)
282 | 
283 |     elif address and not class_hash:
284 |         cli_ctx.abort("--class-hash is required when importing an account for the first time.")
285 | 
286 |     elif address:
287 |         # Account is being imported for the first time.
288 |         private_key = click.prompt(f"Enter private key for '{alias}'", hide_input=True).strip()
289 | 
290 |         if private_key.isnumeric():
291 |             # NOTE: Check base 10 before 16 because is_hex("123") is True.
292 |             private_key = int(private_key)
293 |         elif is_hex(private_key):
294 |             private_key = int(private_key, 16)
295 |         else:
296 |             cli_ctx.abort("Invalid private key. Expecting numeric value.")
297 | 
298 |         if private_key < 1 or private_key >= EC_ORDER:
299 |             cli_ctx.abort("Private key not in range [1, EC_ORDER).")
300 | 
301 |         deployments = [
302 |             StarknetAccountDeployment(contract_address=address, network_name=n, salt=salt)
303 |             for n in network
304 |         ]
305 |         container.import_account(alias, class_hash, private_key, salt=salt, deployments=deployments)
306 | 
307 |     else:
308 |         cli_ctx.abort("--address required when importing and account for the first time.")
309 | 
310 |     cli_ctx.logger.success(f"Imported account '{alias}'.")
311 | 
312 | 
313 | @accounts.command(short_help="Export an account private key")
314 | @ape_cli_context()
315 | @existing_alias_argument(account_type=StarknetKeyfileAccount)
316 | def export(cli_ctx, alias):
317 |     account = cast(StarknetKeyfileAccount, _get_container(cli_ctx).load(alias))
318 |     path = account.key_file_path
319 |     account_json = json.loads(path.read_text())
320 |     passphrase = click.prompt("Enter password to decrypt account", hide_input=True)
321 |     passphrase_bytes = text_if_str(to_bytes, passphrase)
322 |     decoded_json = HexBytes(decode_keyfile_json(account_json, passphrase_bytes))
323 |     private_key = to_int(decoded_json.hex())
324 |     cli_ctx.logger.success(
325 |         f"Account {account.alias} private key: {click.style(private_key, bold=True)})"
326 |     )
327 | 
328 | 
329 | @accounts.command()
330 | @ape_cli_context()
331 | @existing_alias_argument(account_type=BaseStarknetAccount)
332 | @network_option()
333 | @address_option()
334 | def delete(cli_ctx, alias, network, address):
335 |     """Delete an existing account deployment"""
336 |     container = _get_container(cli_ctx)
337 |     account = container.load(alias)
338 |     deployments_before = len(account.deployments)
339 |     container.delete_account(alias, networks=network, address=address, leave_unlocked=False)
340 | 
341 |     if account.address_int not in container:
342 |         cli_ctx.logger.success(f"Account '{alias}' deleted.")
343 |     elif (len(account.deployments) < deployments_before) and network:
344 |         choices_str = ",".join([x.replace("starknet:", "") for x in network])
345 |         cli_ctx.logger.success(f"Account '{alias}' deployments on network '{choices_str}' deleted.")
346 | 
347 | 
348 | @accounts.command()
349 | @ape_cli_context()
350 | @existing_alias_argument(account_type=StarknetKeyfileAccount)
351 | def change_password(cli_ctx, alias):
352 |     """Change the password of an existing account"""
353 |     account = cli_ctx.account_manager.load(alias)
354 |     account.change_password(leave_unlocked=False)
355 |     cli_ctx.logger.success(f"Password has been changed for account '{alias}'")
356 | 


--------------------------------------------------------------------------------
/ape_starknet/utils/__init__.py:
--------------------------------------------------------------------------------
  1 | import asyncio
  2 | import re
  3 | from asyncio import gather
  4 | from dataclasses import asdict
  5 | from json import JSONDecodeError, loads
  6 | from typing import Any, Dict, List, Optional, Union, cast
  7 | 
  8 | from ape.api.networks import LOCAL_NETWORK_NAME
  9 | from ape.contracts import ContractEvent
 10 | from ape.exceptions import (
 11 |     ApeException,
 12 |     ContractError,
 13 |     ContractLogicError,
 14 |     OutOfGasError,
 15 |     SignatureError,
 16 | )
 17 | from ape.logging import logger
 18 | from ape.types import AddressType, RawAddress
 19 | from eth_typing import HexAddress, HexStr
 20 | from eth_utils import add_0x_prefix, is_0x_prefixed, is_hex, is_text, remove_0x_prefix, to_hex
 21 | from eth_utils import to_int as eth_to_int
 22 | from ethpm_types import ContractType
 23 | from ethpm_types.abi import EventABI, MethodABI
 24 | from hexbytes import HexBytes
 25 | from starknet_py.net import KeyPair
 26 | from starknet_py.net.client_errors import ClientError
 27 | from starknet_py.net.client_models import (
 28 |     BlockSingleTransactionTrace,
 29 |     DeclareTransaction,
 30 |     DeployAccountTransaction,
 31 |     InvokeTransaction,
 32 |     Transaction,
 33 | )
 34 | from starknet_py.net.models import TransactionType
 35 | from starknet_py.net.models.address import parse_address
 36 | from starknet_py.transaction_exceptions import TransactionRejectedError
 37 | from starkware.cairo.bootloaders.compute_fact import keccak_ints
 38 | from starkware.crypto.signature.signature import get_random_private_key as get_random_pkey
 39 | from starkware.starknet.core.os.class_hash import compute_class_hash
 40 | from starkware.starknet.definitions.general_config import StarknetChainId
 41 | from starkware.starknet.public.abi import get_selector_from_name
 42 | from starkware.starknet.services.api.contract_class import ContractClass
 43 | from starkware.starknet.third_party.open_zeppelin.starknet_contracts import account_contract
 44 | 
 45 | from ape_starknet.exceptions import StarknetProviderError
 46 | from ape_starknet.utils.basemodel import create_contract_class
 47 | 
 48 | PLUGIN_NAME = "starknet"
 49 | NETWORKS = {
 50 |     # chain_id, network_id
 51 |     "mainnet": (StarknetChainId.MAINNET.value, StarknetChainId.MAINNET.value),
 52 |     "testnet": (StarknetChainId.TESTNET.value, StarknetChainId.TESTNET.value),
 53 |     "testnet2": (StarknetChainId.TESTNET2.value, StarknetChainId.TESTNET.value),
 54 | }
 55 | _HEX_ADDRESS_REG_EXP = re.compile("(0x)?[0-9a-f]*", re.IGNORECASE | re.ASCII)
 56 | """Same as from eth-utils except not limited length."""
 57 | ALPHA_MAINNET_WL_DEPLOY_TOKEN_KEY = "ALPHA_MAINNET_WL_DEPLOY_TOKEN"
 58 | EXECUTE_METHOD_NAME = "__execute__"
 59 | EXECUTE_SELECTOR = get_selector_from_name(EXECUTE_METHOD_NAME)
 60 | DEFAULT_ACCOUNT_SEED = 2147483647  # Prime
 61 | ContractEventABI = Union[List[Union[EventABI, ContractEvent]], Union[EventABI, ContractEvent]]
 62 | MAX_FEE = int(1e20)
 63 | _DECLARE_ERROR_PATTERN = re.compile(r"Class with hash (0x[0-9a-fA-F]+) is not declared")
 64 | STARKNET_FEE_TOKEN_SYMBOL = "ETH"
 65 | _CLIENT_FAILED_PREFIX_PATTERN = re.compile(r"Client failed( with code \d+)?: (.*)")
 66 | 
 67 | 
 68 | def convert_contract_class_to_contract_type(
 69 |     name: str, source_id: str, contract_class: ContractClass
 70 | ):
 71 |     return ContractType.parse_obj(
 72 |         {
 73 |             "contractName": name,
 74 |             "sourceId": source_id,
 75 |             "deploymentBytecode": {"bytecode": contract_class.serialize().hex()},
 76 |             "runtimeBytecode": {},
 77 |             "abi": contract_class.abi,
 78 |         }
 79 |     )
 80 | 
 81 | 
 82 | OPEN_ZEPPELIN_ACCOUNT_SOURCE_ID = "openzeppelin/account/Account.cairo"
 83 | OPEN_ZEPPELIN_ACCOUNT_CONTRACT_TYPE = convert_contract_class_to_contract_type(
 84 |     "Account", OPEN_ZEPPELIN_ACCOUNT_SOURCE_ID, account_contract
 85 | )
 86 | OPEN_ZEPPELIN_ACCOUNT_CLASS_HASH = compute_class_hash(account_contract)
 87 | EXECUTE_ABI = OPEN_ZEPPELIN_ACCOUNT_CONTRACT_TYPE.mutable_methods[EXECUTE_METHOD_NAME]
 88 | 
 89 | # Taken from https://github.com/argentlabs/argent-x/blob/develop/packages/extension/src/background/wallet.ts  # noqa: E501
 90 | ARGENTX_ACCOUNT_CLASS_HASH = int(
 91 |     "0x025ec026985a3bf9d0cc1fe17326b245dfdc3ff89b8fde106542a3ea56c5a918", 16
 92 | )
 93 | ARGENTX_ACCOUNT_SOURCE_ID = "account/ArgentAccount.cairo"
 94 | DEVNET_ACCOUNT_START_BALANCE = 1000000000000000000000
 95 | 
 96 | 
 97 | def get_chain_id(network_id: Union[str, int]) -> StarknetChainId:
 98 |     if isinstance(network_id, int):
 99 |         return StarknetChainId(network_id)
100 | 
101 |     elif network_id == LOCAL_NETWORK_NAME:
102 |         return StarknetChainId.TESTNET  # Use TESTNET chain ID for local network
103 | 
104 |     elif network_id not in NETWORKS:
105 |         raise StarknetProviderError(f"Unknown network '{network_id}'.")
106 | 
107 |     return StarknetChainId(NETWORKS[network_id][0])
108 | 
109 | 
110 | def to_checksum_address(address: RawAddress) -> AddressType:
111 |     if is_checksum_address(address):
112 |         return cast(AddressType, address)
113 | 
114 |     return _to_checksum_address(address)
115 | 
116 | 
117 | def _to_checksum_address(address: RawAddress) -> AddressType:
118 |     if isinstance(address, bytes):
119 |         address = HexBytes(address).hex()
120 | 
121 |     address_int = parse_address(address)
122 |     address_str = pad_hex_str(HexBytes(address_int).hex().lower())
123 |     chars = [c for c in remove_0x_prefix(HexStr(address_str))]
124 |     hashed = [b for b in HexBytes(keccak_ints([address_int]))]
125 | 
126 |     for i in range(0, len(chars), 2):
127 |         try:
128 |             if hashed[i >> 1] >> 4 >= 8:
129 |                 chars[i] = chars[i].upper()
130 |             if (hashed[i >> 1] & 0x0F) >= 8:
131 |                 chars[i + 1] = chars[i + 1].upper()
132 |         except IndexError:
133 |             continue
134 | 
135 |     rejoined_address_str = add_0x_prefix(HexStr("".join(chars)))
136 |     return AddressType(HexAddress(HexStr(rejoined_address_str)))
137 | 
138 | 
139 | def is_hex_address(value: Any) -> bool:
140 |     return _HEX_ADDRESS_REG_EXP.fullmatch(value) is not None if is_text(value) else False
141 | 
142 | 
143 | def is_checksum_address(value: Any) -> bool:
144 |     if not is_text(value):
145 |         return False
146 | 
147 |     if not is_hex_address(value):
148 |         return False
149 | 
150 |     return value == _to_checksum_address(value)
151 | 
152 | 
153 | def extract_trace_data(trace: BlockSingleTransactionTrace) -> Dict[str, Any]:
154 |     if not trace:
155 |         return {}
156 | 
157 |     trace_data = trace.function_invocation
158 | 
159 |     # Keep the most relevant `result`: given the account implementation, `result`
160 |     # may contain an additional number prepend to the data to expose the total
161 |     # number of items. For a method returning a 3-items array like `[1, 2, 3]`,
162 |     # in such scenario `results` would be `[0x4, 0x3, 0x1, 0x2, 0x3]` (the prepend
163 |     # number: 4, the array length: 3, then array items: 1, 2, and 3).
164 |     # As there is no known way to guess when to remove such a number, we prefer to "scan"
165 |     # trace internals to select the most appropriate result. For instance, when `result`
166 |     # contains the additional value, we just need to use the "internal call" `result`
167 |     # that will contain the exact value the method returned.
168 |     invocation_result = trace_data["result"]
169 |     internal_calls = trace_data["internal_calls"]
170 |     trace_data["result"] = (
171 |         internal_calls[-1]["result"] if internal_calls else invocation_result
172 |     ) or invocation_result
173 |     return trace_data
174 | 
175 | 
176 | def handle_client_errors(f):
177 |     def func(*args, **kwargs):
178 |         try:
179 |             result = f(*args, **kwargs)
180 |             if isinstance(result, dict) and result.get("error"):
181 |                 message = result["error"].get("message") or "Transaction failed"
182 |                 raise StarknetProviderError(message)
183 | 
184 |             return result
185 | 
186 |         except Exception as err:
187 |             new_err = handle_client_error(err)
188 |             if new_err:
189 |                 raise new_err from err
190 | 
191 |             raise  # Original error
192 | 
193 |     return func
194 | 
195 | 
196 | def handle_client_error(err: Exception) -> Optional[Exception]:
197 |     if isinstance(err, ApeException) or not isinstance(
198 |         err, (ClientError, TransactionRejectedError)
199 |     ):
200 |         return err
201 | 
202 |     err_msg = err.message
203 |     if "Actual fee exceeded max fee" in err_msg:
204 |         return OutOfGasError()
205 | 
206 |     maybe_contract_logic_error = False
207 |     if "Error message:" in err_msg:
208 |         err_msg = err_msg.split("Error message:")[-1].splitlines()[0].strip().split("\\n")[0]
209 |         maybe_contract_logic_error = True
210 | 
211 |     elif "Error at pc=" in err_msg:
212 |         err_msg = err_msg.strip().replace("\\n", " ")
213 |         err_msg = _try_extract_message_from_json(err_msg)
214 |         maybe_contract_logic_error = True
215 | 
216 |     if "INVALID_SIGNATURE_LENGTH" in err_msg:
217 |         return SignatureError("Invalid signature length.")
218 | 
219 |     elif "UNINITIALIZED_CONTRACT" in err_msg and "is not deployed" in err_msg:
220 |         address = err_msg.split("is not deployed")[0].strip().split(" ")[-1]
221 |         if is_hex(address):
222 |             return ContractError(f"Contract at address '{address}' not deployed.")
223 | 
224 |     elif "Signature" in err_msg and "is invalid, with respect to the public key" in err_msg:
225 |         message = "Invalid signature"
226 |         parts = err_msg.split("public key ")
227 |         if len(parts) == 2:
228 |             key_str = parts[-1].split(" ")[0].rstrip(",")
229 |             if key_str.isnumeric():
230 |                 key = to_hex(int(key_str))
231 |                 message = f"{message} with respect to public key {key}"
232 | 
233 |         return SignatureError(f"{message}.")
234 | 
235 |     declare_error_search = _DECLARE_ERROR_PATTERN.search(err_msg)
236 |     if declare_error_search:
237 |         address = declare_error_search.groups()[0]
238 |         return StarknetProviderError(f"Contract with address '{address}' not declared.")
239 | 
240 |     elif maybe_contract_logic_error:
241 |         return ContractLogicError(revert_message=err_msg)
242 | 
243 |     err_msg = err_msg.strip().rstrip(".")
244 |     match = _CLIENT_FAILED_PREFIX_PATTERN.match(err_msg)
245 |     if match:
246 |         groups = match.groups()
247 |         if groups:
248 |             trimmed = groups[-1]
249 |             if trimmed:
250 |                 err_msg = trimmed
251 | 
252 |     if err_msg.endswith("\n."):
253 |         err_msg = "\n.".join(err_msg.split("\n.")[:-1])
254 | 
255 |     err_msg = _try_extract_message_from_json(err_msg)
256 | 
257 |     if not err_msg.endswith("."):
258 |         err_msg = f"{err_msg}."
259 | 
260 |     return StarknetProviderError(err_msg)
261 | 
262 | 
263 | def _try_extract_message_from_json(value: str) -> str:
264 |     try:
265 |         msg_dict = loads(value)
266 |     except JSONDecodeError:
267 |         return value
268 | 
269 |     if "message" in msg_dict:
270 |         return msg_dict["message"]
271 | 
272 |     return value
273 | 
274 | 
275 | def get_dict_from_tx_info(txn_info: Transaction) -> Dict:
276 |     txn_dict = {**asdict(txn_info)}
277 |     if isinstance(txn_info, InvokeTransaction):
278 |         txn_dict["type"] = TransactionType.INVOKE_FUNCTION
279 |     elif isinstance(txn_info, DeclareTransaction):
280 |         txn_dict["type"] = TransactionType.DECLARE
281 |     elif isinstance(txn_info, DeployAccountTransaction):
282 |         txn_dict["type"] = TransactionType.DEPLOY_ACCOUNT
283 | 
284 |     return txn_dict
285 | 
286 | 
287 | def get_method_abi_from_selector(
288 |     selector: Union[str, int], contract_type: ContractType
289 | ) -> MethodABI:
290 |     # TODO: Properly integrate with ethpm-types
291 | 
292 |     if isinstance(selector, str):
293 |         selector = int(selector, 16)
294 | 
295 |     for abi in contract_type.mutable_methods:
296 |         selector_to_check = get_selector_from_name(abi.name)
297 | 
298 |         if selector == selector_to_check:
299 |             return abi
300 | 
301 |     raise ContractError(f"Method '{selector}' not found in '{contract_type.name}'.")
302 | 
303 | 
304 | def get_random_private_key() -> str:
305 |     private_key = HexBytes(get_random_pkey()).hex()
306 |     return pad_hex_str(private_key)
307 | 
308 | 
309 | def pad_hex_str(value: str, to_length: int = 64) -> str:
310 |     val = value.replace("0x", "")
311 |     actual_len = len(val)
312 |     padding = "0" * (to_length - actual_len)
313 |     return f"0x{padding}{val}"
314 | 
315 | 
316 | def run_until_complete(*coroutine):
317 |     coroutines = list(coroutine)
318 |     if len(coroutines) > 1:
319 |         task = gather(*coroutine, return_exceptions=True)
320 |     else:
321 |         task = coroutines[0]
322 | 
323 |     loop = asyncio.get_event_loop()
324 |     result = loop.run_until_complete(task)
325 |     return result
326 | 
327 | 
328 | def to_int(val: Any) -> int:
329 |     if isinstance(val, int):
330 |         return val
331 | 
332 |     elif isinstance(val, str) and is_0x_prefixed(val):
333 |         return eth_to_int(hexstr=val)
334 | 
335 |     elif isinstance(val, str) and val.isnumeric():
336 |         return int(val)
337 | 
338 |     elif isinstance(val, str):
339 |         return eth_to_int(val.encode())
340 | 
341 |     elif hasattr(val, "address"):
342 |         return to_int(val.address)
343 | 
344 |     return eth_to_int(val)
345 | 
346 | 
347 | def get_class_hash(code: Union[str, HexBytes]):
348 |     contract_class = create_contract_class(code)
349 |     return compute_class_hash(contract_class)
350 | 
351 | 
352 | def create_keypair(private_key: Union[str, int]) -> KeyPair:
353 |     # Validate private key.
354 |     if isinstance(private_key, str) and is_0x_prefixed(private_key):
355 |         private_key = to_int(private_key.strip("'\""))
356 |     elif isinstance(private_key, str):
357 |         private_key = to_int(private_key)
358 | 
359 |     return KeyPair.from_private_key(private_key)
360 | 
361 | 
362 | def get_account_constructor_calldata(key_pair: KeyPair, class_hash: int) -> List[Any]:
363 |     # Use known ctor data
364 |     if class_hash == OPEN_ZEPPELIN_ACCOUNT_CLASS_HASH:
365 |         return [key_pair.public_key]
366 |     elif class_hash == ARGENTX_ACCOUNT_CLASS_HASH:
367 |         return []
368 |     else:
369 |         logger.warning(f"Constructor calldata for account with class '{class_hash}' not known.")
370 |         return []
371 | 


--------------------------------------------------------------------------------
/tests/integration/test_accounts.py:
--------------------------------------------------------------------------------
  1 | import random
  2 | import re
  3 | from typing import List, Tuple, Union
  4 | 
  5 | import pytest
  6 | from eth_utils import to_hex
  7 | from starknet_py.utils.crypto.facade import message_signature
  8 | from starkware.crypto.signature.signature import EC_ORDER
  9 | 
 10 | from ape_starknet.types import StarknetSignableMessage
 11 | from ape_starknet.utils import get_random_private_key, to_int
 12 | 
 13 | from .conftest import ApeStarknetCliRunner
 14 | 
 15 | 
 16 | def get_random_alias() -> str:
 17 |     return "".join(random.choice(["a", "b", "c", "d", "e", "f"]) for _ in range(6))
 18 | 
 19 | 
 20 | TESTNET_KEY = "Contract address (testnet)"
 21 | TESTNET2_KEY = "Contract address (testnet2)"
 22 | MAINNET_KEY = "Contract address (mainnet)"
 23 | 
 24 | 
 25 | class ListOutputSection:
 26 |     def __init__(self, alias: str, lines: List[str]):
 27 |         self.alias = alias
 28 |         self.lines = lines
 29 | 
 30 |     def __iter__(self):
 31 |         yield from self.lines
 32 | 
 33 |     def __str__(self):
 34 |         return "\n".join(self.lines)
 35 | 
 36 |     def __repr__(self):
 37 |         return str(self) if bool(self) else "<no section>"
 38 | 
 39 |     def __bool__(self):
 40 |         return len(self.lines) > 0
 41 | 
 42 |     def __contains__(self, item: Union[Tuple, str]) -> bool:
 43 |         if isinstance(item, str):
 44 |             return any([item in line for line in self.lines])
 45 | 
 46 |         key, value = item
 47 |         key = key.replace("(", r"\(").replace(")", r"\)")
 48 |         pattern = re.compile(rf"{key} +- {value}")
 49 |         return any([pattern.match(x) for x in self.lines])
 50 | 
 51 |     def fail_msg(self, key: str, value: str) -> str:
 52 |         return f"{self.alias} with '{key} - {value}' not found. Full output: {self}"
 53 | 
 54 | 
 55 | class ListOutputWrapper:
 56 |     def __init__(self, output: str):
 57 |         self.output = output
 58 | 
 59 |     @property
 60 |     def lines(self) -> List[str]:
 61 |         return self.output.splitlines()
 62 | 
 63 |     def __iter__(self):
 64 |         yield from self.lines
 65 | 
 66 |     def __repr__(self):
 67 |         return self.output
 68 | 
 69 |     def get_section(self, alias: str) -> ListOutputSection:
 70 |         section: List[str] = []
 71 |         for index, line in enumerate(self.lines):
 72 |             if alias not in line and not section:
 73 |                 # Haven't found start of the section yet.
 74 |                 continue
 75 | 
 76 |             part = line.strip()
 77 |             if section and not part:
 78 |                 # End found - next section started.
 79 |                 return ListOutputSection(alias, section)
 80 | 
 81 |             section.append(part)
 82 | 
 83 |         # End found - no more output.
 84 |         return ListOutputSection(alias, section)
 85 | 
 86 | 
 87 | @pytest.fixture(scope="module")
 88 | def accounts_runner(ape_cli):
 89 |     class AccountsCliRunner(ApeStarknetCliRunner):
 90 |         def __init__(self):
 91 |             super().__init__(ape_cli, ["starknet", "accounts"])
 92 | 
 93 |         def invoke_list(self, *args, **kwargs) -> ListOutputWrapper:
 94 |             output = self.invoke("list", *args, **kwargs)
 95 |             return ListOutputWrapper(output)
 96 | 
 97 |     return AccountsCliRunner()
 98 | 
 99 | 
100 | @pytest.fixture(scope="module")
101 | def root_accounts_runner(ape_cli):
102 |     return ApeStarknetCliRunner(ape_cli, ["accounts"])
103 | 
104 | 
105 | def test_create_then_list_then_deploy(accounts_runner, account_container, password):
106 |     """
107 |     * Create a new acount key-pair (using OZ class hash by default).
108 |     * Deploy an instance of the account.
109 |     """
110 | 
111 |     # Create the keypair locally, without deployments.
112 |     alias = get_random_alias()
113 |     user_input = [password, password]  # ["123", confirm]
114 |     output = accounts_runner.invoke("create", alias, input=user_input)
115 | 
116 |     # Ensure output used correct prompt.
117 |     assert output.splitlines()[1].startswith(f"Create passphrase to encrypt account '{alias}'")
118 | 
119 |     # Ensure the account was created.
120 |     assert f"Created account key-pair for alias '{alias}'" in output
121 |     account = account_container.load(alias)
122 |     assert not account.deployments
123 | 
124 |     # Ensure the alias shows in the list command as "not deployed".
125 |     output = accounts_runner.invoke_list()
126 |     section = output.get_section(alias)
127 |     key = "Contract address (not deployed)"
128 |     value = account.address
129 |     assert (key, value) in section, section.fail_msg(key, value)
130 | 
131 |     # Deploy and verify.
132 |     user_input = [password, "y"]  # ["123", yes to sign].
133 |     output = accounts_runner.invoke("deploy", alias, "--funder", "0", input=user_input)
134 |     assert "Account successfully deployed to " in output
135 |     assert account.deployments
136 | 
137 | 
138 | def test_deploy_with_custom_calldata(accounts_runner, account_container, password):
139 |     alias = get_random_alias()
140 |     accounts_runner.invoke("create", alias, input=[password, password])
141 |     account = account_container.load(alias)
142 | 
143 |     # Deploy and verify.
144 |     user_input = [password, "y"]  # ["123", yes to sign].
145 |     calldata = account.public_key  # Have to use real public key or will get other signature errors.
146 |     output = accounts_runner.invoke(
147 |         "deploy", alias, "--funder", "0", "--constructor-calldata", calldata, input=user_input
148 |     )
149 |     assert "Account successfully deployed to " in output
150 |     assert account.deployments
151 |     assert accounts_runner
152 |     assert account.constructor_calldata == [account.public_key_int]
153 | 
154 | 
155 | def test_create_then_use_then_delete_account_with_empty_passphrase(
156 |     accounts_runner, account_container
157 | ):
158 |     alias = get_random_alias()
159 |     output = accounts_runner.invoke("create", alias, input=["", ""])
160 |     assert "SUCCESS" in output
161 | 
162 |     account = account_container.load(alias)
163 | 
164 |     # Input meaning: ENTER (no pass).
165 |     with accounts_runner.runner.isolation(input="\n"):
166 |         account.unlock()
167 | 
168 |     output = accounts_runner.invoke("delete", alias, input=["", "y"])
169 |     assert "SUCCESS" in output
170 | 
171 | 
172 | @pytest.mark.parametrize(
173 |     "class_hash",
174 |     (
175 |         "0x025ec026985a3bf9d0cc1fe17326b245dfdc3ff89b8fde106542a3ea56c5a918",
176 |         str(int("0x025ec026985a3bf9d0cc1fe17326b245dfdc3ff89b8fde106542a3ea56c5a918", 16)),
177 |     ),
178 | )
179 | def test_create_with_class_hash_and_calldata(
180 |     accounts_runner, account_container, class_hash, password
181 | ):
182 |     """
183 |     Create a keypair with a custom class hash.
184 |     """
185 | 
186 |     # Create the account with a custom class hash.
187 |     alias = get_random_alias()
188 |     calldata = "0x223"
189 |     user_input = [password, password]  # ["123", confirm]
190 |     output = accounts_runner.invoke(
191 |         "create",
192 |         alias,
193 |         "--class-hash",
194 |         class_hash,
195 |         "--constructor-calldata",
196 |         calldata,
197 |         input=user_input,
198 |     )
199 |     assert f"Created account key-pair for alias '{alias}'" in output
200 |     account = account_container.load(alias)
201 |     assert account.class_hash == to_int(class_hash)
202 |     assert account.constructor_calldata == [0x223]
203 | 
204 |     # Ensure the custom class hash gets displayed.
205 |     output = accounts_runner.invoke_list()
206 |     section = output.get_section(alias)
207 |     key = "Class hash"
208 |     value = to_hex(to_int(class_hash))
209 |     assert (key, value) in section, section.fail_msg(key, value)
210 | 
211 | 
212 | def test_list(accounts_runner, key_file_account, contract_address):
213 |     """
214 |     Ensure the list command works in a basic sense for an account with a single
215 |     deployment.
216 |     """
217 |     output = accounts_runner.invoke_list()
218 |     section = output.get_section(key_file_account.alias)
219 |     alias = ("Alias", key_file_account.alias)
220 |     public_key = ("Public key", key_file_account.public_key)
221 |     class_hash = ("Class hash", to_hex(key_file_account.class_hash))
222 |     deployment = (TESTNET_KEY, contract_address)
223 |     assert alias in section, section.fail_msg(*alias)
224 |     assert public_key in section, section.fail_msg(*public_key)
225 |     assert class_hash in section, section.fail_msg(*class_hash)
226 |     assert deployment in section, section.fail_msg(*deployment)
227 | 
228 | 
229 | def test_import_then_delete_deployment(
230 |     accounts_runner, key_file_account, password, contract_address
231 | ):
232 |     """
233 |     * Start with an account with single deployments on testnet
234 |     * Import deployments to testnet2 and mainnet
235 |     * Delete deployments testnet2 and mainnet
236 | 
237 |     The account never completely goes away because it has multiple deployments.
238 |     """
239 | 
240 |     # Import the deployments.
241 |     accounts_runner.invoke(
242 |         "import",
243 |         key_file_account.alias,
244 |         "--network",
245 |         "testnet2,mainnet",
246 |         "--address",
247 |         contract_address,
248 |         "--class-hash",
249 |         key_file_account.class_hash,
250 |         input=password,
251 |     )
252 |     actual_0 = (TESTNET_KEY, contract_address)
253 |     actual_1 = (TESTNET2_KEY, contract_address)
254 |     actual_2 = (MAINNET_KEY, contract_address)
255 | 
256 |     # Ensure new deployments show up in list output.
257 |     output = accounts_runner.invoke_list()
258 |     section = output.get_section(key_file_account.alias)
259 |     assert actual_0 in section, section.fail_msg(*actual_0)
260 |     assert actual_1 in section, section.fail_msg(*actual_1)
261 |     assert actual_2 in section, section.fail_msg(*actual_2)
262 | 
263 |     # Delete the new deployments.
264 |     user_input = [password]  # ["123"]
265 |     output = accounts_runner.invoke(
266 |         "delete",
267 |         key_file_account.alias,
268 |         "--network",
269 |         "mainnet,testnet2",
270 |         "--address",
271 |         contract_address,
272 |         input=user_input,
273 |     )
274 |     assert (
275 |         f"Account '{key_file_account.alias}' deployments on network 'mainnet,testnet2' deleted"
276 |     ) in output
277 | 
278 |     # Ensure testnet deployment was deleted but not testnet2.
279 |     output = accounts_runner.invoke_list()
280 |     section = output.get_section(key_file_account.alias)
281 |     assert actual_0 in section, section.fail_msg(*actual_0)
282 |     assert actual_1 not in section, f"{TESTNET2_KEY} still present."
283 | 
284 | 
285 | def test_import_then_delete_account(
286 |     accounts_runner,
287 |     key_file_account,
288 |     account_container,
289 |     password,
290 | ):
291 |     # Import a new account (no deployments or keys set at all for this alias).
292 |     alias = get_random_alias()
293 | 
294 |     # [privkey, new pass, confirm pass]
295 |     user_input = [str(get_random_private_key()), password, password]
296 | 
297 |     accounts_runner.invoke(
298 |         "import",
299 |         alias,
300 |         "--network",
301 |         "testnet",
302 |         "--address",
303 |         key_file_account.address,
304 |         "--class-hash",
305 |         key_file_account.class_hash,
306 |         input=user_input,
307 |     )
308 | 
309 |     # Verify it shows up in list output.
310 |     output = accounts_runner.invoke_list()
311 |     section = output.get_section(alias)
312 |     assert (TESTNET_KEY, key_file_account.address) in section, section.fail_msg(
313 |         key_file_account.address
314 |     )
315 | 
316 |     # Delete the account.
317 |     user_input = [password, "y"]  # ["123", yes delete entire thing]
318 |     accounts_runner.invoke("delete", alias, input=user_input)
319 | 
320 |     # Verify it does not show in the list output.
321 |     output = accounts_runner.invoke_list()
322 |     section = output.get_section(alias)
323 |     assert not section
324 | 
325 | 
326 | def test_import_invalid_private_key(accounts_runner, key_file_account):
327 |     # Import a new account (no deployments or keys set at all for this alias).
328 |     alias = get_random_alias()
329 |     user_input = ["This is not a valid private key"]
330 |     output = accounts_runner.invoke(
331 |         "import",
332 |         alias,
333 |         "--network",
334 |         "testnet",
335 |         "--address",
336 |         key_file_account.address,
337 |         "--class-hash",
338 |         key_file_account.class_hash,
339 |         input=user_input,
340 |         ensure_successful=False,
341 |     )
342 |     assert "Invalid private key. Expecting numeric value." in output
343 | 
344 | 
345 | @pytest.mark.parametrize("private_key", (0, EC_ORDER))
346 | def test_import_private_key_out_of_range(accounts_runner, key_file_account, private_key):
347 |     # Import a new account (no deployments or keys set at all for this alias).
348 |     alias = get_random_alias()
349 |     user_input = [private_key]
350 |     output = accounts_runner.invoke(
351 |         "import",
352 |         alias,
353 |         "--network",
354 |         "testnet",
355 |         "--address",
356 |         key_file_account.address,
357 |         "--class-hash",
358 |         key_file_account.class_hash,
359 |         input=user_input,
360 |         ensure_successful=False,
361 |     )
362 |     assert "Private key not in range [1, EC_ORDER)." in output
363 | 
364 | 
365 | def test_core_accounts_list_all(root_accounts_runner, key_file_account, existing_key_file_alias):
366 |     """
367 |     Ensure the normal `ape accounts list --all` command works.
368 |     """
369 | 
370 |     assert existing_key_file_alias in root_accounts_runner.invoke("list", "--all")
371 | 
372 | 
373 | def test_change_password(accounts_runner, key_file_account, password, existing_key_file_alias):
374 |     """
375 |     Changes the password and then changes it back.
376 |     """
377 | 
378 |     new_password = "321"
379 |     assert "SUCCESS" in accounts_runner.invoke(
380 |         "change-password", existing_key_file_alias, input=[password, new_password, new_password]
381 |     )
382 |     assert "SUCCESS" in accounts_runner.invoke(
383 |         "change-password", existing_key_file_alias, input=[new_password, password, password]
384 |     )
385 | 
386 | 
387 | def test_export(accounts_runner, key_file_account, password):
388 |     output = accounts_runner.invoke("export", key_file_account.alias, input=[password])
389 |     key_from_output = int(output.split(" private key: ")[-1].strip(" )\n"))
390 | 
391 |     # Sign a message using the exported private key.
392 |     msg = StarknetSignableMessage(message="test test test")
393 |     actual_signature = message_signature(msg.hash, key_from_output)
394 | 
395 |     # Sign the same message using the account.
396 |     with accounts_runner.runner.isolation(f"y\n{password}\n"):
397 |         expected_signature = key_file_account.sign_message(msg)
398 | 
399 |     # The signatures should be the same to prove exporting works.
400 |     assert actual_signature == expected_signature
401 | 


--------------------------------------------------------------------------------