├── .circleci
    ├── config.yml
    └── merge_pr.sh
├── .env_defaults
├── .github
    ├── ISSUE_TEMPLATE.md
    └── PULL_REQUEST_TEMPLATE.md
├── .gitignore
├── Procfile
├── README.md
├── bin
    └── install_solc-0.4.2.sh
├── func_sig_registry
    ├── __init__.py
    ├── api_urls.py
    ├── gunicorn.conf
    ├── registry
    │   ├── __init__.py
    │   ├── api_views.py
    │   ├── apps.py
    │   ├── filters.py
    │   ├── forms.py
    │   ├── migrations
    │   │   ├── 0001_initial.py
    │   │   ├── 0002_auto_20160709_0331.py
    │   │   ├── 0003_auto_20160709_0451.py
    │   │   ├── 0004_auto_20160804_1923.py
    │   │   ├── 0005_bytessignature_bytes4_signature.py
    │   │   ├── 0006_remove_bytessignature_unicode_bytes4_signature.py
    │   │   ├── 0007_auto_20160804_1929.py
    │   │   ├── 0008_auto_20160804_1929.py
    │   │   ├── 0009_bytessignature_hex_signature.py
    │   │   ├── 0010_auto_20160804_2028.py
    │   │   ├── 0011_auto_20160804_2047.py
    │   │   ├── 0012_auto_20160805_0441.py
    │   │   ├── 0013_auto_20160805_0446.py
    │   │   ├── 0014_eventsignature.py
    │   │   └── __init__.py
    │   ├── models.py
    │   ├── pagination.py
    │   ├── serializers.py
    │   ├── tables.py
    │   ├── tasks.py
    │   ├── templates
    │   │   └── registry
    │   │   │   ├── contract_abi_import.html
    │   │   │   ├── eventsignature_list.html
    │   │   │   ├── signature_create.html
    │   │   │   ├── signature_list.html
    │   │   │   └── solidity_source_import.html
    │   └── views.py
    ├── settings.py
    ├── settings_dev.py
    ├── settings_test.py
    ├── static
    │   ├── css
    │   │   ├── bootstrap-theme.css
    │   │   ├── bootstrap-theme.css.map
    │   │   ├── bootstrap-theme.min.css
    │   │   ├── bootstrap-theme.min.css.map
    │   │   ├── bootstrap.css
    │   │   ├── bootstrap.css.map
    │   │   ├── bootstrap.min.css
    │   │   ├── bootstrap.min.css.map
    │   │   └── project.css
    │   ├── fonts
    │   │   ├── glyphicons-halflings-regular.eot
    │   │   ├── glyphicons-halflings-regular.svg
    │   │   ├── glyphicons-halflings-regular.ttf
    │   │   ├── glyphicons-halflings-regular.woff
    │   │   └── glyphicons-halflings-regular.woff2
    │   ├── images
    │   │   └── favicon.ico
    │   └── js
    │   │   ├── bootstrap.js
    │   │   ├── bootstrap.min.js
    │   │   └── npm.js
    ├── templates
    │   ├── base.html
    │   ├── documentation.html
    │   ├── home.html
    │   ├── layout_full.html
    │   └── partials
    │   │   ├── file_input.html
    │   │   ├── form_errors_as_alerts.html
    │   │   ├── main_footer.html
    │   │   ├── pagination.html
    │   │   └── table.html
    ├── urls.py
    ├── utils
    │   ├── __init__.py
    │   ├── abi.py
    │   ├── encoding.py
    │   ├── events_solidity.py
    │   ├── github.py
    │   ├── import_statistics.py
    │   └── solidity.py
    └── wsgi.py
├── manage.py
├── migrations
    └── __init__.py
├── pytest.ini
├── requirements-dev.txt
├── requirements.txt
├── runtime.txt
├── setup.py
├── ssl.md
├── tests
    └── web
    │   ├── api
    │       ├── test_contract_abi_import_view.py
    │       ├── test_event_signature_api.py
    │       ├── test_event_signature_serializer.py
    │       ├── test_searching_signature_api_view.py
    │       ├── test_signature_api_view.py
    │       ├── test_signature_serializer.py
    │       ├── test_solidity_code_and_file_import.py
    │       ├── test_solidity_file_import.py
    │       └── test_solidity_source_import.py
    │   ├── conftest.py
    │   ├── factories.py
    │   ├── github
    │       ├── test_get_repository_solidity_files.py
    │       └── test_github_webhook_serializer.py
    │   ├── registry
    │       ├── test_browsable_event_signatures.py
    │       ├── test_browsable_function_signatures.py
    │       ├── test_event_signature_filter.py
    │       └── test_signature_import_from_raw_text_signature.py
    │   ├── regressions
    │       └── test_00_prefixed_signatures_save_correctly.py
    │   ├── utility
    │       ├── test_event_definition_to_text_signature.py
    │       ├── test_extract_event_signatures.py
    │       ├── test_extract_function_signatures.py
    │       ├── test_function_definition_to_text_signature.py
    │       ├── test_is_valid_contract_abi.py
    │       ├── test_make_4byte_signature.py
    │       ├── test_normalize_event_signature.py
    │       ├── test_normalize_function_signature.py
    │       └── test_retrieve_stats_from_import_results.py
    │   └── views
    │       └── test_signature_submit.py
└── tox.ini


/.circleci/config.yml:
--------------------------------------------------------------------------------
 1 | version: 2.0
 2 | 
 3 | # heavily inspired by https://raw.githubusercontent.com/pinax/pinax-wiki/6bd2a99ab6f702e300d708532a6d1d9aa638b9f8/.circleci/config.yml
 4 | 
 5 | common: &common
 6 |   working_directory: ~/repo
 7 |   steps:
 8 |     - checkout
 9 |     - run:
10 |         name: merge pull request base
11 |         command: ./.circleci/merge_pr.sh
12 |     - run:
13 |         name: merge pull request base (2nd try)
14 |         command: ./.circleci/merge_pr.sh
15 |         when: on_fail
16 |     - run:
17 |         name: merge pull request base (3nd try)
18 |         command: ./.circleci/merge_pr.sh
19 |         when: on_fail
20 |     - restore_cache:
21 |         keys:
22 |           - cache-{{ .Environment.CIRCLE_JOB }}-{{ checksum "setup.py" }}-{{ checksum "tox.ini" }}
23 |     - run:
24 |         name: install dependencies
25 |         command: pip install --user tox
26 |     - run:
27 |         name: setup env variables
28 |         command: |
29 |           echo 'export REDIS_URL=redis://localhost:6379' >> $BASH_ENV
30 |           echo 'export DATABASE_URL=postgres://postgres@localhost/func_sig_registry' >> $BASH_ENV
31 |     - run:
32 |         name: Waiting for Postgres to be ready
33 |         command: |
34 |           if [[ -z "${POSTGRES_USER}" ]]; then
35 |             echo No need for Postgres && exit 0
36 |           fi
37 |           for i in `seq 1 10`;
38 |           do
39 |             nc -z localhost 5432 && echo Success && exit 0
40 |             echo -n .
41 |             sleep 1
42 |           done
43 |           echo Failed waiting for Postgres && exit 1
44 |     - run:
45 |         name: run tox
46 |         command: ~/.local/bin/tox -r
47 |     - save_cache:
48 |         paths:
49 |           - .hypothesis
50 |           - .tox
51 |           - ~/.cache/pip
52 |           - ~/.local
53 |           - ./eggs
54 |         key: cache-{{ .Environment.CIRCLE_JOB }}-{{ checksum "setup.py" }}-{{ checksum "tox.ini" }}
55 | 
56 | jobs:
57 |   flake8:
58 |     <<: *common
59 |     docker:
60 |       - image: circleci/python:3.6
61 |         environment:
62 |           TOXENV: flake8
63 |   py36-django19:
64 |     <<: *common
65 |     docker:
66 |       - image: circleci/python:3.6
67 |         environment:
68 |           TOXENV: py36-django19
69 |       - image: circleci/postgres:9.6.2-alpine
70 |         environment:
71 |             POSTGRES_USER: postgres
72 |             POSTGRES_DB: func_sig_registry
73 | workflows:
74 |   version: 2
75 |   test:
76 |     jobs:
77 |       - flake8
78 |       - py36-django19


--------------------------------------------------------------------------------
/.circleci/merge_pr.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | if [[ -n "${CIRCLE_PR_NUMBER}" ]]; then
 4 |   PR_INFO_URL=https://api.github.com/repos/$CIRCLE_PROJECT_USERNAME/$CIRCLE_PROJECT_REPONAME/pulls/$CIRCLE_PR_NUMBER
 5 |   PR_BASE_BRANCH=$(curl -L "$PR_INFO_URL" | python -c 'import json, sys; obj = json.load(sys.stdin); sys.stdout.write(obj["base"]["ref"])')
 6 |   git fetch origin +"$PR_BASE_BRANCH":circleci/pr-base
 7 |   # We need these config values or git complains when creating the
 8 |   # merge commit
 9 |   git config --global user.name "Circle CI"
10 |   git config --global user.email "circleci@example.com"
11 |   git merge --no-edit circleci/pr-base
12 | fi


--------------------------------------------------------------------------------
/.env_defaults:
--------------------------------------------------------------------------------
 1 | DJANGO_SECRET_KEY='this-is-not-a-real-secret-key-do-not-use-me'
 2 | DJANGO_DEBUG='True'
 3 | DJANGO_DEBUG_TOOLBAR_ENABLED='True'
 4 | 
 5 | REDIS_URL='redis://127.0.0.1:6379'
 6 | #
 7 | # Database Examples (should go in your local untracked .env)
 8 | #
 9 | # In Memory Database (good for testing)
10 | # DATABASE_URL='sqlite//memory:'
11 | # Postgres: dbname=dynamis dbuser=postgres
12 | # DATABASE_URL='postgres://postgres@localhost/dynamis'
13 | 
14 | #
15 | # AWS
16 | #
17 | # AWS_ACCESS_KEY_ID=<aws-access-key>
18 | # AWS_SECRET_ACCESS_KEY=<aws-secret-access-key>
19 | # AWS_STORAGE_BUCKET_NAME=<aws-s3-bucket-name>
20 | # AWS_DEFAULT_REGION=<the-region-the-s3-bucket-is-in>
21 | #
22 | # DJANGO_DEFAULT_FILE_STORAGE='s3_folder_storage.s3.DefaultStorage'
23 | # DJANGO_MEDIA_ROOT='/media/'
24 | # DJANGO_MEDIA_URL='//<s3-aws-region>.amazonaws.com/<bucket_name>/media/'
25 | #
26 | # DJANGO_STATICFILES_STORAGE='s3_folder_storage.s3.StaticStorage'
27 | # DJANGO_STATIC_ROOT='/static/'
28 | # DJANGO_STATIC_URL='//<s3-aws-region>.amazonaws.com/<bucket_name>/static/'
29 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE.md:
--------------------------------------------------------------------------------
 1 | * OS: osx/linux/win
 2 | * Python version (output of `python --version`):
 3 | * Environment (output of `pip freeze`):
 4 | 
 5 | ### What is wrong?
 6 | 
 7 | Please include information like:
 8 | 
 9 | * full output of the error you received
