add permit

test/utils/SignHelper.ts

@@ -0,0 +1,114 @@
+const ethUtil = require('ethereumjs-util');
+const abi =  require('ethereumjs-abi');
+
+export class SignHelper {
+
+    private typedData = {
+        types: {
+            EIP712Domain: [
+                { name: 'name', type: 'string' },
+                { name: 'version', type: 'string' },
+                { name: 'chainId', type: 'uint256' },
+                { name: 'verifyingContract', type: 'address' },
+            ],
+            Permit: [
+                { name: 'owner', type: 'address' },
+                { name: 'spender', type: 'address' },
+                { name: 'value', type: 'uint256' },
+                { name: 'nonce', type: 'uint256' },
+                { name: 'deadline', type: 'uint256' },
+            ]
+        },
+        primaryType: 'Permit',
+    };
+
+    private types = this.typedData.types;
+
+    // Recursively finds all the dependencies of a type
+    private dependencies(primaryType, found = []) {
+        if (found.includes(primaryType)) {
+            return found;
+        }
+        if (this.types[primaryType] === undefined) {
+            return found;
+        }
+        found.push(primaryType);
+        for (let field of this.types[primaryType]) {
+            for (let dep of this.dependencies(field.type, found)) {
+                if (!found.includes(dep)) {
+                    found.push(dep);
+                }
+            }
+        }
+        return found;
+    }
+
+    private encodeType(primaryType): Buffer {
+        // Get dependencies primary first, then alphabetical
+        let deps = this.dependencies(primaryType);
+        deps = deps.filter(t => t != primaryType);
+        deps = [primaryType].concat(deps.sort());
+
+        // Format as a string with fields
+        let result = '';
+        for (let type of deps) {
+            result += `${type}(${this.types[type].map(({ name, type }) => `${type} ${name}`).join(',')})`;
+        }
+        return Buffer.from(result);
+    }
+
+    private typeHash(primaryType) {
+        return ethUtil.keccak256(this.encodeType(primaryType));
+    }
+
+    private encodeData(primaryType, data):Buffer {
+        let encTypes = [];
+        let encValues = [];
+        // Add typehash
+        encTypes.push('bytes32');
+        encValues.push(this.typeHash(primaryType));
+
+        // Add field contents
+        for (let field of this.types[primaryType]) {
+            let value = data[field.name];
+            // console.log("type:" + field.type);
+            // console.log("value:" + value);
+            // encTypes.push(field.type);
+            // encValues.push(value);
+            if (field.type == 'string' || field.type == 'bytes') {
+                encTypes.push('bytes32');
+                value = ethUtil.keccak256(Buffer.from(value));
+                encValues.push(value);
+            } else if (this.types[field.type] !== undefined) {
+                encTypes.push('bytes32');
+                value = ethUtil.keccak256(this.encodeData(field.type, value));
+                encValues.push(value);
+            } else if (field.type.lastIndexOf(']') === field.type.length - 1) {
+                throw 'TODO: Arrays currently unimplemented in encodeData';
+            } else {
+                encTypes.push(field.type);
+                encValues.push(value);
+            }
+        }
+
+        return abi.rawEncode(encTypes, encValues);
+    }
+
+    private structHash(primaryType, data) {
+        return ethUtil.keccak256(this.encodeData(primaryType, data));
+    }
+
+    public signHash(domain: string, message: any) {
+        var digest = ethUtil.keccak256(
+            Buffer.concat([
+                Buffer.from('1901', 'hex'),
+                Buffer.from(domain),
+                // this.structHash('EIP712Domain', domain),
+                this.structHash(this.typedData.primaryType, message),
+            ]),
+        );
+        console.log("digest:", "0x" + digest.toString("hex"));
+        return digest;
+    }
+}
+