@onekeyfe/hd-transport 0.1.39 → 0.1.42

package/.eslintrc

@@ -16,6 +16,8 @@
       // note you must disable the base rule as it can report incorrect errors
       "no-use-before-define": "off",
       "@typescript-eslint/no-use-before-define": ["error"],
-      "require-await": ["error"]
+      "@typescript-eslint/no-var-requires": "off",
+      "require-await": ["error"],
+      "import/no-named-default": "off"
   }
 }

package/__tests__/build-receive.test.js

@@ -0,0 +1,117 @@
+const { parseConfigure } = require('../src/serialization/protobuf/messages');
+const { buildOne } = require('../src/serialization/send');
+const { receiveOne } = require('../src/serialization/receive');
+
+const { buildEncodeBuffers } = require('../src/serialization/send');
+
+const messages = {
+  StellarPaymentOp: {
+    fields: {
+      source_account: {
+        type: 'string',
+        id: 1,
+      },
+      destination_account: {
+        rule: 'required',
+        type: 'string',
+        id: 2,
+      },
+      asset: {
+        rule: 'required',
+        type: 'StellarAsset',
+        id: 3,
+      },
+      amount: {
+        rule: 'required',
+        type: 'sint64',
+        id: 4,
+      },
+    },
+  },
+  StellarAssetType: {
+    values: {
+      NATIVE: 0,
+      ALPHANUM4: 1,
+      ALPHANUM12: 2,
+    },
+  },
+  StellarAsset: {
+    fields: {
+      type: {
+        rule: 'required',
+        type: 'StellarAssetType',
+        id: 1,
+      },
+      code: {
+        type: 'string',
+        id: 2,
+      },
+      issuer: {
+        type: 'string',
+        id: 3,
+      },
+    },
+  },
+  MessageType: {
+    values: {
+      MessageType_StellarSignTx: 202,
+      MessageType_StellarTxOpRequest: 203,
+      MessageType_StellarGetAddress: 207,
+      MessageType_StellarAddress: 208,
+      MessageType_StellarCreateAccountOp: 210,
+      MessageType_StellarPaymentOp: 211,
+      MessageType_StellarPathPaymentOp: 212,
+      MessageType_StellarManageOfferOp: 213,
+      MessageType_StellarCreatePassiveOfferOp: 214,
+      MessageType_StellarSetOptionsOp: 215,
+      MessageType_StellarChangeTrustOp: 216,
+      MessageType_StellarAllowTrustOp: 217,
+      MessageType_StellarAccountMergeOp: 218,
+      MessageType_StellarManageDataOp: 220,
+      MessageType_StellarBumpSequenceOp: 221,
+      MessageType_StellarSignedTx: 230,
+    },
+  },
+};
+
+const fixtures = [
+  {
+    name: 'StellarPaymentOp',
+    in: {
+      source_account: 'meow'.repeat(100), // make message longer then 63 bytes
+      destination_account: 'wuff',
+      asset: {
+        type: 'NATIVE',
+        code: 'hello',
+        issuer: 'world',
+      },
+      amount: 10,
+    },
+  },
+];
+
+const parsedMessages = parseConfigure({
+  nested: { hw: { nested: { trezor: { nested: { messages: { nested: messages } } } } } },
+});
+
+describe('encoding json -> protobuf -> json', () => {
+  fixtures.forEach(f => {
+    describe(f.name, () => {
+      test('buildOne - receiveOne', () => {
+        // encoded message
+        const encodedMessage = buildOne(parsedMessages, f.name, f.in);
+        // then decode message and check, whether decoded message matches original json
+        const decodedMessage = receiveOne(parsedMessages, encodedMessage);
+        expect(decodedMessage.type).toEqual(f.name);
+        expect(decodedMessage.message).toEqual(f.in);
+      });
+
+      test('buildBuffers - receiveAndParse', () => {
+        const result = buildEncodeBuffers(parsedMessages, f.name, f.in);
+        result.forEach(r => {
+          expect(r.byteLength).toBeLessThanOrEqual(63);
+        });
+      });
+    });
+  });
+});

package/__tests__/encode-decode-basic.test.js

