automatic import of python-eip712-structs

3 files changed, 677 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..77cdb90 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/eip712-structs-1.1.0.tar.gz
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  [![Build Status](https://travis-ci.org/ajrgrubbs/py-eip712-structs.svg?branch=master)](https://travis-ci.org/ajrgrubbs/py-eip712-structs) [![Coverage Status](https://coveralls.io/repos/github/ajrgrubbs/py-eip712-structs/badge.svg?branch=master)](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  [![Build Status](https://travis-ci.org/ajrgrubbs/py-eip712-structs.svg?branch=master)](https://travis-ci.org/ajrgrubbs/py-eip712-structs) [![Coverage Status](https://coveralls.io/repos/github/ajrgrubbs/py-eip712-structs/badge.svg?branch=master)](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  [![Build Status](https://travis-ci.org/ajrgrubbs/py-eip712-structs.svg?branch=master)](https://travis-ci.org/ajrgrubbs/py-eip712-structs) [![Coverage Status](https://coveralls.io/repos/github/ajrgrubbs/py-eip712-structs/badge.svg?branch=master)](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
diff --git a/sources b/sources
new file mode 100644
index 0000000..0f0dc01
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+91b66a28a1e8343dd6fe94312d12aa5d  eip712-structs-1.1.0.tar.gz