115 lines
3.8 KiB
TypeScript
115 lines
3.8 KiB
TypeScript
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;
|
|
}
|
|
}
|
|
|