@ledgerhq/hw-app-eth/tests/EIP712/utils.unit.test.ts

Ledger Hardware Wallet Ethereum Application API

import BigNumber from "bignumber.js";
import { hexBuffer, padHexString } from "../../src/utils";
import {
  constructTypeDescByteString,
  destructTypeFromString,
  EIP712_TYPE_ENCODERS,
  getAppAndVersion,
  getCoinRefTokensMap,
  getFilterDisplayNameAndSigBuffers,
  getPayloadForFilterV2,
  makeTypeEntryStructBuffer,
} from "../../src/modules/EIP712/utils";

const convertTwosComplementToDecimalString = (hex: string, initialValue: string) => {
  if (!initialValue?.startsWith("-")) {
    return new BigNumber(padHexString(hex), 16).toFixed();
  }

  const hexAsBN = new BigNumber(padHexString(hex), 16);
  const maskAsBN = new BigNumber(Buffer.alloc(hex.length / 2, 0xff).toString("hex"), 16);

  return hexAsBN.minus(maskAsBN).minus(1).toFixed();
};

describe("EIP712", () => {
  describe("Utils", () => {
    describe("destructTypeFromString", () => {
      test("'string[]' should return [{name: 'string', size: undefined}, [null]]", () => {
        expect(destructTypeFromString("string[]")).toEqual([
          { name: "string", size: undefined },
          [null],
        ]);
      });

      test("'uint8[2][][4]' should return [{name: 'uint', size: 8}, [2, null, 4]]", () => {
        expect(destructTypeFromString("uint8[2][][4]")).toEqual([
          { name: "uint", size: 8 },
          [2, null, 4],
        ]);
      });

      test("'bytes64' should return [{ name: 'bytes', size: 64 }, []]", () => {
        expect(destructTypeFromString("bytes64")).toEqual([{ name: "bytes", size: 64 }, []]);
      });

      test("'bool' should return [{ name: 'bool', size: undefined }, []]", () => {
        expect(destructTypeFromString("bool")).toEqual([{ name: "bool", size: undefined }, []]);
      });

      test("'bool[any]' should not throw and return ['bool', []]", () => {
        expect(destructTypeFromString("bool[any]")).toEqual([
          { name: "bool", size: undefined },
          [],
        ]);
      });

      test("V2DutchOrder should not be splitted even though it contains a number not related to the size", () => {
        expect(destructTypeFromString("V2DutchOrder")).toEqual([
          { name: "V2DutchOrder", size: undefined },
          [],
        ]);
      });

      test("KvnV2 should not be splitted even though it contains a number at the end not related to the size", () => {
        expect(destructTypeFromString("KvnV2")).toEqual([{ name: "KvnV2", size: undefined }, []]);
      });

      test("should not throw with undefined", () => {
        expect(destructTypeFromString(undefined)).toEqual([null, []]);
      });
    });

    describe("constructTypeDescByteString", () => {
      const bitwiseImplem = (isArray: boolean, typeSize: number | null, typeValue) =>
        (Number(isArray) << 7) | (Number(typeSize !== null) << 6) | typeValue;

      test("should return 1 as hex int and 01 as hexa string", () => {
        expect(parseInt(constructTypeDescByteString(false, null, 1), 16)).toEqual(1);
        expect(constructTypeDescByteString(false, null, 1)).toEqual("01");
      });

      test("should return 129 as hex int and 81 as hexa string", () => {
        expect(parseInt(constructTypeDescByteString(true, null, 1), 16)).toEqual(129);
        expect(constructTypeDescByteString(true, null, 1)).toEqual("81");
      });

      test("should return 193 as hex int and c1 as hexa string", () => {
        expect(parseInt(constructTypeDescByteString(true, 64, 1), 16)).toEqual(193);
        expect(constructTypeDescByteString(true, 64, 1)).toEqual("c1");
      });

      test("should return 207 as hex int and cf as hexa string", () => {
        expect(parseInt(constructTypeDescByteString(true, 64, 15), 16)).toEqual(207);
        expect(constructTypeDescByteString(true, 64, 15)).toEqual("cf");
      });

      test("should return 143 as hex int and 8f as hexa string", () => {
        expect(parseInt(constructTypeDescByteString(true, null, 15), 16)).toEqual(143);
        expect(constructTypeDescByteString(true, null, 15)).toEqual("8f");
      });

      test("should return 15 as hex int and ", () => {
        expect(parseInt(constructTypeDescByteString(false, null, 15), 16)).toEqual(15);
        expect(constructTypeDescByteString(false, null, 15)).toEqual("0f");
      });

      test("should throw if typeValue >= 16", () => {
        expect(() => constructTypeDescByteString(false, null, 16)).toThrow();
      });

      test("should return the same as the bitewise implementation", () => {
        expect(parseInt(constructTypeDescByteString(false, null, 1), 16)).toEqual(
          bitwiseImplem(false, null, 1),
        );

        expect(parseInt(constructTypeDescByteString(true, null, 1), 16)).toEqual(
          bitwiseImplem(true, null, 1),
        );

        expect(parseInt(constructTypeDescByteString(true, 64, 1), 16)).toEqual(
          bitwiseImplem(true, 64, 1),
        );

        expect(parseInt(constructTypeDescByteString(true, 64, 15), 16)).toEqual(
          bitwiseImplem(true, 64, 15),
        );

        expect(parseInt(constructTypeDescByteString(true, null, 15), 16)).toEqual(
          bitwiseImplem(true, null, 15),
        );

        expect(parseInt(constructTypeDescByteString(false, null, 15), 16)).toEqual(
          bitwiseImplem(false, null, 15),
        );
      });
    });

    describe("makeTypeEntryStructBuffer", () => {
      test("should return the correct buffer for entry type `int`", () => {
        expect(
          makeTypeEntryStructBuffer({
            name: "nameForInt",
            type: "int",
          }).toString("hex"),
        ).toEqual("410a6e616d65466f72496e74");
      });

      test("should return the correct buffer for entry type `int8`", () => {
        expect(
          makeTypeEntryStructBuffer({
            name: "nameForInt",
            type: "int8",
          }).toString("hex"),
        ).toEqual("41010a6e616d65466f72496e74");
      });

      test("should return the correct buffer for entry type `uint`", () => {
        expect(
          makeTypeEntryStructBuffer({
            name: "nameForUint",
            type: "uint",
          }).toString("hex"),
        ).toEqual("420b6e616d65466f7255696e74");
      });

      test("should return the correct buffer for entry type `uint64`", () => {
        expect(
          makeTypeEntryStructBuffer({
            name: "nameForUint",
            type: "uint64",
          }).toString("hex"),
        ).toEqual("42080b6e616d65466f7255696e74");
      });

      test("should return the correct buffer for entry type `address`", () => {
        expect(
          makeTypeEntryStructBuffer({
            name: "nameForAddress",
            type: "address",
          }).toString("hex"),
        ).toEqual("030e6e616d65466f7241646472657373");
      });

      test("should return the correct buffer for entry type `bool`", () => {
        expect(
          makeTypeEntryStructBuffer({
            name: "nameForBool",
            type: "bool",
          }).toString("hex"),
        ).toEqual("040b6e616d65466f72426f6f6c");
      });

      test("should return the correct buffer for entry type `string`", () => {
        expect(
          makeTypeEntryStructBuffer({
            name: "nameForString",
            type: "string",
          }).toString("hex"),
        ).toEqual("050d6e616d65466f72537472696e67");
      });

      test("should return the correct buffer for entry type `string[3][]`", () => {
        expect(
          makeTypeEntryStructBuffer({
            name: "document",
            type: "string[3][]",
          }).toString("hex"),
        ).toEqual("850201030008646f63756d656e74");
      });

      test("should return the correct buffer for entry type `bytes`", () => {
        expect(
          makeTypeEntryStructBuffer({
            name: "nameForBytes",
            type: "bytes",
          }).toString("hex"),
        ).toEqual("070c6e616d65466f724279746573");
      });

      test("should return the correct buffer for entry type `bytes32`", () => {
        expect(
          makeTypeEntryStructBuffer({
            name: "nameForBytes",
            type: "bytes32",
          }).toString("hex"),
        ).toEqual("46200c6e616d65466f724279746573");
      });

      test("should return the correct buffer for entry type `bytes32[4]`", () => {
        expect(
          makeTypeEntryStructBuffer({
            name: "nameForBytes",
            type: "bytes32[4]",
          }).toString("hex"),
        ).toEqual("c6200101040c6e616d65466f724279746573");
      });

      test("should return the correct buffer for entry type `bytes32[4][]`", () => {
        expect(
          makeTypeEntryStructBuffer({
            name: "nameForBytes",
            type: "bytes32[4][]",
          }).toString("hex"),
        ).toEqual("c620020104000c6e616d65466f724279746573");
      });

      test("should return the correct buffer for entry type `bytes32[4][][256]`", () => {
        expect(
          makeTypeEntryStructBuffer({
            name: "nameForBytes",
            type: "bytes32[4][][256]",
          }).toString("hex"),
        ).toEqual("c6200301040001100c6e616d65466f724279746573");
      });

      test("should return the correct buffer for entry type `custom`", () => {
        expect(
          makeTypeEntryStructBuffer({
            name: "nameForBytes",
            type: "somethingelseunknown",
          }).toString("hex"),
        ).toEqual("0014736f6d657468696e67656c7365756e6b6e6f776e0c6e616d65466f724279746573");
      });
    });

    describe("EIP712_TYPE_ENCODERS", () => {
      describe("INT", () => {
        const defaultSizes = [8, 16, 32, 64, 128, 256];
        const couples: [string, number[]][] = [
          ["115792089237316195423570985008687907853269984665640564039457584007913129639935", [256]],
          ["-57896044618658097711785492504343953926634992332820282019728792003956564819968", [256]],
          ["57896044618658097711785492504343953926634992332820282019728792003956564819967", [256]],
          ["-170141183460469231731687303715884105728", [128, 256]],
          ["170141183460469231731687303715884105727", [128, 256]],
          ["-9223372036854775808", [64, 128, 256]],
          ["9223372036854775807", [64, 128, 256]],
          ["-2147483648", [32, 64, 128, 256]],
          ["2147483647", [32, 64, 128, 256]],
          ["-32768", [16, 32, 64, 128, 256]],
          ["32767", [16, 32, 64, 128, 256]],
          ["-256", defaultSizes],
          ["256", defaultSizes],
          ["-128", defaultSizes],
          ["128", defaultSizes],
          ["-64", defaultSizes],
          ["64", defaultSizes],
          ["32", defaultSizes],
          ["-32", defaultSizes],
          ["-16", defaultSizes],
          ["16", defaultSizes],
          ["8", defaultSizes],
          ["-8", defaultSizes],
          ["0", defaultSizes],
        ];

        describe("from decimal string", () => {
          couples.forEach(([value, sizes]) => {
            sizes.forEach(size => {
              test(`should have the right return for value: ${value} and size: ${size}`, () => {
                const hexBuffer = EIP712_TYPE_ENCODERS.INT(value, size);

                expect(
                  convertTwosComplementToDecimalString(hexBuffer.toString("hex"), value),
                ).toEqual(value);
              });
            });
          });
        });

        describe("from hex string", () => {
          couples.forEach(([value, sizes]) => {
            sizes.forEach(size => {
              test(`should have the right return for value: ${value} and size: ${size}`, () => {
                const valueAsHex = EIP712_TYPE_ENCODERS.INT(value, size).toString("hex"); // Reusing valid values from a first run

                const hexBuffer = EIP712_TYPE_ENCODERS.INT("0x" + padHexString(valueAsHex), size);

                expect(
                  convertTwosComplementToDecimalString(hexBuffer.toString("hex"), value),
                ).toEqual(value);
              });
            });
          });
        });
      });

      describe("UINT", () => {
        it("should use the same logic as INT", () => {
          const value = "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
          const spy = jest.spyOn(EIP712_TYPE_ENCODERS, "INT");
          EIP712_TYPE_ENCODERS.UINT(value);
          expect(spy).toHaveBeenCalledWith(value);
        });
      });

      describe("BOOL", () => {
        test("should not break from null", () => {
          expect(EIP712_TYPE_ENCODERS.BOOL(null).toString("hex")).toEqual("00");
        });

        describe("from string", () => {
          test("should return 00", () => {
            expect(EIP712_TYPE_ENCODERS.BOOL("0").toString("hex")).toEqual("00");
          });

          test("should return 00", () => {
            expect(EIP712_TYPE_ENCODERS.BOOL("0x00").toString("hex")).toEqual("00");
          });

          test("should return 01", () => {
            expect(EIP712_TYPE_ENCODERS.BOOL("1").toString("hex")).toEqual("01");
          });

          test("should return 01", () => {
            expect(EIP712_TYPE_ENCODERS.BOOL("0x01").toString("hex")).toEqual("01");
          });
        });

        describe("from boolean", () => {
          test("should return 00", () => {
            expect(EIP712_TYPE_ENCODERS.BOOL(false).toString("hex")).toEqual("00");
          });

          test("should return 01", () => {
            expect(EIP712_TYPE_ENCODERS.BOOL(true).toString("hex")).toEqual("01");
          });
        });

        describe("from number", () => {
          test("should return 00", () => {
            expect(EIP712_TYPE_ENCODERS.BOOL(0).toString("hex")).toEqual("00");
          });

          test("should return 01", () => {
            expect(EIP712_TYPE_ENCODERS.BOOL(1).toString("hex")).toEqual("01");
          });
        });
      });

      describe("ADDRESS", () => {
        test("should not break from null", () => {
          expect(EIP712_TYPE_ENCODERS.ADDRESS(null).toString("hex")).toEqual("");
        });

        test("should return 183c938611642ae18790db0A1eFC21Dfe009aA1c", () => {
          expect(
            EIP712_TYPE_ENCODERS.ADDRESS("0x183c938611642ae18790db0A1eFC21Dfe009aA1c").toString(
              "hex",
            ),
          ).toEqual("183c938611642ae18790db0a1efc21dfe009aa1c");
        });

        test("should return 03d7be9a073d7ed9ac0ccb2558d7f7c6a43d3c0aa993e00f2c03424fff0a80f3", () => {
          expect(
            EIP712_TYPE_ENCODERS.ADDRESS(
              // Starknet address are longer, yet the address type is supposed to be 20 characters only
              "0x03d7be9a073d7ed9ac0ccb2558d7f7c6a43d3c0aa993e00f2c03424fff0a80f3",
            ).toString("hex"),
          ).toEqual("03d7be9a073d7ed9ac0ccb2558d7f7c6a43d3c0a");
        });
      });

      describe("STRING", () => {
        test("should not break from null", () => {
          expect(EIP712_TYPE_ENCODERS.STRING(null).toString("hex")).toEqual("");
        });

        test("should not break from empty string", () => {
          expect(EIP712_TYPE_ENCODERS.STRING("").toString("hex")).toEqual("");
        });

        test("should return 6b766e49734147656e697573", () => {
          expect(EIP712_TYPE_ENCODERS.STRING("kvnIsAGenius").toString("hex")).toEqual(
            "6b766e49734147656e697573",
          );
        });
      });

      describe("BYTES", () => {
        describe("from fixed size bytes", () => {
          test("should not break from null", () => {
            expect(EIP712_TYPE_ENCODERS.BYTES(null).toString("hex")).toEqual("");
          });

          test("should return 973bb640", () => {
            expect(EIP712_TYPE_ENCODERS.BYTES("0x973bb640", 4).toString("hex")).toEqual("973bb640");
          });
          test("should return 973bb640", () => {
            expect(
              EIP712_TYPE_ENCODERS.BYTES(
                "0x000000000000000000000000495f947276749ce646f68ac8c248420045cb7b5ebdf2657ffc1fadfd73cf0a8cde95d50b62d3df8c000000000000070000000032",
              ).toString("hex"),
            ).toEqual(
              "000000000000000000000000495f947276749ce646f68ac8c248420045cb7b5ebdf2657ffc1fadfd73cf0a8cde95d50b62d3df8c000000000000070000000032",
            );
          });
        });
      });
    });

    describe("hexBuffer", () => {
      const hexValues = [
        "0",
        "1",
        "2",
        "3",
        "4",
        "5",
        "6",
        "7",
        "8",
        "9",
        "A",
        "B",
        "C",
        "D",
        "E",
        "F",
      ];
      it.each(hexValues)(
        "should bufferize every possible byte string of: %s",
        (noPrefixShorthand: string) => {
          const prefixFull = `0x0${noPrefixShorthand}`;
          const prefixShorthand = `0x${noPrefixShorthand}`;
          expect(Buffer.compare(hexBuffer(prefixFull), hexBuffer(prefixShorthand))).toBe(0);
          expect(Buffer.compare(hexBuffer(prefixFull), hexBuffer(noPrefixShorthand))).toBe(0);
        },
      );
    });

    describe("getCoinRefTokensMap", () => {
      it("should create a map for 2 tokens in the message", () => {
        const filters = {
          fields: [
            {
              coin_ref: 0,
              format: "token",
              label: "Amount allowance",
              path: "details.token",
              signature:
                "304402203b28bb137a21a6f08903489c6b158fd54280367d6bb72f87bf3e2f287a92440f02207ecc609b12b363cd0e8cbef7079776dfb363cef2fc11da39750598ee4cda4877",
            },
            {
              coin_ref: 0,
              format: "amount",
              label: "Amount allowance",
              path: "details.amount",
              signature:
                "30440220574f7322c9cd212d295c15d92a48aeb6b490978cb87d61fe8afb71b97053ceb7022016489970af3ff80903a45a966ea07dd9ca1435f6b6da9124e03f3087485d1c5b",
            },
            {
              coin_ref: 1,
              format: "token",
              label: "Amount allowance",
              path: "details.token2",
              signature:
                "304402203b28bb137a21a6f08903489c6b158fd54280367d6bb72f87bf3e2f287a92440f02207ecc609b12b363cd0e8cbef7079776dfb363cef2fc11da39750598ee4cda4877",
            },
            {
              coin_ref: 1,
              format: "amount",
              label: "Amount allowance",
              path: "details.amount2",
              signature:
                "30440220574f7322c9cd212d295c15d92a48aeb6b490978cb87d61fe8afb71b97053ceb7022016489970af3ff80903a45a966ea07dd9ca1435f6b6da9124e03f3087485d1c5b",
            },
            {
              format: "raw",
              label: "Approve to spender",
              path: "spender",
              signature:
                "30450221008eecd0e1f432daf722fd00c54038a4cd4d96624cc117ddfb12c7ed10a59b260d02203d34c811a5918c2654e301a071b624088aa9a0813f19dbfa1c803f3dcec64557",
            },
          ],
        } as any;
        const message = {
          message: {
            details: { token: "0x01", amount: "0x02", token2: "0x03", amount2: "0x04" },
            spender: "0x05",
          },
        } as any;

        expect(getCoinRefTokensMap(filters, false, message)).toEqual({
          0: { token: "0x01" },
          1: { token: "0x03" },
        });
      });

      it("should create a map with a token in being the verifying contract", () => {
        const filters = {
          fields: [
            {
              coin_ref: 255,
              format: "amount",
              label: "Amount allowance",
              path: "details.amount",
              signature:
                "304402203b28bb137a21a6f08903489c6b158fd54280367d6bb72f87bf3e2f287a92440f02207ecc609b12b363cd0e8cbef7079776dfb363cef2fc11da39750598ee4cda4877",
            },
            {
              format: "raw",
              label: "Approve to spender",
              path: "spender",
              signature:
                "30450221008eecd0e1f432daf722fd00c54038a4cd4d96624cc117ddfb12c7ed10a59b260d02203d34c811a5918c2654e301a071b624088aa9a0813f19dbfa1c803f3dcec64557",
            },
          ],
        } as any;
        const message = {
          domain: {
            verifyingContract: "0x01",
          },
          message: {
            details: { token: "0x01", amount: "0x02", token2: "0x03", amount2: "0x04" },
            spender: "0x05",
          },
        } as any;

        expect(getCoinRefTokensMap(filters, false, message)).toEqual({
          255: { token: "0x01" },
        });
      });

      it("should create return an empty map for filters v1", () => {
        const filters = {
          fields: [
            {
              coin_ref: 0,
              format: "token",
              label: "Token allowance",
              path: "details.token.[]",
              signature:
                "304402203b28bb137a21a6f08903489c6b158fd54280367d6bb72f87bf3e2f287a92440f02207ecc609b12b363cd0e8cbef7079776dfb363cef2fc11da39750598ee4cda4877",
            },
            {
              format: "raw",
              label: "Approve to spender",
              path: "spender",
              signature:
                "30450221008eecd0e1f432daf722fd00c54038a4cd4d96624cc117ddfb12c7ed10a59b260d02203d34c811a5918c2654e301a071b624088aa9a0813f19dbfa1c803f3dcec64557",
            },
          ],
        } as any;
        const message = {
          message: {
            details: { token: ["0x01", "0x02"] },
            spender: "0x05",
          },
        } as any;

        expect(getCoinRefTokensMap(filters, true, message)).toEqual({});
      });

      it("should create return an empty map for filters v1", () => {
        const filters = {
          fields: [
            {
              coin_ref: 0,
              format: "token",
              label: "Token allowance",
              path: "details.token.[]",
              signature:
                "304402203b28bb137a21a6f08903489c6b158fd54280367d6bb72f87bf3e2f287a92440f02207ecc609b12b363cd0e8cbef7079776dfb363cef2fc11da39750598ee4cda4877",
            },
            {
              format: "raw",
              label: "Approve to spender",
              path: "spender",
              signature:
                "30450221008eecd0e1f432daf722fd00c54038a4cd4d96624cc117ddfb12c7ed10a59b260d02203d34c811a5918c2654e301a071b624088aa9a0813f19dbfa1c803f3dcec64557",
            },
          ],
        } as any;
        const message = {
          message: {
            details: { token: ["0x01", "0x02"] },
            spender: "0x05",
          },
        } as any;

        expect(() => getCoinRefTokensMap(filters, false, message)).toThrow(
          "Array of tokens is not supported with a single coin ref",
        );
      });

      it("should order correctly the map", () => {
        const filters = {
          fields: [
            {
              coin_ref: 1,
              format: "token",
              label: "Amount allowance",
              path: "details.token2",
              signature:
                "304402203b28bb137a21a6f08903489c6b158fd54280367d6bb72f87bf3e2f287a92440f02207ecc609b12b363cd0e8cbef7079776dfb363cef2fc11da39750598ee4cda4877",
            },
            {
              coin_ref: 1,
              format: "amount",
              label: "Amount allowance",
              path: "details.amount2",
              signature:
                "30440220574f7322c9cd212d295c15d92a48aeb6b490978cb87d61fe8afb71b97053ceb7022016489970af3ff80903a45a966ea07dd9ca1435f6b6da9124e03f3087485d1c5b",
            },
            {
              coin_ref: 0,
              format: "token",
              label: "Amount allowance",
              path: "details.token",
              signature:
                "304402203b28bb137a21a6f08903489c6b158fd54280367d6bb72f87bf3e2f287a92440f02207ecc609b12b363cd0e8cbef7079776dfb363cef2fc11da39750598ee4cda4877",
            },
            {
              coin_ref: 0,
              format: "amount",
              label: "Amount allowance",
              path: "details.amount",
              signature:
                "30440220574f7322c9cd212d295c15d92a48aeb6b490978cb87d61fe8afb71b97053ceb7022016489970af3ff80903a45a966ea07dd9ca1435f6b6da9124e03f3087485d1c5b",
            },
            {
              format: "raw",
              label: "Approve to spender",
              path: "spender",
              signature:
                "30450221008eecd0e1f432daf722fd00c54038a4cd4d96624cc117ddfb12c7ed10a59b260d02203d34c811a5918c2654e301a071b624088aa9a0813f19dbfa1c803f3dcec64557",
            },
          ],
        } as any;
        const message = {
          message: {
            details: { token: "0x01", amount: "0x02", token2: "0x03", amount2: "0x04" },
            spender: "0x05",
          },
        } as any;

        expect(getCoinRefTokensMap(filters, false, message)).toEqual({
          0: { token: "0x01" },
          1: { token: "0x03" },
        });
      });
    });

    describe("getAppAndVersion", () => {
      it("should return the app and version", async () => {
        const transport = {
          send: () =>
            Promise.resolve(Buffer.from("0108457468657265756d06312e31312e3101009000", "hex")),
        } as any;

        expect(await getAppAndVersion(transport)).toEqual({
          name: "Ethereum",
          version: "1.11.1",
        });
      });
    });

    describe("getFilterDisplayNameAndSigBuffers", () => {
      it("should return the display name and signature buffers", async () => {
        expect(
          getFilterDisplayNameAndSigBuffers("kvn", Buffer.from("dootdoot").toString("hex")),
        ).toEqual({
          displayNameBuffer: Buffer.from("036b766e", "hex"),
          sigBuffer: Buffer.from("08646f6f74646f6f74", "hex"),
        });
      });
    });

    describe("getPayloadForFilterV2", () => {
      const { displayNameBuffer, sigBuffer } = getFilterDisplayNameAndSigBuffers(
        "kvn",
        Buffer.from("dootdoot").toString("hex"),
      );

      it("should return a payload for a raw filter", () => {
        expect(
          getPayloadForFilterV2("raw", 0, { 0: { token: "0x01" } }, displayNameBuffer, sigBuffer),
        ).toEqual(Buffer.concat([displayNameBuffer, sigBuffer]));
      });

      it("should return a payload for a datetime filter", () => {
        expect(
          getPayloadForFilterV2(
            "datetime",
            0,
            { 0: { token: "0x01" } },
            displayNameBuffer,
            sigBuffer,
          ),
        ).toEqual(Buffer.concat([displayNameBuffer, sigBuffer]));
      });

      it("should return a payload for a token filter", () => {
        expect(
          getPayloadForFilterV2(
            "token",
            0,
            { 0: { token: "0x01", deviceTokenIndex: 123 } },
            displayNameBuffer,
            sigBuffer,
          ),
        ).toEqual(Buffer.concat([Buffer.from("7B", "hex"), sigBuffer]));
      });

      it("should return the coinRef if a token hasn't been registered by the device (token not in CAL for example)", () => {
        expect(
          getPayloadForFilterV2("token", 0, { 0: { token: "0x01" } }, displayNameBuffer, sigBuffer),
        ).toEqual(Buffer.concat([Buffer.from("00", "hex"), sigBuffer]));
      });

      it("should return a payload for an amount filter", () => {
        expect(
          getPayloadForFilterV2(
            "amount",
            0,
            { 0: { token: "0x01", deviceTokenIndex: 123 } },
            displayNameBuffer,
            sigBuffer,
          ),
        ).toEqual(Buffer.concat([displayNameBuffer, Buffer.from("7B", "hex"), sigBuffer]));
      });

      it("should return the coinRef if a token hasn't been registered by the device (token not in CAL for example)", () => {
        expect(
          getPayloadForFilterV2(
            "amount",
            0,
            { 0: { token: "0x01" } },
            displayNameBuffer,
            sigBuffer,
          ),
        ).toEqual(Buffer.concat([displayNameBuffer, Buffer.from("00", "hex"), sigBuffer]));
      });

      it("should should throw for an unknown filter format", () => {
        expect(() =>
          getPayloadForFilterV2(
            "anything" as any,
            0,
            { 0: { token: "0x01" } },
            displayNameBuffer,
            sigBuffer,
          ),
        ).toThrow("Invalid format");
      });
    });
  });
});