@@ -0,0 +1,272 @@
+const ProtoBuf = require('protobufjs/light');
+const { encode } = require('../src/serialization/protobuf/encode');
+const { decode } = require('../src/serialization/protobuf/decode');
+
+const messages = {
+  nested: {
+    messages: {
+      nested: {
+        String: {
+          fields: {
+            field: {
+              rule: 'required',
+              type: 'string',
+              id: 1,
+            },
+          },
+        },
+        Uint32: {
+          fields: {
+            field: {
+              rule: 'required',
+              type: 'uint32',
+              id: 2,
+            },
+          },
+        },
+        Uint64: {
+          fields: {
+            field: {
+              rule: 'required',
+              type: 'uint64',
+              id: 3,
+            },
+          },
+        },
+        Bool: {
+          fields: {
+            field: {
+              rule: 'required',
+              type: 'bool',
+              id: 4,
+            },
+          },
+        },
+        Sint32: {
+          fields: {
+            field: {
+              rule: 'required',
+              type: 'sint32',
+              id: 5,
+            },
+          },
+        },
+        Sint64: {
+          fields: {
+            field: {
+              rule: 'required',
+              type: 'sint64',
+              id: 6,
+            },
+          },
+        },
+        Bytes: {
+          fields: {
+            field: {
+              rule: 'required',
+              type: 'bytes',
+              id: 7,
+            },
+          },
+        },
+
+        //  complex and real life examples
+        ComplexFieldOfOptionals: {
+          fields: {
+            bool: {
+              rule: 'optional',
+              type: 'bool',
+              id: 8,
+            },
+            number: {
+              rule: 'optional',
+              type: 'uint32',
+              id: 9,
+            },
+          },
+        },
+
+        Repeated: {
+          fields: {
+            bool: {
+              rule: 'repeated',
+              type: 'bool',
+              id: 8,
+            },
+          },
+        },
+
+        Defaults: {
+          fields: {
+            string: {
+              type: 'string',
+              id: 8,
+              options: {
+                defaults: 'hello world',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+};
+
+const basicFixtures = [
+  {
+    name: 'String',
+    params: { field: 'foo' },
+    encoded: '0a03666f6f',
+  },
+  {
+    name: 'Uint32',
+    params: { field: 4294967295 },
+    encoded: '10ffffffff0f',
+  },
+  {
+    name: 'Uint64',
+    params: { field: 1844674407370955 },
+    encoded: '18cba19cd68bb7a303',
+  },
+  {
+    name: 'Uint64',
+    params: { field: '166054873161269248' }, // over Number.MAX_SAFE_INTEGER is sent as string
+    encoded: '1880808080f0c0fca602',
+  },
+  {
+    name: 'Sint64',
+    params: { field: '-166054873161269248' }, // over Number.MAX_SAFE_INTEGER is sent as string
+    encoded: '30ffffffffdf81f9cd04',
+  },
+  {
+    name: 'Bool',
+    params: { field: true },
+    encoded: '2001',
+  },
+  {
+    name: 'Bool',
+    params: { field: false },
+    encoded: '2000',
+  },
+  {
+    name: 'Sint32',
+    params: { field: -4294967 },
+    encoded: '28eda48c04',
+  },
+  {
+    name: 'Sint64',
+    params: { field: -1844674407370955 },
+    encoded: '3095c3b8ac97eec606',
+  },
+  {
+    name: 'Bytes',
+    params: {
+      field:
+        '851fc9542342321af63ecbba7d3ece545f2a42bad01ba32cff5535b18e54b6d3106e10b6a4525993d185a1443d9a125186960e028eabfdd8d76cf70a3a7e3100',
+    },
+    encoded:
+      '3a40851fc9542342321af63ecbba7d3ece545f2a42bad01ba32cff5535b18e54b6d3106e10b6a4525993d185a1443d9a125186960e028eabfdd8d76cf70a3a7e3100',
+  },
+];
+
+// note: difference in bool encoding. if type === bool && field = optional && not message of only one field, bool is encoded as ""
+const advancedFixtures = [
+  {
+    name: 'ComplexFieldOfOptionals',
+    in: { number: 1 },
+    encoded: '4801',
+    out: { bool: null, number: 1 },
+  },
+  {
+    name: 'Repeated',
+    in: { bool: [true, false, true, false] },
+    encoded: '420401000100',
+    out: { bool: [true, false, true, false] },
+  },
+  {
+    name: 'Defaults',
+    in: { string: '' },
+    encoded: '4200',
+    out: { string: '' },
+  },
+];
+
+describe('basic concepts', () => {
+  const Messages = ProtoBuf.Root.fromJSON(messages);
+
+  describe('primitives encode/decode', () => {
+    basicFixtures.forEach(f => {
+      describe(f.name, () => {
+        const Message = Messages.lookup(`messages.${f.name}`);
+
+        test(f.name, () => {
+          // serialize new way - this is to confirm new lib won't break old behavior
+          const encoded = encode(Message, f.params);
+          expect(encoded.toString('hex')).toEqual(f.encoded);
+
+          // deserialize new way - this is to confirm new lib won't break old behavior
+          const decoded = decode(Message, encoded);
+          expect(decoded).toEqual(f.params);
+        });
+      });
+    });
+  });
+
+  describe('advanced', () => {
+    advancedFixtures.forEach(f => {
+      describe(f.name, () => {
+        const Message = Messages.lookup(`messages.${f.name}`);
+
+        test(f.name, () => {
+          // serialize new way - this is to confirm new lib won't break old behavior
+          const encoded = encode(Message, f.in);
+
+          expect(encoded.toString('hex')).toEqual(f.encoded);
+
+          // deserialize new way - this is to confirm new lib won't break old behavior
+          const decoded = decode(Message, encoded);
+
+          expect(decoded).toEqual(f.out);
+        });
+      });
+    });
+
+    test('Different protobuf between receiving ends', () => {
+      const messages = {
+        nested: {
+          messages: {
+            nested: {
+              ButtonRequest: {
+                fields: {
+                  code: {
+                    type: 'string',
+                    id: 1,
+                  },
+                  pages: {
+                    type: 'uint32',
+                    id: 2,
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+
+      const SenderMessages = ProtoBuf.Root.fromJSON(messages);
+      const senderEncoded = encode(SenderMessages.lookup('messages.ButtonRequest'), {
+        type: 'foo',
+        pages: 123,
+      });
+
+      const receiverMessages = messages;
+      // now change field type from uint32 to string
+      receiverMessages.nested.messages.nested.ButtonRequest.fields.pages.type = 'string';
+      const ReceiverMessages = ProtoBuf.Root.fromJSON(receiverMessages);
+
+      expect(() => {
+        decode(ReceiverMessages.lookup('messages.ButtonRequest'), senderEncoded);
+      }).toThrow();
+    });
+  });
+});