diff options
Diffstat (limited to 'python-eip712-structs.spec')
| -rw-r--r-- | python-eip712-structs.spec | 675 |
1 files changed, 675 insertions, 0 deletions
diff --git a/python-eip712-structs.spec b/python-eip712-structs.spec new file mode 100644 index 0000000..19d6f8b --- /dev/null +++ b/python-eip712-structs.spec @@ -0,0 +1,675 @@ +%global _empty_manifest_terminate_build 0 +Name: python-eip712-structs +Version: 1.1.0 +Release: 1 +Summary: A python library for EIP712 objects +License: MIT +URL: https://github.com/ajrgrubbs/py-eip712-structs +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/36/e0/0c79d27da8918f7642cba8ad4b0e6176ff7a8b4774f363c6ceb2513474be/eip712-structs-1.1.0.tar.gz +BuildArch: noarch + + +%description +# EIP-712 Structs [](https://travis-ci.org/ajrgrubbs/py-eip712-structs) [](https://coveralls.io/github/ajrgrubbs/py-eip712-structs?branch=master) + +A python interface for simple EIP-712 struct construction. + +In this module, a "struct" is structured data as defined in the standard. +It is not the same as the Python Standard Library's struct (e.g., `import struct`). + +Read the proposal:<br/> +https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md + +#### Supported Python Versions +- `3.6` +- `3.7` + +## Install +```bash +pip install eip712-structs +``` + +## Usage +See [API.md](API.md) for a succinct summary of available methods. + +Examples/Details below. + +#### Quickstart +Say we want to represent the following struct, convert it to a message and sign it: +```text +struct MyStruct { + string some_string; + uint256 some_number; +} +``` + +With this module, that would look like: +```python +# Make a unique domain +from eip712_structs import make_domain +domain = make_domain(name='Some name', version='1.0.0') # Make a Domain Separator + +# Define your struct type +from eip712_structs import EIP712Struct, String, Uint +class MyStruct(EIP712Struct): + some_string = String() + some_number = Uint(256) + +# Create an instance with some data +mine = MyStruct(some_string='hello world', some_number=1234) + +# Into a message dict (serializable to JSON) - domain required +my_msg = mine.to_message(domain) + +# Into signable bytes - domain required +my_bytes = mine.signable_bytes(domain) +``` + +See [Member Types](#member-types) for more information on supported types. + +#### Dynamic construction +Attributes may be added dynamically as well. This may be necessary if you +want to use a reserved keyword like `from`. + +```python +from eip712_structs import EIP712Struct, Address +class Message(EIP712Struct): + pass + +Message.to = Address() +setattr(Message, 'from', Address()) +``` + +#### The domain separator +EIP-712 specifies a domain struct, to differentiate between identical structs that may be unrelated. +A helper method exists for this purpose. +All values to the `make_domain()` +function are optional - but at least one must be defined. If omitted, the resulting +domain struct's definition leaves out the parameter entirely. + +The full signature: <br/> +`make_domain(name: string, version: string, chainId: uint256, verifyingContract: address, salt: bytes32)` + +##### Setting a default domain +Constantly providing the same domain can be cumbersome. You can optionally set a default, and then forget it. +It is automatically used by `.to_message()` and `.signable_bytes()` + +```python +import eip712_structs + +foo = SomeStruct() + +my_domain = eip712_structs.make_domain(name='hello world') +eip712_structs.default_domain = my_domain + +assert foo.to_message() == foo.to_message(my_domain) +assert foo.signable_bytes() == foo.signable_bytes(my_domain) +``` + +## Member Types + +### Basic types +EIP712's basic types map directly to solidity types. + +```python +from eip712_structs import Address, Boolean, Bytes, Int, String, Uint + +Address() # Solidity's 'address' +Boolean() # 'bool' +Bytes() # 'bytes' +Bytes(N) # 'bytesN' - N must be an int from 1 through 32 +Int(N) # 'intN' - N must be a multiple of 8, from 8 to 256 +String() # 'string' +Uint(N) # 'uintN' - N must be a multiple of 8, from 8 to 256 +``` + +Use like: +```python +from eip712_structs import EIP712Struct, Address, Bytes + +class Foo(EIP712Struct): + member_name_0 = Address() + member_name_1 = Bytes(5) + # ...etc +``` + +### Struct references +In addition to holding basic types, EIP712 structs may also hold other structs! +Usage is almost the same - the difference is you don't "instantiate" the class. + +Example: +```python +from eip712_structs import EIP712Struct, String + +class Dog(EIP712Struct): + name = String() + breed = String() + +class Person(EIP712Struct): + name = String() + dog = Dog # Take note - no parentheses! + +# Dog "stands alone" +Dog.encode_type() # Dog(string name,string breed) + +# But Person knows how to include Dog +Person.encode_type() # Person(string name,Dog dog)Dog(string name,string breed) +``` + +Instantiating the structs with nested values may be done a couple different ways: + +```python +# Method one: set it to a struct +dog = Dog(name='Mochi', breed='Corgi') +person = Person(name='E.M.', dog=dog) + +# Method two: set it to a dict - the underlying struct is built for you +person = Person( + name='E.M.', + dog={ + 'name': 'Mochi', + 'breed': 'Corgi', + } +) +``` + +### Arrays +Arrays are also supported for the standard. + +```python +array_member = Array(<item_type>[, <optional_length>]) +``` + +- `<item_type>` - The basic type or struct that will live in the array +- `<optional_length>` - If given, the array is set to that length. + +For example: +```python +dynamic_array = Array(String()) # String[] dynamic_array +static_array = Array(String(), 10) # String[10] static_array +struct_array = Array(MyStruct, 10) # MyStruct[10] - again, don't instantiate structs like the basic types +``` + +## Development +Contributions always welcome. + +Install dependencies: +- `pip install -r requirements.txt` + +Run tests: +- `python setup.py test` +- Some tests expect an active local ganache chain on http://localhost:8545. Docker will compile the contracts and start the chain for you. +- Docker is optional, but useful to test the whole suite. If no chain is detected, chain tests are skipped. +- Usage: + - `docker-compose up -d` (Starts containers in the background) + - Note: Contracts are compiled when you run `up`, but won't be deployed until the test is run. + - Cleanup containers when you're done: `docker-compose down` + +Deploying a new version: +- Bump the version number in `setup.py`, commit it into master. +- Make a release tag on the master branch in Github. Travis should handle the rest. + + +## Shameless Plug +Written by [ConsenSys](https://consensys.net) for ourselves and the community! :heart: + +%package -n python3-eip712-structs +Summary: A python library for EIP712 objects +Provides: python-eip712-structs +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-eip712-structs +# EIP-712 Structs [](https://travis-ci.org/ajrgrubbs/py-eip712-structs) [](https://coveralls.io/github/ajrgrubbs/py-eip712-structs?branch=master) + +A python interface for simple EIP-712 struct construction. + +In this module, a "struct" is structured data as defined in the standard. +It is not the same as the Python Standard Library's struct (e.g., `import struct`). + +Read the proposal:<br/> +https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md + +#### Supported Python Versions +- `3.6` +- `3.7` + +## Install +```bash +pip install eip712-structs +``` + +## Usage +See [API.md](API.md) for a succinct summary of available methods. + +Examples/Details below. + +#### Quickstart +Say we want to represent the following struct, convert it to a message and sign it: +```text +struct MyStruct { + string some_string; + uint256 some_number; +} +``` + +With this module, that would look like: +```python +# Make a unique domain +from eip712_structs import make_domain +domain = make_domain(name='Some name', version='1.0.0') # Make a Domain Separator + +# Define your struct type +from eip712_structs import EIP712Struct, String, Uint +class MyStruct(EIP712Struct): + some_string = String() + some_number = Uint(256) + +# Create an instance with some data +mine = MyStruct(some_string='hello world', some_number=1234) + +# Into a message dict (serializable to JSON) - domain required +my_msg = mine.to_message(domain) + +# Into signable bytes - domain required +my_bytes = mine.signable_bytes(domain) +``` + +See [Member Types](#member-types) for more information on supported types. + +#### Dynamic construction +Attributes may be added dynamically as well. This may be necessary if you +want to use a reserved keyword like `from`. + +```python +from eip712_structs import EIP712Struct, Address +class Message(EIP712Struct): + pass + +Message.to = Address() +setattr(Message, 'from', Address()) +``` + +#### The domain separator +EIP-712 specifies a domain struct, to differentiate between identical structs that may be unrelated. +A helper method exists for this purpose. +All values to the `make_domain()` +function are optional - but at least one must be defined. If omitted, the resulting +domain struct's definition leaves out the parameter entirely. + +The full signature: <br/> +`make_domain(name: string, version: string, chainId: uint256, verifyingContract: address, salt: bytes32)` + +##### Setting a default domain +Constantly providing the same domain can be cumbersome. You can optionally set a default, and then forget it. +It is automatically used by `.to_message()` and `.signable_bytes()` + +```python +import eip712_structs + +foo = SomeStruct() + +my_domain = eip712_structs.make_domain(name='hello world') +eip712_structs.default_domain = my_domain + +assert foo.to_message() == foo.to_message(my_domain) +assert foo.signable_bytes() == foo.signable_bytes(my_domain) +``` + +## Member Types + +### Basic types +EIP712's basic types map directly to solidity types. + +```python +from eip712_structs import Address, Boolean, Bytes, Int, String, Uint + +Address() # Solidity's 'address' +Boolean() # 'bool' +Bytes() # 'bytes' +Bytes(N) # 'bytesN' - N must be an int from 1 through 32 +Int(N) # 'intN' - N must be a multiple of 8, from 8 to 256 +String() # 'string' +Uint(N) # 'uintN' - N must be a multiple of 8, from 8 to 256 +``` + +Use like: +```python +from eip712_structs import EIP712Struct, Address, Bytes + +class Foo(EIP712Struct): + member_name_0 = Address() + member_name_1 = Bytes(5) + # ...etc +``` + +### Struct references +In addition to holding basic types, EIP712 structs may also hold other structs! +Usage is almost the same - the difference is you don't "instantiate" the class. + +Example: +```python +from eip712_structs import EIP712Struct, String + +class Dog(EIP712Struct): + name = String() + breed = String() + +class Person(EIP712Struct): + name = String() + dog = Dog # Take note - no parentheses! + +# Dog "stands alone" +Dog.encode_type() # Dog(string name,string breed) + +# But Person knows how to include Dog +Person.encode_type() # Person(string name,Dog dog)Dog(string name,string breed) +``` + +Instantiating the structs with nested values may be done a couple different ways: + +```python +# Method one: set it to a struct +dog = Dog(name='Mochi', breed='Corgi') +person = Person(name='E.M.', dog=dog) + +# Method two: set it to a dict - the underlying struct is built for you +person = Person( + name='E.M.', + dog={ + 'name': 'Mochi', + 'breed': 'Corgi', + } +) +``` + +### Arrays +Arrays are also supported for the standard. + +```python +array_member = Array(<item_type>[, <optional_length>]) +``` + +- `<item_type>` - The basic type or struct that will live in the array +- `<optional_length>` - If given, the array is set to that length. + +For example: +```python +dynamic_array = Array(String()) # String[] dynamic_array +static_array = Array(String(), 10) # String[10] static_array +struct_array = Array(MyStruct, 10) # MyStruct[10] - again, don't instantiate structs like the basic types +``` + +## Development +Contributions always welcome. + +Install dependencies: +- `pip install -r requirements.txt` + +Run tests: +- `python setup.py test` +- Some tests expect an active local ganache chain on http://localhost:8545. Docker will compile the contracts and start the chain for you. +- Docker is optional, but useful to test the whole suite. If no chain is detected, chain tests are skipped. +- Usage: + - `docker-compose up -d` (Starts containers in the background) + - Note: Contracts are compiled when you run `up`, but won't be deployed until the test is run. + - Cleanup containers when you're done: `docker-compose down` + +Deploying a new version: +- Bump the version number in `setup.py`, commit it into master. +- Make a release tag on the master branch in Github. Travis should handle the rest. + + +## Shameless Plug +Written by [ConsenSys](https://consensys.net) for ourselves and the community! :heart: + +%package help +Summary: Development documents and examples for eip712-structs +Provides: python3-eip712-structs-doc +%description help +# EIP-712 Structs [](https://travis-ci.org/ajrgrubbs/py-eip712-structs) [](https://coveralls.io/github/ajrgrubbs/py-eip712-structs?branch=master) + +A python interface for simple EIP-712 struct construction. + +In this module, a "struct" is structured data as defined in the standard. +It is not the same as the Python Standard Library's struct (e.g., `import struct`). + +Read the proposal:<br/> +https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md + +#### Supported Python Versions +- `3.6` +- `3.7` + +## Install +```bash +pip install eip712-structs +``` + +## Usage +See [API.md](API.md) for a succinct summary of available methods. + +Examples/Details below. + +#### Quickstart +Say we want to represent the following struct, convert it to a message and sign it: +```text +struct MyStruct { + string some_string; + uint256 some_number; +} +``` + +With this module, that would look like: +```python +# Make a unique domain +from eip712_structs import make_domain +domain = make_domain(name='Some name', version='1.0.0') # Make a Domain Separator + +# Define your struct type +from eip712_structs import EIP712Struct, String, Uint +class MyStruct(EIP712Struct): + some_string = String() + some_number = Uint(256) + +# Create an instance with some data +mine = MyStruct(some_string='hello world', some_number=1234) + +# Into a message dict (serializable to JSON) - domain required +my_msg = mine.to_message(domain) + +# Into signable bytes - domain required +my_bytes = mine.signable_bytes(domain) +``` + +See [Member Types](#member-types) for more information on supported types. + +#### Dynamic construction +Attributes may be added dynamically as well. This may be necessary if you +want to use a reserved keyword like `from`. + +```python +from eip712_structs import EIP712Struct, Address +class Message(EIP712Struct): + pass + +Message.to = Address() +setattr(Message, 'from', Address()) +``` + +#### The domain separator +EIP-712 specifies a domain struct, to differentiate between identical structs that may be unrelated. +A helper method exists for this purpose. +All values to the `make_domain()` +function are optional - but at least one must be defined. If omitted, the resulting +domain struct's definition leaves out the parameter entirely. + +The full signature: <br/> +`make_domain(name: string, version: string, chainId: uint256, verifyingContract: address, salt: bytes32)` + +##### Setting a default domain +Constantly providing the same domain can be cumbersome. You can optionally set a default, and then forget it. +It is automatically used by `.to_message()` and `.signable_bytes()` + +```python +import eip712_structs + +foo = SomeStruct() + +my_domain = eip712_structs.make_domain(name='hello world') +eip712_structs.default_domain = my_domain + +assert foo.to_message() == foo.to_message(my_domain) +assert foo.signable_bytes() == foo.signable_bytes(my_domain) +``` + +## Member Types + +### Basic types +EIP712's basic types map directly to solidity types. + +```python +from eip712_structs import Address, Boolean, Bytes, Int, String, Uint + +Address() # Solidity's 'address' +Boolean() # 'bool' +Bytes() # 'bytes' +Bytes(N) # 'bytesN' - N must be an int from 1 through 32 +Int(N) # 'intN' - N must be a multiple of 8, from 8 to 256 +String() # 'string' +Uint(N) # 'uintN' - N must be a multiple of 8, from 8 to 256 +``` + +Use like: +```python +from eip712_structs import EIP712Struct, Address, Bytes + +class Foo(EIP712Struct): + member_name_0 = Address() + member_name_1 = Bytes(5) + # ...etc +``` + +### Struct references +In addition to holding basic types, EIP712 structs may also hold other structs! +Usage is almost the same - the difference is you don't "instantiate" the class. + +Example: +```python +from eip712_structs import EIP712Struct, String + +class Dog(EIP712Struct): + name = String() + breed = String() + +class Person(EIP712Struct): + name = String() + dog = Dog # Take note - no parentheses! + +# Dog "stands alone" +Dog.encode_type() # Dog(string name,string breed) + +# But Person knows how to include Dog +Person.encode_type() # Person(string name,Dog dog)Dog(string name,string breed) +``` + +Instantiating the structs with nested values may be done a couple different ways: + +```python +# Method one: set it to a struct +dog = Dog(name='Mochi', breed='Corgi') +person = Person(name='E.M.', dog=dog) + +# Method two: set it to a dict - the underlying struct is built for you +person = Person( + name='E.M.', + dog={ + 'name': 'Mochi', + 'breed': 'Corgi', + } +) +``` + +### Arrays +Arrays are also supported for the standard. + +```python +array_member = Array(<item_type>[, <optional_length>]) +``` + +- `<item_type>` - The basic type or struct that will live in the array +- `<optional_length>` - If given, the array is set to that length. + +For example: +```python +dynamic_array = Array(String()) # String[] dynamic_array +static_array = Array(String(), 10) # String[10] static_array +struct_array = Array(MyStruct, 10) # MyStruct[10] - again, don't instantiate structs like the basic types +``` + +## Development +Contributions always welcome. + +Install dependencies: +- `pip install -r requirements.txt` + +Run tests: +- `python setup.py test` +- Some tests expect an active local ganache chain on http://localhost:8545. Docker will compile the contracts and start the chain for you. +- Docker is optional, but useful to test the whole suite. If no chain is detected, chain tests are skipped. +- Usage: + - `docker-compose up -d` (Starts containers in the background) + - Note: Contracts are compiled when you run `up`, but won't be deployed until the test is run. + - Cleanup containers when you're done: `docker-compose down` + +Deploying a new version: +- Bump the version number in `setup.py`, commit it into master. +- Make a release tag on the master branch in Github. Travis should handle the rest. + + +## Shameless Plug +Written by [ConsenSys](https://consensys.net) for ourselves and the community! :heart: + +%prep +%autosetup -n eip712-structs-1.1.0 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-eip712-structs -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Thu May 18 2023 Python_Bot <Python_Bot@openeuler.org> - 1.1.0-1 +- Package Spec generated |