feat(aztec.js): add permit signing function

add associated test
tidy up other MetaMask comparison tests

packages/aztec.js/src/signer/index.js

@@ -202,6 +202,34 @@ signer.signNoteACEDomain = (verifyingContract, spender, privateKey) => {
     return { signature, encodedTypedData };
 };
 
+/**
+ * Allows a user to create a signature for use in the DAI.permit() function. Creates an EIP712 ECDSA
+ * signature
+ * 
+ * @method signPermit
+ * @param {Object} holderAccount - address that owns the tokens, which is approving a spender to spend
+ * @param {Address} spender - address being approved to spend the tokens
+ * @param {Number} nonce - nonce of the transaction. Used for replay protection in the DAI token contract
+ * @param {Number} expiry - unix timestamp corresponding to the upper boundary for when the permit is valid
+ * @param {Bool} allowed - whether approval is being granted or revoked
+ */
+signer.signPermit = (verifyingContract, holderAccount, spender, nonce, expiry, allowed) => {
+    const { address: holder, privateKey } = holderAccount;
+    const domain = signer.generateAccountRegistryDomainParams(verifyingContract);
+    const schema = constants.eip712.PERMIT_SIGNATURE;
+
+    const message = {
+        holder,
+        spender,
+        nonce,
+        expiry,
+        allowed,
+    };
+
+    const { unformattedSignature } = signer.signTypedData(domain, schema, message, privateKey);
+    return `0x${unformattedSignature.slice(0, 130)}`;
+};
+
 /**
  * Create an EIP712 ECDSA signature over structured data. This is a low level function that returns the signature parameters
  * in an unstructured form - `r`, `s` and `v` are all 32 bytes in size.

packages/aztec.js/test/signer/index.js

@@ -235,25 +235,12 @@ describe('Signer', () => {
             const testNoteValue = 10;
             const testNote = await note.create(aztecAccount.publicKey, testNoteValue);
 
+            const domain = signer.generateZKAssetDomainParams(verifyingContract);
+            const { types, primaryType } = constants.eip712.NOTE_SIGNATURE;
             const metaMaskTypedData = {
-                domain: {
-                    name: 'ZK_ASSET',
-                    version: '1',
-                    verifyingContract,
-                },
-                types: {
-                    NoteSignature: [
-                        { name: 'noteHash', type: 'bytes32' },
-                        { name: 'spender', type: 'address' },
-                        { name: 'spenderApproval', type: 'bool' },
-                    ],
-                    EIP712Domain: [
-                        { name: 'name', type: 'string' },
-                        { name: 'version', type: 'string' },
-                        { name: 'verifyingContract', type: 'address' },
-                    ],
-                },
-                primaryType: 'NoteSignature',
+                domain,
+                types,
+                primaryType,
                 message: {
                     noteHash: testNote.noteHash,
                     spender,
@@ -280,8 +267,8 @@ describe('Signer', () => {
             const aztecAccount = secp256k1.generateAccount();
             const spender = randomHex(20);
             const verifyingContract = randomHex(20);
-
             const joinSplitProof = randomHex(20);
+            const proofHash = keccak256(joinSplitProof);
 
             const aztecSignature = signer.signApprovalForProof(
                 verifyingContract,
@@ -291,41 +278,54 @@ describe('Signer', () => {
                 aztecAccount.privateKey,
             );
 
-            const proofHash = keccak256(joinSplitProof);
-
-            const message = {
-                proofHash,
-                spender,
-                approval: true,
-            };
 
+            const domain = signer.generateZKAssetDomainParams(verifyingContract);
+            const { types, primaryType } = constants.eip712.PROOF_SIGNATURE;
             const metaMaskTypedData = {
-                domain: {
-                    name: 'ZK_ASSET',
-                    version: '1',
-                    verifyingContract,
-                },
-                types: {
-                    ProofSignature: [
-                        { name: 'proofHash', type: 'bytes32' },
-                        { name: 'spender', type: 'address' },
-                        { name: 'approval', type: 'bool' },
-                    ],
-                    EIP712Domain: [
-                        { name: 'name', type: 'string' },
-                        { name: 'version', type: 'string' },
-                        { name: 'verifyingContract', type: 'address' },
-                    ],
+                domain,
+                types,
+                primaryType,
+                message: {
+                    proofHash,
+                    spender,
+                    approval: true,
                 },
-                primaryType: 'ProofSignature',
-                message,
             };
 
             // eth-sig-util is the MetaMask signing package
             const metaMaskSignature = ethSigUtil.signTypedData_v4(Buffer.from(aztecAccount.privateKey.slice(2), 'hex'), {
                 data: metaMaskTypedData,
             });
+            expect(aztecSignature).to.equal(metaMaskSignature);
+        });
 
+        it('signPermit() should produce same signature as MetaMask signing function', async () => {
+            const verifyingContract = randomHex(20);
+            const holderAccount = secp256k1.generateAccount();
+            const spender = randomHex(20);
+            const nonce = 5;
+            const expiry = 10;
+            const allowed = true;
+            const aztecSignature = signer.signPermit(verifyingContract, holderAccount, spender, nonce, expiry, allowed);
+
+            const domain = signer.generateAccountRegistryDomainParams(verifyingContract);
+            const { types, primaryType } = constants.eip712.PERMIT_SIGNATURE;
+            const metaMaskTypedData = {
+                domain,
+                types,
+                primaryType,
+                message: {
+                    holder: holderAccount.address,
+                    spender,
+                    nonce,
+                    expiry,
+                    allowed,
+                },
+            };
+            // eth-sig-util is the MetaMask signing package
+            const metaMaskSignature = ethSigUtil.signTypedData_v4(Buffer.from(holderAccount.privateKey.slice(2), 'hex'), {
+                data: metaMaskTypedData,
+            });
             expect(aztecSignature).to.equal(metaMaskSignature);
         });
     });