10 | * what command you ran
11 | * the code that caused the failure (see [this link](https://help.github.com/articles/basic-writing-and-formatting-syntax/) for help with formatting code)
12 | 
13 | 
14 | ### How can it be fixed
15 | 
16 | Fill this in if you know how to fix it.
17 | 


--------------------------------------------------------------------------------
/.github/PULL_REQUEST_TEMPLATE.md:
--------------------------------------------------------------------------------
 1 | ### What was wrong?
 2 | 
 3 | 
 4 | 
 5 | ### How was it fixed?
 6 | 
 7 | 
 8 | ### To-Do
 9 | 
10 | [//]: # (Stay ahead of things, add list items here!)
11 | - [ ] Clean up commit history
12 | 
13 | #### Cute Animal Picture
14 | 
15 | ![put a cute animal picture link inside the parentheses]()
16 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | public/
 2 | __pycache__/
 3 | *.pyc
 4 | *.sqlite3
 5 | .env
 6 | bower_components/
 7 | node_modules/
 8 | .cache/
 9 | tmp/
10 | *.log
11 | build/
12 | .hypothesis
13 | chains/
14 | .tox
15 | .vscode
16 | venv*
17 | .mypy_cache
18 | 


--------------------------------------------------------------------------------
/Procfile:
--------------------------------------------------------------------------------
1 | web: gunicorn func_sig_registry.wsgi -c func_sig_registry/gunicorn.conf -w 3
2 | worker: python manage.py run_huey --verbosity=3
3 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Ethereum Function Signature Database
 2 | 
 3 | This project is meant to be a resource for mapping the 4-byte function
 4 | selectors used by the EVM back to a list of known canonical function signatures
 5 | that will generate those 4-byte selectors.
 6 | 
 7 | The project currently consists of two primary components:
 8 | 
 9 | 1. Current website located at [https://www.4byte.directory/](https://www.4byte.directory/).
10 | 2. An Ethereum smart contract that houses the signature data. (This portion is
11 |    a work in progress and is not yet live).
12 | 
13 | 
14 | ## Running the tests
15 | 
16 | > Note: This project is only supported under Python3.  If it works in Python2.x that is purely coincidental.
17 | 
18 | First install the relevant system dependencies.
19 | 
20 | * OSX: `brew install pkg-config libffi autoconf automake libtool openssl postgres`
21 | * Linux: `sudo apt-get install libssl-dev postgresql postgresql-contrib`
22 | 
23 | There are two primary test suites located under the [`./tests/`](./tests/)
24 | directory.
25 | 
26 | * [`./tests/web/`](./tests/web/): contains all of the tests for the website.
27 | * [`./tests/contracts/`](./tests/contracts/): contains all of the tests for the
28 |   smart contracts.
29 | 
30 | First you will need to install the requirements.
31 | 
32 | ```bash
33 | $ pip install -r requirements.txt -r requirements-dev.txt
34 | ```
35 | 
36 | To run the full test suite:
37 | 
38 | ```bash
39 | $ tox
40 | ```
41 | 
42 | To run the individual tests suites.
43 | 
44 | ```bash
45 | $ py.test tests/web
46 | $ py.test tests/contracts
47 | ```
48 | 
49 | ## Serve the site on a development machine
50 | 
51 | To serve the site on a development machine, bypassing several security measures, run:
52 | 
53 | ```bash
54 | python manage.py runserver --settings func_sig_registry.settings_dev
55 | ```
56 | 


--------------------------------------------------------------------------------
/bin/install_solc-0.4.2.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | #
 3 | # Install solc 
 4 | #
 5 | 
 6 | set -e
 7 | set -u
 8 | 
 9 | if [ ! -e solc-versions/solidity-0.4.2/build/solc/solc ] ; then
10 |     wget -O solc.tar.gz "https://github.com/ethereum/solidity/archive/v0.4.2.tar.gz"
11 |     install -d solc-versions
12 |     cd solc-versions
13 |     tar -zxvf ../solc.tar.gz
14 |     cd solidity-0.4.2
15 |     ./scripts/install_deps.sh
16 |     echo "af6afb0415761b53721f89c7f65064807f41cbd3" > commit_hash.txt
17 |     mkdir -p build
18 |     cd build
19 |     cmake .. && make
20 |     ln -fs $PWD/solc/solc ../../../solc-versions/solc-0.4.2
21 |     chmod +x ../../../solc-versions/solc-0.4.2
22 |     echo "Geth installed at $PWD/solc-0.4.2"
23 | else
24 |     echo "Geth already installed at $PWD/solc/solc-0.4.2"
25 | fi
26 | 


--------------------------------------------------------------------------------
/func_sig_registry/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gobitfly/ethereum-function-signature-registry/cb11e9dd5c04ae80c597d99f5d10b68a17407616/func_sig_registry/__init__.py


--------------------------------------------------------------------------------
/func_sig_registry/api_urls.py:
--------------------------------------------------------------------------------
 1 | from django.conf.urls import url
 2 | 
 3 | from rest_framework import routers
 4 | 
 5 | from func_sig_registry.registry.api_views import (
 6 |     SignatureViewSet,
 7 |     EventSignatureViewSet,
 8 |     SolidityImportAPIView,
 9 |     ContractABIImportAPIView,
10 |     GithubPushWebhookAPIView,
11 | )
12 | 
13 | 
14 | router = routers.SimpleRouter()
15 | router.register(r'signatures', SignatureViewSet)
16 | router.register(r'event-signatures', EventSignatureViewSet)
17 | 
18 | urlpatterns = [
19 |     url(r'import-solidity/$', SolidityImportAPIView.as_view(), name='import-solidity'),
20 |     url(r'import-abi/$', ContractABIImportAPIView.as_view(), name='import-abi'),
21 |     url(r'receive-github-webhook/$', GithubPushWebhookAPIView.as_view(), name='github-webhook'),
22 | ] + router.urls
23 | 


--------------------------------------------------------------------------------
/func_sig_registry/gunicorn.conf:
--------------------------------------------------------------------------------
1 | secure_scheme_headers = {
2 |     'X-FORWARDED-PROTO': 'https'
3 | }
4 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gobitfly/ethereum-function-signature-registry/cb11e9dd5c04ae80c597d99f5d10b68a17407616/func_sig_registry/registry/__init__.py


--------------------------------------------------------------------------------
/func_sig_registry/registry/api_views.py:
--------------------------------------------------------------------------------
 1 | import logging
 2 | 
 3 | from rest_framework import generics
 4 | from rest_framework import viewsets
 5 | from rest_framework import mixins
 6 | from rest_framework import filters
 7 | 
 8 | from .models import (
 9 |     Signature,
10 |     EventSignature,
11 | )
12 | from .tasks import perform_github_import
13 | from .filters import (
14 |     SignatureFilter,
15 |     EventSignatureFilter
16 | )
17 | from .serializers import (
18 |     SignatureSerializer,
19 |     EventSignatureSerializer,
20 |     SolidityImportSerializer,
21 |     ContractABISerializer,
22 |     GithubWebhookSerializer,
23 | )
24 | 
25 | 
26 | logger = logging.getLogger()
27 | 
28 | 
29 | class SignatureViewSet(mixins.CreateModelMixin,
30 |                        mixins.ListModelMixin,
31 |                        mixins.RetrieveModelMixin,
32 |                        viewsets.GenericViewSet):
33 |     queryset = Signature.objects.all().select_related('bytes_signature')
34 |     serializer_class = SignatureSerializer
35 |     filter_class = SignatureFilter
36 |     filter_backends = (filters.DjangoFilterBackend, filters.OrderingFilter)
37 |     ordering_fields = ('created_at',)
38 | 
39 | 
40 | class EventSignatureViewSet(mixins.CreateModelMixin,
41 |                             mixins.ListModelMixin,
42 |                             mixins.RetrieveModelMixin,
43 |                             viewsets.GenericViewSet):
44 |     queryset = EventSignature.objects.all()
45 |     serializer_class = EventSignatureSerializer
46 |     filter_class = EventSignatureFilter
47 |     filter_backends = (filters.DjangoFilterBackend, filters.OrderingFilter)
48 |     ordering_fields = ('created_at',)
49 | 
50 | 
51 | class SolidityImportAPIView(generics.CreateAPIView):
52 |     serializer_class = SolidityImportSerializer
53 | 
54 | 
55 | class ContractABIImportAPIView(generics.CreateAPIView):
56 |     serializer_class = ContractABISerializer
57 | 
58 | 
59 | class GithubPushWebhookAPIView(generics.CreateAPIView):
60 |     serializer_class = GithubWebhookSerializer
61 | 
62 |     def perform_create(self, serializer):
63 |         push_data = serializer.save()
64 |         login = push_data['repository']['owner'].get('login')
65 |         name = push_data['repository']['owner'].get('name')
66 |         repository = push_data['repository']['name']
67 |         commit = push_data['head_commit']['id']
68 | 
69 |         login_or_name = login or name
70 | 
71 |         logger.info(
72 |             "Scheduling github fetch for %s/%s/%s",
73 |             login_or_name,
74 |             repository,
75 |             commit,
76 |         )
77 | 
78 |         perform_github_import(login_or_name, repository, commit)
79 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/apps.py:
--------------------------------------------------------------------------------
1 | from django.apps import AppConfig
2 | 
3 | 
4 | class RegistryConfig(AppConfig):
5 |     name = 'registry'
6 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/filters.py:
--------------------------------------------------------------------------------
 1 | import rest_framework_filters as filters
 2 | 
 3 | from func_sig_registry.utils.encoding import (
 4 |     remove_0x_prefix,
 5 | )
 6 | 
 7 | from .models import (
 8 |     EventSignature,
 9 |     Signature,
10 | )
11 | 
12 | 
13 | class SignatureFilter(filters.FilterSet):
14 |     created_at = filters.AllLookupsFilter(name='created_at')
15 |     text_signature = filters.CharFilter(name='text_signature', lookup_type='icontains')
16 |     bytes_signature = filters.MethodFilter()
17 |     hex_signature = filters.MethodFilter()
18 | 
19 |     class Meta:
20 |         model = Signature
21 |         fields = ['created_at', 'text_signature', 'bytes_signature', 'hex_signature']
22 | 
23 |     def filter_bytes_signature(self, name, qs, value):
24 |         if len(value) == 4:
25 |             return qs.filter(bytes_signature__bytes4_signature=value)
26 |         else:
27 |             return qs
28 | 
29 |     def filter_hex_signature(self, name, qs, value):
30 |         unprefixed_value = remove_0x_prefix(value.lower())
31 | 
32 |         if len(unprefixed_value) == 8:
33 |             return qs.filter(bytes_signature__hex_signature=unprefixed_value)
34 |         else:
35 |             return qs.filter(bytes_signature__hex_signature__icontains=unprefixed_value)
36 | 
37 | 
38 | class EventSignatureFilter(filters.FilterSet):
39 |     created_at = filters.AllLookupsFilter(name='created_at')
40 |     text_signature = filters.CharFilter(name='text_signature',
41 |                                         lookup_type='icontains')
42 |     bytes_signature = filters.MethodFilter()
43 |     hex_signature = filters.MethodFilter()
44 | 
45 |     class Meta:
46 |         model = EventSignature
47 |         fields = ['created_at', 'text_signature',
48 |                   'bytes_signature', 'hex_signature']
49 | 
50 |     def filter_bytes_signature(self, name, qs, value):
51 |         if len(value) == 32:
52 |             return qs.filter(bytes_signature=value)
53 |         else:
54 |             return qs
55 | 
56 |     def filter_hex_signature(self, name, qs, value):
57 |         unprefixed_value = remove_0x_prefix(value.lower())
58 | 
59 |         if len(unprefixed_value) == 64:
60 |             return qs.filter(hex_signature=unprefixed_value)
61 |         else:
62 |             return qs.filter(hex_signature__icontains=unprefixed_value)
63 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/forms.py:
--------------------------------------------------------------------------------
  1 | import json
  2 | 
  3 | from rest_framework import serializers
  4 | from rest_framework.utils import html
  5 | from rest_framework.fields import empty
  6 | 
  7 | from .models import (
  8 |     Signature,
  9 |     EventSignature,
 10 | )
 11 | 
 12 | from func_sig_registry.utils.import_statistics import (
 13 |     retrieve_stats_from_import_results,
 14 | )
 15 | 
 16 | from func_sig_registry.utils.abi import (
 17 |     is_valid_contract_abi,
 18 | )
 19 | 
 20 | from func_sig_registry.utils.solidity import (
 21 |     normalize_function_signature,
 22 | )
 23 | 
 24 | from func_sig_registry.utils.events_solidity import (
 25 |     normalize_event_signature,
 26 | )
 27 | 
 28 | 
 29 | class SignatureSearchForm(serializers.Serializer):
 30 |     bytes4_signature = serializers.CharField(
 31 |         style={'placeholder': '0x70a08231'},
 32 |     )
 33 | 
 34 | 
 35 | class EventSignatureSearchForm(serializers.Serializer):
 36 |     bytes_signature = serializers.CharField(
 37 |         style={'placeholder': '0x82ff462f689e2f73df9fd8306282ad3ad112aca9e0847911e8051e158c525b33'},
 38 |     )
 39 | 
 40 | 
 41 | class SignatureForm(serializers.ModelSerializer):
 42 |     bytes4_signature = serializers.CharField(read_only=True,
 43 |                                              source='bytes_signature.get_hex_display')
 44 | 
 45 |     class Meta:
 46 |         model = Signature
 47 |         fields = ('id', 'text_signature', 'bytes4_signature')
 48 |         read_only_fields = ('bytes4_signature',)
 49 | 
 50 |     def validate_text_signature(self, value):
 51 |         return normalize_function_signature(value)
 52 | 
 53 | 
 54 | class AllSignatureCreateForm(serializers.Serializer):
 55 |     text_signature = serializers.CharField(write_only=True)
 56 | 
 57 |     def create(self, validated_data):
 58 |         if 'function_signature' in validated_data['text_signature']:
 59 |             function_signature = Signature.import_from_raw_text_signature(
 60 |                 validated_data['text_signature']['function_signature'],
 61 |             )
 62 |         else:
 63 |             function_signature = None
 64 |         if 'event_signature' in validated_data['text_signature']:
 65 |             event_signature = EventSignature.import_from_raw_text_signature(
 66 |                 validated_data['text_signature']['event_signature'],
 67 |             )
 68 |         else:
 69 |             event_signature = None
 70 |         return (function_signature, event_signature)
 71 | 
 72 |     def validate_text_signature(self, value):
 73 |         validated_signatures = dict()
 74 |         exceptions_messages = []
 75 |         try:
 76 |             normalized_function_signature = normalize_function_signature(value)
 77 |             validated_signatures.update({'function_signature': normalized_function_signature})
 78 |         except ValueError as e:
 79 |             exceptions_messages.append(f'Function import error: {str(e)}.')
 80 | 
 81 |         try:
 82 |             normalized_event_signature = normalize_event_signature(value)
 83 |             validated_signatures.update({'event_signature': normalized_event_signature})
 84 |         except ValueError as e:
 85 |             exceptions_messages.append(f'Event import error: {str(e)}.')
 86 | 
 87 |         if len(validated_signatures) == 0:
 88 |             raise ValueError(' '.join(exceptions_messages))
 89 |         return validated_signatures
 90 | 
 91 | 
 92 | class MultiFileField(serializers.FileField):
 93 |     """
 94 |     Allow file uploads via inputs with `multipule=true` enabled.
 95 |     """
 96 | 
 97 |     def __init__(self, *args, **kwargs):
 98 |         kwargs['style'] = {'multiple': True, 'template': 'partials/file_input.html'}
 99 |         super(MultiFileField, self).__init__(*args, **kwargs)
100 | 
101 |     def get_value(self, dictionary):
102 |         if self.field_name not in dictionary:
103 |             if getattr(self.root, 'partial', False):
104 |                 return empty
105 |         # We override the default field access in order to support
106 |         # lists in HTML forms.
107 |         if html.is_html_input(dictionary):
108 |             val = dictionary.getlist(self.field_name, [])
109 |             if len(val) > 0:
110 |                 # Support QueryDict lists in HTML input.
111 |                 return val
112 |             return html.parse_html_list(dictionary, prefix=self.field_name)
113 |         return dictionary.getlist(self.field_name, empty)
114 | 
115 |     def to_internal_value(self, data):
116 |         return data
117 | 
118 | 
119 | class SolidityImportForm(serializers.Serializer):
120 |     source_files = MultiFileField()
121 | 
122 |     def create(self, validated_data):
123 |         return validated_data
124 | 
125 | 
126 | class ContractABIForm(serializers.Serializer):
127 |     contract_abi = serializers.CharField(
128 |         style={'base_template': 'textarea.html'},
129 |         write_only=True,
130 |     )
131 | 
132 |     num_processed = serializers.IntegerField(read_only=True)
133 |     num_imported = serializers.IntegerField(read_only=True)
134 |     num_duplicates = serializers.IntegerField(read_only=True)
135 |     num_ignored = serializers.IntegerField(read_only=True)
136 | 
137 |     def validate_contract_abi(self, value):
138 |         try:
139 |             contract_abi = json.loads(value)
140 |         except json.JSONDecodeError:
141 |             raise serializers.ValidationError('Invalid JSON')
142 | 
143 |         if not is_valid_contract_abi(contract_abi):
144 |             raise serializers.ValidationError('Could not validate ABI')
145 | 
146 |         return contract_abi
147 | 
148 |     def create(self, validated_data):
149 |         contract_abi = validated_data['contract_abi']
150 | 
151 |         stats_function = retrieve_stats_from_import_results(
152 |             Signature.import_from_contract_abi(contract_abi))
153 |         stats_event = retrieve_stats_from_import_results(
154 |             EventSignature.import_from_contract_abi(contract_abi))
155 | 
156 |         return {
157 |             'num_processed':
158 |                 stats_function.num_processed + stats_event.num_processed,
159 |             'num_imported':
160 |                 stats_function.num_imported + stats_event.num_imported,
161 |             'num_duplicates':
162 |                 stats_function.num_duplicates + stats_event.num_duplicates,
163 |             'num_ignored':
164 |                 stats_function.num_ignored + stats_event.num_ignored,
165 |         }
166 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/migrations/0001_initial.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | # Generated by Django 1.9.7 on 2016-07-06 22:20
 3 | from __future__ import unicode_literals
 4 | 
 5 | import django.core.validators
 6 | from django.db import migrations, models
 7 | import django.db.models.deletion
 8 | 
 9 | 
10 | class Migration(migrations.Migration):
11 | 
12 |     initial = True
13 | 
14 |     dependencies = [
15 |     ]
16 | 
17 |     operations = [
18 |         migrations.CreateModel(
19 |             name='BytesSignature',
20 |             fields=[
21 |                 ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
22 |                 ('bytes4_signature', models.CharField(max_length=4, unique=True, validators=[django.core.validators.MinLengthValidator(4)])),
23 |             ],
24 |         ),
25 |         migrations.CreateModel(
26 |             name='Signature',
27 |             fields=[
28 |                 ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
29 |                 ('created_at', models.DateTimeField(auto_now_add=True)),
30 |                 ('updated_at', models.DateTimeField(auto_now=True)),
31 |                 ('text_signature', models.TextField(unique=True, validators=[django.core.validators.MinLengthValidator(3)])),
32 |                 ('bytes_signature', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='registry.BytesSignature')),
33 |             ],
34 |         ),
35 |         migrations.AlterUniqueTogether(
36 |             name='signature',
37 |             unique_together=set([('text_signature', 'bytes_signature')]),
38 |         ),
39 |     ]
40 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/migrations/0002_auto_20160709_0331.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | # Generated by Django 1.9.7 on 2016-07-09 03:31
 3 | from __future__ import unicode_literals
 4 | 
 5 | from django.db import migrations
 6 | 
 7 | 
 8 | class Migration(migrations.Migration):
 9 | 
10 |     dependencies = [
11 |         ('registry', '0001_initial'),
12 |     ]
13 | 
14 |     operations = [
15 |         migrations.AlterModelOptions(
16 |             name='signature',
17 |             options={'ordering': ('-created_at',)},
18 |         ),
19 |     ]
20 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/migrations/0003_auto_20160709_0451.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | # Generated by Django 1.9.7 on 2016-07-09 04:51
 3 | from __future__ import unicode_literals
 4 | 
 5 | from django.db import migrations, models
 6 | 
 7 | 
 8 | class Migration(migrations.Migration):
 9 | 
10 |     dependencies = [
11 |         ('registry', '0002_auto_20160709_0331'),
12 |     ]
13 | 
14 |     operations = [
15 |         migrations.AlterField(
16 |             model_name='signature',
17 |             name='created_at',
18 |             field=models.DateTimeField(auto_now_add=True, db_index=True),
19 |         ),
20 |     ]
21 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/migrations/0004_auto_20160804_1923.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | # Generated by Django 1.9.9 on 2016-08-04 19:23
 3 | from __future__ import unicode_literals
 4 | 
 5 | from django.db import migrations
 6 | 
 7 | 
 8 | class Migration(migrations.Migration):
 9 | 
10 |     dependencies = [
11 |         ('registry', '0003_auto_20160709_0451'),
12 |     ]
13 | 
14 |     operations = [
15 |         migrations.RenameField(
16 |             model_name='bytessignature',
17 |             old_name='bytes4_signature',
18 |             new_name='unicode_bytes4_signature',
19 |         ),
20 |     ]
21 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/migrations/0005_bytessignature_bytes4_signature.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | # Generated by Django 1.9.9 on 2016-08-04 19:24
 3 | from __future__ import unicode_literals
 4 | 
 5 | import django.core.validators
 6 | from django.db import migrations, models
 7 | 
 8 | 
 9 | class Migration(migrations.Migration):
10 | 
11 |     dependencies = [
12 |         ('registry', '0004_auto_20160804_1923'),
13 |     ]
14 | 
15 |     operations = [
16 |         migrations.AddField(
17 |             model_name='bytessignature',
18 |             name='bytes4_signature',
19 |             field=models.BinaryField(max_length=4, null=True, unique=True, validators=[django.core.validators.MinLengthValidator(4)]),
20 |         ),
21 |     ]
22 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/migrations/0006_remove_bytessignature_unicode_bytes4_signature.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | # Generated by Django 1.9.9 on 2016-08-04 19:24
 3 | from __future__ import unicode_literals
 4 | 
 5 | from django.db import migrations
 6 | 
 7 | 
 8 | class Migration(migrations.Migration):
 9 | 
10 |     dependencies = [
11 |         ('registry', '0005_bytessignature_bytes4_signature'),
12 |     ]
13 | 
14 |     operations = [
15 |         migrations.RemoveField(
16 |             model_name='bytessignature',
17 |             name='unicode_bytes4_signature',
18 |         ),
19 |     ]
20 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/migrations/0007_auto_20160804_1929.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | # Generated by Django 1.9.9 on 2016-08-04 19:29
 3 | from __future__ import unicode_literals
 4 | 
 5 | from django.db import migrations, models
 6 | import django.db.models.deletion
 7 | 
 8 | 
 9 | class Migration(migrations.Migration):
10 | 
11 |     dependencies = [
12 |         ('registry', '0006_remove_bytessignature_unicode_bytes4_signature'),
13 |     ]
14 | 
15 |     operations = [
16 |         migrations.AlterField(
17 |             model_name='signature',
18 |             name='bytes_signature',
19 |             field=models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, to='registry.BytesSignature'),
20 |         ),
21 |     ]
22 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/migrations/0008_auto_20160804_1929.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | # Generated by Django 1.9.9 on 2016-08-04 19:24
 3 | from __future__ import unicode_literals
 4 | 
 5 | from django.db import migrations
 6 | from sha3 import sha3_256
 7 | 
 8 | 
 9 | def force_bytes(value):
10 |     if isinstance(value, bytes):
11 |         return value
12 |     elif isinstance(value, memoryview):
13 |         return bytes(value)
14 |     elif isinstance(value, str):
15 |         return bytes(value, 'utf8')
16 |     else:
17 |         raise TypeError("Unsupported type: {0}".format(type(value)))
18 | 
19 | 
20 | def make_4byte_signature(text_signature):
21 |     return sha3_256(force_bytes(text_signature)).digest()[:4]
22 | 
23 | 
24 | def populate_bytes4_signature(apps, schema_editor):
25 |     Signature = apps.get_model('registry', 'Signature')
26 |     BytesSignature = apps.get_model('registry', 'BytesSignature')
27 | 
28 |     for signature in Signature.objects.all():
29 |         signature.bytes_signature, _ = BytesSignature.objects.get_or_create(
30 |             bytes4_signature=make_4byte_signature(signature.text_signature),
31 |         )
32 |         signature.save()
33 | 
34 |     bytes_signatures_to_remove = BytesSignature.objects.filter(
35 |         signature__isnull=True,
36 |     )
37 |     if bytes_signatures_to_remove.exists():
38 |         print("Removing {0} abandoned bytes signatures".format(
39 |             bytes_signatures_to_remove.count()
40 |         ))
41 |         bytes_signatures_to_remove.delete()
42 | 
43 | 
44 | class Migration(migrations.Migration):
45 | 
46 |     dependencies = [
47 |         ('registry', '0007_auto_20160804_1929'),
48 |     ]
49 | 
50 |     operations = [
51 |         migrations.RunPython(populate_bytes4_signature),
52 |     ]
53 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/migrations/0009_bytessignature_hex_signature.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | # Generated by Django 1.9.9 on 2016-08-04 20:28
 3 | from __future__ import unicode_literals
 4 | 
 5 | import django.core.validators
 6 | from django.db import migrations, models
 7 | 
 8 | 
 9 | class Migration(migrations.Migration):
10 | 
11 |     dependencies = [
12 |         ('registry', '0008_auto_20160804_1929'),
13 |     ]
14 | 
15 |     operations = [
16 |         migrations.AddField(
17 |             model_name='bytessignature',
18 |             name='hex_signature',
19 |             field=models.CharField(max_length=8, null=True, unique=True, validators=[django.core.validators.MinLengthValidator(4)]),
20 |         ),
21 |     ]
22 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/migrations/0010_auto_20160804_2028.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | # Generated by Django 1.9.9 on 2016-08-04 20:28
 3 | from __future__ import unicode_literals
 4 | 
 5 | from django.db import migrations
 6 | 
 7 | 
 8 | def populate_hex_signature(apps, schema_editor):
 9 |     BytesSignature = apps.get_model('registry', 'BytesSignature')
10 | 
11 |     for bytes_signature in BytesSignature.objects.all():
12 |         bytes_signature.save()
13 | 
14 | 
15 | class Migration(migrations.Migration):
16 | 
17 |     dependencies = [
18 |         ('registry', '0009_bytessignature_hex_signature'),
19 |     ]
20 | 
21 |     operations = [
22 |         migrations.RunPython(populate_hex_signature),
23 |     ]
24 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/migrations/0011_auto_20160804_2047.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | # Generated by Django 1.9.9 on 2016-08-04 20:47
 3 | from __future__ import unicode_literals
 4 | 
 5 | from django.db import migrations
 6 | 
 7 | 
 8 | def clean_bad_bytes_signatures(apps, schema_editor):
 9 |     BytesSignature = apps.get_model('registry', 'BytesSignature')
10 | 
11 |     BytesSignature.objects.filter(signature__isnull=True).delete()
12 | 
13 |     assert not BytesSignature.objects.filter(bytes4_signature=b'').exists()
14 |     assert not BytesSignature.objects.filter(hex_signature='').exists()
15 | 
16 | 
17 | class Migration(migrations.Migration):
18 | 
19 |     dependencies = [
20 |         ('registry', '0010_auto_20160804_2028'),
21 |     ]
22 | 
23 |     operations = [
24 |         migrations.RunPython(clean_bad_bytes_signatures),
25 |     ]
26 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/migrations/0012_auto_20160805_0441.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | # Generated by Django 1.9.9 on 2016-08-05 04:41
 3 | from __future__ import unicode_literals
 4 | 
 5 | import django.core.validators
 6 | from django.db import migrations, models
 7 | 
 8 | 
 9 | class Migration(migrations.Migration):
10 | 
11 |     dependencies = [
12 |         ('registry', '0011_auto_20160804_2047'),
13 |     ]
14 | 
15 |     operations = [
16 |         migrations.AlterField(
17 |             model_name='bytessignature',
18 |             name='bytes4_signature',
19 |             field=models.BinaryField(max_length=4, unique=True, validators=[django.core.validators.MinLengthValidator(4)]),
20 |         ),
21 |         migrations.AlterField(
22 |             model_name='bytessignature',
23 |             name='hex_signature',
24 |             field=models.CharField(max_length=8, unique=True, validators=[django.core.validators.MinLengthValidator(4)]),
25 |         ),
26 |     ]
27 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/migrations/0013_auto_20160805_0446.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | # Generated by Django 1.9.9 on 2016-08-05 04:46
 3 | from __future__ import unicode_literals
 4 | 
 5 | import django.core.validators
 6 | from django.db import migrations, models
 7 | 
 8 | 
 9 | class Migration(migrations.Migration):
10 | 
11 |     dependencies = [
12 |         ('registry', '0012_auto_20160805_0441'),
13 |     ]
14 | 
15 |     operations = [
16 |         migrations.AlterField(
17 |             model_name='bytessignature',
18 |             name='hex_signature',
19 |             field=models.CharField(max_length=8, unique=True, validators=[django.core.validators.MinLengthValidator(8)]),
20 |         ),
21 |     ]
22 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/migrations/0014_eventsignature.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | # Generated by Django 1.9.13 on 2020-08-07 10:03
 3 | from __future__ import unicode_literals
 4 | 
 5 | import django.core.validators
 6 | from django.db import migrations, models
 7 | 
 8 | 
 9 | class Migration(migrations.Migration):
10 | 
11 |     dependencies = [
12 |         ('registry', '0013_auto_20160805_0446'),
13 |     ]
14 | 
15 |     operations = [
16 |         migrations.CreateModel(
17 |             name='EventSignature',
18 |             fields=[
19 |                 ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
20 |                 ('created_at', models.DateTimeField(auto_now_add=True, db_index=True)),
21 |                 ('updated_at', models.DateTimeField(auto_now=True)),
22 |                 ('text_signature', models.TextField(unique=True, validators=[django.core.validators.MinLengthValidator(3), django.core.validators.MaxLengthValidator(4096)])),
23 |                 ('bytes_signature', models.BinaryField(max_length=32, unique=True, validators=[django.core.validators.MinLengthValidator(32)])),
24 |                 ('hex_signature', models.CharField(max_length=64, unique=True, validators=[django.core.validators.MinLengthValidator(64)])),
25 |             ],
26 |             options={
27 |                 'ordering': ('-created_at',),
28 |             },
29 |         ),
30 |     ]
31 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/migrations/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gobitfly/ethereum-function-signature-registry/cb11e9dd5c04ae80c597d99f5d10b68a17407616/func_sig_registry/registry/migrations/__init__.py


--------------------------------------------------------------------------------
/func_sig_registry/registry/models.py:
--------------------------------------------------------------------------------
  1 | import logging
  2 | import sys
  3 | 
  4 | from django.db import models
  5 | from django.core.validators import (
  6 |     MinLengthValidator,
  7 |     MaxLengthValidator,
  8 | )
  9 | from django.core.exceptions import ValidationError
 10 | from eth_utils import event_signature_to_log_topic
 11 | 
 12 | from func_sig_registry.utils.solidity import (
 13 |     extract_function_signatures,
 14 |     normalize_function_signature,
 15 | )
 16 | from func_sig_registry.utils.events_solidity import (
 17 |     normalize_event_signature,
 18 |     extract_event_signatures,
 19 | )
 20 | from func_sig_registry.utils.abi import (
 21 |     make_4byte_signature,
 22 |     function_definition_to_text_signature,
 23 |     event_definition_to_text_signature,
 24 | )
 25 | from func_sig_registry.utils.encoding import (
 26 |     encode_hex,
 27 |     force_text,
 28 |     add_0x_prefix,
 29 |     remove_0x_prefix,
 30 | )
 31 | 
 32 | 
 33 | logger = logging.getLogger('bytes4.models')
 34 | logger.setLevel(logging.INFO)
 35 | 
 36 | ch = logging.StreamHandler(sys.stdout)
 37 | ch.setLevel(logging.DEBUG)
 38 | formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 39 | ch.setFormatter(formatter)
 40 | logger.addHandler(ch)
 41 | 
 42 | 
 43 | class Signature(models.Model):
 44 |     created_at = models.DateTimeField(auto_now_add=True, db_index=True)
 45 |     updated_at = models.DateTimeField(auto_now=True)
 46 | 
 47 |     text_signature = models.TextField(unique=True,
 48 |                                       validators=[
 49 |                                           MinLengthValidator(3),
 50 |                                       ])
 51 |     bytes_signature = models.ForeignKey(
 52 |         'registry.BytesSignature',
 53 |         on_delete=models.PROTECT,
 54 |     )
 55 | 
 56 |     def __str__(self):
 57 |         return self.text_signature
 58 | 
 59 |     def clean_fields(self, exclude=None):
 60 |         try:
 61 |             self.text_signature = normalize_function_signature(self.text_signature)
 62 |         except ValueError:
 63 |             raise ValidationError('Unknown function signature format')
 64 | 
 65 |     class Meta:
 66 |         unique_together = (
 67 |             ('text_signature', 'bytes_signature'),
 68 |         )
 69 |         ordering = ('-created_at',)
 70 | 
 71 |     def save(self, *args, **kwargs):
 72 |         if self.bytes_signature_id is None:
 73 |             bytes4_signature = make_4byte_signature(self.text_signature)
 74 |             hex_signature = force_text(remove_0x_prefix(encode_hex(bytes4_signature)))
 75 |             self.bytes_signature, _ = BytesSignature.objects.get_or_create(
 76 |                 bytes4_signature=bytes4_signature,
 77 |                 defaults={'hex_signature': hex_signature},
 78 |             )
 79 |         return super(Signature, self).save()
 80 | 
 81 |     #
 82 |     # Import methods
 83 |     #
 84 |     @classmethod
 85 |     def import_from_raw_text_signature(cls, raw_function_signature):
 86 |         try:
 87 |             text_signature = normalize_function_signature(raw_function_signature)
 88 |         except ValueError:
 89 |             logger.error("error function signature: %s", raw_function_signature)
 90 |             return None
 91 |         else:
 92 |             logger.info("importing function signature: %s", text_signature)
 93 |             return cls.objects.get_or_create(
 94 |                 text_signature=text_signature,
 95 |             )
 96 | 
 97 |     @classmethod
 98 |     def import_from_solidity_code(cls, code):
 99 |         function_signatures = extract_function_signatures(code)
100 |         return [
101 |             cls.import_from_raw_text_signature(raw_signature)
102 |             for raw_signature in function_signatures
103 |         ]
104 | 
105 |     @classmethod
106 |     def import_from_solidity_file(cls, file_obj):
107 |         file_obj.seek(0)
108 |         code = force_text(file_obj.read())
109 |         return cls.import_from_solidity_code(code)
110 | 
111 |     @classmethod
112 |     def import_from_contract_abi(cls, contract_abi):
113 |         function_signatures = [
114 |             function_definition_to_text_signature(function_definition)
115 |             for function_definition in contract_abi
116 |             if function_definition['type'] == 'function'
117 |         ]
118 |         return [
119 |             cls.import_from_raw_text_signature(raw_signature)
120 |             for raw_signature in function_signatures
121 |         ]
122 | 
123 | 
124 | class BytesSignature(models.Model):
125 |     bytes4_signature = models.BinaryField(max_length=4,
126 |                                           unique=True,
127 |                                           validators=[MinLengthValidator(4)])
128 |     hex_signature = models.CharField(max_length=8,
129 |                                      unique=True,
130 |                                      validators=[MinLengthValidator(8)])
131 | 
132 |     def save(self, *args, **kwargs):
133 |         if not self.hex_signature:
134 |             self.hex_signature = force_text(remove_0x_prefix(encode_hex(self.bytes4_signature)))
135 |         super(BytesSignature, self).save(*args, **kwargs)
136 | 
137 |     def get_hex_display(self):
138 |         return force_text(add_0x_prefix(self.hex_signature))
139 | 
140 |     def get_bytes_display(self):
141 |         return force_text(self.bytes4_signature)
142 | 
143 | 
144 | class EventSignature(models.Model):
145 |     created_at = models.DateTimeField(auto_now_add=True, db_index=True)
146 |     updated_at = models.DateTimeField(auto_now=True)
147 | 
148 |     text_signature = models.TextField(unique=True,
149 |                                       validators=[
150 |                                         MinLengthValidator(3),
151 |                                         MaxLengthValidator(4096)
152 |                                       ])
153 | 
154 |     bytes_signature = models.BinaryField(max_length=32,
155 |                                          unique=True,
156 |                                          validators=[MinLengthValidator(32)])
157 | 
158 |     hex_signature = models.CharField(max_length=64,
159 |                                      unique=True,
160 |                                      validators=[MinLengthValidator(64)])
161 | 
162 |     def __str__(self):
163 |         return self.text_signature
164 | 
165 |     def clean_fields(self, exclude=None):
166 |         try:
167 |             self.text_signature = normalize_event_signature(
168 |                 self.text_signature)
169 |         except ValueError:
170 |             raise ValidationError('Unknown event signature format')
171 | 
172 |     class Meta:
173 |         ordering = ('-created_at',)
174 | 
175 |     def save(self, *args, **kwargs):
176 |         if len(self.bytes_signature) == 0 or len(self.hex_signature) == 0:
177 |             self.bytes_signature = event_signature_to_log_topic(
178 |                 self.text_signature)
179 |             self.hex_signature = force_text(
180 |                 remove_0x_prefix(encode_hex(self.bytes_signature)))
181 |         return super(EventSignature, self).save()
182 | 
183 |     def get_hex_display(self):
184 |         return force_text(add_0x_prefix(self.hex_signature))
185 | 
186 |     def get_bytes_display(self):
187 |         return force_text(self.bytes_signature)
188 | 
189 |     #
190 |     # Import methods
191 |     #
192 |     @classmethod
193 |     def import_from_raw_text_signature(cls, raw_event_signature):
194 |         try:
195 |             text_signature = normalize_event_signature(raw_event_signature)
196 |         except ValueError:
197 |             logger.error("error event signature: %s", raw_event_signature)
198 |             return None
199 |         else:
200 |             logger.info("importing event signature: %s", text_signature)
201 |             return cls.objects.get_or_create(
202 |                 text_signature=text_signature,
203 |             )
204 | 
205 |     @classmethod
206 |     def import_from_solidity_code(cls, code):
207 |         event_signatures = extract_event_signatures(code)
208 |         return [
209 |             cls.import_from_raw_text_signature(raw_signature)
210 |             for raw_signature in event_signatures
211 |         ]
212 | 
213 |     @classmethod
214 |     def import_from_solidity_file(cls, file_obj):
215 |         file_obj.seek(0)
216 |         code = force_text(file_obj.read())
217 |         return cls.import_from_solidity_code(code)
218 | 
219 |     @classmethod
220 |     def import_from_contract_abi(cls, contract_abi):
221 |         event_signatures = [
222 |             event_definition_to_text_signature(event_definition)
223 |             for event_definition in contract_abi
224 |             if event_definition['type'] == 'event'
225 |         ]
226 |         return [
227 |             cls.import_from_raw_text_signature(raw_signature)
228 |             for raw_signature in event_signatures
229 |         ]
230 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/pagination.py:
--------------------------------------------------------------------------------
1 | from rest_framework import pagination
2 | 
3 | 
4 | class PageNumberPagination(pagination.PageNumberPagination):
5 |     page_size_query_param = 'page_size'
6 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/serializers.py:
--------------------------------------------------------------------------------
  1 | import json
  2 | 
  3 | from rest_framework import serializers
  4 | 
  5 | from func_sig_registry.utils.import_statistics import (
  6 |     retrieve_stats_from_import_results,
  7 | )
  8 | from func_sig_registry.utils.abi import (
  9 |     is_valid_contract_abi,
 10 | )
 11 | from func_sig_registry.utils.events_solidity import (
 12 |     normalize_event_signature,
 13 | )
 14 | from func_sig_registry.utils.solidity import (
 15 |     normalize_function_signature,
 16 | )
 17 | 
 18 | 
 19 | from .models import (
 20 |     Signature,
 21 |     EventSignature,
 22 | )
 23 | 
 24 | 
 25 | class EventSignatureSerializer(serializers.ModelSerializer):
 26 |     hex_signature = serializers.CharField(
 27 |         source='get_hex_display',
 28 |         read_only=True,
 29 |     )
 30 |     bytes_signature = serializers.CharField(
 31 |         source='get_bytes_display',
 32 |         read_only=True,
 33 |     )
 34 | 
 35 |     class Meta:
 36 |         model = EventSignature
 37 |         fields = (
 38 |             'id', 'created_at', 'text_signature',
 39 |             'hex_signature', 'bytes_signature',
 40 |         )
 41 |         read_only_fields = (
 42 |             'created_at', 'hex_signature', 'bytes_signature',
 43 |         )
 44 | 
 45 |     def validate_text_signature(self, data):
 46 |         try:
 47 |             signature = normalize_event_signature(data)
 48 |         except ValueError:
 49 |             raise serializers.ValidationError('Unknown event signature format')
 50 |         return signature
 51 | 
 52 | 
 53 | class SignatureSerializer(serializers.ModelSerializer):
 54 |     hex_signature = serializers.CharField(
 55 |         source='bytes_signature.get_hex_display',
 56 |         read_only=True,
 57 |     )
 58 |     bytes_signature = serializers.CharField(
 59 |         source='bytes_signature.get_bytes_display',
 60 |         read_only=True,
 61 |     )
 62 | 
 63 |     class Meta:
 64 |         model = Signature
 65 |         fields = (
 66 |             'id', 'created_at', 'text_signature', 'hex_signature', 'bytes_signature',
 67 |         )
 68 |         read_only_fields = (
 69 |             'created_at', 'hex_signature', 'bytes_signature',
 70 |         )
 71 | 
 72 |     def validate_text_signature(self, data):
 73 |         try:
 74 |             signature = normalize_function_signature(data)
 75 |         except ValueError:
 76 |             raise serializers.ValidationError('Unknown signature format')
 77 |         return signature
 78 | 
 79 | 
 80 | class SolidityImportSerializer(serializers.Serializer):
 81 |     source_file = serializers.FileField(write_only=True, required=False)
 82 |     source_code = serializers.CharField(write_only=True, required=False)
 83 | 
 84 |     num_processed = serializers.IntegerField(read_only=True)
 85 |     num_imported = serializers.IntegerField(read_only=True)
 86 |     num_duplicates = serializers.IntegerField(read_only=True)
 87 |     num_ignored = serializers.IntegerField(read_only=True)
 88 | 
 89 |     def create(self, validated_data):
 90 |         func_imports = []
 91 |         event_imports = []
 92 | 
 93 |         if validated_data.get('source_file'):
 94 |             func_imports.extend(Signature.import_from_solidity_file(
 95 |                 validated_data['source_file']))
 96 |             event_imports.extend(EventSignature.import_from_solidity_file(
 97 |                 validated_data['source_file']))
 98 | 
 99 |         if validated_data.get('source_code'):
100 |             func_imports.extend(Signature.import_from_solidity_code(
101 |                 validated_data['source_code']))
102 |             event_imports.extend(EventSignature.import_from_solidity_code(
103 |                 validated_data['source_code']))
104 | 
105 |         stats_function = retrieve_stats_from_import_results(func_imports)
106 |         stats_event = retrieve_stats_from_import_results(event_imports)
107 | 
108 |         return {
109 |             'num_processed':
110 |                 stats_function.num_processed + stats_event.num_processed,
111 |             'num_imported':
112 |                 stats_function.num_imported + stats_event.num_imported,
113 |             'num_duplicates':
114 |                 stats_function.num_duplicates + stats_event.num_duplicates,
115 |             'num_ignored':
116 |                 stats_function.num_ignored + stats_event.num_ignored,
117 |         }
118 | 
119 | 
120 | class ContractABISerializer(serializers.Serializer):
121 |     contract_abi = serializers.CharField(write_only=True)
122 | 
123 |     num_processed = serializers.IntegerField(read_only=True)
124 |     num_imported = serializers.IntegerField(read_only=True)
125 |     num_duplicates = serializers.IntegerField(read_only=True)
126 |     num_ignored = serializers.IntegerField(read_only=True)
127 | 
128 |     def validate_contract_abi(self, value):
129 |         try:
130 |             contract_abi = json.loads(value)
131 |         except json.JSONDecodeError:
132 |             raise serializers.ValidationError('Invalid JSON')
133 | 
134 |         if not is_valid_contract_abi(contract_abi):
135 |             raise serializers.ValidationError('Could not validate ABI')
136 | 
137 |         return contract_abi
138 | 
139 |     def create(self, validated_data):
140 |         contract_abi = validated_data['contract_abi']
141 | 
142 |         stats_function = retrieve_stats_from_import_results(
143 |             Signature.import_from_contract_abi(contract_abi))
144 |         stats_event = retrieve_stats_from_import_results(
145 |             EventSignature.import_from_contract_abi(contract_abi))
146 | 
147 |         return {
148 |             'num_processed':
149 |                 stats_function.num_processed + stats_event.num_processed,
150 |             'num_imported':
151 |                 stats_function.num_imported + stats_event.num_imported,
152 |             'num_duplicates':
153 |                 stats_function.num_duplicates + stats_event.num_duplicates,
154 |             'num_ignored':
155 |                 stats_function.num_ignored + stats_event.num_ignored,
156 |         }
157 | 
158 | 
159 | class _OwnerSerializer(serializers.Serializer):
160 |     login = serializers.CharField(required=False)
161 |     name = serializers.CharField(required=False)
162 | 
163 |     def validate(self, data):
164 |         if not data.get('login') and not data.get('name'):
165 |             raise serializers.ValidationError("`name` or `login` are required")
166 |         return data
167 | 
168 | 
169 | class _RepositorySerializer(serializers.Serializer):
170 |     name = serializers.CharField()
171 |     owner = _OwnerSerializer()
172 | 
173 | 
174 | class _HeadCommitSerializer(serializers.Serializer):
175 |     id = serializers.CharField()
176 | 
177 | 
178 | class GithubWebhookSerializer(serializers.Serializer):
179 |     repository = _RepositorySerializer()
180 |     head_commit = _HeadCommitSerializer()
181 | 
182 |     def create(self, validated_data):
183 |         return validated_data
184 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/tables.py:
--------------------------------------------------------------------------------
 1 | import django_tables2 as tables
 2 | 
 3 | from .models import (
 4 |     Signature,
 5 |     EventSignature,
 6 | )
 7 | 
 8 | 
 9 | class SignatureTable(tables.Table):
10 |     bytes_signature = tables.TemplateColumn(
11 |         '<code>{{ record.bytes_signature.get_hex_display }}</code>',
12 |     )
13 | 
14 |     class Meta:
15 |         model = Signature
16 |         fields = (
17 |             'id',
18 |             'text_signature',
19 |             'bytes_signature',
20 |         )
21 |         template = 'partials/table.html'
22 |         attrs = {
23 |             'class': 'table table-striped table-bordered',
24 |         }
25 | 
26 | 
27 | class EventSignatureTable(tables.Table):
28 |     hex_signature = tables.TemplateColumn(
29 |         '<code>{{ record.get_hex_display }}</code>',
30 |     )
31 | 
32 |     class Meta:
33 |         model = EventSignature
34 |         fields = (
35 |             'id',
36 |             'text_signature',
37 |             'hex_signature',
38 |         )
39 |         template = 'partials/table.html'
40 |         attrs = {
41 |             'class': 'table table-striped table-bordered',
42 |         }
43 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/tasks.py:
--------------------------------------------------------------------------------
 1 | import logging
 2 | import sys
 3 | 
 4 | from huey.contrib.djhuey import db_task
 5 | 
 6 | from .models import (
 7 |     Signature,
 8 |     EventSignature,
 9 | )
10 | from func_sig_registry.utils.github import (
11 |     get_repository_solidity_files,
12 | )
13 | 
14 | logger = logging.getLogger('bytes4.github_import')
15 | logger.setLevel(logging.INFO)
16 | 
17 | ch = logging.StreamHandler(sys.stdout)
18 | ch.setLevel(logging.DEBUG)
19 | formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
20 | ch.setFormatter(formatter)
21 | logger.addHandler(ch)
22 | 
23 | 
24 | @db_task()
25 | def perform_github_import(login_or_name, repository, branch):
26 |     logger.info("Importing github repo %s/%s/%s", login_or_name,
27 |                 repository, branch)
28 |     for file_path in get_repository_solidity_files(login_or_name, repository, branch):
29 |         logger.info("importing solidity file: %s", file_path)
30 |         with open(file_path) as solidity_file:
31 |             try:
32 |                 Signature.import_from_solidity_file(solidity_file)
33 |                 EventSignature.import_from_solidity_file(solidity_file)
34 |             except UnicodeDecodeError:
35 |                 logger.error('unicode error reading solidity file: %s', file_path)
36 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/templates/registry/contract_abi_import.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout_full.html' %}
 2 | {% load rest_framework %}
 3 | 
 4 | 
 5 | {% block content %}
 6 |   <div class="row">
 7 |     <div class="col-md-12">
 8 |       <h2>Submit Contract ABI</h2>
 9 |       <p>Paste the contract ABI definition into the textarea.</p>
10 |       <form class="form-inline" action="{% url 'import-abi' %}" method="post" enctype="multipart/form-data">
11 |         {% if serializer_errors %}
12 |           {% include 'partials/form_errors_as_alerts.html' %}
13 |         {% endif %}
14 |         {% csrf_token %}
15 |         {% render_form serializer template_pack='rest_framework/inline' %}
16 |         <button type="submit" class="btn btn-default">Submit Contract ABI</button>
17 |       </form>
18 |     </div>
19 |   </div>
20 | {% endblock content %}
21 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/templates/registry/eventsignature_list.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout_full.html' %}
 2 | {% load render_table from django_tables2 %}
 3 | {% load rest_framework %}
 4 | 
 5 | 
 6 | {% block content %}
 7 |   <div class="row">
 8 |     <div class="col-md-12">
 9 |       <form class="form-inline" action="{% url 'event-signature-list' %}" method="get" novalidate>
10 |         <label for="bytes_signature">Search Signatures</label>
11 |         {% render_form serializer template_pack='rest_framework/inline' %}
12 |         <button type="submit" class="btn btn-default">Search</button>
13 |       </form>
14 |       {% render_table table %}
15 |     </div>
16 |   </div>
17 | {% endblock %}
18 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/templates/registry/signature_create.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout_full.html' %}
 2 | {% load rest_framework %}
 3 | 
 4 | 
 5 | {% block content %}
 6 |   <div class="row">
 7 |     <h2>Submit a Signature</h2>
 8 |     <p>Submit a new signature for the database.</p>
 9 |     <div class="col-md-12">
10 |       <form class="form-inline" action="{% url 'signature-create' %}" method="post" novalidate>
11 |         {% csrf_token %}
12 |         {% render_form serializer template_pack='rest_framework/inline' %}
13 |         <button type="submit" class="btn btn-default">Submit</button>
14 |       </form>
15 |     </div>
16 |   </div>
17 | {% endblock content %}
18 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/templates/registry/signature_list.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout_full.html' %}
 2 | {% load render_table from django_tables2 %}
 3 | {% load rest_framework %}
 4 | 
 5 | 
 6 | {% block content %}
 7 |   <div class="row">
 8 |     <div class="col-md-12">
 9 |       <form class="form-inline" action="{% url 'signature-list' %}" method="get" novalidate>
10 |         <label for="bytes4_signature">Search Signatures</label>
11 |         {% render_form serializer template_pack='rest_framework/inline' %}
12 |         <button type="submit" class="btn btn-default">Search</button>
13 |       </form>
14 |       {% render_table table %}
15 |     </div>
16 |   </div>
17 | {% endblock %}
18 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/templates/registry/solidity_source_import.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout_full.html' %}
 2 | {% load rest_framework %}
 3 | 
 4 | 
 5 | {% block content %}
 6 |   <div class="row">
 7 |     <div class="col-md-12">
 8 |       <h2>Submit Solidity Source Files</h2>
 9 |       <p>Submit solidity source files.  The database will parse out all of the function signatures.  (Hint, you can submit multiple files)</p>
10 |       <form class="form-inline" action="{% url 'import-solidity' %}" method="post" enctype="multipart/form-data">
11 |         {% csrf_token %}
12 |         {% render_form serializer template_pack='rest_framework/inline' %}
13 |         <button type="submit" class="btn btn-default">Submit</button>
14 |       </form>
15 |     </div>
16 |   </div>
17 | {% endblock content %}
18 | 


--------------------------------------------------------------------------------
/func_sig_registry/registry/views.py:
--------------------------------------------------------------------------------
  1 | from django.shortcuts import redirect
  2 | from django.contrib import messages
  3 | from django.views.generic import (
  4 |     ListView,
  5 |     TemplateView,
  6 | )
  7 | 
  8 | from rest_framework import generics
  9 | from rest_framework.response import Response
 10 | from rest_framework.renderers import TemplateHTMLRenderer
 11 | 
 12 | from django_tables2 import SingleTableView
 13 | 
 14 | from func_sig_registry.utils.encoding import (
 15 |     remove_0x_prefix,
 16 | )
 17 | from func_sig_registry.utils.import_statistics import (
 18 |     retrieve_stats_from_import_results,
 19 | )
 20 | 
 21 | from .models import (
 22 |     Signature,
 23 |     EventSignature,
 24 | )
 25 | from .tables import (
 26 |     SignatureTable,
 27 |     EventSignatureTable,
 28 | )
 29 | from .forms import (
 30 |     AllSignatureCreateForm,
 31 |     SolidityImportForm,
 32 |     SignatureSearchForm,
 33 |     EventSignatureSearchForm,
 34 |     ContractABIForm,
 35 | )
 36 | 
 37 | 
 38 | class SiteIndexView(TemplateView):
 39 |     template_name = 'home.html'
 40 | 
 41 |     def get_context_data(self, **kwargs):
 42 |         context = super(SiteIndexView, self).get_context_data(**kwargs)
 43 |         context['serializer'] = SignatureSearchForm()
 44 |         context['total_signatures'] = Signature.objects.count() + EventSignature.objects.count()
 45 |         return context
 46 | 
 47 | 
 48 | class SignatureListView(SingleTableView, ListView):
 49 |     model = Signature
 50 |     table_class = SignatureTable
 51 |     table_pagination = {
 52 |         'per_page': 10
 53 |     }
 54 | 
 55 |     def get_queryset(self):
 56 |         queryset = super(SignatureListView, self).get_queryset().select_related(
 57 |             'bytes_signature',
 58 |         )
 59 |         if self.request.GET.get('bytes4_signature'):
 60 |             hex_signature = self.request.GET['bytes4_signature']
 61 |             unprefixed_hex_signature = remove_0x_prefix(hex_signature.lower())
 62 | 
 63 |             if len(unprefixed_hex_signature) == 8:
 64 |                 return queryset.filter(
 65 |                     bytes_signature__hex_signature=unprefixed_hex_signature,
 66 |                 )
 67 |             else:
 68 |                 return queryset.filter(
 69 |                     bytes_signature__hex_signature__icontains=unprefixed_hex_signature,  # NOQA
 70 |                 )
 71 |         return queryset
 72 | 
 73 |     def get_context_data(self, **kwargs):
 74 |         context = super(SignatureListView, self).get_context_data(**kwargs)
 75 |         if self.request.GET.get('bytes4_signature'):
 76 |             serializer = SignatureSearchForm(data=self.request.GET)
 77 |             serializer.is_valid()
 78 |         else:
 79 |             serializer = SignatureSearchForm()
 80 |         context['serializer'] = serializer
 81 |         return context
 82 | 
 83 | 
 84 | class EventSignatureListView(SingleTableView, ListView):
 85 |     model = EventSignature
 86 |     table_class = EventSignatureTable
 87 |     table_pagination = {
 88 |         'per_page': 10
 89 |     }
 90 | 
 91 |     def get_queryset(self):
 92 |         queryset = super(EventSignatureListView, self).get_queryset()
 93 | 
 94 |         if self.request.GET.get('bytes_signature'):
 95 |             hex_signature = self.request.GET['bytes_signature']
 96 |             unprefixed_hex_signature = remove_0x_prefix(hex_signature.lower())
 97 | 
 98 |             if len(unprefixed_hex_signature) == 64:
 99 |                 return queryset.filter(
100 |                     hex_signature=unprefixed_hex_signature,
101 |                 )
102 |             else:
103 |                 return queryset.filter(
104 |                     hex_signature__icontains=unprefixed_hex_signature,  # NOQA
105 |                 )
106 |         return queryset
107 | 
108 |     def get_context_data(self, **kwargs):
109 |         context = super(EventSignatureListView, self).get_context_data(**kwargs)
110 |         if self.request.GET.get('bytes_signature'):
111 |             serializer = EventSignatureSearchForm(data=self.request.GET)
112 |             serializer.is_valid()
113 |         else:
114 |             serializer = EventSignatureSearchForm()
115 |         context['serializer'] = serializer
116 |         return context
117 | 
118 | 
119 | class SignatureCreateView(generics.CreateAPIView):
120 |     renderer_classes = [TemplateHTMLRenderer]
121 |     template_name = 'registry/signature_create.html'
122 |     serializer_class = AllSignatureCreateForm
123 | 
124 |     def compose_success_message(self, function_signature, event_signature):
125 |         message_parts = []
126 |         if function_signature is not None:
127 |             signature, created = function_signature
128 |             if created:
129 |                 message_parts.append('Added function signature {0}.'.format(
130 |                     signature.text_signature,
131 |                 ))
132 |         if event_signature is not None:
133 |             signature, created = event_signature
134 |             if created:
135 |                 message_parts.append('Added event signature {0}.'.format(
136 |                     signature.text_signature,
137 |                 ))
138 |         return ' '.join(message_parts)
139 | 
140 |     def compose_info_message(self, function_signature, event_signature):
141 |         message_parts = []
142 |         if function_signature is not None:
143 |             signature, created = function_signature
144 |             if not created:
145 |                 message_parts.append('Function signature {0} already exists.'.format(
146 |                     signature.text_signature,
147 |                 ))
148 |         if event_signature is not None:
149 |             signature, created = event_signature
150 |             if not created:
151 |                 message_parts.append('Event signature {0} already exists.'.format(
152 |                     signature.text_signature,
153 |                 ))
154 |         return ' '.join(message_parts)
155 | 
156 |     def any_signature_created(self, function_signature, event_signature):
157 |         function_created = (function_signature is not None) and function_signature[1]
158 |         event_created = (event_signature is not None) and event_signature[1]
159 |         return function_created or event_created
160 | 
161 |     def get(self, *args, **kwargs):
162 |         serializer = self.get_serializer()
163 |         return Response({
164 |             'serializer': serializer,
165 |         })
166 | 
167 |     def post(self, *args, **kwargs):
168 |         serializer = self.get_serializer(data=self.request.data)
169 | 
170 |         try:
171 |             if not serializer.is_valid():
172 |                 return Response({'serializer': serializer})
173 |         except ValueError as e:
174 |             messages.error(
175 |                 self.request._request,
176 |                 str(e)
177 |             )
178 |             return redirect('/submit')
179 | 
180 |         function_signature, event_signature = serializer.save()
181 | 
182 |         # Check if any signatures were created, otherwise notify the user
183 |         # about existing signatures
184 |         if self.any_signature_created(function_signature, event_signature):
185 |             messages.success(
186 |                 self.request._request,
187 |                 self.compose_success_message(function_signature, event_signature)
188 |             )
189 |         else:
190 |             messages.info(
191 |                 self.request._request,
192 |                 self.compose_info_message(function_signature, event_signature)
193 |             )
194 |         return redirect('signature-list')
195 | 
196 | 
197 | class SolidityImportView(generics.GenericAPIView):
198 |     renderer_classes = [TemplateHTMLRenderer]
199 |     template_name = 'registry/solidity_source_import.html'
200 |     serializer_class = SolidityImportForm
201 | 
202 |     def get(self, *args, **kwargs):
203 |         serializer = self.get_serializer()
204 |         return Response({
205 |             'serializer': serializer,
206 |         })
207 | 
208 |     def post(self, *args, **kwargs):
209 |         serializer = self.get_serializer(data=self.request.data)
210 |         if not serializer.is_valid():
211 |             return Response({'serializer': serializer})
212 |         results = serializer.save()
213 |         import_function_results = []
214 |         import_event_results = []
215 |         for file_obj in results['source_files']:
216 |             import_function_results.extend(Signature.import_from_solidity_file(file_obj))
217 |             import_event_results.extend(EventSignature.import_from_solidity_file(file_obj))
218 | 
219 |         stats_function = retrieve_stats_from_import_results(import_function_results)
220 |         stats_event = retrieve_stats_from_import_results(import_event_results)
221 | 
222 |         num_processed = stats_function.num_processed + stats_event.num_processed
223 |         num_imported = stats_function.num_imported + stats_event.num_imported
224 |         num_duplicates = stats_function.num_duplicates + stats_event.num_duplicates
225 |         num_ignored = stats_function.num_ignored + stats_event.num_ignored
226 | 
227 |         if num_processed == 0:
228 |             messages.info(self.request._request, "No function or event signatures found")
229 |         else:
230 |             messages.success(
231 |                 self.request._request,
232 |                 "Found {0} function and event signatures.  Imported {1}, \
233 |                     Ignored {2}, Skipped {3} duplicates.".format(
234 |                     num_processed, num_imported, num_ignored, num_duplicates,
235 |                 ),
236 |             )
237 |         return redirect('signature-list')
238 | 
239 | 
240 | class ImportContractABIView(generics.GenericAPIView):
241 |     renderer_classes = [TemplateHTMLRenderer]
242 |     template_name = 'registry/contract_abi_import.html'
243 |     serializer_class = ContractABIForm
244 | 
245 |     def get(self, *args, **kwargs):
246 |         serializer = self.get_serializer()
247 |         return Response({
248 |             'serializer': serializer,
249 |         })
250 | 
251 |     def post(self, *args, **kwargs):
252 |         serializer = self.get_serializer(data=self.request.data)
253 | 
254 |         if not serializer.is_valid():
255 |             return Response({
256 |                 'serializer': serializer,
257 |                 'serializer_errors': serializer.errors,
258 |             })
259 |         results = serializer.save()
260 | 
261 |         num_processed = results['num_processed']
262 |         num_imported = results['num_imported']
263 |         num_duplicates = results['num_duplicates']
264 |         num_ignored = results['num_ignored']
265 | 
266 |         messages.success(
267 |             self.request._request,
268 |             "Found {0} function and event signatures.  \
269 |                 Imported {1}, Ignored {2}, Skipped {3} duplicates.".format(
270 |                 num_processed, num_imported, num_ignored, num_duplicates
271 |             ),
272 |         )
273 |         return redirect('signature-list')
274 | 


--------------------------------------------------------------------------------
/func_sig_registry/settings.py:
--------------------------------------------------------------------------------
  1 | """
  2 | Django settings for func_sig_registry project.
  3 | 
  4 | Generated by 'django-admin startproject' using Django 1.9.7.
  5 | 
  6 | For more information on this file, see
  7 | https://docs.djangoproject.com/en/1.9/topics/settings/
  8 | 
  9 | For the full list of settings and their values, see
 10 | https://docs.djangoproject.com/en/1.9/ref/settings/
 11 | """
 12 | 
 13 | import os
 14 | import urllib.parse
 15 | 
 16 | import dj_database_url
 17 | import excavator as env
 18 | 
 19 | # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
 20 | BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 21 | APP_DIR = os.path.dirname(os.path.abspath(__file__))
 22 | 
 23 | 
 24 | # Quick-start development settings - unsuitable for production
 25 | # See https://docs.djangoproject.com/en/1.9/howto/deployment/checklist/
 26 | 
 27 | # SECURITY WARNING: keep the secret key used in production secret!
 28 | SECRET_KEY = env.get('DJANGO_SECRET_KEY', required=True)
 29 | 
 30 | # SECURITY WARNING: don't run with debug turned on in production!
 31 | DEBUG = env.get('DJANGO_DEBUG', type=bool, default=False)
 32 | 
 33 | ALLOWED_HOSTS = env.get('DJANGO_ALLOWED_HOSTS', type=list, required=not DEBUG)
 34 | 
 35 | SECURE_SSL_REDIRECT = env.get('DJANGO_SECURE_SSL_REDIRECT', type=bool, default=True)
 36 | 
 37 | # Application definition
 38 | 
 39 | INSTALLED_APPS = [
 40 |     'django.contrib.auth',
 41 |     'django.contrib.contenttypes',
 42 |     'django.contrib.sessions',
 43 |     'django.contrib.messages',
 44 |     'django.contrib.staticfiles',
 45 |     'django.contrib.humanize',
 46 |     'func_sig_registry.registry',
 47 |     'rest_framework',
 48 |     'django_tables2',
 49 |     'storages',
 50 |     's3_folder_storage',
 51 |     'huey.contrib.djhuey',
 52 |     'corsheaders',
 53 | ]
 54 | 
 55 | 
 56 | DJANGO_DEBUG_TOOLBAR_ENABLED = env.get(
 57 |     'DJANGO_DEBUG_TOOLBAR_ENABLED', type=bool, default=True,
 58 | )
 59 | 
 60 | if DJANGO_DEBUG_TOOLBAR_ENABLED:
 61 |     # Django Debug Toolbar
 62 |     # Provides useful tools for debugging sites either in development or
 63 |     # production.
 64 |     try:
 65 |         import debug_toolbar  # NOQA
 66 |         INSTALLED_APPS.append('debug_toolbar')
 67 |     except ImportError:
 68 |         pass
 69 | 
 70 | MIDDLEWARE_CLASSES = [
 71 |     'django.middleware.security.SecurityMiddleware',
 72 |     'django.contrib.sessions.middleware.SessionMiddleware',
 73 |     'corsheaders.middleware.CorsMiddleware',
 74 |     'django.middleware.common.CommonMiddleware',
 75 |     'django.middleware.csrf.CsrfViewMiddleware',
 76 |     'django.contrib.auth.middleware.AuthenticationMiddleware',
 77 |     'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
 78 |     'django.contrib.messages.middleware.MessageMiddleware',
 79 |     'django.middleware.clickjacking.XFrameOptionsMiddleware',
 80 |     'rollbar.contrib.django.middleware.RollbarNotifierMiddleware',
 81 | ]
 82 | 
 83 | ROOT_URLCONF = 'func_sig_registry.urls'
 84 | 
 85 | TEMPLATES = [
 86 |     {
 87 |         'BACKEND': 'django.template.backends.django.DjangoTemplates',
 88 |         'DIRS': [
 89 |             os.path.join(APP_DIR, 'templates'),
 90 |         ],
 91 |         'APP_DIRS': True,
 92 |         'OPTIONS': {
 93 |             'context_processors': [
 94 |                 'django.template.context_processors.debug',
 95 |                 'django.template.context_processors.request',
 96 |                 'django.contrib.auth.context_processors.auth',
 97 |                 'django.contrib.messages.context_processors.messages',
 98 |             ],
 99 |         },
100 |     },
101 | ]
102 | 
103 | WSGI_APPLICATION = 'func_sig_registry.wsgi.application'
104 | 
105 | 
106 | # Database
107 | # https://docs.djangoproject.com/en/1.9/ref/settings/#databases
108 | 
109 | DATABASES = {}
110 | 
111 | DATABASES['default'] = dj_database_url.config(
112 |     default='sqlite:///' + os.path.join(BASE_DIR, 'db.sqlite3')
113 | )
114 | 
115 | DATABASES['default']['ATOMIC_REQUESTS'] = env.get(
116 |     'DJANGO_ATOMIC_REQUESTS',
117 |     type=bool,
118 |     default=True,
119 | )
120 | 
121 | 
122 | # Internationalization
123 | # https://docs.djangoproject.com/en/1.9/topics/i18n/
124 | 
125 | LANGUAGE_CODE = 'en-us'
126 | 
127 | TIME_ZONE = 'UTC'
128 | 
129 | USE_I18N = True
130 | 
131 | USE_L10N = True
132 | 
133 | USE_TZ = True
134 | 
135 | 
136 | # Files
137 | # https://docs.djangoproject.com/en/1.9/topics/files/
138 | DEFAULT_FILE_STORAGE = env.get(
139 |     'DJANGO_DEFAULT_FILE_STORAGE',
140 |     type=str,
141 |     default='django.core.files.storage.FileSystemStorage',
142 | )
143 | 
144 | MEDIA_ROOT = env.get(
145 |     'DJANGO_MEDIA_ROOT',
146 |     type=str,
147 |     default=os.path.join(BASE_DIR, 'public', 'media'),
148 | )
149 | MEDIA_URL = env.get(
150 |     'DJANGO_MEDIA_URL',
151 |     type=str,
152 |     default='/media/',
153 | )
154 | 
155 | # Static files (CSS, JavaScript, Images)
156 | # https://docs.djangoproject.com/en/1.9/howto/static-files/
157 | STATICFILES_DIRS = [
158 |     os.path.join(APP_DIR, 'static'),
159 | ]
160 | 
161 | 
162 | STATIC_ROOT = env.get(
163 |     'DJANGO_STATIC_ROOT',
164 |     type=str,
165 |     default=os.path.join(BASE_DIR, 'public', 'static'),
166 | )
167 | 
168 | STATIC_URL = env.get(
169 |     'DJANGO_STATIC_URL',
170 |     type=str,
171 |     default='/static/',
172 | )
173 | 
174 | STATICFILES_FINDERS = (
175 |     'django.contrib.staticfiles.finders.FileSystemFinder',
176 |     'django.contrib.staticfiles.finders.AppDirectoriesFinder',
177 | )
178 | 
179 | STATICFILES_STORAGE = env.get(
180 |     'DJANGO_STATICFILES_STORAGE',
181 |     type=str,
182 |     default='django.contrib.staticfiles.storage.StaticFilesStorage',
183 | )
184 | 
185 | 
186 | # AWS Configuration
187 | DEFAULT_S3_PATH = "media"
188 | STATIC_S3_PATH = "static"
189 | 
190 | AWS_ACCESS_KEY_ID = env.get('AWS_ACCESS_KEY_ID', type=str, default=None)
191 | AWS_SECRET_ACCESS_KEY = env.get('AWS_SECRET_ACCESS_KEY', type=str, default=None)
192 | AWS_STORAGE_BUCKET_NAME = env.get('AWS_STORAGE_BUCKET_NAME', type=str, default=None)
193 | AWS_DEFAULT_REGION = env.get('AWS_DEFAULT_REGION', type=str, default=None)
194 | 
195 | # Boto config
196 | AWS_REDUCED_REDUNDANCY = True
197 | AWS_QUERYSTRING_AUTH = False
198 | AWS_S3_FILE_OVERWRITE = True
199 | AWS_S3_SECURE_URLS = True
200 | AWS_IS_GZIPPED = False
201 | AWS_PRELOAD_METADATA = True
202 | AWS_HEADERS = {
203 |     "Cache-Control": "public, max-age=86400",
204 | }
205 | 
206 | if AWS_DEFAULT_REGION:
207 |     # Fix for https://github.com/boto/boto/issues/621
208 |     AWS_S3_HOST = "s3-{0}.amazonaws.com".format(AWS_DEFAULT_REGION)
209 | 
210 | 
211 | # DRF
212 | REST_FRAMEWORK = {
213 |     'DEFAULT_PERMISSION_CLASSES': [
214 |         'rest_framework.permissions.AllowAny',
215 |     ],
216 |     'TEST_REQUEST_DEFAULT_FORMAT': 'json',
217 |     'DEFAULT_PAGINATION_CLASS': 'func_sig_registry.registry.pagination.PageNumberPagination',
218 |     'PAGE_SIZE': 100,
219 |     'DEFAULT_FILTER_BACKENDS': (
220 |         'rest_framework_filters.backends.DjangoFilterBackend',
221 |     ),
222 | }
223 | 
224 | 
225 | redis_url_parts = urllib.parse.urlparse(env.get('REDIS_URL'))
226 | 
227 | # HUEY
228 | HUEY = {
229 |     'name': 'func_sig_registry',
230 |     'connection': {
231 |         'host': redis_url_parts.hostname,
232 |         'port': int(redis_url_parts.port),
233 |         'password': redis_url_parts.password,
234 |     },
235 |     'consumer': {
236 |         'workers': env.get('HUEY_WORKER_COUNT', type=int, default=2),
237 |         'worker_type': env.get('HUEY_WORKER_TYPE', default='greenlet'),
238 |     },
239 | }
240 | 
241 | 
242 | # Rollbar
243 | ROLLBAR = {
244 |     'access_token': env.get('ROLLBAR_ACCESS_TOKEN', required=not DEBUG),
245 |     'environment': env.get('ROLLBAR_ENVIRONMENT', required=not DEBUG),
246 |     'branch': 'master',
247 |     'root': BASE_DIR,
248 | }
249 | 
250 | # CORS
251 | CORS_ORIGIN_ALLOW_ALL = True
252 | CORS_URLS_REGEX = r'^/api/.*$'
253 | CORS_ALLOW_METHODS = (
254 |     'GET',
255 |     'OPTIONS',
256 | )
257 | 


--------------------------------------------------------------------------------
/func_sig_registry/settings_dev.py:
--------------------------------------------------------------------------------
 1 | from .settings import *  # NOQA
 2 | 
 3 | CORS_REPLACE_HTTPS_REFERER = False
 4 | HOST_SCHEME = "http://"
 5 | SECURE_PROXY_SSL_HEADER = None
 6 | SECURE_SSL_REDIRECT = False
 7 | SESSION_COOKIE_SECURE = False
 8 | CSRF_COOKIE_SECURE = False
 9 | SECURE_HSTS_SECONDS = None
10 | SECURE_HSTS_INCLUDE_SUBDOMAINS = False
11 | SECURE_FRAME_DENY = False
12 | 


--------------------------------------------------------------------------------
/func_sig_registry/settings_test.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import getpass
 3 | 
 4 | os.environ.setdefault('DJANGO_SECRET_KEY', 'not-a-real-secret-key')
 5 | os.environ.setdefault('DJANGO_ALLOWED_HOSTS', '*')
 6 | os.environ.setdefault('DJANGO_SECURE_SSL_REDIRECT', 'False')
 7 | os.environ.setdefault('REDIS_URL', 'redis://localhost:6379')
 8 | os.environ.setdefault(
 9 |     'DATABASE_URL',
10 |     'postgres://{user}@localhost/func_sig_registry'.format(user=getpass.getuser()),
11 | )
12 | os.environ.setdefault('ROLLBAR_ACCESS_TOKEN', 'not-a-real-access-token')
13 | os.environ.setdefault('ROLLBAR_ENVIRONMENT', 'test')
14 | 
15 | from .settings import *  # NOQA
16 | 


--------------------------------------------------------------------------------
/func_sig_registry/static/css/bootstrap-theme.min.css.map:
--------------------------------------------------------------------------------
1 | {"version":3,"sources":["less/theme.less","less/mixins/vendor-prefixes.less","less/mixins/gradients.less","less/mixins/reset-filter.less"],"names":[],"mappings":";;;;AAmBA,YAAA,aAAA,UAAA,aAAA,aAAA,aAME,YAAA,EAAA,KAAA,EAAA,eC2CA,mBAAA,MAAA,EAAA,IAAA,EAAA,sBAAA,EAAA,IAAA,IAAA,iBACQ,WAAA,MAAA,EAAA,IAAA,EAAA,sBAAA,EAAA,IAAA,IAAA,iBDvCR,mBAAA,mBAAA,oBAAA,oBAAA,iBAAA,iBAAA,oBAAA,oBAAA,oBAAA,oBAAA,oBAAA,oBCsCA,mBAAA,MAAA,EAAA,IAAA,IAAA,iBACQ,WAAA,MAAA,EAAA,IAAA,IAAA,iBDlCR,qBAAA,sBAAA,sBAAA,uBAAA,mBAAA,oBAAA,sBAAA,uBAAA,sBAAA,uBAAA,sBAAA,uBAAA,+BAAA,gCAAA,6BAAA,gCAAA,gCAAA,gCCiCA,mBAAA,KACQ,WAAA,KDlDV,mBAAA,oBAAA,iBAAA,oBAAA,oBAAA,oBAuBI,YAAA,KAyCF,YAAA,YAEE,iBAAA,KAKJ,aErEI,YAAA,EAAA,IAAA,EAAA,KACA,iBAAA,iDACA,iBAAA,4CAAA,iBAAA,qEAEA,iBAAA,+CCnBF,OAAA,+GH4CA,OAAA,0DACA,kBAAA,SAuC2C,aAAA,QAA2B,aAAA,KArCtE,mBAAA,mBAEE,iBAAA,QACA,oBAAA,EAAA,MAGF,oBAAA,oBAEE,iBAAA,QACA,aAAA,QAMA,sBAAA,6BAAA,4BAAA,6BAAA,4BAAA,4BAAA,uBAAA,8BAAA,6BAAA,8BAAA,6BAAA,6BAAA,gCAAA,uCAAA,sCAAA,uCAAA,sCAAA,sCAME,iBAAA,QACA,iBAAA,KAgBN,aEtEI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDAEA,OAAA,+GCnBF,OAAA,0DH4CA,kBAAA,SACA,aAAA,QAEA,mBAAA,mBAEE,iBAAA,QACA,oBAAA,EAAA,MAGF,oBAAA,oBAEE,iBAAA,QACA,aAAA,QAMA,sBAAA,6BAAA,4BAAA,6BAAA,4BAAA,4BAAA,uBAAA,8BAAA,6BAAA,8BAAA,6BAAA,6BAAA,gCAAA,uCAAA,sCAAA,uCAAA,sCAAA,sCAME,iBAAA,QACA,iBAAA,KAiBN,aEvEI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDAEA,OAAA,+GCnBF,OAAA,0DH4CA,kBAAA,SACA,aAAA,QAEA,mBAAA,mBAEE,iBAAA,QACA,oBAAA,EAAA,MAGF,oBAAA,oBAEE,iBAAA,QACA,aAAA,QAMA,sBAAA,6BAAA,4BAAA,6BAAA,4BAAA,4BAAA,uBAAA,8BAAA,6BAAA,8BAAA,6BAAA,6BAAA,gCAAA,uCAAA,sCAAA,uCAAA,sCAAA,sCAME,iBAAA,QACA,iBAAA,KAkBN,UExEI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDAEA,OAAA,+GCnBF,OAAA,0DH4CA,kBAAA,SACA,aAAA,QAEA,gBAAA,gBAEE,iBAAA,QACA,oBAAA,EAAA,MAGF,iBAAA,iBAEE,iBAAA,QACA,aAAA,QAMA,mBAAA,0BAAA,yBAAA,0BAAA,yBAAA,yBAAA,oBAAA,2BAAA,0BAAA,2BAAA,0BAAA,0BAAA,6BAAA,oCAAA,mCAAA,oCAAA,mCAAA,mCAME,iBAAA,QACA,iBAAA,KAmBN,aEzEI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDAEA,OAAA,+GCnBF,OAAA,0DH4CA,kBAAA,SACA,aAAA,QAEA,mBAAA,mBAEE,iBAAA,QACA,oBAAA,EAAA,MAGF,oBAAA,oBAEE,iBAAA,QACA,aAAA,QAMA,sBAAA,6BAAA,4BAAA,6BAAA,4BAAA,4BAAA,uBAAA,8BAAA,6BAAA,8BAAA,6BAAA,6BAAA,gCAAA,uCAAA,sCAAA,uCAAA,sCAAA,sCAME,iBAAA,QACA,iBAAA,KAoBN,YE1EI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDAEA,OAAA,+GCnBF,OAAA,0DH4CA,kBAAA,SACA,aAAA,QAEA,kBAAA,kBAEE,iBAAA,QACA,oBAAA,EAAA,MAGF,mBAAA,mBAEE,iBAAA,QACA,aAAA,QAMA,qBAAA,4BAAA,2BAAA,4BAAA,2BAAA,2BAAA,sBAAA,6BAAA,4BAAA,6BAAA,4BAAA,4BAAA,+BAAA,sCAAA,qCAAA,sCAAA,qCAAA,qCAME,iBAAA,QACA,iBAAA,KA2BN,eAAA,WClCE,mBAAA,EAAA,IAAA,IAAA,iBACQ,WAAA,EAAA,IAAA,IAAA,iBD2CV,0BAAA,0BE3FI,iBAAA,QACA,iBAAA,oDACA,iBAAA,+CAAA,iBAAA,wEACA,iBAAA,kDACA,OAAA,+GF0FF,kBAAA,SAEF,yBAAA,+BAAA,+BEhGI,iBAAA,QACA,iBAAA,oDACA,iBAAA,+CAAA,iBAAA,wEACA,iBAAA,kDACA,OAAA,+GFgGF,kBAAA,SASF,gBE7GI,iBAAA,iDACA,iBAAA,4CACA,iBAAA,qEAAA,iBAAA,+CACA,OAAA,+GACA,OAAA,0DCnBF,kBAAA,SH+HA,cAAA,ICjEA,mBAAA,MAAA,EAAA,IAAA,EAAA,sBAAA,EAAA,IAAA,IAAA,iBACQ,WAAA,MAAA,EAAA,IAAA,EAAA,sBAAA,EAAA,IAAA,IAAA,iBD6DV,sCAAA,oCE7GI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,SD2CF,mBAAA,MAAA,EAAA,IAAA,IAAA,iBACQ,WAAA,MAAA,EAAA,IAAA,IAAA,iBD0EV,cAAA,iBAEE,YAAA,EAAA,IAAA,EAAA,sBAIF,gBEhII,iBAAA,iDACA,iBAAA,4CACA,iBAAA,qEAAA,iBAAA,+CACA,OAAA,+GACA,OAAA,0DCnBF,kBAAA,SHkJA,cAAA,IAHF,sCAAA,oCEhII,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,SD2CF,mBAAA,MAAA,EAAA,IAAA,IAAA,gBACQ,WAAA,MAAA,EAAA,IAAA,IAAA,gBDgFV,8BAAA,iCAYI,YAAA,EAAA,KAAA,EAAA,gBAKJ,qBAAA,kBAAA,mBAGE,cAAA,EAqBF,yBAfI,mDAAA,yDAAA,yDAGE,MAAA,KE7JF,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,UFqKJ,OACE,YAAA,EAAA,IAAA,EAAA,qBC3HA,mBAAA,MAAA,EAAA,IAAA,EAAA,sBAAA,EAAA,IAAA,IAAA,gBACQ,WAAA,MAAA,EAAA,IAAA,EAAA,sBAAA,EAAA,IAAA,IAAA,gBDsIV,eEtLI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,SF8KF,aAAA,QAKF,YEvLI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,SF8KF,aAAA,QAMF,eExLI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,SF8KF,aAAA,QAOF,cEzLI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,SF8KF,aAAA,QAeF,UEjMI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,SFuMJ,cE3MI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,SFwMJ,sBE5MI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,SFyMJ,mBE7MI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,SF0MJ,sBE9MI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,SF2MJ,qBE/MI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,SF+MJ,sBElLI,iBAAA,yKACA,iBAAA,oKACA,iBAAA,iKFyLJ,YACE,cAAA,IC9KA,mBAAA,EAAA,IAAA,IAAA,iBACQ,WAAA,EAAA,IAAA,IAAA,iBDgLV,wBAAA,8BAAA,8BAGE,YAAA,EAAA,KAAA,EAAA,QEnOE,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,SFiOF,aAAA,QALF,+BAAA,qCAAA,qCAQI,YAAA,KAUJ,OCnME,mBAAA,EAAA,IAAA,IAAA,gBACQ,WAAA,EAAA,IAAA,IAAA,gBD4MV,8BE5PI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,SFyPJ,8BE7PI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,SF0PJ,8BE9PI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,SF2PJ,2BE/PI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,SF4PJ,8BEhQI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,SF6PJ,6BEjQI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,SFoQJ,MExQI,iBAAA,oDACA,iBAAA,+CACA,iBAAA,wEAAA,iBAAA,kDACA,OAAA,+GACA,kBAAA,SFsQF,aAAA,QC3NA,mBAAA,MAAA,EAAA,IAAA,IAAA,gBAAA,EAAA,IAAA,EAAA,qBACQ,WAAA,MAAA,EAAA,IAAA,IAAA,gBAAA,EAAA,IAAA,EAAA"}


--------------------------------------------------------------------------------
/func_sig_registry/static/css/project.css:
--------------------------------------------------------------------------------
 1 | .alert-error {
 2 |   background-image: -webkit-linear-gradient(top, #f2dede 0%, #e7c3c3 100%);
 3 |   background-image:      -o-linear-gradient(top, #f2dede 0%, #e7c3c3 100%);
 4 |   background-image: -webkit-gradient(linear, left top, left bottom, from(#f2dede), to(#e7c3c3));
 5 |   background-image:         linear-gradient(to bottom, #f2dede 0%, #e7c3c3 100%);
 6 |   filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff2dede', endColorstr='#ffe7c3c3', GradientType=0);
 7 |   background-repeat: repeat-x;
 8 |   border-color: #dca7a7;
 9 | }
10 | 
11 | body {
12 |   display: flex;
13 |   flex-direction: column;
14 | }
15 | .main-content {
16 |   flex: 1 0 auto;
17 | }
18 | .main-footer {
19 |   flex-shrink: 0;
20 | }
21 | 
22 | .footer-item {
23 |   margin-right: 10px;
24 | }


--------------------------------------------------------------------------------
/func_sig_registry/static/fonts/glyphicons-halflings-regular.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gobitfly/ethereum-function-signature-registry/cb11e9dd5c04ae80c597d99f5d10b68a17407616/func_sig_registry/static/fonts/glyphicons-halflings-regular.eot


--------------------------------------------------------------------------------
/func_sig_registry/static/fonts/glyphicons-halflings-regular.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gobitfly/ethereum-function-signature-registry/cb11e9dd5c04ae80c597d99f5d10b68a17407616/func_sig_registry/static/fonts/glyphicons-halflings-regular.ttf


--------------------------------------------------------------------------------
/func_sig_registry/static/fonts/glyphicons-halflings-regular.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gobitfly/ethereum-function-signature-registry/cb11e9dd5c04ae80c597d99f5d10b68a17407616/func_sig_registry/static/fonts/glyphicons-halflings-regular.woff


--------------------------------------------------------------------------------
/func_sig_registry/static/fonts/glyphicons-halflings-regular.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gobitfly/ethereum-function-signature-registry/cb11e9dd5c04ae80c597d99f5d10b68a17407616/func_sig_registry/static/fonts/glyphicons-halflings-regular.woff2


--------------------------------------------------------------------------------
/func_sig_registry/static/images/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gobitfly/ethereum-function-signature-registry/cb11e9dd5c04ae80c597d99f5d10b68a17407616/func_sig_registry/static/images/favicon.ico


--------------------------------------------------------------------------------
/func_sig_registry/static/js/npm.js:
--------------------------------------------------------------------------------
 1 | // This file is autogenerated via the `commonjs` Grunt task. You can require() this file in a CommonJS environment.
 2 | require('../../js/transition.js')
 3 | require('../../js/alert.js')
 4 | require('../../js/button.js')
 5 | require('../../js/carousel.js')
 6 | require('../../js/collapse.js')
 7 | require('../../js/dropdown.js')
 8 | require('../../js/modal.js')
 9 | require('../../js/tooltip.js')
10 | require('../../js/popover.js')
11 | require('../../js/scrollspy.js')
12 | require('../../js/tab.js')
13 | require('../../js/affix.js')


--------------------------------------------------------------------------------
/func_sig_registry/templates/base.html:
--------------------------------------------------------------------------------
 1 | {% load staticfiles %}<html lang="en">
 2 |   <head>
 3 |     <title>Ethereum Signature Database</title>
 4 |     <link rel="shortcut icon" href="{% static 'images/favicon.ico' %}" type="image/x-icon">
 5 |     <link rel="icon" href="{% static 'images/favicon.ico' %}" type="image/x-icon">
 6 |     <link rel="stylesheet" href="{% static 'css/project.css' %}">
 7 |     <link rel="stylesheet" href="{% static 'css/bootstrap.min.css' %}">
 8 |     <link rel="stylesheet" href="{% static 'css/bootstrap-theme.min.css' %}">
 9 |   </head>
10 |   <body>
11 |     <nav class="navbar navbar-default">
12 |       <div class="container-fluid">
13 |         <!-- Brand and toggle get grouped for better mobile display -->
14 |         <div class="navbar-header">
15 |           <a class="navbar-brand" href="{% url 'site-index' %}">Ethereum Signature Database</a>
16 |         </div><!-- /.navbar-header -->	
17 |         <div>
18 | 					<ul class="nav navbar-nav">
19 | 						<li><a href="{% url 'signature-list' %}">Function Signatures</a></li>
20 | 						<li><a href="{% url 'event-signature-list' %}">Event Signatures</a></li>
21 | 						<li><a href="{% url 'signature-create' %}">Submit Signatures</a></li>
22 | 						<li><a href="{% url 'import-abi' %}">Submit ABI</a></li>
23 | 						<li><a href="{% url 'import-solidity' %}">Submit Solidity Source File</a></li>
24 | 					</ul>
25 |         </div><!-- /.navbar-links -->
26 |         <div class="pull-xs-right">
27 | 					<ul class="nav navbar-nav">
28 | 						<li><a href="{% url 'documentation' %}">API Docs</a></li>
29 | 					</ul>
30 |         </div><!-- /.navbar-right -->
31 |       </div><!-- /.container-fluid -->
32 |     </nav>
33 |     {% block messages %}
34 |       <div class="container">
35 |         <div class="row">
36 |           <div class="col-md-12">
37 |             {% for message in messages %}
38 |               <div class="alert alert-{{ message.tags }}" role="alert">
39 |                 {{ message }}
40 |               </div>
41 |             {% endfor %}
42 |           </div>
43 |         </div>
44 |       </div>
45 |     {% endblock messages %}
46 |     {% block body %}
47 |     {% endblock body %}
48 |   </body>
49 | </html>
50 | 


--------------------------------------------------------------------------------
/func_sig_registry/templates/documentation.html:
--------------------------------------------------------------------------------
  1 | {% extends 'layout_full.html' %}
  2 | 
  3 | 
  4 | {% block content %}
  5 |   <div class="row">
  6 |     <div class="col-md-12">
  7 |       <h1>API Documentation</h1>
  8 |       <p>The function and event signature database exposes a RESTful API that is provided free to use by anyone without restriction.</p>
  9 |       <h1>Authentication</h1>
 10 |       <p>There is no authentication necessary to access this API</p>
 11 |       <h1>Content Types</h1>
 12 |       <p>All api endpoints accept requests with the following content types unless specified otherwise.</p>
 13 |       <ul>
 14 |         <li><code>application/json</code>
 15 |         <li><code>application/x-www-form-urlencoded</code>
 16 |         <li><code>multipart/form-data</code>
 17 |       </ul>
 18 |       <h1>Github Webhook Integration</h1>
 19 |       <p>The easiest way to help populate the database is with a github webook on your repository.</p>
 20 |       <ul>
 21 |         <li>Under the <strong>Webhooks &amp; Services</strong> section in the repository settings, click the <strong>Add Webhook</strong> button.</li>
 22 |         <li>Use the url: <code>https://www.4byte.directory{% url 'api:github-webhook' %}</code>.</li>
 23 |         <li>Select the <code>application/json</code> content type.</li>
 24 |       </ul>
 25 |       <p>Once configured, after each new git push or merged pull request, the site will pull down your codebase and parse all of the solidity files for function and event signatures</p>
 26 |       <h1>Importing Source Files</h1>
 27 |       <h2>Solidity Imports <code>{% url 'api:import-solidity' %}</a></code> <span class="label label-primary">POST</span></h2>
 28 |       <p>This endpoint either solidity source files or the solidity source code itsel, parses it for function & event signatures and imports them.</p>
 29 |       <h3>Example Request for Source Import</h3>
 30 |       <pre>{
 31 |   "source_code": "contract Wallet { function withdraw() { msg.sender.send(this.balance); } }"
 32 | }</pre>
 33 |       <h3>Example Request for File Import</h3>
 34 |       <pre>$ curl -F source_file=@/path/to/some/Contract.sol https://www.4byte.directory{% url 'api:import-solidity' %}</pre>
 35 |       <h3>Example Response</h3>
 36 |       <pre>{
 37 |   "num_processed": 25,
 38 |   "num_imported": 3,
 39 |   "num_duplicates": 18,
 40 |   "num_ignored": 4
 41 | }</pre>
 42 |       <h2>Content Types</h2>
 43 |       <p>When importing files <code>multipart/form-data</code> is accepted.   Otherwise, all content types are accepted.</p>
 44 |       <h3>How to import a bunch of files</h3>
 45 |       <p>If you'd like to import many source files, you can do so with the following command line magic.</p>
 46 |       <pre>$ find /path/to/recursively/search/ -name *.sol | xargs -n 1 -I {} curl -F source_file=@{} https://www.4byte.directory{% url 'api:import-solidity' %}</pre>
 47 |       <h1>Importing from Contract ABI</h1>
 48 |       <p>You can import all of the function & event signatures from a contract by submitting the ABI</p>
 49 |       <h3>Example Request</h3>
 50 |       <pre>{
 51 |   "contract_abi": '[
 52 |     {"constant":false,"inputs":[],"name":"f","outputs":[],"type":"function"},{"inputs":[],"type":"constructor"},
 53 |     {"anonymous":false,"inputs":[{"name":"", "type":"string", "indexed":true}],"name":"E","type":"event"}
 54 |   ]'
 55 | }</pre>
 56 |       <h3>Example Response</h3>
 57 |       <pre>{
 58 |   "num_processed": 4,
 59 |   "num_imported": 2,
 60 |   "num_duplicates": 1,
 61 |   "num_ignored": 1
 62 | }</pre>
 63 |       <h1>Signatures</h1>
 64 |       <p>The primary data model exposed by the API is the <code>Signature</code>.  Each signature is a mapping between the human readable function signature and the 4-byte function selector used by the EVM.  See the official <a href="https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI#function-selector" target="_blank">Ethereum Contract ABI documentation</a> for more information.</p>
 65 |       <p>Each signature object returned from the API has the following fields.</p>
 66 |       <ul>
 67 |         <li><code>id</code> (integer): The primary key of the signature.</li>
 68 |         <li><code>text_signature</code> (string): The text representation of the function signature.</li>
 69 |         <li><code>bytes_signature</code> (string): The 4-byte function selector</li>
 70 |         <li><code>hex_signature</code> (string): The hex encoded 4-byte function selector.</li>
 71 |       </ul>
 72 |       <pre>{
 73 |   "id": 1,
 74 |   "text_signature": "balanceOf(address)",
 75 |   "bytes_signature": "r'\x13\xf7",
 76 |   "hex_signature": "0x722713f7",
 77 | }</pre>
 78 |       <h2>Listing Signatures <code><a href="{% url 'api:signature-list' %}">{% url 'api:signature-list' %}</a></code> <span class="label label-primary">GET</span></h2>
 79 |       <p>Returns a paginated list of signatures.</p>
 80 |       <h3>Example Response</h4>
 81 |       <pre>{
 82 |   "next": "/api/v1/signatures/?page=2",
 83 |   "previous": null,
 84 |   "count": 100,
 85 |   "results": [
 86 |     { 
 87 |       "id": 1,
 88 |       "text_signature": "balanceOf(address)",
 89 |       "bytes_signature": "r'\x13\xf7",
 90 |       "hex_signature": "0x722713f7",
 91 |     },
 92 |     ...
 93 |   ]
 94 | }</pre>
 95 |       <h3>Response Status Codes</h4>
 96 |       <ul>
 97 |         <li><code>200</code> Success</li>
 98 |       </ul>
 99 |       <h3>Filtering Results</h3>
100 |       <p>The following options are available for filtering the results</p>
101 |       <h4>Filtering on <code>text_signature</code></h4>
102 |       <blockquote><code>/api/v1/signatures/?text_signature=balanceOf()</code></blockquote>
103 |       <p>Exact match on the <code>text_signature</code> field.</p>
104 |       <blockquote><code>/api/v1/signatures/?text_signature__iexact</code></blockquote>
105 |       <p>Case insensitive exact match on the <code>text_signature</code> field.</p>
106 |       <blockquote><code>/api/v1/signatures/?text_signature__contains</code></blockquote>
107 |       <p>Substring match on the <code>text_signature</code> field.</p>
108 |       <blockquote><code>/api/v1/signatures/?text_signature__icontains</code></blockquote>
109 |       <p>Case insensitive substring match on the <code>text_signature</code> field.</p>
110 |       <blockquote><code>/api/v1/signatures/?text_signature__startswith</code></blockquote>
111 |       <p>Matches on beginning of the <code>text_signature</code> field.</p>
112 |       <blockquote><code>/api/v1/signatures/?text_signature__istartswith</code></blockquote>
113 |       <p>Case insensitive match on beginning of the <code>text_signature</code> field.</p>
114 |       <blockquote><code>/api/v1/signatures/?text_signature__endswith</code></blockquote>
115 |       <p>Matches on end of the <code>text_signature</code> field.</p>
116 |       <blockquote><code>/api/v1/signatures/?text_signature__iendswith</code></blockquote>
117 |       <p>Case insensitive match on end of the <code>text_signature</code> field.</p>
118 |       <h4>Filtering on <code>hex_signature</code></h4>
119 |       <p>Filters the results base on the <code>hex_signature</code> field.</p>
120 |       <blockquote><code>/api/v1/signatures/?hex_signature=0xabcd1234</code></blockquote>
121 |       <div class="alert alert-info" role="alert">
122 |         <p>The <code>0x</code> prefix on the query value is optional.</p>
123 |       </div>
124 |       <p>
125 |       <ul>
126 |         <li>If the provided query is exactly 4 bytes long then results are filtered by exact match.</li>
127 |         <li>If the provided query is less than 4 bytes long then the results are filtered by substring match.</li>
128 |         <li>If the provided query is longer than 4 bytes then the results are not filtered since it is an invalid query.</li>
129 |       </ul>
130 |       <h2>Creating Signatures <code>/api/v1/signatures/</code> <span class="label label-primary">POST</span></h2>
131 |       <p>Creates a new signature</p>
132 |       <h3>Example Request</h3>
133 |       <pre>{
134 |       "text_signature": "balanceOf(address)"
135 | }</pre>
136 |       <h3>Response Status Codes</h4>
137 |       <ul>
138 |         <li><code>200</code> Success</li>
139 |         <li><code>400</code> Error</li>
140 |       </ul>
141 |       <h4>Example Success Response</h3>
142 |       <p>On success, the serialized record will be returned</p>
143 |       <pre>{
144 |   "id": 1,
145 |   "text_signature": "balanceOf(address)",
146 |   "bytes_signature": "r'\x13\xf7",
147 |   "hex_signature": "0x722713f7",
148 | }</pre>
149 |       <h3>Accepted Formats for <code>text_signature</code></h3>
150 |       <p>Function signatures are <strong>normalized</strong> during creation.  The normalization process can handle a wide array of input formats.  Any of the following will normalize to <code>transfer(address,uint256)</code></p>
151 |       <ul>
152 |         <li></code>function transfer(address _to, uint _value)</code></li>
153 |         <li></code>function transfer(address _to, uint256 _value)</code></li>
154 |         <li></code>transfer(address _to, uint256 _value)</code></li>
155 |         <li></code>transfer(address _to, uint _value)</code></li>
156 |         <li></code>transfer(address, uint)</code></li>
157 |         <li></code>transfer(address, uint256)</code></li>
158 |         <li></code>transfer ( address, uint256 )</code></li>
159 |         <li></code>transfer ( address, uint256 )</code></li>
160 |       </ul>
161 |       <h3>Example Error Response</h3>
162 |       <p>When an error occurs, the response will be an object with keys mapping to arrays of error messages.  A <code>400</code> response will be returned if the signature is already present, or if the format of the signature could not be recognized.</p>
163 |       <pre>{
164 |       "text_signature": ["Unknown signature format"]
165 | }</pre>
166 |       <h2>Retrieving Signatures <code>/api/v1/signatures/:id/</code> <span class="label label-primary">GET</span></h2>
167 |       <p>You can retrieve an individual signature using this endpoint.</p>
168 |       <h3>Response Status Codes</h4>
169 |       <ul>
170 |         <li><code>200</code> Success</li>
171 |         <li><code>404</code> Not Found</li>
172 |       </ul>
173 |       <h4>Example Success Response</h3>
174 |       <p>On success, the serialized record will be returned</p>
175 |       <pre>{
176 |   "id": 1,
177 |   "text_signature": "balanceOf(address)",
178 |   "bytes_signature": "r'\x13\xf7",
179 |   "hex_signature": "0x722713f7",
180 | }</pre>
181 |     <h1>Event Signatures</h1>
182 |     <p>The API also exposes the signatures for events which are represented under the data model <code>Event Signature</code>.  Each signature is a mapping between the human readable event signature and the 32-byte event selector used by the EVM.  See the official <a href="https://solidity.readthedocs.io/en/develop/abi-spec.html" target="_blank">Ethereum Contract ABI documentation</a> for more information.</p>
183 |     <p>Each event signature object returned from the API has the following fields.</p>
184 |     <ul>
185 |       <li><code>id</code> (integer): The primary key of the event signature.</li>
186 |       <li><code>text_signature</code> (string): The text representation of the event signature.</li>
187 |       <li><code>bytes_signature</code> (string): The 32-byte event selector</li>
188 |       <li><code>hex_signature</code> (string): The hex encoded 32-byte event selector.</li>
189 |     </ul>  
190 | <pre>{
191 |   "id": 19,
192 |   "created_at": "2020-09-13T18:45:58.559831Z",
193 |   "text_signature": "RequestCreated(address,address,int256,uint256[12])",
194 |   "hex_signature": "0x15aac4af776447c09d895192c86bab463c38b92191f3ba3f7b8831723c548d6e",
195 |   "bytes_signature": "r'\x15\xaa\xc4\xafwdG\xc0\x9d\x89Q\x92\xc8k\xabF18\xb9!\x91\xf3\xba?{\x881r1T\x8dn"
196 | }</pre>
197 |     <h2>Listing Event Signatures <code><a href="{% url 'api:eventsignature-list' %}">{% url 'api:eventsignature-list' %}</a></code> <span class="label label-primary">GET</span></h2>
198 |     <p>Returns a paginated list of event signatures.</p>
199 | <pre>{
200 |   "next": "/api/v1/event-signatures/?page=2",
201 |   "previous": null,
202 |   "count": 100,
203 |   "results": [
204 |     {
205 |       "id": 1,
206 |       "created_at": "2020-09-13T18:45:58.559831Z",
207 |       "text_signature": "RequestCreated(address,address,int256,uint256[12])",
208 |       "hex_signature": "0x15aac4af776447c09d895192c86bab463c38b92191f3ba3f7b8831723c548d6e",
209 |       "bytes_signature": "r'\x15\xaa\xc4\xafwdG\xc0\x9d\x89Q\x92\xc8k\xabF18\xb9!\x91\xf3\xba?{\x881r1T\x8dn"
210 |     },
211 |     ...
212 |   ]
213 | }</pre>
214 | <h3>Response Status Codes</h4>
215 | <ul>
216 |   <li><code>200</code> Success</li>
217 | </ul>
218 | <h3>Filtering Results</h3>
219 | <p>Filtering results are done similarly to filtering <strong>function</strong> <code>Signature</code> results</p>
220 | <h2>Creating Event Signatures <code>/api/v1/event-signatures/</code> <span class="label label-primary">POST</span></h2>
221 | <p>Creates a new event signature</p>
222 |       <h3>Example Request</h3>
223 | <pre>{
224 |   "text_signature": "MyEvent(address,uint)"
225 | }</pre>
226 |       <h3>Response Status Codes</h4>
227 |       <ul>
228 |         <li><code>200</code> Success</li>
229 |         <li><code>400</code> Error</li>
230 |       </ul>
231 |       <h4>Example Success Response</h3>
232 |       <p>On success, the serialized record will be returned</p>
233 | <pre>{
234 |   "id": 1,
235 |   "created_at": "2020-09-13T18:45:58.559831Z",
236 |   "text_signature": "RequestCreated(address,address,int256,uint256[12])",
237 |   "hex_signature": "0x15aac4af776447c09d895192c86bab463c38b92191f3ba3f7b8831723c548d6e",
238 |   "bytes_signature": "r'\x15\xaa\xc4\xafwdG\xc0\x9d\x89Q\x92\xc8k\xabF18\xb9!\x91\xf3\xba?{\x881r1T\x8dn"
239 | }</pre>
240 |       <h3>Accepted Formats for <code>text_signature</code></h3>
241 |       <p>Event signatures are <strong>normalized</strong> during creation.  The normalization process can handle a wide array of input formats.  Any of the following will normalize to <code>transfer(address,uint256)</code></p>
242 |       <ul>
243 |         <li></code>event transfer(address _to, uint _value)</code></li>
244 |         <li></code>event transfer(address _to, uint256 _value)</code></li>
245 |         <li></code>transfer(address indexed _to, uint256 _value)</code></li>
246 |         <li></code>transfer(address _to, uint _value)</code></li>
247 |         <li></code>transfer(address, uint)</code></li>
248 |         <li></code>transfer(address, uint256)</code></li>
249 |         <li></code>transfer ( address, uint256 )</code></li>
250 |         <li></code>transfer ( address indexed, uint256 ) anonymous</code></li>
251 |       </ul>
252 |       <h3>Example Error Response</h3>
253 |       <p>When an error occurs, the response will be an object with keys mapping to arrays of error messages.  A <code>400</code> response will be returned if the signature is already present, or if the format of the event signature could not be recognized.</p>
254 | <pre>{
255 |   "text_signature": ["Unknown signature format"]
256 | }</pre>
257 | <h2>Retrieving Event Signatures <code>/api/v1/event-signatures/:id/</code> <span class="label label-primary">GET</span></h2>
258 |       <p>You can retrieve an individual event signature using this endpoint.</p>
259 |       <h3>Response Status Codes</h4>
260 |       <ul>
261 |         <li><code>200</code> Success</li>
262 |         <li><code>404</code> Not Found</li>
263 |       </ul>
264 |       <h4>Example Success Response</h3>
265 |       <p>On success, the serialized record will be returned</p>
266 | <pre>{
267 |   "id": 1,
268 |   "created_at": "2020-09-13T18:45:58.559831Z",
269 |   "text_signature": "RequestCreated(address,address,int256,uint256[12])",
270 |   "hex_signature": "0x15aac4af776447c09d895192c86bab463c38b92191f3ba3f7b8831723c548d6e",
271 |   "bytes_signature": "r'\x15\xaa\xc4\xafwdG\xc0\x9d\x89Q\x92\xc8k\xabF18\xb9!\x91\xf3\xba?{\x881r1T\x8dn"
272 | }</pre>
273 | 
274 | </div>
275 |   </div>
276 | {% endblock %}
277 | 


--------------------------------------------------------------------------------
/func_sig_registry/templates/home.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout_full.html' %}
 2 | {% load rest_framework humanize %}
 3 | 
 4 | 
 5 | {% block content %}
 6 |   <div class="row">
 7 |     <div class="col-md-12">
 8 |       <div class="jumbotron">
 9 |         <h1 class="display-3">Welcome to the Ethereum Signature Database</h1>
10 |         <p class="lead">Function calls in the Ethereum Virtual Machine are specified by the first four bytes of data sent with a transaction.  These 4-byte signatures are defined as the first four bytes of the Keccak hash (SHA3) of the canonical representation of the function signature. The database also contains mappings for event signatures. Unlike function signatures, they are defined as 32-bytes of the Keccak hash (SHA3) of the canonical form of the event signature. Since this is a one-way operation, it is not possible to derive the human-readable representation of the function or event from the bytes signature.  This database is meant to allow mapping those bytes signatures back to their human-readable versions.</p>
11 |         <h2>There are {{ total_signatures|intcomma }} signatures in the database</h2>
12 |         <hr class="m-y-2">
13 |         <p class="lead">
14 |           <form class="form-inline" action="{% url 'signature-list' %}" method="get" novalidate>
15 |             <label for="bytes4_signature">Search Signatures</label>
16 |             {% render_form serializer template_pack='rest_framework/inline' %}
17 |             <button type="submit" class="btn btn-default">Search</button>
18 |           </form>
19 |         </p>
20 |       </div>
21 |     </div>
22 |   </div>
23 |   <div class="row">
24 |     <div class="col-md-12">
25 |         <h2 class="display-3">TOS and Licensing</h2>
26 |         <p>The data from this service is given free of any license or restrictions on how it may be used.</p>
27 |         <p>Usage of the API is also granted with the single restriction that your usage should not disrupt the service itself.  If you wish to scrape this data, feel free, but please do so with limited concurrency.  You are encouraged to scrape your own copy of this data if your use case is likely to produce heavy load on the API.</p>
28 |       </div>
29 |     </div>
30 |   </div>
31 | {% endblock %}
32 | 


--------------------------------------------------------------------------------
/func_sig_registry/templates/layout_full.html:
--------------------------------------------------------------------------------
 1 | {% extends 'base.html' %}
 2 | 
 3 | {% block body %}
 4 |   <div class="container main-content">
 5 |     {% block content %}
 6 |     {% endblock content %}
 7 |   </div>
 8 |   {% include 'partials/main_footer.html' %}
 9 | {% endblock body %}
10 | 


--------------------------------------------------------------------------------
/func_sig_registry/templates/partials/file_input.html:
--------------------------------------------------------------------------------
 1 | <div class="form-group {% if field.errors %}has-error{% endif %}">
 2 |   {% if field.label %}
 3 |     <label class="sr-only">
 4 |       {{ field.label }}
 5 |     </label>
 6 |   {% endif %}
 7 | 
 8 |   <input name="{{ field.name }}" {% if style.input_type != "file" %}class="form-control"{% endif %} type="{{ style.input_type }}" {% if style.placeholder %}placeholder="{{ style.placeholder }}"{% endif %} {% if field.value %}value="{{ field.value }}"{% endif %}{% if style.multiple %} multiple{% endif %}>
 9 | </div>
10 | 


--------------------------------------------------------------------------------
/func_sig_registry/templates/partials/form_errors_as_alerts.html:
--------------------------------------------------------------------------------
1 | {% for key, errors in serializer_errors.items %}
2 |   {% for error in errors %}
3 |     <div class="alert alert-danger" role="alert">
4 |       {{ key }}: {{ error }}
5 |     </div>
6 |   {% endfor %}
7 | {% endfor %}
8 | 


--------------------------------------------------------------------------------
/func_sig_registry/templates/partials/main_footer.html:
--------------------------------------------------------------------------------
1 | <div class="main-footer panel-footer text-right">
2 |   <a class="footer-item" href="https://github.com/gobitfly/ethereum-function-signature-registry">Github Project Page</a>
3 |   <a class="footer-item" href="https://github.com/gobitfly/ethereum-function-signature-registry/issues/new">File an issue</a>
4 |   <span class="footer-item">with ♥ by <a target="_blank" href="https://beaconcha.in/">beaconcha.in</a></span>
5 | </div>
6 | 


--------------------------------------------------------------------------------
/func_sig_registry/templates/partials/pagination.html:
--------------------------------------------------------------------------------
 1 | {% load django_tables2 %}
 2 | 
 3 | 
 4 | {% if page_obj.has_other_pages %}
 5 |     <nav>
 6 |         <ul class="pagination">
 7 |             {% if page_obj.has_previous %}
 8 |                 <li><a href="{% querystring "page"=page_obj.previous_page_number %}" aria-label="Previous"><span aria-hidden="true">&laquo;</span> Prev</a></li>
 9 |                 <li><a href="{% querystring "page"=page_obj.previous_page_number %}">{{ page_obj.previous_page_number }}</a></li>
10 |             {% endif %}
11 | 
12 |             <li class="active"><a href="{% querystring "page"=page_obj.number %}">{{ page_obj.number }}</a></li>
13 | 
14 |             {% if page_obj.has_next %}
15 |                 <li><a href="{% querystring "page"=page_obj.next_page_number %}">{{ page_obj.next_page_number }}</a></li>
16 |                 <li><a href="{% querystring "page"=page_obj.next_page_number %}" aria-label="Next">Next <span aria-hidden="true">&raquo;</span></a></li>
17 |             {% endif %}
18 |         </ul>
19 |     </nav>
20 | {% endif %}
21 | 


--------------------------------------------------------------------------------
/func_sig_registry/templates/partials/table.html:
--------------------------------------------------------------------------------
 1 | {% extends 'django_tables2/table.html' %}
 2 | {% load django_tables2 %}
 3 | 
 4 | 
 5 | {% block pagination %}
 6 |     {% with page_obj=table.page paginator=table.paginator %}
 7 |         {% include "partials/pagination.html" %}
 8 |     {% endwith %}
 9 | {% endblock pagination %}
10 | 


--------------------------------------------------------------------------------
/func_sig_registry/urls.py:
--------------------------------------------------------------------------------
 1 | """func_sig_registry URL Configuration
 2 | 
 3 | The `urlpatterns` list routes URLs to views. For more information please see:
 4 |     https://docs.djangoproject.com/en/1.9/topics/http/urls/
 5 | Examples:
 6 | Function views
 7 |     1. Add an import:  from my_app import views
 8 |     2. Add a URL to urlpatterns:  url(r'^$', views.home, name='home')
 9 | Class-based views
10 |     1. Add an import:  from other_app.views import Home
11 |     2. Add a URL to urlpatterns:  url(r'^$', Home.as_view(), name='home')
12 | Including another URLconf
13 |     1. Import the include() function: from django.conf.urls import url, include
14 |     2. Add a URL to urlpatterns:  url(r'^blog/', include('blog.urls'))
15 | """
16 | import os
17 | from django.conf.urls import (
18 |     url,
19 |     include,
20 | )
21 | from django.views.generic import TemplateView
22 | 
23 | from func_sig_registry.registry.views import (
24 |     SiteIndexView,
25 |     SignatureListView,
26 |     SignatureCreateView,
27 |     SolidityImportView,
28 |     ImportContractABIView,
29 |     EventSignatureListView,
30 | )
31 | 
32 | 
33 | def lets_encrypt(request):
34 |     from django.http import HttpResponse
35 |     return HttpResponse(os.environ.get('LETS_ENCRYPT_SECRET', ''))
36 | 
37 | 
38 | urlpatterns = [
39 |     url(r'^$', SiteIndexView.as_view(), name='site-index'),
40 |     url(r'^signatures/$', SignatureListView.as_view(), name='signature-list'),
41 |     url(r'^event-signatures/$', EventSignatureListView.as_view(), name='event-signature-list'),
42 |     url(r'^submit/$', SignatureCreateView.as_view(), name='signature-create'),
43 |     url(r'^import-solidity/$', SolidityImportView.as_view(), name='import-solidity'),
44 |     url(r'^import-abi/$', ImportContractABIView.as_view(), name='import-abi'),
45 |     url(
46 |         r'^docs/$',
47 |         TemplateView.as_view(template_name='documentation.html'),
48 |         name='documentation',
49 |     ),
50 | 
51 |     # API
52 |     url(r'^api/v1/', include('func_sig_registry.api_urls', namespace='api')),
53 |     url(
54 |         r'^\.well-known/acme-challenge/{0}$'.format(
55 |             os.environ.get('LETS_ENCRYPT_SECRET_PATH'),
56 |         ),
57 |         lets_encrypt,
58 |     ),
59 | ]
60 | 


--------------------------------------------------------------------------------
/func_sig_registry/utils/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gobitfly/ethereum-function-signature-registry/cb11e9dd5c04ae80c597d99f5d10b68a17407616/func_sig_registry/utils/__init__.py


--------------------------------------------------------------------------------
/func_sig_registry/utils/abi.py:
--------------------------------------------------------------------------------
  1 | from typing import (
  2 |     Any,
  3 |     Dict,
  4 | )
  5 | 
  6 | from eth_utils.abi import (
  7 |     collapse_if_tuple,
  8 | )
  9 | from jsonschema import (
 10 |     validate,
 11 |     ValidationError,
 12 | )
 13 | from sha3 import (
 14 |     keccak_256,
 15 | )
 16 | 
 17 | 
 18 | # sanity check we are using the right sha3 function
 19 | assert keccak_256(b'').hexdigest() == 'c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470', keccak_256(b'').hexdigest()  # NOQA
 20 | 
 21 | 
 22 | def make_4byte_signature(text_signature):
 23 |     from .encoding import force_bytes
 24 |     return keccak_256(force_bytes(text_signature)).digest()[:4]
 25 | 
 26 | 
 27 | ARGUMENT_SCHEMA = {
 28 |     'type': 'object',
 29 |     'properties': {
 30 |         'name': {
 31 |             'type': 'string',
 32 |         },
 33 |         'type': {
 34 |             'type': 'string',
 35 |         },
 36 |         'components': {
 37 |             'type': 'array',
 38 |             'items': {'$ref': '#/definitions/argument'},
 39 |         },
 40 |     },
 41 |     'required': ['name', 'type'],
 42 | }
 43 | 
 44 | 
 45 | NAME = {'type': 'string'}
 46 | BOOLEAN = {'type': 'boolean'}
 47 | INPUTS = OUTPUTS = {'type': 'array', 'items': {'$ref': '#/definitions/argument'}}
 48 | EVENT_TYPE = {'type': 'string', 'enum': ['event']}
 49 | CONSTRUCTOR_TYPE = {'type': 'string', 'enum': ['constructor']}
 50 | 
 51 | EVENT_ARGUMENT_SCHEMA = {
 52 |     'type': 'object',
 53 |     'properties': {
 54 |         'name': NAME,
 55 |         'type': NAME,
 56 |         'indexed': BOOLEAN,
 57 |     },
 58 |     'required': ['name', 'type', 'indexed'],
 59 | }
 60 | 
 61 | FUNCTION_SCHEMA = {
 62 |     'type': 'object',
 63 |     'properties': {
 64 |         'type': {'type': 'string', 'enum': ['function', 'receive']},
 65 |         'inputs': INPUTS,
 66 |         'outputs': OUTPUTS,
 67 |         'name': NAME,
 68 |         'stateMutability': {'type': 'string', 'enum': ['pure', 'view', 'nonpayable', 'payable']},
 69 |     },
 70 |     'required': ['type', 'inputs', 'outputs', 'name'],
 71 |     'definitions': {
 72 |         'argument': ARGUMENT_SCHEMA,
 73 |     },
 74 | }
 75 | 
 76 | FALLBACK_SCHEMA = {
 77 |     'type': 'object',
 78 |     'properties': {
 79 |         'type': {'type': 'string', 'enum': ['fallback']},
 80 |         'stateMutability': {'type': 'string', 'enum': ['pure', 'view', 'nonpayable', 'payable']},
 81 |     },
 82 |     'required': ['type'],
 83 |     'definitions': {
 84 |         'argument': ARGUMENT_SCHEMA,
 85 |     },
 86 | }
 87 | 
 88 | EVENT_SCHEMA = {
 89 |     'type': 'object',
 90 |     'properties': {
 91 |         'anonymous': BOOLEAN,
 92 |         'type': {'type': 'string', 'enum': ['event']},
 93 |         'inputs': {
 94 |             'type': 'array',
 95 |             'items': EVENT_ARGUMENT_SCHEMA,
 96 |         },
 97 |         'name': NAME,
 98 |     },
 99 |     'required': ['type', 'inputs', 'name'],
100 | }
101 | 
102 | CONSTRUCTOR_SCHEMA = {
103 |     'type': 'object',
104 |     'properties': {
105 |         'type': {'type': 'string', 'enum': ['constructor']},
106 |         'inputs': INPUTS,
107 |         'stateMutability': {'type': 'string', 'enum': ['pure', 'view', 'nonpayable', 'payable']},
108 |     },
109 |     'required': ['type', 'inputs'],
110 |     'definitions': {
111 |         'argument': ARGUMENT_SCHEMA,
112 |     },
113 | }
114 | 
115 | CONTRACT_ABI_SCHEMA = {
116 |     'type': 'array',
117 |     'items': {
118 |         'anyOf': [
119 |             {'$ref': '#/definitions/fallback'},
120 |             {'$ref': '#/definitions/function'},
121 |             {'$ref': '#/definitions/event'},
122 |             {'$ref': '#/definitions/constructor'},
123 |         ],
124 |     },
125 |     'definitions': {
126 |         'function': FUNCTION_SCHEMA,
127 |         'event': EVENT_SCHEMA,
128 |         'constructor': CONSTRUCTOR_SCHEMA,
129 |         'argument': ARGUMENT_SCHEMA,
130 |         'fallback': FALLBACK_SCHEMA,
131 |     }
132 | }
133 | 
134 | 
135 | def validate_contract_abi(contract_abi):
136 |     validate(contract_abi, CONTRACT_ABI_SCHEMA)
137 | 
138 | 
139 | def is_valid_contract_abi(contract_abi):
140 |     try:
141 |         validate_contract_abi(contract_abi)
142 |     except ValidationError:
143 |         return False
144 |     else:
145 |         return True
146 | 
147 | 
148 | def function_definition_to_text_signature(abi: Dict[str, Any]) -> str:
149 |     return '{fn_name}({fn_input_types})'.format(
150 |         fn_name=abi['name'],
151 |         fn_input_types=','.join(
152 |             [collapse_if_tuple(abi_input) for abi_input in abi.get('inputs', [])]
153 |         ),
154 |     )
155 | 
156 | 
157 | def event_definition_to_text_signature(abi: Dict[str, Any]) -> str:
158 |     return '{fn_name}({fn_input_types})'.format(
159 |         fn_name=abi['name'],
160 |         fn_input_types=','.join(
161 |             [f"{collapse_if_tuple(abi_input)}{' indexed' if abi_input['indexed'] else ''}"
162 |                 for abi_input in abi.get('inputs', [])]
163 |         ),
164 |     )
165 | 


--------------------------------------------------------------------------------
/func_sig_registry/utils/encoding.py:
--------------------------------------------------------------------------------
 1 | import codecs
 2 | 
 3 | 
 4 | def force_bytes(value):
 5 |     if isinstance(value, bytes):
 6 |         return value
 7 |     elif isinstance(value, memoryview):
 8 |         return bytes(value)
 9 |     elif isinstance(value, str):
10 |         return bytes(value, 'utf8')
11 |     else:
12 |         raise TypeError("Unsupported type: {0}".format(type(value)))
13 | 
14 | 
15 | def force_text(value):
16 |     if isinstance(value, str):
17 |         return value
18 |     elif isinstance(value, bytes):
19 |         return str(value, 'latin1')
20 |     elif isinstance(value, memoryview):
21 |         return str(bytes(value), 'latin1')
22 |     else:
23 |         raise TypeError("Unsupported type: {0}".format(type(value)))
24 | 
25 | 
26 | def remove_0x_prefix(value):
27 |     if force_bytes(value).startswith(b'0x'):
28 |         return value[2:]
29 |     return value
30 | 
31 | 
32 | def add_0x_prefix(value):
33 |     if force_bytes(value).startswith(b'0x'):
34 |         return force_bytes(value)
35 |     return b'0x' + force_bytes(value)
36 | 
37 | 
38 | def encode_hex(value):
39 |     return b'0x' + codecs.encode(force_bytes(value), 'hex')
40 | 
41 | 
42 | def decode_hex(value):
43 |     return codecs.decode(remove_0x_prefix(force_bytes(value)), 'hex')
44 | 


--------------------------------------------------------------------------------
/func_sig_registry/utils/events_solidity.py:
--------------------------------------------------------------------------------
  1 | import itertools
  2 | import re
  3 | 
  4 | from eth_abi.exceptions import (
  5 |     ParseError,
  6 |     ABITypeError,
  7 | )
  8 | from eth_abi.grammar import (
  9 |     parse as parse_type,
 10 |     normalize as normalize_type,
 11 | )
 12 | 
 13 | from func_sig_registry.utils.solidity import (
 14 |     get_arg_types,
 15 |     validate_standard_type,
 16 | )
 17 | 
 18 | DYNAMIC_TYPES = ['bytes', 'string']
 19 | 
 20 | STATIC_TYPE_ALIASES = [
 21 |     'uint',
 22 |     'int',
 23 |     'ufixed',
 24 |     'fixed',
 25 |     'byte',
 26 | ]
 27 | 
 28 | BITS_REGEX = r'(?:{})'.format('|'.join(str(i) for i in range(8, 257, 8)))
 29 | PLACES_REGEX = r'(?:{})'.format('|'.join(str(i) for i in range(1, 81)))
 30 | 
 31 | STATIC_TYPES = [
 32 |     'uint{0}'.format(BITS_REGEX),
 33 |     'int{0}'.format(BITS_REGEX),
 34 |     'address',
 35 |     'bool',
 36 |     'fixed{0}x{1}'.format(BITS_REGEX, PLACES_REGEX),
 37 |     'ufixed{0}x{1}'.format(BITS_REGEX, PLACES_REGEX),
 38 | ] + ['bytes{0}'.format(i) for i in range(1, 33)]
 39 | 
 40 | TYPE_REGEX = '|'.join((
 41 |     _type + r'(?![a-z0-9])'
 42 |     for _type
 43 |     in itertools.chain(STATIC_TYPES, STATIC_TYPE_ALIASES, DYNAMIC_TYPES)
 44 | ))
 45 | 
 46 | NAME_REGEX = (
 47 |     r'[a-zA-Z_]'
 48 |     r'[a-zA-Z0-9_]*'
 49 | )
 50 | 
 51 | SUB_TYPE_REGEX = (
 52 |     r'\['
 53 |     r'[0-9]*'
 54 |     r'\]'
 55 | )
 56 | 
 57 | EVENT_ARGUMENT_REGEX = (
 58 |     r'(?:{type})'
 59 |     r'(?:(?:{sub_type})*)?'
 60 |     r'(?:\s+indexed)?'
 61 |     r'\s+'
 62 |     '{name}'
 63 | ).format(
 64 |     type=TYPE_REGEX,
 65 |     sub_type=SUB_TYPE_REGEX,
 66 |     name=NAME_REGEX,
 67 | )
 68 | 
 69 | RAW_EVENT_RE = re.compile(r"""
 70 | event                             # leading "event" keyword
 71 | \s+
 72 | {name}                            # event name
 73 | \s*
 74 | \(                                # opening paren before arg list
 75 |     \s*
 76 |     (?:
 77 |         {arg}                     # first arg in arg list
 78 |         (?:
 79 |             (?:\s*,\s*{arg}\s*)*  # other args in arg list
 80 |         )?
 81 |         (?:,)?                    # optional trailing comma in arg list
 82 |     )?                            # optional arg list
 83 |     \s*
 84 | \)                                # closing paren after arg list
 85 | (?:\s*anonymous)?                 # optional anonymous
 86 | """.format(name=NAME_REGEX, arg=EVENT_ARGUMENT_REGEX), re.VERBOSE)
 87 | 
 88 | 
 89 | def extract_event_signatures(code):
 90 |     """
 91 |     Given a string of solidity code, extract all of the event declarations,
 92 |     including anonymous
 93 |     """
 94 |     matches = RAW_EVENT_RE.findall(code)
 95 |     return matches or []
 96 | 
 97 | 
 98 | EVENT_PARTS_RE = re.compile(r"""
 99 | ^
100 | \s*
101 | (?:event\s+)?                     # optional leading "event" keyword
102 | (?P<et_name>[a-zA-Z_][a-zA-Z0-9_]*)  # function name
103 | \s*
104 | \(                                   # opening paren before arg list
105 |     (?P<arglist>.*)                  # argument list
106 | \)                                   # closing paren after arg list
107 | \s*
108 | (?:anonymous)?                       # optional "anonymous" keyword
109 | \s*
110 | $
111 | """, re.DOTALL | re.VERBOSE)
112 | 
113 | 
114 | def extract_event_name(raw_signature):
115 |     et_parts_match = EVENT_PARTS_RE.match(raw_signature)
116 | 
117 |     if et_parts_match is None:
118 |         raise ValueError("Could not parse event signature")
119 | 
120 |     group_dict = et_parts_match.groupdict()
121 |     et_name = group_dict['et_name']
122 | 
123 |     if et_name == 'event':
124 |         raise ValueError("Bad event name")
125 | 
126 |     arglist = group_dict['arglist']
127 | 
128 |     return et_name, arglist
129 | 
130 | 
131 | def validate_indexed_args(arglist: str):
132 |     """
133 |     Raise Exception if number of indexed arguments is greater than 3.
134 |     Accepts only comma-delimited list of arguments
135 |     """
136 |     parts = arglist.split(',')
137 |     indexed_amt = 0
138 | 
139 |     for p in parts:
140 |         arg_parts = p.split()
141 |         if(len(arg_parts) > 1 and arg_parts[1] == "indexed"):
142 |             indexed_amt += 1
143 | 
144 |     if(indexed_amt > 3):
145 |         raise ValueError("Too many indexed arguments")
146 | 
147 | 
148 | def normalize_event_signature(raw_signature: str) -> str:
149 |     """
150 |     Return a normalized event signature from the input signature
151 |     ``raw_signature``.  This function must return a normalized event
152 |     signature or raise a ``ValueError``.
153 |     """
154 |     et_name, args = extract_event_name(raw_signature)
155 | 
156 |     # Check if number of indexed arguments is allowed
157 |     validate_indexed_args(args)
158 | 
159 |     try:
160 |         # Make arg list look like tuple and try to parse as normalized abi type
161 |         args_tuple_type = parse_type(normalize_type(f'({args})'))
162 |     except ParseError:
163 |         # If not parseable, assume it's a solidity function signature, extract
164 |         # types, and attempt to parse again
165 |         arg_types = ','.join(get_arg_types(args))
166 |         try:
167 |             args_tuple_type = parse_type(normalize_type(f'({arg_types})'))
168 |         except ParseError as e:
169 |             raise ValueError('could not parse function args') from e
170 | 
171 |     # If args list parseable as abi type, do some validation and return string
172 |     # representation
173 |     try:
174 |         # No custom ABI types
175 |         validate_standard_type(args_tuple_type)
176 |         # All basic types have expected properties
177 |         args_tuple_type.validate()
178 |     except ABITypeError as e:
179 |         raise ValueError('event args contain non-standard types') from e
180 |     else:
181 |         return f'{et_name}{args_tuple_type.to_type_str()}'
182 | 


--------------------------------------------------------------------------------
/func_sig_registry/utils/github.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import tempfile
 3 | import tarfile
 4 | 
 5 | import requests
 6 | 
 7 | 
 8 | ARCHIVE_URL = "https://github.com/{username}/{repository}/archive/{branch}.tar.gz"
 9 | 
10 | 
11 | def get_repository_solidity_files(username, repository, branch='master'):
12 |     archive_url = ARCHIVE_URL.format(
13 |         username=username,
14 |         repository=repository,
15 |         branch=branch,
16 |     )
17 |     with tempfile.TemporaryDirectory() as base_dir:
18 |         response = requests.get(archive_url, stream=True)
19 |         response.raise_for_status()
20 | 
21 |         archive_path = os.path.join(base_dir, '{branch}.tar.gz'.format(branch=branch))
22 | 
23 |         with open(archive_path, 'wb') as archive_file:
24 |             for chunk in response:
25 |                 archive_file.write(chunk)
26 | 
27 |         extract_path = os.path.join(base_dir, 'files')
28 |         os.mkdir(extract_path)
29 | 
30 |         with tarfile.open(archive_path) as archive_file:
31 |             archive_file.extractall(extract_path)
32 | 
33 |         for dirpath, _, filenames in os.walk(extract_path):
34 |             for filename in filenames:
35 |                 _, extension = os.path.splitext(filename)
36 |                 if extension == ".sol":
37 |                     full_path = os.path.join(dirpath, filename)
38 |                     yield full_path
39 | 


--------------------------------------------------------------------------------
/func_sig_registry/utils/import_statistics.py:
--------------------------------------------------------------------------------
 1 | from collections import namedtuple
 2 | 
 3 | ImportStats = namedtuple('ImportStats', ['num_processed', 'num_imported',
 4 |                                          'num_duplicates', 'num_ignored'])
 5 | 
 6 | 
 7 | def empty_import_stats():
 8 |     return ImportStats(
 9 |         num_processed=0,
10 |         num_imported=0,
11 |         num_duplicates=0,
12 |         num_ignored=0,
13 |     )
14 | 
15 | 
16 | def retrieve_stats_from_import_results(raw_import_results):
17 |     num_processed = len(raw_import_results)
18 | 
19 |     import_results = [
20 |         result
21 |         for result in raw_import_results
22 |         if result is not None
23 |     ]
24 | 
25 |     num_ignored = num_processed - len(import_results)
26 | 
27 |     if len(import_results) == 0:
28 |         num_imported = 0
29 |         num_duplicates = 0
30 |     else:
31 |         num_imported = sum(tuple(zip(*import_results))[1])
32 |         num_duplicates = len(import_results) - num_imported
33 | 
34 |     return ImportStats(
35 |         num_processed=num_processed,
36 |         num_imported=num_imported,
37 |         num_duplicates=num_duplicates,
38 |         num_ignored=num_ignored,
39 |     )
40 | 


--------------------------------------------------------------------------------
/func_sig_registry/utils/solidity.py:
--------------------------------------------------------------------------------
  1 | import itertools
  2 | import re
  3 | from typing import (
  4 |     List,
  5 | )
  6 | 
  7 | from eth_abi.exceptions import (
  8 |     ParseError,
  9 |     ABITypeError,
 10 | )
 11 | from eth_abi.grammar import (
 12 |     parse as parse_type,
 13 |     normalize as normalize_type,
 14 |     ABIType,
 15 |     TupleType,
 16 |     BasicType,
 17 | )
 18 | 
 19 | 
 20 | DYNAMIC_TYPES = ['bytes', 'string']
 21 | 
 22 | STATIC_TYPE_ALIASES = [
 23 |     'uint',
 24 |     'int',
 25 |     'ufixed',
 26 |     'fixed',
 27 |     'byte',
 28 | ]
 29 | 
 30 | BITS_REGEX = r'(?:{})'.format('|'.join(str(i) for i in range(8, 257, 8)))
 31 | PLACES_REGEX = r'(?:{})'.format('|'.join(str(i) for i in range(1, 81)))
 32 | 
 33 | STATIC_TYPES = [
 34 |     'uint{0}'.format(BITS_REGEX),
 35 |     'int{0}'.format(BITS_REGEX),
 36 |     'address',
 37 |     'bool',
 38 |     'fixed{0}x{1}'.format(BITS_REGEX, PLACES_REGEX),
 39 |     'ufixed{0}x{1}'.format(BITS_REGEX, PLACES_REGEX),
 40 | ] + ['bytes{0}'.format(i) for i in range(1, 33)]
 41 | 
 42 | TYPE_REGEX = '|'.join((
 43 |     _type + r'(?![a-z0-9])'
 44 |     for _type
 45 |     in itertools.chain(STATIC_TYPES, STATIC_TYPE_ALIASES, DYNAMIC_TYPES)
 46 | ))
 47 | 
 48 | NAME_REGEX = (
 49 |     r'[a-zA-Z_]'
 50 |     r'[a-zA-Z0-9_]*'
 51 | )
 52 | 
 53 | SUB_TYPE_REGEX = (
 54 |     r'\['
 55 |     r'[0-9]*'
 56 |     r'\]'
 57 | )
 58 | 
 59 | FUNCTION_ARGUMENT_REGEX = (
 60 |     r'(?:{type})'
 61 |     r'(?:(?:{sub_type})*)?'
 62 |     r'\s+'
 63 |     '{name}'
 64 | ).format(
 65 |     type=TYPE_REGEX,
 66 |     sub_type=SUB_TYPE_REGEX,
 67 |     name=NAME_REGEX,
 68 | )
 69 | 
 70 | RAW_FUNCTION_RE = re.compile(r"""
 71 | function                          # leading "function" keyword
 72 | \s+
 73 | {name}                            # function name
 74 | \s*
 75 | \(                                # opening paren before arg list
 76 |     \s*
 77 |     (?:
 78 |         {arg}                     # first arg in arg list
 79 |         (?:
 80 |             (?:\s*,\s*{arg}\s*)*  # other args in arg list
 81 |         )?
 82 |         (?:,)?                    # optional trailing comma in arg list
 83 |     )?                            # optional arg list
 84 |     \s*
 85 | \)                                # closing paren after arg list
 86 | """.format(name=NAME_REGEX, arg=FUNCTION_ARGUMENT_REGEX), re.VERBOSE)
 87 | 
 88 | 
 89 | def extract_function_signatures(code):
 90 |     """
 91 |     Given a string of solidity code, extract all of the function declarations.
 92 |     """
 93 |     matches = RAW_FUNCTION_RE.findall(code)
 94 |     return matches or []
 95 | 
 96 | 
 97 | FUNCTION_PARTS_RE = re.compile(r"""
 98 | ^
 99 | \s*
100 | (?:function\s+)?                     # optional leading "function" keyword
101 | (?P<fn_name>[a-zA-Z_][a-zA-Z0-9_]*)  # function name
102 | \s*
103 | \(                                   # opening paren before arg list
104 |     (?P<arglist>.*)                  # argument list
105 | \)                                   # closing paren after arg list
106 | \s*
107 | $
108 | """, re.DOTALL | re.VERBOSE)
109 | 
110 | 
111 | def extract_function_name(raw_signature):
112 |     fn_parts_match = FUNCTION_PARTS_RE.match(raw_signature)
113 | 
114 |     if fn_parts_match is None:
115 |         raise ValueError("Could not parse function signature")
116 | 
117 |     group_dict = fn_parts_match.groupdict()
118 |     fn_name = group_dict['fn_name']
119 | 
120 |     if fn_name == 'function':
121 |         raise ValueError("Bad function name")
122 | 
123 |     arglist = group_dict['arglist']
124 | 
125 |     return fn_name, arglist
126 | 
127 | 
128 | STANDARD_BASE_TYPES = {
129 |     'uint',
130 |     'int',
131 |     'address',
132 |     'bool',
133 |     'fixed',
134 |     'ufixed',
135 |     'bytes',
136 |     'function',
137 |     'string',
138 | }
139 | 
140 | 
141 | def validate_standard_type(abi_type: ABIType) -> None:
142 |     """
143 |     Assert that an abi type is standard.  A basic ABI type is standard if its
144 |     type base is one of the standard ABI base types.  A tuple ABI type is
145 |     standard if all basic types contained within it are standard.
146 |     """
147 |     if isinstance(abi_type, BasicType):
148 |         if abi_type.base not in STANDARD_BASE_TYPES:
149 |             raise ABITypeError(
150 |                 f'type "{abi_type.to_type_str()}" '
151 |                 f'has invalid base "{abi_type.base}"'
152 |             )
153 |     elif isinstance(abi_type, TupleType):
154 |         for t in abi_type.components:
155 |             validate_standard_type(t)
156 |     else:
157 |         raise Exception('unreachable branch arm')
158 | 
159 | 
160 | def get_arg_types(arglist: str) -> List[str]:
161 |     """
162 |     Return a list of types from a comma-delimited list of type/name pairs.
163 | 
164 |     Example:
165 |     >>> get_arg_types('  T   x, T.X y, int z, bool a , a')
166 |     ['T', 'T.X', 'int', 'bool', 'a']
167 |     """
168 |     parts = arglist.split(',')
169 |     types = [p.strip().split(maxsplit=1)[0] for p in parts]
170 | 
171 |     return types
172 | 
173 | 
174 | def normalize_function_signature(raw_signature: str) -> str:
175 |     """
176 |     Return a normalized function signature from the input signature
177 |     ``raw_signature`` that is suitable for generating a function selector via
178 |     the Keccak hash function.  This function must return a normalized function
179 |     signature or raise a ``ValueError``.
180 |     """
181 |     fn_name, args = extract_function_name(raw_signature)
182 | 
183 |     try:
184 |         # Make arg list look like tuple and try to parse as normalized abi type
185 |         args_tuple_type = parse_type(normalize_type(f'({args})'))
186 |     except ParseError:
187 |         # If not parseable, assume it's a solidity function signature, extract
188 |         # types, and attempt to parse again
189 |         arg_types = ','.join(get_arg_types(args))
190 |         try:
191 |             args_tuple_type = parse_type(normalize_type(f'({arg_types})'))
192 |         except ParseError as e:
193 |             raise ValueError('could not parse function args') from e
194 | 
195 |     # If args list parseable as abi type, do some validation and return string
196 |     # representation
197 |     try:
198 |         # No custom ABI types
199 |         validate_standard_type(args_tuple_type)
200 |         # All basic types have expected properties
201 |         args_tuple_type.validate()
202 |     except ABITypeError as e:
203 |         raise ValueError('function args contain non-standard types') from e
204 |     else:
205 |         return f'{fn_name}{args_tuple_type.to_type_str()}'
206 | 


--------------------------------------------------------------------------------
/func_sig_registry/wsgi.py:
--------------------------------------------------------------------------------
 1 | """
 2 | WSGI config for func_sig_registry project.
 3 | 
 4 | It exposes the WSGI callable as a module-level variable named ``application``.
 5 | 
 6 | For more information on this file, see
 7 | https://docs.djangoproject.com/en/1.9/howto/deployment/wsgi/
 8 | """
 9 | 
10 | import os
11 | 
12 | import dotenv
13 | 
14 | from django.core.wsgi import get_wsgi_application
15 | 
16 | dotenv.load_dotenv('.env')  # Local overrides (not tracked)
17 | dotenv.load_dotenv('.env_defaults')  # Development defaults (tracked)
18 | 
19 | os.environ.setdefault("DJANGO_SETTINGS_MODULE", "func_sig_registry.settings")
20 | 
21 | application = get_wsgi_application()
22 | 


--------------------------------------------------------------------------------
/manage.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | import os
 3 | import sys
 4 | import dotenv
 5 | 
 6 | dotenv.load_dotenv('.env')  # Local overrides (not tracked)
 7 | dotenv.load_dotenv('.env_defaults')  # Development defaults (tracked)
 8 | 
 9 | if __name__ == "__main__":
10 |     os.environ.setdefault("DJANGO_SETTINGS_MODULE", "func_sig_registry.settings")
11 | 
12 |     from django.core.management import execute_from_command_line
13 | 
14 |     execute_from_command_line(sys.argv)
15 | 


--------------------------------------------------------------------------------
/migrations/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gobitfly/ethereum-function-signature-registry/cb11e9dd5c04ae80c597d99f5d10b68a17407616/migrations/__init__.py


--------------------------------------------------------------------------------
/pytest.ini:
--------------------------------------------------------------------------------
1 | [pytest]
2 | DJANGO_SETTINGS_MODULE=func_sig_registry.settings_test
3 | 


--------------------------------------------------------------------------------
/requirements-dev.txt:
--------------------------------------------------------------------------------
1 | pytest==2.9.2
2 | pytest-django==2.9.1
3 | django-webtest==1.7.9
4 | WebTest==2.0.21
5 | factory-boy==2.7.0
6 | fake-factory==0.7.4
7 | hypothesis==3.5.3
8 | tox==2.4.1
9 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
 1 | Django>=1.9.9,<1.10.0
 2 | django-tables2>=1.2.3,<1.3.0
 3 | djangorestframework>=3.3.3,<3.4.0
 4 | ipython>=6.2.1
 5 | pysha3==1.0.2
 6 | django-s3-folder-storage>=0.3,<0.4
 7 | django-storages>=1.4.1,<1.5.0
 8 | boto>=2.41.0,<3.0.0
 9 | env-excavator>=1.5.0,<1.6.0
10 | python-dotenv>=0.5.1,<0.6.0
11 | psycopg2-binary>=2.7.4,<2.8.0
12 | dj-database-url>=0.4.1,<0.5.0
13 | django-debug-toolbar>=1.5,<1.6
14 | gunicorn>=19.6.0,<20.0.0
15 | django-filter>=0.13.0,<0.14.0
16 | djangorestframework-filters>=0.8.0,<0.9.0
17 | jsonschema>=2.5.1,<2.6.0
18 | huey>=1.2.0,<1.3.0
19 | redis>=2.10.5,<2.11.0
20 | requests>=2.10.0,<2.11.0
21 | rollbar>=0.13.6,<0.14.0
22 | django-cors-headers>=1.3.1,<1.4.0
23 | six==1.10.0
24 | eth-abi>=2.1,<2.2
25 | eth-utils>=1.8.1,<1.9
26 | 


--------------------------------------------------------------------------------
/runtime.txt:
--------------------------------------------------------------------------------
1 | python-3.6.5
2 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | # -*- coding: utf-8 -*-
 3 | from setuptools import (
 4 |     setup,
 5 |     find_packages,
 6 | )
 7 | 
 8 | extras_require = {
 9 |     'py36-django19': [
10 |         "pytest==5.4.1",
11 |         "pytest-xdist",
12 |         "tox==3.14.6",
13 |     ],
14 |     'flake8': [
15 |         "flake8==3.7.9",
16 |         "isort>=4.2.15,<5",
17 |         "mypy==0.770",
18 |         "pydocstyle>=3.0.0,<4",
19 |     ]
20 | }
21 | 
22 | extras_require['dev'] = (
23 |     extras_require['dev'] +  # noqa: W504
24 |     extras_require['py36-django19'] +  # noqa: W504
25 |     extras_require['flake8']
26 | )
27 | 
28 | 
29 | with open('./README.md') as readme:
30 |     long_description = readme.read()
31 | 
32 | 
33 | setup(
34 |     name='4byte-directory',
35 |     # *IMPORTANT*: Don't manually change the version here. Use `make bump`, as described in readme
36 |     version='0.1.0-alpha.0',
37 |     description="""4byte-directory: Registry of 4byte function, event signatures and \
38 |         their human readable counterparts.""",
39 |     long_description=long_description,
40 |     long_description_content_type='text/markdown',
41 |     author='Piper Merriam',
42 |     author_email='piper@pipermerriam.com',
43 |     url='https://github.com/pipermerriam/ethereum-function-signature-registry',
44 |     include_package_data=True,
45 |     install_requires=[
46 |         "eth-utils>=1,<2",
47 |     ],
48 |     python_requires='>=3.6, <4',
49 |     extras_require=extras_require,
50 |     py_modules=[''],
51 |     license="MIT",
52 |     zip_safe=False,
53 |     keywords='ethereum',
54 |     packages=find_packages(exclude=["tests", "tests.*"]),
55 |     classifiers=[
56 |         'Development Status :: 3 - Alpha',
57 |         'Intended Audience :: Developers',
58 |         'License :: OSI Approved :: MIT License',
59 |         'Natural Language :: English',
60 |         'Programming Language :: Python :: 3.6',
61 |     ],
62 | )
63 | 


--------------------------------------------------------------------------------
/ssl.md:
--------------------------------------------------------------------------------
1 | This is how to do the ssl update every few months.
2 | 
3 | ```
4 | sudo certbot certonly --manual
5 | h config:set LETS_ENCRYPT_SECRET="the-secret" LETS_ENCRYPT_SECRET_PATH="the path" DJANGO_SECURE_SSL_REDIRECT="False"
6 | sudo heroku certs:update --app bytes4 /etc/letsencrypt/live/www.4byte.directory/fullchain.pem /etc/letsencrypt/live/www.4byte.directory/privkey.pem
7 | ```
8 | 


--------------------------------------------------------------------------------
/tests/web/api/test_contract_abi_import_view.py:
--------------------------------------------------------------------------------
 1 | from rest_framework import status
 2 | from django.core.urlresolvers import reverse
 3 | 
 4 | ABI_WITH_INVALID_ENTRIES = """
 5 | [
 6 |     {"constant":false,"inputs":[{"name":"","type":"uint256"},{"name":"","type":"int256"},{"name":"","type":"address"}],"name":"c","outputs":[],"type":"function"},
 7 |     {"constant":false,"inputs":[],"name":"f","outputs":[],"type":"function"},
 8 |     {"constant":false,"inputs":[{"name":"","type":"int256"},{"name":"","type":"int256"}],"name":"b","outputs":[],"type":"function"},
 9 |     {"inputs":[],"type":"constructor"},
10 |     {"anonymous":false,"inputs":[{"name":"", "type":"string", "indexed":true}],"name":"E","type":"event"},
11 |     {"anonymous":false,"inputs":[{"name":"", "type":"strong", "indexed":true}],"name":"Error","type":"event"},
12 |     {"constant":false,"inputs":[{"name":"", "type":"myint"}],"name":"ErrorF","outputs":[],"type":"function"}
13 | ]
14 | """
15 | 
16 | 
17 | def test_importing_contract_abi(api_client, factories):
18 |     factories.SignatureFactory(text_signature='b(int256,int256)')
19 | 
20 |     import_url = reverse('api:import-abi')
21 | 
22 |     response = api_client.post(import_url,
23 |                                {'contract_abi': ABI_WITH_INVALID_ENTRIES})
24 | 
25 |     assert response.status_code == status.HTTP_201_CREATED
26 |     data = response.data
27 |     assert data['num_processed'] == 6
28 |     assert data['num_imported'] == 3
29 |     assert data['num_duplicates'] == 1
30 |     assert data['num_ignored'] == 2
31 | 


--------------------------------------------------------------------------------
/tests/web/api/test_event_signature_api.py:
--------------------------------------------------------------------------------
  1 | import datetime
  2 | import pytest
  3 | 
  4 | from rest_framework import status
  5 | from django.core.urlresolvers import reverse
  6 | from django.utils import timezone
  7 | 
  8 | from eth_utils import event_signature_to_log_topic
  9 | 
 10 | from func_sig_registry.utils.encoding import force_text
 11 | from func_sig_registry.utils.events_solidity import normalize_event_signature
 12 | 
 13 | EVENT_API_URL = '/api/v1/event-signatures/'
 14 | 
 15 | 
 16 | def test_event_signature_api_count(api_client, factories):
 17 |     factories.EventSignatureFactory.create_batch(35)
 18 | 
 19 |     response = api_client.get(EVENT_API_URL)
 20 | 
 21 |     assert response.status_code == status.HTTP_200_OK
 22 |     count = response.data['count']
 23 | 
 24 |     assert count == 35
 25 | 
 26 | 
 27 | def test_event_signature_api_pagination(api_client, factories):
 28 |     factories.EventSignatureFactory.create_batch(101)
 29 | 
 30 |     response = api_client.get(EVENT_API_URL)
 31 | 
 32 |     assert response.status_code == status.HTTP_200_OK
 33 |     data = response.data
 34 | 
 35 |     assert len(data['results']) == 100
 36 | 
 37 | 
 38 | def test_event_signature_api_ordering(api_client, factories):
 39 |     ascending_url = EVENT_API_URL + "?ordering=created_at"
 40 |     decending_url = EVENT_API_URL + "?ordering=-created_at"
 41 | 
 42 |     factories.EventSignatureFactory()
 43 | 
 44 |     sig_b = factories.EventSignatureFactory()
 45 |     sig_b.created_at = timezone.now() + datetime.timedelta(1)
 46 | 
 47 |     response_a = api_client.get(ascending_url)
 48 |     assert response_a.status_code == status.HTTP_200_OK
 49 |     results_a = response_a.data['results']
 50 | 
 51 |     response_b = api_client.get(decending_url)
 52 |     assert response_b.status_code == status.HTTP_200_OK
 53 |     results_b = response_b.data['results']
 54 | 
 55 |     assert len(results_a) == 2
 56 |     assert len(results_b) == 2
 57 |     assert tuple(v['id'] for v in results_a) == tuple(reversed(tuple(v['id'] for v in results_b)))
 58 | 
 59 | 
 60 | def test_event_signature_api_pagination_page_size_query_param(api_client, factories):
 61 |     list_url = EVENT_API_URL + '?page_size=50'
 62 |     factories.EventSignatureFactory.create_batch(101)
 63 | 
 64 |     response = api_client.get(list_url)
 65 |     assert response.status_code == status.HTTP_200_OK
 66 |     data = response.data
 67 |     assert data['count'] == 101
 68 |     assert len(data['results']) == 50
 69 | 
 70 | 
 71 | def test_event_signature_api_create(api_client):
 72 |     response = api_client.post(EVENT_API_URL,
 73 |                                {'text_signature': 'account(address)'})
 74 |     assert response.status_code == status.HTTP_201_CREATED
 75 |     data = response.data
 76 |     assert data['text_signature'] == 'account(address)'
 77 |     assert data['bytes_signature'] == force_text(
 78 |         event_signature_to_log_topic(data['text_signature']))
 79 |     assert data['hex_signature'] == '0x73b9aa91e3748e9df0e79073dca453a3ec1c019407cb9290c3173ad56df0f573'
 80 | 
 81 | 
 82 | def test_create_duplicate_signature(api_client, factories):
 83 |     signature = factories.EventSignatureFactory()
 84 | 
 85 |     response = api_client.post(EVENT_API_URL,
 86 |                                {'text_signature': signature.text_signature})
 87 |     assert response.status_code == status.HTTP_400_BAD_REQUEST
 88 | 
 89 | 
 90 | def test_create_complex_signature(api_client):
 91 |     text_signature = 'getOrdersInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[])'  # noqa: E501
 92 | 
 93 |     response = api_client.post(EVENT_API_URL,
 94 |                                {'text_signature': text_signature})
 95 |     assert response.status_code == status.HTTP_201_CREATED
 96 |     data = response.data
 97 |     assert data['text_signature'] == text_signature
 98 |     assert data['bytes_signature'] == force_text(
 99 |         event_signature_to_log_topic(
100 |             normalize_event_signature(data['text_signature'])))
101 |     assert data['hex_signature'] == '0x7e9d74dc5e5d1a841950b2603b1fc48e0a1c1391bbb4ed24915c26cf1ff33ccb'
102 | 
103 | 
104 | def test_retrieve_signature(api_client, factories):
105 |     signature = factories.EventSignatureFactory()
106 |     detail_url = EVENT_API_URL + str(signature.id) + '/'
107 | 
108 |     response = api_client.get(detail_url)
109 |     assert response.status_code == status.HTTP_200_OK
110 | 
111 |     data = response.data
112 | 
113 |     assert data['id'] == signature.id
114 |     assert data['text_signature'] == signature.text_signature
115 |     assert data['bytes_signature'] == force_text(signature.bytes_signature)
116 |     assert data['hex_signature'] == signature.get_hex_display()
117 | 
118 | 
119 | def test_cannot_update_with_put_signature(api_client, factories):
120 |     signature = factories.EventSignatureFactory()
121 |     detail_url = EVENT_API_URL + str(signature.id) + '/'
122 | 
123 |     response = api_client.put(detail_url, {'text_signature': 'newEvent()'})
124 |     assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
125 | 
126 | 
127 | def test_cannot_update_with_post_signature(api_client, factories):
128 |     signature = factories.EventSignatureFactory()
129 |     detail_url = EVENT_API_URL + str(signature.id) + '/'
130 | 
131 |     response = api_client.post(detail_url, {'text_signature': 'newFunction()'})
132 |     assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
133 | 
134 | 
135 | def test_cannot_delete_signature(api_client, factories):
136 |     signature = factories.EventSignatureFactory()
137 |     detail_url = EVENT_API_URL + str(signature.id) + '/'
138 | 
139 |     response = api_client.delete(detail_url)
140 |     assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
141 | 
142 | 
143 | def test_exact_hex_search(api_client, factories):
144 |     s1, s2, s3, s4, s5 = factories.EventSignatureFactory.create_batch(5)
145 | 
146 |     search_url = EVENT_API_URL + '?hex_signature={0}'.format(
147 |         s2.get_hex_display())
148 |     response = api_client.get(search_url)
149 | 
150 |     assert response.status_code == status.HTTP_200_OK
151 |     data = response.data
152 |     assert data['count'] == 1
153 |     assert len(data['results']) == 1
154 | 
155 |     result = data['results'][0]
156 | 
157 |     assert result['id'] == s2.id
158 | 
159 | 
160 | def test_exact_without_0x_hex_search(api_client, factories):
161 |     s1, s2, s3, s4, s5 = factories.EventSignatureFactory.create_batch(5)
162 | 
163 |     search_url = EVENT_API_URL + '?hex_signature={0}'.format(
164 |         s2.get_hex_display()[2:])
165 |     response = api_client.get(search_url)
166 | 
167 |     assert response.status_code == status.HTTP_200_OK
168 |     data = response.data
169 |     assert data['count'] == 1
170 |     assert len(data['results']) == 1
171 | 
172 |     result = data['results'][0]
173 | 
174 |     assert result['id'] == s2.id
175 | 
176 | 
177 | def test_substring_hex_search_with_0x(api_client, factories):
178 |     s1, s2, s3, s4, s5 = factories.EventSignatureFactory.create_batch(5)
179 | 
180 |     search_url = EVENT_API_URL + '?hex_signature={0}'.format(
181 |         s2.get_hex_display()[:8])
182 |     response = api_client.get(search_url)
183 | 
184 |     assert response.status_code == status.HTTP_200_OK
185 |     data = response.data
186 |     assert data['count'] == 1
187 |     assert len(data['results']) == 1
188 | 
189 |     result = data['results'][0]
190 | 
191 |     assert result['id'] == s2.id
192 | 
193 | 
194 | def test_substring_hex_search_without_0x(api_client, factories):
195 |     s1, s2, s3, s4, s5 = factories.EventSignatureFactory.create_batch(5)
196 | 
197 |     search_url = EVENT_API_URL + '?hex_signature={0}'.format(
198 |         s2.get_hex_display()[2:8])
199 |     response = api_client.get(search_url)
200 | 
201 |     assert response.status_code == status.HTTP_200_OK
202 |     data = response.data
203 |     assert data['count'] == 1
204 |     assert len(data['results']) == 1
205 | 
206 |     result = data['results'][0]
207 | 
208 |     assert result['id'] == s2.id
209 | 


--------------------------------------------------------------------------------
/tests/web/api/test_event_signature_serializer.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | 
 3 | from func_sig_registry.registry.serializers import EventSignatureSerializer
 4 | from func_sig_registry.utils.encoding import force_text
 5 | 
 6 | 
 7 | def test_serialization(factories):
 8 |     signature = factories.EventSignatureFactory()
 9 |     serializer = EventSignatureSerializer(signature)
10 |     data = serializer.data
11 | 
12 |     assert data['id'] == signature.id
13 |     assert data['text_signature'] == signature.text_signature
14 |     assert data['bytes_signature'] == force_text(signature.bytes_signature)
15 |     assert data['hex_signature'] == signature.get_hex_display()
16 | 
17 | 
18 | @pytest.mark.parametrize(
19 |     'raw_signature,expected',
20 |     (
21 |         ('foo()', 'foo()'),
22 |         (' foo()', 'foo()'),
23 |         ('event foo()', 'foo()'),
24 |         (' event foo()', 'foo()'),
25 |         (' event foo() ', 'foo()'),
26 |         (' event foo() anonymous ', 'foo()'),
27 |     ),
28 | )
29 | def test_creation_with_good_signatures(factories, raw_signature, expected):
30 |     serializer = EventSignatureSerializer(data={
31 |         'text_signature': raw_signature,
32 |     })
33 |     assert serializer.is_valid(), serializer.errors
34 |     signature = serializer.save()
35 |     assert signature.text_signature == expected
36 | 
37 | 
38 | @pytest.mark.parametrize(
39 |     'bad_signature',
40 |     (   
41 |         # reserved word as event name
42 |         'event()',
43 |         # empty text signature
44 |         '',
45 |         # incorrect event name format
46 |         '1asd()',
47 |         # random hex string
48 |         '0x337b1cf9',
49 |         # incorrect type
50 |         'event asd(quint, strong)',
51 |         # too many indexed
52 |         'asd(int indexed, string indexed, address indexed, uint indexed)'
53 |     ),
54 | )
55 | def test_creation_with_bad_signatures(factories, bad_signature):
56 |     serializer = EventSignatureSerializer(data={
57 |         'text_signature': bad_signature,
58 |     })
59 |     assert not serializer.is_valid()
60 | 


--------------------------------------------------------------------------------
/tests/web/api/test_searching_signature_api_view.py:
--------------------------------------------------------------------------------
 1 | from rest_framework import status
 2 | from django.core.urlresolvers import reverse
 3 | 
 4 | 
 5 | def test_exact_hex_search(api_client, factories):
 6 |     list_url = reverse('api:signature-list')
 7 |     s1, s2, s3, s4, s5 = factories.SignatureFactory.create_batch(5)
 8 | 
 9 |     search_url = list_url + '?hex_signature={0}'.format(s2.bytes_signature.get_hex_display())
10 |     response = api_client.get(search_url)
11 | 
12 |     assert response.status_code == status.HTTP_200_OK
13 |     data = response.data
14 |     assert data['count'] == 1
15 |     assert len(data['results']) == 1
16 | 
17 |     result = data['results'][0]
18 | 
19 |     assert result['id'] == s2.id
20 | 
21 | 
22 | def test_exact_without_0x_hex_search(api_client, factories):
23 |     list_url = reverse('api:signature-list')
24 |     s1, s2, s3, s4, s5 = factories.SignatureFactory.create_batch(5)
25 | 
26 |     search_url = list_url + '?hex_signature={0}'.format(s2.bytes_signature.get_hex_display()[2:])
27 |     response = api_client.get(search_url)
28 | 
29 |     assert response.status_code == status.HTTP_200_OK
30 |     data = response.data
31 |     assert data['count'] == 1
32 |     assert len(data['results']) == 1
33 | 
34 |     result = data['results'][0]
35 | 
36 |     assert result['id'] == s2.id
37 | 
38 | 
39 | def test_substring_hex_search_with_0x(api_client, factories):
40 |     list_url = reverse('api:signature-list')
41 |     s1, s2, s3, s4, s5 = factories.SignatureFactory.create_batch(5)
42 | 
43 |     search_url = list_url + '?hex_signature={0}'.format(s2.bytes_signature.get_hex_display()[:6])
44 |     response = api_client.get(search_url)
45 | 
46 |     assert response.status_code == status.HTTP_200_OK
47 |     data = response.data
48 |     assert data['count'] == 1
49 |     assert len(data['results']) == 1
50 | 
51 |     result = data['results'][0]
52 | 
53 |     assert result['id'] == s2.id
54 | 
55 | 
56 | def test_substring_hex_search_without_0x(api_client, factories):
57 |     list_url = reverse('api:signature-list')
58 |     s1, s2, s3, s4, s5 = factories.SignatureFactory.create_batch(5)
59 | 
60 |     search_url = list_url + '?hex_signature={0}'.format(s2.bytes_signature.get_hex_display()[2:6])
61 |     response = api_client.get(search_url)
62 | 
63 |     assert response.status_code == status.HTTP_200_OK
64 |     data = response.data
65 |     assert data['count'] == 1
66 |     assert len(data['results']) == 1
67 | 
68 |     result = data['results'][0]
69 | 
70 |     assert result['id'] == s2.id
71 | 


--------------------------------------------------------------------------------
/tests/web/api/test_signature_api_view.py:
--------------------------------------------------------------------------------
  1 | import datetime
  2 | 
  3 | from rest_framework import status
  4 | 
  5 | from django.core.urlresolvers import reverse
  6 | from django.utils import timezone
  7 | 
  8 | from func_sig_registry.utils.encoding import (
  9 |     force_text,
 10 | )
 11 | 
 12 | 
 13 | def test_list_view(api_client, factories):
 14 |     list_url = reverse('api:signature-list')
 15 |     factories.SignatureFactory.create_batch(5)
 16 | 
 17 |     response = api_client.get(list_url)
 18 |     assert response.status_code == status.HTTP_200_OK
 19 |     data = response.data
 20 |     assert data['count'] == 5
 21 |     assert len(data['results']) == 5
 22 | 
 23 | 
 24 | def test_list_view_pagination(api_client, factories):
 25 |     list_url = reverse('api:signature-list')
 26 |     factories.SignatureFactory.create_batch(101)
 27 | 
 28 |     response = api_client.get(list_url)
 29 |     assert response.status_code == status.HTTP_200_OK
 30 |     data = response.data
 31 |     assert data['count'] == 101
 32 |     assert len(data['results']) == 100
 33 | 
 34 | 
 35 | def test_list_view_ordering(api_client, factories):
 36 |     list_url = reverse('api:signature-list')
 37 | 
 38 |     ascending_url = list_url + "?ordering=created_at"
 39 |     decending_url = list_url + "?ordering=-created_at"
 40 | 
 41 |     factories.SignatureFactory()
 42 | 
 43 |     sig_b = factories.SignatureFactory()
 44 |     sig_b.created_at = timezone.now() + datetime.timedelta(1)
 45 | 
 46 |     response_a = api_client.get(ascending_url)
 47 |     assert response_a.status_code == status.HTTP_200_OK
 48 |     results_a = response_a.data['results']
 49 | 
 50 |     response_b = api_client.get(decending_url)
 51 |     assert response_b.status_code == status.HTTP_200_OK
 52 |     results_b = response_b.data['results']
 53 | 
 54 |     assert tuple(v['id'] for v in results_a) == tuple(reversed(tuple(v['id'] for v in results_b)))
 55 | 
 56 | 
 57 | def test_list_view_pagination_page_size_query_param(api_client, factories):
 58 |     list_url = reverse('api:signature-list') + '?page_size=50'
 59 |     factories.SignatureFactory.create_batch(101)
 60 | 
 61 |     response = api_client.get(list_url)
 62 |     assert response.status_code == status.HTTP_200_OK
 63 |     data = response.data
 64 |     assert data['count'] == 101
 65 |     assert len(data['results']) == 50
 66 | 
 67 | 
 68 | def test_create_signature(api_client):
 69 |     create_url = reverse('api:signature-list')
 70 | 
 71 |     response = api_client.post(create_url, {'text_signature': 'balanceOf(address)'})
 72 |     assert response.status_code == status.HTTP_201_CREATED
 73 |     data = response.data
 74 |     assert data['text_signature'] == 'balanceOf(address)'
 75 |     assert data['bytes_signature'] == 'p\xa0\x821'
 76 |     assert data['hex_signature'] == '0x70a08231'
 77 | 
 78 | 
 79 | def test_create_duplicate_signature(api_client, factories):
 80 |     create_url = reverse('api:signature-list')
 81 |     signature = factories.SignatureFactory()
 82 | 
 83 |     response = api_client.post(create_url, {'text_signature': signature.text_signature})
 84 |     assert response.status_code == status.HTTP_400_BAD_REQUEST
 85 | 
 86 | 
 87 | def test_create_complex_signature(api_client):
 88 |     create_url = reverse('api:signature-list')
 89 | 
 90 |     text_signature = 'getOrdersInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[])'  # noqa: E501
 91 | 
 92 |     response = api_client.post(create_url, {'text_signature': text_signature})
 93 |     assert response.status_code == status.HTTP_201_CREATED
 94 |     data = response.data
 95 |     assert data['text_signature'] == text_signature
 96 |     assert data['bytes_signature'] == '~\x9dt\xdc'
 97 |     assert data['hex_signature'] == '0x7e9d74dc'
 98 | 
 99 | 
100 | def test_retrieve_signature(api_client, factories):
101 |     signature = factories.SignatureFactory()
102 |     detail_url = reverse('api:signature-detail', kwargs={'pk': signature.pk})
103 | 
104 |     response = api_client.get(detail_url)
105 |     assert response.status_code == status.HTTP_200_OK
106 | 
107 |     data = response.data
108 | 
109 |     assert data['id'] == signature.id
110 |     assert data['text_signature'] == signature.text_signature
111 |     assert data['bytes_signature'] == force_text(signature.bytes_signature.bytes4_signature)
112 |     assert data['hex_signature'] == signature.bytes_signature.get_hex_display()
113 | 
114 | 
115 | def test_cannot_update_with_put_signature(api_client, factories):
116 |     signature = factories.SignatureFactory()
117 |     detail_url = reverse('api:signature-detail', kwargs={'pk': signature.pk})
118 | 
119 |     response = api_client.put(detail_url, {'text_signature': 'newFunction()'})
120 |     assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
121 | 
122 | 
123 | def test_cannot_update_with_post_signature(api_client, factories):
124 |     signature = factories.SignatureFactory()
125 |     detail_url = reverse('api:signature-detail', kwargs={'pk': signature.pk})
126 | 
127 |     response = api_client.post(detail_url, {'text_signature': 'newFunction()'})
128 |     assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
129 | 
130 | 
131 | def test_cannot_delete_signature(api_client, factories):
132 |     signature = factories.SignatureFactory()
133 |     detail_url = reverse('api:signature-detail', kwargs={'pk': signature.pk})
134 | 
135 |     response = api_client.delete(detail_url)
136 |     assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
137 | 


--------------------------------------------------------------------------------
/tests/web/api/test_signature_serializer.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | 
 3 | from func_sig_registry.registry.serializers import SignatureSerializer
 4 | from func_sig_registry.utils.encoding import force_text
 5 | 
 6 | 
 7 | def test_serialization(factories):
 8 |     signature = factories.SignatureFactory()
 9 |     serializer = SignatureSerializer(signature)
10 |     data = serializer.data
11 | 
12 |     assert data['id'] == signature.id
13 |     assert data['text_signature'] == signature.text_signature
14 |     assert data['bytes_signature'] == force_text(signature.bytes_signature.bytes4_signature)
15 |     assert data['hex_signature'] == signature.bytes_signature.get_hex_display()
16 | 
17 | 
18 | @pytest.mark.parametrize(
19 |     'raw_signature,expected',
20 |     (
21 |         ('foo()', 'foo()'),
22 |         (' foo()', 'foo()'),
23 |         ('function foo()', 'foo()'),
24 |         (' function foo()', 'foo()'),
25 |         (' function foo() ', 'foo()'),
26 |     ),
27 | )
28 | def test_creation_with_good_signatures(factories, raw_signature, expected):
29 |     serializer = SignatureSerializer(data={
30 |         'text_signature': raw_signature,
31 |     })
32 |     assert serializer.is_valid(), serializer.errors
33 |     signature = serializer.save()
34 |     assert signature.text_signature == expected
35 | 
36 | 
37 | @pytest.mark.parametrize(
38 |     'bad_signature',
39 |     (
40 |         'function()',
41 |         '3()',
42 |         '0x337b1cf9',
43 |     ),
44 | )
45 | def test_creation_with_bad_signatures(factories, bad_signature):
46 |     serializer = SignatureSerializer(data={
47 |         'text_signature': bad_signature,
48 |     })
49 |     assert not serializer.is_valid()
50 | 


--------------------------------------------------------------------------------
/tests/web/api/test_solidity_code_and_file_import.py:
--------------------------------------------------------------------------------
 1 | from io import BytesIO
 2 | from rest_framework import status
 3 | from django.core.urlresolvers import reverse
 4 | 
 5 | 
 6 | CODE = """
 7 | contract Foo {
 8 |     function foo_1(uint a) {
 9 |     }
10 | 
11 |     event foo_2(uint a);
12 | }
13 | """
14 | 
15 | FILE = b"""
16 | contract Bar {
17 |     function bar_1(uint a) {
18 | 
19 |     }
20 | 
21 |     event bar_2(uint a);
22 | }
23 | """
24 | 
25 | 
26 | def test_importing_solidity_source_code(api_client, factories):
27 |     import_url = reverse('api:import-solidity')
28 |     source_file = BytesIO(FILE)
29 | 
30 |     response = api_client.post(import_url, {
31 |         'source_code': CODE,
32 |         'source_file': source_file,
33 |     }, format='multipart')
34 | 
35 |     assert response.status_code == status.HTTP_201_CREATED
36 |     data = response.data
37 |     assert data['num_processed'] == 4
38 |     assert data['num_imported'] == 4
39 |     assert data['num_duplicates'] == 0
40 |     assert data['num_ignored'] == 0
41 | 


--------------------------------------------------------------------------------
/tests/web/api/test_solidity_file_import.py:
--------------------------------------------------------------------------------
  1 | from io import BytesIO
  2 | from rest_framework import status
  3 | from django.core.urlresolvers import reverse
  4 | 
  5 | 
  6 | CODE = b"""
  7 | contract Foo {
  8 |     // Empty Function
  9 |     function foo_1() {
 10 |     }
 11 | 
 12 |     // Abstract Function
 13 |     function foo_2();
 14 | 
 15 |     // single argument
 16 |     function foo_3(int a) {
 17 |     }
 18 | 
 19 |     // with return
 20 |     function foo_4(int a) returns (int) {
 21 |     }
 22 | 
 23 |     // multiline
 24 |     function foo_5(int a,
 25 |                    int b,
 26 |                    int c) {
 27 |     }
 28 | 
 29 |     // awkward spacing
 30 |     function foo_6 ( int a ) {
 31 |     }
 32 | 
 33 |     // touching braces
 34 |     function foo_7(int a){}
 35 | 
 36 |     // commented out
 37 |     // function foo_8(address x) {}
 38 | 
 39 |     // fixed types
 40 |     function foo_9(fixed a, ufixed b){}
 41 | 
 42 |     struct T {
 43 |         int x;
 44 |         int y;
 45 |     }
 46 | 
 47 |     // functions with struct args ignored
 48 |     function foo_10(T a, ufixed b){}
 49 | 
 50 |     // functions with non-standard type args ignored
 51 |     function foo_11(bar a, ufixed b){}
 52 | 
 53 |     // inavlid function name (ignored)
 54 |     function function(uint a) {}
 55 | 
 56 |     // empty event
 57 |     event bar_1();
 58 | 
 59 |     // event with one argument (normalized)
 60 |     event bar_2(uint256 a);
 61 | 
 62 |     // event with one argument (not normalized)
 63 |     event bar_3(uint a);
 64 | 
 65 |     // event with indexed argument
 66 |     event bar_4(address indexed a);
 67 | 
 68 |     // event with dynamic type argument
 69 |     event bar_5(bytes[32] a);
 70 | 
 71 |     // event with dynamic and indexex argument
 72 |     event bar_6(bytes[32] indexed a);
 73 | 
 74 |     // werid spacing
 75 |     event bar_7  ( address from,address to ) ;
 76 | 
 77 |     // weird spacing and mutlitline (2)
 78 |     event bar_8 (
 79 |         uint a,
 80 |         uint b,
 81 |         uint c
 82 |     );
 83 | 
 84 |     // commented event
 85 |     // event bar_9(uint8 b);
 86 | 
 87 |     // invalid event, wrong argument type (not processed)
 88 |     event bar_10(function a);
 89 | 
 90 |     // invalid, wrong argument delimeter (not processed)
 91 |     event bar_11(uint a; uint b);
 92 | 
 93 |     // duplicate event signature (duplicated)
 94 |     event bar_12(uint a, uint b);
 95 | 
 96 |     // invalid event name
 97 |     event event(uint a);
 98 | }
 99 | """
100 | 
101 | 
102 | def test_importing_solidity_source_file(api_client, factories):
103 |     # function signature import expected stats:
104 |     # processed: 10 | imported: 7 | duplicated: 2 | ignored: 1
105 |     #
106 |     # event signature import expected stats:
107 |     # processed: 11 | imported: 9 | duplicated: 1 | ignored: 1
108 |     #
109 |     # total:
110 |     # processed: 21 | imported 16 | duplicated: 3 | ignored: 2
111 |     factories.SignatureFactory(text_signature='foo_7(int256)')
112 |     factories.SignatureFactory(text_signature='foo_6(int256)')
113 |     factories.EventSignatureFactory(text_signature='bar_12(uint256,uint256)')
114 | 
115 |     import_url = reverse('api:import-solidity')
116 |     source_file = BytesIO(CODE)
117 | 
118 |     response = api_client.post(import_url, {'source_file': source_file}, format='multipart')
119 | 
120 |     assert response.status_code == status.HTTP_201_CREATED
121 |     data = response.data
122 |     assert data['num_processed'] == 21
123 |     assert data['num_imported'] == 16
124 |     assert data['num_duplicates'] == 3
125 |     assert data['num_ignored'] == 2
126 | 


--------------------------------------------------------------------------------
/tests/web/api/test_solidity_source_import.py:
--------------------------------------------------------------------------------
  1 | from rest_framework import status
  2 | from django.core.urlresolvers import reverse
  3 | 
  4 | 
  5 | CODE = """
  6 | contract Foo {
  7 |     // Empty Function
  8 |     function foo_1() {
  9 |     }
 10 | 
 11 |     // Abstract Function
 12 |     function foo_2();
 13 | 
 14 |     // single argument
 15 |     function foo_3(int a) {
 16 |     }
 17 | 
 18 |     // with return
 19 |     function foo_4(int a) returns (int) {
 20 |     }
 21 | 
 22 |     // multiline
 23 |     function foo_5(int a,
 24 |                    int b,
 25 |                    int c) {
 26 |     }
 27 | 
 28 |     // awkward spacing
 29 |     function foo_6 ( int a ) {
 30 |     }
 31 | 
 32 |     // touching braces
 33 |     function foo_7(int a){}
 34 | 
 35 |     // commented out
 36 |     // function foo_8(address x) {}
 37 | 
 38 |     // inavlid function name (ignored)
 39 |     function function(uint a) {}
 40 | 
 41 |     // empty event
 42 |     event bar_1();
 43 | 
 44 |     // event with one argument (normalized)
 45 |     event bar_2(uint256 a);
 46 | 
 47 |     // event with one argument (not normalized)
 48 |     event bar_3(uint a);
 49 | 
 50 |     // event with indexed argument
 51 |     event bar_4(address indexed a);
 52 | 
 53 |     // event with dynamic type argument
 54 |     event bar_5(bytes[32] a);
 55 | 
 56 |     // event with dynamic and indexex argument
 57 |     event bar_6(bytes[32] indexed a);
 58 | 
 59 |     // werid spacing
 60 |     event bar_7  ( address from,address to ) ;
 61 | 
 62 |     // weird spacing and mutlitline (2)
 63 |     event bar_8 (
 64 |         uint a,
 65 |         uint b,
 66 |         uint c
 67 |     );
 68 | 
 69 |     // commented event
 70 |     // event bar_9(uint8 b);
 71 | 
 72 |     // invalid event, wrong argument type (not processed)
 73 |     event bar_10(function a);
 74 | 
 75 |     // invalid, wrong argument delimeter (not processed)
 76 |     event bar_11(uint a; uint b);
 77 | 
 78 |     // duplicate event signature (duplicated)
 79 |     event bar_12(uint a, uint b);
 80 | 
 81 |     // invalid event name
 82 |     event event(uint a);
 83 | }
 84 | """
 85 | 
 86 | 
 87 | def test_importing_solidity_source_code(api_client, factories):
 88 |     # function signature import expected stats:
 89 |     # processed: 9 | imported: 6 | duplicated: 2 | ignored: 1
 90 |     #
 91 |     # event signature import expected stats:
 92 |     # processed: 11 | imported: 9 | duplicated: 1 | ignored: 1
 93 |     #
 94 |     # total:
 95 |     # processed: 20 | imported 15 | duplicated: 3 | ignored: 2
 96 |     factories.SignatureFactory(text_signature='foo_7(int256)')
 97 |     factories.SignatureFactory(text_signature='foo_6(int256)')
 98 |     factories.EventSignatureFactory(text_signature='bar_12(uint256,uint256)')
 99 | 
100 |     import_url = reverse('api:import-solidity')
101 | 
102 |     response = api_client.post(import_url, {'source_code': CODE})
103 | 
104 |     assert response.status_code == status.HTTP_201_CREATED
105 |     data = response.data
106 |     assert data['num_processed'] == 20
107 |     assert data['num_imported'] == 15
108 |     assert data['num_duplicates'] == 3
109 |     assert data['num_ignored'] == 2
110 | 


--------------------------------------------------------------------------------
/tests/web/conftest.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | 
 3 | import pytest
 4 | import factory
 5 | 
 6 | from django_webtest import (
 7 |     WebTest as BaseWebTest,
 8 |     DjangoTestApp
 9 | )
10 | 
11 | from rest_framework.test import APIClient
12 | 
13 | 
14 | @pytest.fixture()  # NOQA
15 | def factories(transactional_db):
16 |     from factories import (  # NOQA
17 |         SignatureFactory,
18 |         BytesSignatureFactory,
19 |         EventSignatureFactory
20 |     )
21 | 
22 |     def is_factory(obj):
23 |         if not isinstance(obj, type):
24 |             return False
25 |         return issubclass(obj, factory.Factory)
26 | 
27 |     dict_ = {k: v for k, v in locals().items() if is_factory(v)}
28 | 
29 |     return type(
30 |         'fixtures',
31 |         (object,),
32 |         dict_,
33 |     )
34 | 
35 | 
36 | @pytest.fixture()  # NOQA
37 | def models_no_db():
38 |     from django.apps import apps
39 | 
40 |     dict_ = {M._meta.object_name: M for M in apps.get_models()}
41 | 
42 |     return type(
43 |         'models',
44 |         (object,),
45 |         dict_,
46 |     )
47 | 
48 | 
49 | @pytest.fixture()  # NOQA
50 | def models(models_no_db, transactional_db):
51 |     return models_no_db
52 | 
53 | 
54 | class WebTest(BaseWebTest):
55 |     app_class = DjangoTestApp
56 | 
57 | 
58 | @pytest.fixture()  # NOQA
59 | def webtest_client(transactional_db):
60 |     web_test = WebTest(methodName='__call__')
61 |     web_test()
62 |     return web_test.app
63 | 
64 | 
65 | @pytest.fixture()
66 | def api_client(transactional_db):
67 |     """
68 |     A rest_framework api test client not auth'd.
69 |     """
70 |     client = APIClient()
71 |     return client
72 | 


--------------------------------------------------------------------------------
/tests/web/factories.py:
--------------------------------------------------------------------------------
 1 | import factory
 2 | 
 3 | from func_sig_registry.registry.models import (
 4 |     Signature,
 5 |     BytesSignature,
 6 |     EventSignature,
 7 | )
 8 | 
 9 | 
10 | class SignatureFactory(factory.DjangoModelFactory):
11 |     text_signature = factory.Sequence(lambda n: "return{n}()".format(n=n))
12 | 
13 |     class Meta:
14 |         model = Signature
15 | 
16 | 
17 | def int_to_bytes4(i):
18 |     unpadded_hex = hex(i)[2:]
19 |     return "0x" + unpadded_hex.zfill(8)
20 | 
21 | 
22 | class BytesSignatureFactory(factory.DjangoModelFactory):
23 |     bytes4_signature = factory.Sequence(int_to_bytes4)
24 | 
25 |     class Meta:
26 |         model = BytesSignature
27 | 
28 | 
29 | class EventSignatureFactory(factory.DjangoModelFactory):
30 |     text_signature = factory.Sequence(lambda n: "return{n}()".format(n=n))
31 | 
32 |     class Meta:
33 |         model = EventSignature
34 | 


--------------------------------------------------------------------------------
/tests/web/github/test_get_repository_solidity_files.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | 
 3 | from func_sig_registry.utils.github import (
 4 |     get_repository_solidity_files,
 5 | )
 6 | 
 7 | 
 8 | @pytest.mark.skip(reason='makes an http request')
 9 | def test_getting_repository_solidity_files():
10 |     file_list = list(get_repository_solidity_files(
11 |         'pipermerriam',
12 |         'ethereum-alarm-clock',
13 |     ))
14 |     assert len(file_list) == 24
15 | 


--------------------------------------------------------------------------------
/tests/web/registry/test_browsable_event_signatures.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | import string
 3 | 
 4 | from django.test import Client
 5 | 
 6 | EVENT_TEXT_SIGNATURE = 'a(uint256)'
 7 | EVENT_HEX_SIGNATURE = '0xf0fdf83467af68171df09204c0b00056c1e4c80e368b3fff732778b858f7966d'
 8 | 
 9 | EVENT_SIGNATURE_HTML = f'<td class="text_signature">{EVENT_TEXT_SIGNATURE}</td>'
10 | EVENT_SIGNATURE_HEX_HTML = ''.join([
11 |     '<td class="hex_signature">',
12 |     '<code>',
13 |     EVENT_HEX_SIGNATURE,
14 |     '</code>',
15 |     '</td>',
16 | ])
17 | 
18 | SEARCH_INPUT_HTML_WITH_VALUE = ' '.join([
19 |     '<input name="bytes_signature" class="form-control" type="text"',
20 |     'placeholder="0x82ff462f689e2f73df9fd8306282ad3ad112aca9e0847911e8051e158c525b33"',
21 |     f'value="{EVENT_HEX_SIGNATURE}">',
22 | ])
23 | SEARCH_INPUT_HTML_EMPTY = ' '.join([
24 |     '<input name="bytes_signature" class="form-control" type="text"',
25 |     'placeholder="0x82ff462f689e2f73df9fd8306282ad3ad112aca9e0847911e8051e158c525b33" >'
26 | ])
27 | 
28 | 
29 | @pytest.mark.django_db
30 | def test_browsable_event_signature_html(factories):
31 |     factories.EventSignatureFactory(text_signature='a(uint256)')
32 | 
33 |     client = Client(HTTP_USER_AGENT='Mozilla/5.0', enforce_csrf_checks=True)
34 |     response = client.get('/event-signatures/')
35 | 
36 |     assert(str.encode(EVENT_SIGNATURE_HTML) in response.content)
37 |     assert(str.encode(EVENT_SIGNATURE_HEX_HTML) in response.content)
38 | 
39 | 
40 | @pytest.mark.django_db
41 | def test_browsable_event_signature_search(factories):
42 |     factories.EventSignatureFactory(text_signature='a(uint256)')
43 |     factories.EventSignatureFactory(text_signature='b(uint256)')
44 | 
45 |     client = Client(HTTP_USER_AGENT='Mozilla/5.0', enforce_csrf_checks=True)
46 | 
47 |     response = client.get('/event-signatures/',
48 |                           {'bytes_signature': EVENT_HEX_SIGNATURE})
49 | 
50 |     assert(b'a(uint256)' in response.content)
51 |     assert(b'b(uint256)' not in response.content)
52 | 
53 | 
54 | @pytest.mark.django_db
55 | def test_event_signature_list_get_context_data():
56 |     client = Client(HTTP_USER_AGENT='Mozilla/5.0', enforce_csrf_checks=True)
57 | 
58 |     response = client.get('/event-signatures/',
59 |                           {'bytes_signature': EVENT_HEX_SIGNATURE})
60 | 
61 |     assert(str.encode(SEARCH_INPUT_HTML_WITH_VALUE) in response.content)
62 | 
63 | 
64 | @pytest.mark.django_db
65 | def test_event_signature_list_get_context_data_empty():
66 |     client = Client(HTTP_USER_AGENT='Mozilla/5.0', enforce_csrf_checks=True)
67 | 
68 |     response = client.get('/event-signatures/')
69 | 
70 |     assert(str.encode(SEARCH_INPUT_HTML_EMPTY) in response.content)
71 | 


--------------------------------------------------------------------------------
/tests/web/registry/test_browsable_function_signatures.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | import string
 3 | 
 4 | from django.test import Client
 5 | 
 6 | SEARCH_INPUT_WITH_DATA = ' '.join([
 7 |     '<input name="bytes4_signature" class="form-control" type="text"',
 8 |     'placeholder="0x70a08231" value="0xf0fdf834">',
 9 | ])
10 | SEARCH_INPUT_EMPTY = ' '.join([
11 |     '<input name="bytes4_signature" class="form-control" type="text"',
12 |     'placeholder="0x70a08231" >',
13 | ])
14 | 
15 | @pytest.mark.django_db
16 | def test_browsable_function_signature_table(factories):
17 |     factories.SignatureFactory(text_signature='a(uint256)')
18 | 
19 |     client = Client(HTTP_USER_AGENT='Mozilla/5.0', enforce_csrf_checks=True)
20 |     response = client.get('/signatures/')
21 | 
22 |     assert(b'a(uint256)' in response.content)
23 |     assert(b'0xf0fdf834' in response.content)
24 | 
25 | 
26 | @pytest.mark.django_db
27 | def test_browsable_function_signature_search(factories):
28 |     factories.SignatureFactory(text_signature='a(uint256)')
29 |     factories.SignatureFactory(text_signature='b(uint256)')
30 | 
31 |     client = Client(HTTP_USER_AGENT='Mozilla/5.0', enforce_csrf_checks=True)
32 | 
33 |     response = client.get('/signatures/',
34 |                           {'bytes4_signature': '0xf0fdf834'})
35 | 
36 |     assert(b'a(uint256)' in response.content)
37 |     assert(b'b(uint256)' not in response.content)
38 | 
39 | 
40 | @pytest.mark.django_db
41 | def test_function_signature_list_get_context_data():
42 |     client = Client(HTTP_USER_AGENT='Mozilla/5.0', enforce_csrf_checks=True)
43 | 
44 |     response = client.get('/signatures/',
45 |                           {'bytes4_signature': '0xf0fdf834'})
46 | 
47 |     assert(str.encode(SEARCH_INPUT_WITH_DATA) in response.content)
48 | 
49 | 
50 | @pytest.mark.django_db
51 | def test_function_signature_list_get_context_data_empty():
52 |     client = Client(HTTP_USER_AGENT='Mozilla/5.0', enforce_csrf_checks=True)
53 | 
54 |     response = client.get('/signatures/')
55 | 
56 |     print(response.content.decode('utf-8'))
57 | 
58 |     assert(str.encode(SEARCH_INPUT_EMPTY) in response.content)
59 | 


--------------------------------------------------------------------------------
/tests/web/registry/test_event_signature_filter.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | 
 3 | from func_sig_registry.registry.filters import EventSignatureFilter
 4 | 
 5 | # Sample data to populate the database (key -> text_signature)
 6 | TEST_EVENT_DATA = {
 7 |     'asd': 'asd(int256,int256)',
 8 |     'bsd': 'bsd(int256,int256)',
 9 |     'dsa': 'dsa(uint, uint indexed, string)',
10 |     'foo': 'foo(address, string, uint)',
11 | }
12 | 
13 | 
14 | # expected is array of keys of TEST_EVENT_DATA
15 | @pytest.mark.parametrize(
16 |     'filter_data,expected',
17 |     (
18 |         # full text_signature
19 |         ({'text_signature': 'asd(int256,int256)'},
20 |          ['asd']),
21 | 
22 |         # partial text_signature
23 |         ({'text_signature': 'asd'},
24 |          ['asd']),
25 | 
26 |         # partial text_signature with multiple results
27 |         ({'text_signature': 'sd'},
28 |          ['asd', 'bsd']),
29 | 
30 |         # text_signature with empty result
31 |         ({'text_signature': 'qwerty'},
32 |          []),
33 | 
34 |         # full hex_signature
35 |         ({'hex_signature': '1484d385b26b57c843ba735623eb866d226e6fc37fae7b665e3696e9544cf3e9'},
36 |          ['asd']),
37 | 
38 |         # partial hex_signature
39 |         ({'hex_signature': '1484d385b26b57'},
40 |          ['asd']),
41 | 
42 |         # hex_signature with empty result
43 |         ({'hex_signature': '1484d385b26b57c843ba735623eb866d226e6fc37fae7b665e3696e9544cf3e1'},
44 |          []),
45 |     ),
46 | )
47 | def test_event_signature_filter_by_text_hex_signature(factories, filter_data, expected):
48 |     signature_dict = {}
49 |     for key, value in TEST_EVENT_DATA.items():
50 |         signature_dict[key] = factories.EventSignatureFactory(
51 |             text_signature=value)
52 | 
53 |     event_filter = EventSignatureFilter(data=filter_data)
54 | 
55 |     assert len(event_filter.qs) == len(expected)
56 | 
57 |     for value in expected:
58 |         assert signature_dict[value] in event_filter.qs
59 | 
60 | 
61 | def test_event_signature_filter_by_bytes_signature(factories):
62 |     for key, value in TEST_EVENT_DATA.items():
63 |         event_signature = factories.EventSignatureFactory(
64 |             text_signature=value)
65 | 
66 |         event_filter = EventSignatureFilter(data={
67 |             'bytes_signature': event_signature.bytes_signature})
68 | 
69 |         assert len(event_filter.qs) == 1
70 |         assert event_signature in event_filter.qs
71 | 


--------------------------------------------------------------------------------
/tests/web/registry/test_signature_import_from_raw_text_signature.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | 
 3 | 
 4 | @pytest.mark.parametrize(
 5 |     'raw_signature,expected',
 6 |     (
 7 |         ('balanceOf(address who)', 'balanceOf(address)'),
 8 |         ('balanceOf( address who )', 'balanceOf(address)'),
 9 |         ('balanceOf( address who )', 'balanceOf(address)'),
10 |         ('transfer(address who, uint amount)', 'transfer(address,uint256)'),
11 |         ('register(bytes32[] names, uint[] values)', 'register(bytes32[],uint256[])'),
12 |     )
13 | )
14 | def test_import_from_raw_text_signature(raw_signature, expected, models):
15 |     sig, _ = models.Signature.import_from_raw_text_signature(raw_signature)
16 |     assert sig.text_signature == expected
17 | 
18 | 
19 | @pytest.mark.parametrize(
20 |     'bad_signature',
21 |     (
22 |         'balanceOf(',
23 |         '0x1234abcd',
24 |         '[]',
25 |     )
26 | )
27 | def test_import_from_raw_text_signature_with_bad_signatures(bad_signature, models):
28 |     res = models.Signature.import_from_raw_text_signature(bad_signature)
29 |     assert res is None
30 | 


--------------------------------------------------------------------------------
/tests/web/regressions/test_00_prefixed_signatures_save_correctly.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | 
 3 | from func_sig_registry.utils.encoding import (
 4 |     force_text,
 5 | )
 6 | from func_sig_registry.utils.abi import (
 7 |     make_4byte_signature,
 8 | )
 9 | 
10 | 
11 | @pytest.mark.parametrize(
12 |     'text_signature,bytes4_signature',
13 |     (
14 |         ('NewPoll(string,string,uint256,uint256)', '\x00\x10\n\x18'),
15 |         ('computeResponse(uint256,uint16)', '\x00µ²#'),
16 |         ('setLowerFeePercentage(uint8)', '\x00;\x9d\x88'),
17 |         ('setHand(uint256)', '\x00Ç!«'),
18 |         ('comparisonchr(string)', '\x00\x873g'),
19 |         ('getTokenDivisor()', '\x00úôÝ'),
20 |         ('getFrontend()', '\x000tÿ'),
21 |         ('triggerPayment()', '\x00Î W'),
22 |         ('setMinimumPassPercentage(uint8)', '\x00äg\x00'),
23 |     ),
24 | )
25 | def test_00_prefixed_signatures_result_in_correct_4byte_signature(factories,
26 |                                                                   models,
27 |                                                                   text_signature,
28 |                                                                   bytes4_signature):
29 |     signature = models.Signature(text_signature=text_signature)
30 |     signature.save()
31 | 
32 |     bytes_signature = models.BytesSignature.objects.get(pk=signature.bytes_signature_id)
33 | 
34 |     assert len(bytes_signature.bytes4_signature) == 4
35 |     assert bytes_signature.get_bytes_display() == bytes4_signature
36 | 


--------------------------------------------------------------------------------
/tests/web/utility/test_event_definition_to_text_signature.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | 
 3 | import pytest
 4 | 
 5 | from func_sig_registry.utils.abi import (
 6 |     event_definition_to_text_signature,
 7 | )
 8 | 
 9 | 
10 | ABI_SINGLE_ARG = {
11 |     "inputs": [
12 |         {"name": "a", "type": "int256", "indexed" : False},
13 |     ],
14 |     "name": "foo",
15 |     "type": "event",
16 |     "anonymous": False,
17 | }
18 | 
19 | 
20 | ABI_TWO_ARGS = {
21 |     "inputs": [
22 |         {"name": "a", "type": "address", "indexed" : True},
23 |         {"name": "b", "type": "uint256", "indexed" : False},
24 |     ],
25 |     "name": "foo",
26 |     "type": "event",
27 |     "anonymous": False,
28 | }
29 | 
30 | ABI_TUPLE_ARG = json.loads('{"inputs":[{"indexed":false, "components":[{"internalType":"int256","name":"x","type":"int256"},{"internalType":"int256","name":"y","type":"int256"}],"internalType":"struct Test2.Test","name":"a","type":"tuple"}],"name":"myEvent","type":"event"}')
31 | 
32 | ABI_GET_ORDERS_INFO = json.loads('{"inputs":[{"indexed":false, "components":[{"name":"makerAddress","type":"address"},{"name":"takerAddress","type":"address"},{"name":"feeRecipientAddress","type":"address"},{"name":"senderAddress","type":"address"},{"name":"makerAssetAmount","type":"uint256"},{"name":"takerAssetAmount","type":"uint256"},{"name":"makerFee","type":"uint256"},{"name":"takerFee","type":"uint256"},{"name":"expirationTimeSeconds","type":"uint256"},{"name":"salt","type":"uint256"},{"name":"makerAssetData","type":"bytes"},{"name":"takerAssetData","type":"bytes"}],"name":"orders","type":"tuple[]"}],"name":"OrdersInfo","type":"event"}')
33 | 
34 | 
35 | @pytest.mark.parametrize(
36 |     'fn_abi,expected',
37 |     (
38 |         (ABI_SINGLE_ARG, 'foo(int256)'),
39 |         (ABI_TWO_ARGS, 'foo(address indexed,uint256)'),
40 |         (ABI_TUPLE_ARG, 'myEvent((int256,int256))'),
41 |         (ABI_GET_ORDERS_INFO, 'OrdersInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[])'),
42 |     ),
43 | )
44 | def test_function_definition_to_text_signature(fn_abi, expected):
45 |     actual = event_definition_to_text_signature(fn_abi)
46 |     assert actual == expected
47 | 


--------------------------------------------------------------------------------
/tests/web/utility/test_extract_event_signatures.py:
--------------------------------------------------------------------------------
 1 | from func_sig_registry.utils.events_solidity import (
 2 |     extract_event_signatures,
 3 | )
 4 | 
 5 | 
 6 | CODE = """
 7 | contract Foo {
 8 |     // Empty Function
 9 |     event foo_1();
10 | 
11 |     // Anonymous Event
12 |     event foo_2() anonymous;
13 | 
14 |     // single argument
15 |     event foo_3(int a);
16 | 
17 |     // with return
18 |     event foo_4(int a);
19 | 
20 |     // multiline
21 |     event foo_5(int a,
22 |                    int b,
23 |                    int c);
24 | 
25 |     // awkward spacing
26 |     event foo_6 ( int a );
27 | 
28 |     // touching braces
29 |     event foo_7(int a);
30 | 
31 |     // commented out
32 |     // event foo_8(address x);
33 | 
34 |     // contains indexed argugment
35 |     event foo_9(int256 indexed a);
36 | 
37 |     // invalid parentheses
38 |     event foo_10(uint a};
39 | 
40 |     // invalid type
41 |     event foo_11(uint10 a);
42 | 
43 |     // invalid, not an event
44 |     function foo_12(uint a);
45 | 
46 |     // invalid, mismatch of parentheses
47 |     event foo_13(
48 | 
49 |     event foo_14)
50 | }
51 | """
52 | 
53 | 
54 | def test_extract_event_signatures():
55 |     signatures = extract_event_signatures(CODE)
56 |     assert len(signatures) == 9
57 |     assert set(signatures) == {
58 |         'event foo_1()',
59 |         'event foo_2() anonymous',
60 |         'event foo_3(int a)',
61 |         'event foo_4(int a)',
62 |         'event foo_5(int a,\n                   int b,\n                   int c)',
63 |         'event foo_6 ( int a )',
64 |         'event foo_7(int a)',
65 |         'event foo_8(address x)',
66 |         'event foo_9(int256 indexed a)',
67 |     }
68 | 


--------------------------------------------------------------------------------
/tests/web/utility/test_extract_function_signatures.py:
--------------------------------------------------------------------------------
 1 | from func_sig_registry.utils.solidity import (
 2 |     extract_function_signatures,
 3 | )
 4 | 
 5 | 
 6 | CODE = """
 7 | contract Foo {
 8 |     // Empty Function
 9 |     function foo_1() {
10 |     }
11 | 
12 |     // Abstract Function
13 |     function foo_2();
14 | 
15 |     // single argument
16 |     function foo_3(int a) {
17 |     }
18 | 
19 |     // with return
20 |     function foo_4(int a) returns (int) {
21 |     }
22 | 
23 |     // multiline
24 |     function foo_5(int a,
25 |                    int b,
26 |                    int c) {
27 |     }
28 | 
29 |     // awkward spacing
30 |     function foo_6 ( int a ) {
31 |     }
32 | 
33 |     // touching braces
34 |     function foo_7(int a){}
35 | 
36 |     // commented out
37 |     // function foo_8(address x) {}
38 | }
39 | """
40 | 
41 | 
42 | def test_extract_function_signatures():
43 |     signatures = extract_function_signatures(CODE)
44 |     assert len(signatures) == 8
45 |     assert set(signatures) == {
46 |         'function foo_1()',
47 |         'function foo_2()',
48 |         'function foo_3(int a)',
49 |         'function foo_4(int a)',
50 |         'function foo_5(int a,\n                   int b,\n                   int c)',
51 |         'function foo_6 ( int a )',
52 |         'function foo_7(int a)',
53 |         'function foo_8(address x)',
54 |     }
55 | 


--------------------------------------------------------------------------------
/tests/web/utility/test_function_definition_to_text_signature.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | 
 3 | import pytest
 4 | 
 5 | from func_sig_registry.utils.abi import (
 6 |     function_definition_to_text_signature,
 7 | )
 8 | 
 9 | 
10 | ABI_NO_ARGS = {
11 |     "constant": False,
12 |     "inputs": [],
13 |     "name": "foo",
14 |     "outputs": [],
15 |     "type": "function",
16 | }
17 | 
18 | 
19 | ABI_SINGLE_ARG = {
20 |     "constant": False,
21 |     "inputs": [
22 |         {"name": "a", "type": "int256"},
23 |     ],
24 |     "name": "foo",
25 |     "outputs": [],
26 |     "type": "function",
27 | }
28 | 
29 | 
30 | ABI_TWO_ARGS = {
31 |     "constant": False,
32 |     "inputs": [
33 |         {"name": "a", "type": "address"},
34 |         {"name": "b", "type": "uint256"},
35 |     ],
36 |     "name": "foo",
37 |     "outputs": [],
38 |     "type": "function",
39 | }
40 | 
41 | ABI_TUPLE_ARG = json.loads('{"constant":false,"inputs":[{"components":[{"internalType":"int256","name":"x","type":"int256"},{"internalType":"int256","name":"y","type":"int256"}],"internalType":"struct Test2.Test","name":"a","type":"tuple"}],"name":"myFun","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}')
42 | 
43 | # from 0x4f833a24e1f95d70f028921e27040ca56e09ab0b mainnet address:
44 | # https://github.com/pipermerriam/ethereum-function-signature-registry/issues/37
45 | ABI_GET_ORDERS_INFO = json.loads('{"constant":true,"inputs":[{"components":[{"name":"makerAddress","type":"address"},{"name":"takerAddress","type":"address"},{"name":"feeRecipientAddress","type":"address"},{"name":"senderAddress","type":"address"},{"name":"makerAssetAmount","type":"uint256"},{"name":"takerAssetAmount","type":"uint256"},{"name":"makerFee","type":"uint256"},{"name":"takerFee","type":"uint256"},{"name":"expirationTimeSeconds","type":"uint256"},{"name":"salt","type":"uint256"},{"name":"makerAssetData","type":"bytes"},{"name":"takerAssetData","type":"bytes"}],"name":"orders","type":"tuple[]"}],"name":"getOrdersInfo","outputs":[{"components":[{"name":"orderStatus","type":"uint8"},{"name":"orderHash","type":"bytes32"},{"name":"orderTakerAssetFilledAmount","type":"uint256"}],"name":"","type":"tuple[]"}],"payable":false,"stateMutability":"view","type":"function"}')
46 | 
47 | 
48 | @pytest.mark.parametrize(
49 |     'fn_abi,expected',
50 |     (
51 |         (ABI_NO_ARGS, 'foo()'),
52 |         (ABI_SINGLE_ARG, 'foo(int256)'),
53 |         (ABI_TWO_ARGS, 'foo(address,uint256)'),
54 |         (ABI_TUPLE_ARG, 'myFun((int256,int256))'),
55 |         (ABI_GET_ORDERS_INFO, 'getOrdersInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[])'),
56 |     ),
57 | )
58 | def test_function_definition_to_text_signature(fn_abi, expected):
59 |     actual = function_definition_to_text_signature(fn_abi)
60 |     assert actual == expected
61 | 


--------------------------------------------------------------------------------
/tests/web/utility/test_is_valid_contract_abi.py:
--------------------------------------------------------------------------------
  1 | import pytest
  2 | import json
  3 | 
  4 | from func_sig_registry.utils.abi import (
  5 |     is_valid_contract_abi,
  6 | )
  7 | 
  8 | 
  9 | CONSTRUCTOR_ONLY = json.loads('[{"inputs":[{"name":"a","type":"address"},{"name":"b","type":"uint256"}],"type":"constructor"}]')
 10 | 
 11 | SINGLE_FUNCTION = json.loads('[{"constant":false,"inputs":[{"name":"a","type":"address"},{"name":"b","type":"uint256"}],"name":"f","outputs":[],"type":"function"}]')
 12 | 
 13 | SINGLE_FUNCTION_WITH_RETURN = json.loads('[{"constant":false,"inputs":[{"name":"a","type":"address"},{"name":"b","type":"uint256"}],"name":"f","outputs":[{"name":"","type":"uint256"},{"name":"","type":"address"}],"type":"function"}]')
 14 | 
 15 | SINGLE_EVENT = json.loads('[{"anonymous":false,"inputs":[],"name":"F","type":"event"}]')
 16 | 
 17 | SOME_OF_EACH = json.loads('[{"constant":false,"inputs":[],"name":"f","outputs":[],"type":"function"},{"inputs":[],"type":"constructor"},{"anonymous":false,"inputs":[],"name":"E","type":"event"}]')
 18 | 
 19 | SOME_OF_EACH_AND_THREE_FUNCTIONS = json.loads('[{"constant":false,"inputs":[{"name":"","type":"uint256"},{"name":"","type":"int256"},{"name":"","type":"address"}],"name":"c","outputs":[],"type":"function"},{"constant":false,"inputs":[],"name":"f","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"","type":"int256"},{"name":"","type":"int256"}],"name":"b","outputs":[],"type":"function"},{"inputs":[],"type":"constructor"},{"anonymous":false,"inputs":[],"name":"E","type":"event"}]')
 20 | 
 21 | SINGLE_EVENT_INDEXED = [{
 22 |     "type": "event",
 23 |     "inputs": [
 24 |         {"name": "a", "type": "uint256", "indexed": True},
 25 |         {"name": "b", "type": "bytes32", "indexed": False}
 26 |         ],
 27 |     "name": "foo",
 28 |     "anonymous": False
 29 | }]
 30 | 
 31 | MISSING_INDEXED_EVENT = [{
 32 |     "type": "event",
 33 |     "inputs": [
 34 |         {"name": "a", "type": "uint256"},
 35 |         {"name": "b", "type": "bytes32", "indexed": False}
 36 |         ],
 37 |     "name": "foo",
 38 |     "anonymous": False
 39 | }]
 40 | 
 41 | INCORRECT_INDEXED_TYPE = [{
 42 |     "type": "event",
 43 |     "inputs": [
 44 |         {"name": "a", "type": "uint256", "indexed": "True"},
 45 |         {"name": "b", "type": "bytes32", "indexed": False}
 46 |         ],
 47 |     "name": "foo",
 48 |     "anonymous": False
 49 | }]
 50 | 
 51 | MISSING_FUNCTION_NAME = [{
 52 |     'constant': True,
 53 |     'inputs': [],
 54 |     'outputs': [],
 55 |     'type': 'function',
 56 | }]
 57 | 
 58 | MISSING_FUNCTION_TYPE = [{
 59 |     'constant': True,
 60 |     'name': 'foo',
 61 |     'inputs': [],
 62 |     'outputs': [],
 63 | }]
 64 | 
 65 | ABI_TUPLE_ARG = json.loads('[{"constant":false,"inputs":[{"components":[{"internalType":"int256","name":"x","type":"int256"},{"internalType":"int256","name":"y","type":"int256"}],"internalType":"struct Test2.Test","name":"a","type":"tuple"}],"name":"myFun","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]')
 66 | 
 67 | # from 0x4f833a24e1f95d70f028921e27040ca56e09ab0b mainnet address:
 68 | # https://github.com/pipermerriam/ethereum-function-signature-registry/issues/37
 69 | ABI_GET_ORDERS_INFO = json.loads('[{"constant":true,"inputs":[{"components":[{"name":"makerAddress","type":"address"},{"name":"takerAddress","type":"address"},{"name":"feeRecipientAddress","type":"address"},{"name":"senderAddress","type":"address"},{"name":"makerAssetAmount","type":"uint256"},{"name":"takerAssetAmount","type":"uint256"},{"name":"makerFee","type":"uint256"},{"name":"takerFee","type":"uint256"},{"name":"expirationTimeSeconds","type":"uint256"},{"name":"salt","type":"uint256"},{"name":"makerAssetData","type":"bytes"},{"name":"takerAssetData","type":"bytes"}],"name":"orders","type":"tuple[]"}],"name":"getOrdersInfo","outputs":[{"components":[{"name":"orderStatus","type":"uint8"},{"name":"orderHash","type":"bytes32"},{"name":"orderTakerAssetFilledAmount","type":"uint256"}],"name":"","type":"tuple[]"}],"payable":false,"stateMutability":"view","type":"function"}]')
 70 | 
 71 | 
 72 | ISSUE_92_ABI = json.loads('''
 73 | [ { "constant": false, "inputs": [ { "name": "newImplementation", "type": "address" } ], "name": "upgradeTo", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [ { "name": "newImplementation", "type": "address" }, { "name": "data", "type": "bytes" } ], "name": "upgradeToAndCall", "outputs": [], "payable": true, "stateMutability": "payable", "type": "function" }, { "constant": false, "inputs": [], "name": "implementation", "outputs": [ { "name": "", "type": "address" } ], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [ { "name": "newAdmin", "type": "address" } ], "name": "changeAdmin", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [], "name": "admin", "outputs": [ { "name": "", "type": "address" } ], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "name": "_logic", "type": "address" }, { "name": "_admin", "type": "address" }, { "name": "_data", "type": "bytes" } ], "payable": true, "stateMutability": "payable", "type": "constructor" }, { "payable": true, "stateMutability": "payable", "type": "fallback" }, { "anonymous": false, "inputs": [ { "indexed": false, "name": "previousAdmin", "type": "address" }, { "indexed": false, "name": "newAdmin", "type": "address" } ], "name": "AdminChanged", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "name": "implementation", "type": "address" } ], "name": "Upgraded", "type": "event" } ]
 74 | ''')  # noqa: E501
 75 | 
 76 | 
 77 | @pytest.mark.parametrize(
 78 |     'contract_abi,expected',
 79 |     (
 80 |         # obviously invalid
 81 |         ([1], False),
 82 |         (['1'], False),
 83 |         ([[]], False),
 84 |         ([True], False),
 85 |         # empty
 86 |         ([], True),
 87 |         # actual ABI definitions
 88 |         (CONSTRUCTOR_ONLY, True),
 89 |         (SINGLE_FUNCTION, True),
 90 |         (SINGLE_FUNCTION_WITH_RETURN, True),
 91 |         (SINGLE_EVENT, True),
 92 |         (SOME_OF_EACH, True),
 93 |         (SOME_OF_EACH_AND_THREE_FUNCTIONS, True),
 94 |         # complex ABI definitions
 95 |         (ABI_TUPLE_ARG, True),
 96 |         (ABI_GET_ORDERS_INFO, True),
 97 |         # bad definitions
 98 |         (MISSING_FUNCTION_NAME, False),
 99 |         (MISSING_FUNCTION_TYPE, False),
100 |         (MISSING_INDEXED_EVENT, False),
101 |         (INCORRECT_INDEXED_TYPE, False),
102 |         # event with indexed
103 |         (SINGLE_EVENT_INDEXED, True),
104 |         # Issue 92
105 |         (ISSUE_92_ABI, True),
106 | 
107 |     ),
108 | )
109 | def test_is_valid_contract_abi(contract_abi, expected):
110 |     actual = is_valid_contract_abi(contract_abi)
111 |     assert actual is expected
112 | 


--------------------------------------------------------------------------------
/tests/web/utility/test_make_4byte_signature.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | 
 3 | from func_sig_registry.utils.abi import make_4byte_signature
 4 | 
 5 | 
 6 | @pytest.mark.parametrize(
 7 |     'text_signature,hex_signature',
 8 |     (
 9 |         ('isCancellable()', '0x4500054f'),
10 |     ),
11 | )
12 | def test_make_4byte_signature(factories, text_signature, hex_signature):
13 |     signature = factories.SignatureFactory(text_signature=text_signature)
14 |     assert hex_signature == signature.bytes_signature.get_hex_display()
15 | 


--------------------------------------------------------------------------------
/tests/web/utility/test_normalize_event_signature.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | 
 3 | from func_sig_registry.utils.events_solidity import (
 4 |     normalize_event_signature
 5 | )
 6 | 
 7 | 
 8 | @pytest.mark.parametrize(
 9 |     'raw_signature,expected',
10 |     (
11 |         # from raw signatures
12 |         ('event foo(int a, int b, int c, int d)', 'foo(int256,int256,int256,int256)'),
13 |         ('event foo(address v)', 'foo(address)'),
14 |         ('event   foo  ( address v )', 'foo(address)'),
15 |         ('event foo(address v,\nint i)', 'foo(address,int256)'),
16 |         ('event foo(\naddress   v,\nint i\n)', 'foo(address,int256)'),
17 |         ('event foo (address v)', 'foo(address)'),
18 |         ('event foo(address v, int i)', 'foo(address,int256)'),
19 |         ('event foo(address v,int i)', 'foo(address,int256)'),
20 |         ('event foo(address[] v, int i)', 'foo(address[],int256)'),
21 |         ('event foo(address[2] v, int i)', 'foo(address[2],int256)'),
22 |         ('event foo(address[2][][3] v, int i)', 'foo(address[2][][3],int256)'),
23 |         # without event prefix
24 |         ('foo(int a, int b, int c, int d)', 'foo(int256,int256,int256,int256)'),
25 |         ('foo(address v)', 'foo(address)'),
26 |         ('  foo  ( address v )', 'foo(address)'),
27 |         ('foo(address v,\nint i)', 'foo(address,int256)'),
28 |         ('foo(\naddress   v,\nint i\n)', 'foo(address,int256)'),
29 |         ('foo (address v)', 'foo(address)'),
30 |         ('foo(address v, int i)', 'foo(address,int256)'),
31 |         ('foo(address v,int i)', 'foo(address,int256)'),
32 |         ('foo(address[] v, int i)', 'foo(address[],int256)'),
33 |         ('foo(address[2] v, int i)', 'foo(address[2],int256)'),
34 |         ('foo(address[2][][3] v, int i)', 'foo(address[2][][3],int256)'),
35 |         # poorly normalized
36 |         ('foo(address )', 'foo(address)'),
37 |         ('foo( address)', 'foo(address)'),
38 |         ('foo( address )', 'foo(address)'),
39 |         ('foo (address )', 'foo(address)'),
40 |         ('foo ( address)', 'foo(address)'),
41 |         ('foo ( address )', 'foo(address)'),
42 |         ('foo(int)', 'foo(int256)'),
43 |         ('foo(int,uint)', 'foo(int256,uint256)'),
44 |         ('foo(int, uint)', 'foo(int256,uint256)'),
45 |         ('foo(int, uint )', 'foo(int256,uint256)'),
46 |         ('foo( int, uint)', 'foo(int256,uint256)'),
47 |         ('foo( int, uint )', 'foo(int256,uint256)'),
48 |         (' foo(uint256)', 'foo(uint256)'),
49 |         ('foo(uint256) ', 'foo(uint256)'),
50 |         (' foo(uint256) ', 'foo(uint256)'),
51 |         # bytes32
52 |         ('foo(bytes32)', 'foo(bytes32)'),
53 |         ('foo(address[1])', 'foo(address[1])'),
54 |         ('foo(bytes32[])', 'foo(bytes32[])'),
55 |         ('foo(uint8[])', 'foo(uint8[])'),
56 |         ('foo(uint8[][2][][3])', 'foo(uint8[][2][][3])'),
57 |         ('foo(uint8[][2][][3], uint, bytes32[3][])', 'foo(uint8[][2][][3],uint256,bytes32[3][])'),
58 |         # types in method name
59 |         ('mintToken(uint,address)', 'mintToken(uint256,address)'),
60 |         ('uint()', 'uint()'),
61 |         ('uint256()', 'uint256()'),
62 |         # mixed named/unnamed types
63 |         ('foo(uint x, bool)', 'foo(uint256,bool)'),
64 |         # complex ABI signature
65 |         ('foo(((int,int)[],(bool,fixed))[][2])', 'foo(((int256,int256)[],(bool,fixed128x18))[][2])'),  # noqa: E501
66 |         # indexed Arguments
67 |         ('foo(uint indexed a, string indexed b, address indexed c)', 'foo(uint256,string,address)'),
68 |         ('foo(uint indexed a)', 'foo(uint256)'),
69 |         # anonymous keyword
70 |         ('foo(uint) anonymous ', 'foo(uint256)')
71 |     )
72 | )
73 | def test_normalizing_event_signatures(raw_signature, expected):
74 |     actual = normalize_event_signature(raw_signature)
75 |     assert actual == expected
76 | 
77 | 
78 | @pytest.mark.parametrize(
79 |     'raw_signature',
80 |     (
81 |         '0x337b1cf9',
82 |         'foo(T x, U y)',
83 |         'foo(foo x, bar y)',
84 |         # mixed solidity/abi types
85 |         'foo(foo x, (bool,bool) y)',
86 |         # too many indexed arguments
87 |         'foo(uint indexed a, string indexed b, address indexed c, int indexed d)',
88 |         'foo(uint indexed a, string indexed b, address indexed c, int indexed d, string indexed e)',
89 |         # event name
90 |         'event 2asd(uint)',
91 |         'qwe qwe(uint)',
92 |         # random
93 |         'anonymous asd(uint) anonymous'
94 |     )
95 | )
96 | def test_bad_event_signatures(raw_signature):
97 |     with pytest.raises(ValueError):
98 |         normalize_event_signature(raw_signature)
99 | 


--------------------------------------------------------------------------------
/tests/web/utility/test_normalize_function_signature.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | 
 3 | from func_sig_registry.utils.solidity import (
 4 |     normalize_function_signature,
 5 | )
 6 | 
 7 | 
 8 | @pytest.mark.parametrize(
 9 |     'raw_signature,expected',
10 |     (
11 |         # from raw signatures
12 |         ('function foo(int a, int b, int c, int d)', 'foo(int256,int256,int256,int256)'),
13 |         ('function foo(address v)', 'foo(address)'),
14 |         ('function   foo  ( address v )', 'foo(address)'),
15 |         ('function foo(address v,\nint i)', 'foo(address,int256)'),
16 |         ('function foo(\naddress   v,\nint i\n)', 'foo(address,int256)'),
17 |         ('function foo (address v)', 'foo(address)'),
18 |         ('function foo(address v, int i)', 'foo(address,int256)'),
19 |         ('function foo(address v,int i)', 'foo(address,int256)'),
20 |         ('function foo(address[] v, int i)', 'foo(address[],int256)'),
21 |         ('function foo(address[2] v, int i)', 'foo(address[2],int256)'),
22 |         ('function foo(address[2][][3] v, int i)', 'foo(address[2][][3],int256)'),
23 |         # without function prefix
24 |         ('foo(int a, int b, int c, int d)', 'foo(int256,int256,int256,int256)'),
25 |         ('foo(address v)', 'foo(address)'),
26 |         ('  foo  ( address v )', 'foo(address)'),
27 |         ('foo(address v,\nint i)', 'foo(address,int256)'),
28 |         ('foo(\naddress   v,\nint i\n)', 'foo(address,int256)'),
29 |         ('foo (address v)', 'foo(address)'),
30 |         ('foo(address v, int i)', 'foo(address,int256)'),
31 |         ('foo(address v,int i)', 'foo(address,int256)'),
32 |         ('foo(address[] v, int i)', 'foo(address[],int256)'),
33 |         ('foo(address[2] v, int i)', 'foo(address[2],int256)'),
34 |         ('foo(address[2][][3] v, int i)', 'foo(address[2][][3],int256)'),
35 |         # poorly normalized
36 |         ('foo(address )', 'foo(address)'),
37 |         ('foo( address)', 'foo(address)'),
38 |         ('foo( address )', 'foo(address)'),
39 |         ('foo (address )', 'foo(address)'),
40 |         ('foo ( address)', 'foo(address)'),
41 |         ('foo ( address )', 'foo(address)'),
42 |         ('foo(int)', 'foo(int256)'),
43 |         ('foo(int,uint)', 'foo(int256,uint256)'),
44 |         ('foo(int, uint)', 'foo(int256,uint256)'),
45 |         ('foo(int, uint )', 'foo(int256,uint256)'),
46 |         ('foo( int, uint)', 'foo(int256,uint256)'),
47 |         ('foo( int, uint )', 'foo(int256,uint256)'),
48 |         (' foo(uint256)', 'foo(uint256)'),
49 |         ('foo(uint256) ', 'foo(uint256)'),
50 |         (' foo(uint256) ', 'foo(uint256)'),
51 |         # bytes32
52 |         ('foo(bytes32)', 'foo(bytes32)'),
53 |         ('foo(address[1])', 'foo(address[1])'),
54 |         ('foo(bytes32[])', 'foo(bytes32[])'),
55 |         ('foo(uint8[])', 'foo(uint8[])'),
56 |         ('foo(uint8[][2][][3])', 'foo(uint8[][2][][3])'),
57 |         ('foo(uint8[][2][][3], uint, bytes32[3][])', 'foo(uint8[][2][][3],uint256,bytes32[3][])'),
58 |         # types in method name
59 |         ('mintToken(uint,address)', 'mintToken(uint256,address)'),
60 |         ('uint()', 'uint()'),
61 |         ('uint256()', 'uint256()'),
62 |         # mixed named/unnamed types
63 |         ('foo(uint x, bool)', 'foo(uint256,bool)'),
64 |         # complex ABI signature
65 |         ('foo(((int,int)[],(bool,fixed))[][2])', 'foo(((int256,int256)[],(bool,fixed128x18))[][2])'),  # noqa: E501
66 |     )
67 | )
68 | def test_normalizing_function_signatures(raw_signature, expected):
69 |     actual = normalize_function_signature(raw_signature)
70 |     assert actual == expected
71 | 
72 | 
73 | @pytest.mark.parametrize(
74 |     'raw_signature',
75 |     (
76 |         '0x337b1cf9',
77 |         'foo(T x, U y)',
78 |         'foo(foo x, bar y)',
79 |         # mixed solidity/abi types
80 |         'foo(foo x, (bool,bool) y)',
81 |     )
82 | )
83 | def test_bad_signatures(raw_signature):
84 |     with pytest.raises(ValueError):
85 |         normalize_function_signature(raw_signature)
86 | 


--------------------------------------------------------------------------------
/tests/web/utility/test_retrieve_stats_from_import_results.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | 
 3 | from func_sig_registry.utils.import_statistics import (
 4 |     retrieve_stats_from_import_results,
 5 | )
 6 | 
 7 | 
 8 | @pytest.mark.parametrize(
 9 |     'array_of_tuples,expected',
10 |     (
11 |         (
12 |             [(None, False), (None, True), None, (None, True), (None, False)],
13 |             (5, 2, 2, 1)
14 |         ),
15 |         (  # Empty Array
16 |             [],
17 |             (0, 0, 0, 0)
18 |         ),
19 |         (  # Only None
20 |             [None, None, None, None],
21 |             (4, 0, 0, 4)
22 |         ),
23 |         (  # No None
24 |             [(None, True), (None, True), (None, True),
25 |                 (None, False), (None, False)],
26 |             (5, 3, 2, 0)
27 |         ),
28 |     ),
29 | )
30 | def test_retrieve_stats_from_import_results(array_of_tuples, expected):
31 |     actual = retrieve_stats_from_import_results(array_of_tuples)
32 |     assert actual == expected
33 | 


--------------------------------------------------------------------------------
/tests/web/views/test_signature_submit.py:
--------------------------------------------------------------------------------
  1 | from func_sig_registry.utils.events_solidity import normalize_event_signature
  2 | import pytest
  3 | 
  4 | from django.core.urlresolvers import reverse
  5 | from django.test import Client
  6 | from rest_framework import status
  7 | 
  8 | from func_sig_registry.registry.models import (
  9 |     Signature,
 10 |     EventSignature,
 11 | )
 12 | 
 13 | 
 14 | @pytest.mark.django_db
 15 | def test_function_and_event_signatures_created(api_client):
 16 |     create_url = reverse('signature-create')
 17 | 
 18 |     text_signature = 'foo(uint a)'
 19 |     normalized_text_signature = 'foo(uint256)'
 20 | 
 21 |     response = api_client.post(create_url, {'text_signature': text_signature}, follow=True)
 22 |     assert(response.status_code == status.HTTP_200_OK)
 23 | 
 24 |     function_signatures = Signature.objects.filter(text_signature=normalized_text_signature)
 25 |     event_sginatures = EventSignature.objects.filter(text_signature=normalized_text_signature)
 26 | 
 27 |     assert(len(function_signatures) == 1)
 28 |     assert(len(event_sginatures) == 1)
 29 | 
 30 | 
 31 | @pytest.mark.django_db
 32 | def test_signatures_created_notification():
 33 |     client = Client(HTTP_USER_AGENT='Mozilla/5.0', enforce_csrf_checks=True)
 34 | 
 35 |     response = client.post('/submit/', {'text_signature': 'a(uint256)'}, follow=True)
 36 | 
 37 |     assert(response.status_code == status.HTTP_200_OK)
 38 |     assert(b'Added function signature a(uint256).' in response.content)
 39 |     assert(b'Added event signature a(uint256).' in response.content)
 40 | 
 41 | 
 42 | @pytest.mark.django_db
 43 | def test_signature_duplicate_notification(factories):
 44 |     factories.EventSignatureFactory(text_signature='a(uint256)')
 45 |     factories.SignatureFactory(text_signature='a(uint256)')
 46 | 
 47 |     client = Client(HTTP_USER_AGENT='Mozilla/5.0', enforce_csrf_checks=True)
 48 | 
 49 |     response = client.post('/submit/', {'text_signature': 'a(uint256)'}, follow=True)
 50 | 
 51 |     assert(response.status_code == status.HTTP_200_OK)
 52 |     assert(b'Function signature a(uint256) already exists.' in response.content)
 53 |     assert(b'Event signature a(uint256) already exists.' in response.content)
 54 | 
 55 | 
 56 | @pytest.mark.django_db
 57 | def test_only_function_siganture_created_notification():
 58 |     # Event signature should not be created because signature has too many indexed arguments.
 59 |     function = 'foo(uint indexed a, uint indexed b, uint indexed c, uint indexed d, uint indexed e)'
 60 |     normalized = 'foo(uint256,uint256,uint256,uint256,uint256)'
 61 | 
 62 |     client = Client(HTTP_USER_AGENT='Mozilla/5.0', enforce_csrf_checks=True)
 63 |     response = client.post('/submit/', {'text_signature': function}, follow=True)
 64 | 
 65 |     assert(response.status_code == status.HTTP_200_OK)
 66 |     content = response.content.decode('utf-8')
 67 |     assert('Added function signature {0}.'.format(normalized) in content)
 68 |     assert('Added event signature {0}'.format(normalized) not in content)
 69 | 
 70 | 
 71 | @pytest.mark.django_db
 72 | def test_only_event_siganture_created_notification():
 73 |     # Function signature should not be created because signature is anonymous.
 74 |     signature = 'foo(uint a) anonymous'
 75 |     normalized = 'foo(uint256)'
 76 | 
 77 |     client = Client(HTTP_USER_AGENT='Mozilla/5.0', enforce_csrf_checks=True)
 78 |     response = client.post('/submit/', {'text_signature': signature}, follow=True)
 79 | 
 80 |     assert(response.status_code == status.HTTP_200_OK)
 81 |     content = response.content.decode('utf-8')
 82 |     assert('Added event signature {0}'.format(normalized) in content)
 83 |     assert('Added function signature {0}.'.format(normalized) not in content)
 84 | 
 85 | 
 86 | @pytest.mark.django_db
 87 | def test_error_notification():
 88 |     signature = 'foo(List a)'
 89 | 
 90 |     client = Client(HTTP_USER_AGENT='Mozilla/5.0', enforce_csrf_checks=True)
 91 |     response = client.post('/submit/', {'text_signature': signature}, follow=True)
 92 | 
 93 |     assert(response.status_code == status.HTTP_200_OK)
 94 |     content = response.content.decode('utf-8')
 95 |     assert('Function import error: function args contain non-standard types' in content)
 96 |     assert('Event import error: event args contain non-standard types' in content)
 97 | 
 98 | 
 99 | @pytest.mark.django_db
100 | def test_specific_error_messages_displayed():
101 |     # Function signature can not be created, because text contains anonynous keyword.
102 |     # Event signature can not be created either, because it has too many indexed arguments.
103 |     signature = 'foo(uint indexed a, uint indexed b, uint indexed c, \
104 |         uint indexed d, uint indexed e) anonymous'
105 | 
106 |     client = Client(HTTP_USER_AGENT='Mozilla/5.0', enforce_csrf_checks=True)
107 |     response = client.post('/submit/', {'text_signature': signature}, follow=True)
108 | 
109 |     assert(response.status_code == status.HTTP_200_OK)
110 |     content = response.content.decode('utf-8')
111 |     assert('Function import error: Could not parse function signature' in content)
112 |     assert('Event import error: Too many indexed arguments' in content)
113 | 


--------------------------------------------------------------------------------
/tox.ini:
--------------------------------------------------------------------------------
 1 | [flake8]
 2 | max-line-length = 100
 3 | exclude=**/migrations/*
 4 | 
 5 | [tox]
 6 | envlist=
 7 |     py36-django19,
 8 |     flake8
 9 | skipsdist=True
10 | 
11 | [testenv]
12 | basepython=python3.6
13 | commands=
14 |     django19: py.test {posargs:tests/web}
15 | passenv=
16 |     REDIS_URL
17 |     DATABASE_URL
18 |     SOLC_BINARY
19 | setenv=
20 |     DJANGO_SETTINGS_MODULE=func_sig_registry.settings
21 |     DJANGO_SECRET_KEY=not-a-real-secret-key
22 |     DJANGO_SECURE_SSL_REDIRECT=False
23 |     DJANGO_DEBUG=True
24 | deps =
25 |     -r{toxinidir}/requirements.txt
26 |     -r{toxinidir}/requirements-dev.txt
27 | 
28 | [testenv:flake8]
29 | basepython=python
30 | deps=flake8
31 | commands=flake8 {toxinidir}/func_sig_registry
32 | 


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