aboutsummaryrefslogtreecommitdiffstats
path: root/packages/order-utils/src/eip712_utils.ts
blob: b303c93dcb13b4e1369ac27052935ebddbb5ad58 (plain) (blame)
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
import ethUtil = require('ethereumjs-util');
import * as _ from 'lodash';

import { crypto } from './crypto';
import { EIP712Schema, EIP712Types } from './types';

const EIP191_PREFIX = '\x19\x01';
const EIP712_DOMAIN_NAME = '0x Protocol';
const EIP712_DOMAIN_VERSION = '2';
const EIP712_VALUE_LENGTH = 32;

const EIP712_DOMAIN_SCHEMA: EIP712Schema = {
    name: 'EIP712Domain',
    parameters: [
        { name: 'name', type: EIP712Types.String },
        { name: 'version', type: EIP712Types.String },
        { name: 'verifyingContract', type: EIP712Types.Address },
    ],
};

export const eip712Utils = {
    /**
     * Compiles the EIP712Schema and returns the hash of the schema.
     * @param   schema The EIP712 schema.
     * @return  The hash of the compiled schema
     */
    compileSchema(schema: EIP712Schema): Buffer {
        const eip712Schema = eip712Utils._encodeType(schema);
        const eip712SchemaHashBuffer = crypto.solSHA3([eip712Schema]);
        return eip712SchemaHashBuffer;
    },
    /**
     * Merges the EIP712 hash of a struct with the DomainSeparator for 0x v2.
     * @param   hashStruct the EIP712 hash of a struct
     * @param   contractAddress the exchange contract address
     * @return  The hash of an EIP712 message with domain separator prefixed
     */
    createEIP712Message(hashStruct: Buffer, contractAddress: string): Buffer {
        const domainSeparatorHashBuffer = eip712Utils._getDomainSeparatorHashBuffer(contractAddress);
        const messageBuff = crypto.solSHA3([EIP191_PREFIX, domainSeparatorHashBuffer, hashStruct]);
        return messageBuff;
    },
    /**
     * Pad an address to 32 bytes
     * @param address Address to pad
     * @return padded address
     */
    pad32Address(address: string): Buffer {
        const addressBuffer = ethUtil.toBuffer(address);
        const addressPadded = eip712Utils.pad32Buffer(addressBuffer);
        return addressPadded;
    },
    /**
     * Pad an buffer to 32 bytes
     * @param buffer Address to pad
     * @return padded buffer
     */
    pad32Buffer(buffer: Buffer): Buffer {
        const bufferPadded = ethUtil.setLengthLeft(buffer, EIP712_VALUE_LENGTH);
        return bufferPadded;
    },
    /**
     * Hash together a EIP712 schema with the corresponding data
     * @param schema EIP712-compliant schema
     * @param data Data the complies to the schema
     * @return A buffer containing the SHA256 hash of the schema and encoded data
     */
    structHash(schema: EIP712Schema, data: { [key: string]: any }): Buffer {
        const encodedData = eip712Utils._encodeData(schema, data);
        const schemaHash = eip712Utils.compileSchema(schema);
        const hashBuffer = crypto.solSHA3([schemaHash, ...encodedData]);
        return hashBuffer;
    },
    _getDomainSeparatorSchemaBuffer(): Buffer {
        return eip712Utils.compileSchema(EIP712_DOMAIN_SCHEMA);
    },
    _getDomainSeparatorHashBuffer(exchangeAddress: string): Buffer {
        const domainSeparatorSchemaBuffer = eip712Utils._getDomainSeparatorSchemaBuffer();
        const encodedData = eip712Utils._encodeData(EIP712_DOMAIN_SCHEMA, {
            name: EIP712_DOMAIN_NAME,
            version: EIP712_DOMAIN_VERSION,
            verifyingContract: exchangeAddress,
        });
        const domainSeparatorHashBuff2 = crypto.solSHA3([domainSeparatorSchemaBuffer, ...encodedData]);
        return domainSeparatorHashBuff2;
    },
    _encodeType(schema: EIP712Schema): string {
        const namedTypes = _.map(schema.parameters, ({ name, type }) => `${type} ${name}`);
        const namedTypesJoined = namedTypes.join(',');
        const encodedType = `${schema.name}(${namedTypesJoined})`;
        return encodedType;
    },
    _encodeData(schema: EIP712Schema, data: { [key: string]: any }): any {
        const encodedValues = [];
        for (const parameter of schema.parameters) {
            const value = data[parameter.name];
            if (parameter.type === EIP712Types.String || parameter.type === EIP712Types.Bytes) {
                encodedValues.push(crypto.solSHA3([ethUtil.toBuffer(value)]));
            } else if (parameter.type === EIP712Types.Uint256) {
                encodedValues.push(value);
            } else if (parameter.type === EIP712Types.Address) {
                encodedValues.push(eip712Utils.pad32Address(value));
            } else {
                throw new Error(`Unable to encode ${parameter.type}`);
            }
        }
        return encodedValues;
    },
};