dydx-v3-rust 0.2.3

Rust SDK for dYdX v3 API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

from web3 import Web3

import util

DOMAIN = 'dYdX'
VERSION = '1.0'
EIP712_DOMAIN_STRING_NO_CONTRACT = (
    'EIP712Domain(' +
    'string name,' +
    'string version,' +
    'uint256 chainId' +
    ')'
)


class SignOffChainAction(object):

    def __init__(self, signer, network_id):
        self.signer = signer
        self.network_id = network_id

    def get_hash(self, **message):
        raise NotImplementedError

    def get_eip712_struct(self):
        raise NotImplementedError

    def get_eip712_struct_name(self):
        raise NotImplementedError

    def sign(
        self,
        signer_address,
        **message,
    ):
        eip712_message = self.get_eip712_message(**message)
        message_hash = self.get_hash(**message)
        typed_signature = self.signer.sign(
            eip712_message,
            message_hash,
            signer_address,
        )
        return typed_signature

    def verify(
        self,
        typed_signature,
        expected_signer_address,
        **message,
    ):
        message_hash = self.get_hash(**message)
        signer = util.ec_recover_typed_signature(message_hash, typed_signature)
        return util.addresses_are_equal(signer, expected_signer_address)

    def get_eip712_message(
        self,
        **message,
    ):
        struct_name = self.get_eip712_struct_name()
        return {
            'types': {
                'EIP712Domain': [
                    {
                        'name': 'name',
                        'type': 'string',
                    },
                    {
                        'name': 'version',
                        'type': 'string',
                    },
                    {
                        'name': 'chainId',
                        'type': 'uint256',
                    },
                ],
                struct_name: self.get_eip712_struct(),
            },
            'domain': {
                'name': DOMAIN,
                'version': VERSION,
                'chainId': self.network_id,
            },
            'primaryType': struct_name,
            'message': message,
        }

    def get_eip712_hash(self, struct_hash):
        return Web3.solidityKeccak(
            [
                'bytes2',
                'bytes32',
                'bytes32',
            ],
            [
                '0x1901',
                self.get_domain_hash(),
                struct_hash,
            ]
        )

    def get_domain_hash(self):
        return Web3.solidityKeccak(
            [
                'bytes32',
                'bytes32',
                'bytes32',
                'uint256',
            ],
            [
                util.hash_string(EIP712_DOMAIN_STRING_NO_CONTRACT),
                util.hash_string(DOMAIN),
                util.hash_string(VERSION),
                self.network_id,
            ],
        )