ripple-binary-codec 1.1.3-beta.1 → 1.2.1-beta.0

package/test/hash.test.js

@@ -1,83 +1,87 @@
-const { coreTypes } = require("../dist/types");
-const { Hash160, Hash256, AccountID, Currency } = coreTypes;
-const { Buffer } = require("buffer/");
+const { coreTypes } = require('../dist/types')
+const { Hash160, Hash256, AccountID, Currency } = coreTypes
+const { Buffer } = require('buffer/')
 
-describe("Hash160", function () {
-  test("has a static width member", function () {
-    expect(Hash160.width).toBe(20);
-  });
-  test("inherited by subclasses", function () {
-    expect(AccountID.width).toBe(20);
-    expect(Currency.width).toBe(20);
-  });
-  test("can be compared against another", function () {
-    const h1 = Hash160.from("1000000000000000000000000000000000000000");
-    const h2 = Hash160.from("2000000000000000000000000000000000000000");
-    const h3 = Hash160.from("0000000000000000000000000000000000000003");
-    expect(h1.lt(h2)).toBe(true);
-    expect(h3.lt(h2)).toBe(true);
-  });
-  test("throws when constructed from invalid hash length", () => {
+describe('Hash160', function () {
+  test('has a static width member', function () {
+    expect(Hash160.width).toBe(20)
+  })
+  test('inherited by subclasses', function () {
+    expect(AccountID.width).toBe(20)
+    expect(Currency.width).toBe(20)
+  })
+  test('can be compared against another', function () {
+    const h1 = Hash160.from('1000000000000000000000000000000000000000')
+    const h2 = Hash160.from('2000000000000000000000000000000000000000')
+    const h3 = Hash160.from('0000000000000000000000000000000000000003')
+    expect(h1.lt(h2)).toBe(true)
+    expect(h3.lt(h2)).toBe(true)
+  })
+  test('throws when constructed from invalid hash length', () => {
     expect(() =>
-      Hash160.from("10000000000000000000000000000000000000")
-    ).toThrow("Invalid Hash length 19");
+      Hash160.from('10000000000000000000000000000000000000'),
+    ).toThrow('Invalid Hash length 19')
     expect(() =>
-      Hash160.from("100000000000000000000000000000000000000000")
-    ).toThrow("Invalid Hash length 21");
-  });
-});
+      Hash160.from('100000000000000000000000000000000000000000'),
+    ).toThrow('Invalid Hash length 21')
+  })
+})
 
-describe("Hash256", function () {
-  test("has a static width member", function () {
-    expect(Hash256.width).toBe(32);
-  });
-  test("has a ZERO_256 member", function () {
+describe('Hash256', function () {
+  test('has a static width member', function () {
+    expect(Hash256.width).toBe(32)
+  })
+  test('has a ZERO_256 member', function () {
     expect(Hash256.ZERO_256.toJSON()).toBe(
-      "0000000000000000000000000000000000000000000000000000000000000000"
-    );
-  });
-  test("supports getting the nibblet values at given positions", function () {
+      '0000000000000000000000000000000000000000000000000000000000000000',
+    )
+  })
+  test('supports getting the nibblet values at given positions', function () {
     const h = Hash256.from(
-      "1359BD0000000000000000000000000000000000000000000000000000000000"
-    );
-    expect(h.nibblet(0)).toBe(0x1);
-    expect(h.nibblet(1)).toBe(0x3);
-    expect(h.nibblet(2)).toBe(0x5);
-    expect(h.nibblet(3)).toBe(0x9);
-    expect(h.nibblet(4)).toBe(0x0b);
-    expect(h.nibblet(5)).toBe(0xd);
-  });
-});
+      '1359BD0000000000000000000000000000000000000000000000000000000000',
+    )
+    expect(h.nibblet(0)).toBe(0x1)
+    expect(h.nibblet(1)).toBe(0x3)
+    expect(h.nibblet(2)).toBe(0x5)
+    expect(h.nibblet(3)).toBe(0x9)
+    expect(h.nibblet(4)).toBe(0x0b)
+    expect(h.nibblet(5)).toBe(0xd)
+  })
+})
 
-describe("Currency", function () {
-  test("Will have a null iso() for dodgy XRP ", function () {
-    const bad = Currency.from("0000000000000000000000005852500000000000");
-    expect(bad.iso()).toBeUndefined();
-    expect(bad.isNative()).toBe(false);
-  });
-  test("Currency with lowercase letters decode to hex", () => {
-    expect(Currency.from("xRp").toJSON()).toBe(
-      "0000000000000000000000007852700000000000"
-    );
-  });
-  test("Currency codes with symbols decode to hex", () => {
-    expect(Currency.from("x|p").toJSON()).toBe(
-      "000000000000000000000000787C700000000000"
-    );
-  });
-  test("Currency codes with uppercase and 0-9 decode to ISO codes", () => {
-    expect(Currency.from("X8P").toJSON()).toBe("X8P");
-    expect(Currency.from("USD").toJSON()).toBe("USD");
-  });
-  test("can be constructed from a Buffer", function () {
-    const xrp = new Currency(Buffer.alloc(20));
-    expect(xrp.iso()).toBe("XRP");
-  });
-  test("throws on invalid reprs", function () {
-    expect(() => Currency.from(Buffer.alloc(19))).toThrow();
-    expect(() => Currency.from(1)).toThrow();
+describe('Currency', function () {
+  test('Will throw an error for dodgy XRP ', function () {
     expect(() =>
-      Currency.from("00000000000000000000000000000000000000m")
-    ).toThrow();
-  });
-});
+      Currency.from('0000000000000000000000005852500000000000'),
+    ).toThrow()
+  })
+  test('Currency with lowercase letters decode to hex', () => {
+    expect(Currency.from('xRp').toJSON()).toBe(
+      '0000000000000000000000007852700000000000',
+    )
+  })
+  test('Currency codes with symbols decode to hex', () => {
+    expect(Currency.from('x|p').toJSON()).toBe(
+      '000000000000000000000000787C700000000000',
+    )
+  })
+  test('Currency codes with uppercase and 0-9 decode to ISO codes', () => {
+    expect(Currency.from('X8P').toJSON()).toBe('X8P')
+    expect(Currency.from('USD').toJSON()).toBe('USD')
+  })
+  test('can be constructed from a Buffer', function () {
+    const xrp = new Currency(Buffer.alloc(20))
+    expect(xrp.iso()).toBe('XRP')
+  })
+  test('Can handle non-standard currency codes', () => {
+    const currency = '015841551A748AD2C1F76FF6ECB0CCCD00000000'
+    expect(Currency.from(currency).toJSON()).toBe(currency)
+  })
+  test('throws on invalid reprs', function () {
+    expect(() => Currency.from(Buffer.alloc(19))).toThrow()
+    expect(() => Currency.from(1)).toThrow()
+    expect(() =>
+      Currency.from('00000000000000000000000000000000000000m'),
+    ).toThrow()
+  })
+})

package/test/ledger.test.js

@@ -1,29 +1,29 @@
-const { loadFixture } = require("./utils");
+const { loadFixture } = require('./utils')
 const {
   transactionTreeHash,
   ledgerHash,
   accountStateHash,
-} = require("../dist/ledger-hashes");
+} = require('../dist/ledger-hashes')
 
-describe("Ledger Hashes", function () {
+describe('Ledger Hashes', function () {
   function testFactory(ledgerFixture) {
     describe(`can calculate hashes for ${ledgerFixture}`, function () {
-      const ledger = loadFixture(ledgerFixture);
-      test("computes correct account state hash", function () {
+      const ledger = loadFixture(ledgerFixture)
+      test('computes correct account state hash', function () {
         expect(accountStateHash(ledger.accountState).toHex()).toBe(
-          ledger.account_hash
-        );
-      });
-      test("computes correct transaction tree hash", function () {
+          ledger.account_hash,
+        )
+      })
+      test('computes correct transaction tree hash', function () {
         expect(transactionTreeHash(ledger.transactions).toHex()).toBe(
-          ledger.transaction_hash
-        );
-      });
-      test("computes correct ledger header hash", function () {
-        expect(ledgerHash(ledger).toHex()).toBe(ledger.hash);
-      });
-    });
+          ledger.transaction_hash,
+        )
+      })
+      test('computes correct ledger header hash', function () {
+        expect(ledgerHash(ledger).toHex()).toBe(ledger.hash)
+      })
+    })
   }
-  testFactory("ledger-full-40000.json");
-  testFactory("ledger-full-38129.json");
-});
+  testFactory('ledger-full-40000.json')
+  testFactory('ledger-full-38129.json')
+})

package/test/lower-case-hex.test.js

@@ -1,45 +1,46 @@
-const { encode, decode } = require("../dist");
+const { encode, decode } = require('../dist')
 
 let str =
-  "1100612200000000240000000125000068652D0000000055B6632D6376A2D9319F20A1C6DCCB486432D1E4A79951229D4C3DE2946F51D56662400009184E72A00081140DD319918CD5AE792BF7EC80D63B0F01B4573BBC";
-let lower = str.toLowerCase();
+  '1100612200000000240000000125000068652D0000000055B6632D6376A2D9319F20A1C6DCCB486432D1E4A79951229D4C3DE2946F51D56662400009184E72A00081140DD319918CD5AE792BF7EC80D63B0F01B4573BBC'
+let lower = str.toLowerCase()
 
 let bin =
-  "1100612200000000240000000125000000082D00000000550735A0B32B2A3F4C938B76D6933003E29447DB8C7CE382BBE089402FF12A03E56240000002540BE400811479927BAFFD3D04A26096C0C97B1B0D45B01AD3C0";
+  '1100612200000000240000000125000000082D00000000550735A0B32B2A3F4C938B76D6933003E29447DB8C7CE382BBE089402FF12A03E56240000002540BE400811479927BAFFD3D04A26096C0C97B1B0D45B01AD3C0'
 let json = {
   OwnerCount: 0,
-  Account: "rUnFEsHjxqTswbivzL2DNHBb34rhAgZZZK",
+  Account: 'rUnFEsHjxqTswbivzL2DNHBb34rhAgZZZK',
   PreviousTxnLgrSeq: 8,
-  LedgerEntryType: "AccountRoot",
-  PreviousTxnID: "0735A0B32B2A3F4C938B76D6933003E29447DB8C7CE382BBE089402FF12A03E5".toLowerCase(),
+  LedgerEntryType: 'AccountRoot',
+  PreviousTxnID:
+    '0735A0B32B2A3F4C938B76D6933003E29447DB8C7CE382BBE089402FF12A03E5'.toLowerCase(),
   Flags: 0,
   Sequence: 1,
-  Balance: "10000000000",
-};
+  Balance: '10000000000',
+}
 
 let jsonUpper = {
   OwnerCount: 0,
-  Account: "rUnFEsHjxqTswbivzL2DNHBb34rhAgZZZK",
+  Account: 'rUnFEsHjxqTswbivzL2DNHBb34rhAgZZZK',
   PreviousTxnLgrSeq: 8,
-  LedgerEntryType: "AccountRoot",
+  LedgerEntryType: 'AccountRoot',
   PreviousTxnID:
-    "0735A0B32B2A3F4C938B76D6933003E29447DB8C7CE382BBE089402FF12A03E5",
+    '0735A0B32B2A3F4C938B76D6933003E29447DB8C7CE382BBE089402FF12A03E5',
   Flags: 0,
   Sequence: 1,
-  Balance: "10000000000",
-};
+  Balance: '10000000000',
+}
 
-describe("Lowercase hex test", () => {
-  test("Correctly decodes", () => {
-    expect(decode(lower)).toEqual(decode(str));
-  });
-  test("Re-encodes to uppercase hex", () => {
-    expect(encode(decode(lower))).toEqual(str);
-  });
-  test("Encode when hex field lowercase", () => {
-    expect(encode(json)).toBe(bin);
-  });
-  test("Re-decodes to uppercase hex", () => {
-    expect(decode(encode(json))).toEqual(jsonUpper);
-  });
-});
+describe('Lowercase hex test', () => {
+  test('Correctly decodes', () => {
+    expect(decode(lower)).toEqual(decode(str))
+  })
+  test('Re-encodes to uppercase hex', () => {
+    expect(encode(decode(lower))).toEqual(str)
+  })
+  test('Encode when hex field lowercase', () => {
+    expect(encode(json)).toBe(bin)
+  })
+  test('Re-decodes to uppercase hex', () => {
+    expect(decode(encode(json))).toEqual(jsonUpper)
+  })
+})

package/test/pseudo-transaction.test.js

@@ -1,38 +1,38 @@
-const { encode, decode } = require("../dist");
+const { encode, decode } = require('../dist')
 
 let json = {
-  Account: "rrrrrrrrrrrrrrrrrrrrrhoLvTp",
+  Account: 'rrrrrrrrrrrrrrrrrrrrrhoLvTp',
   Sequence: 0,
-  Fee: "0",
-  SigningPubKey: "",
-  Signature: "",
-};
+  Fee: '0',
+  SigningPubKey: '',
+  Signature: '',
+}
 
 let json_blank_acct = {
-  Account: "",
+  Account: '',
   Sequence: 0,
-  Fee: "0",
-  SigningPubKey: "",
-  Signature: "",
-};
+  Fee: '0',
+  SigningPubKey: '',
+  Signature: '',
+}
 
 let binary =
-  "24000000006840000000000000007300760081140000000000000000000000000000000000000000";
+  '24000000006840000000000000007300760081140000000000000000000000000000000000000000'
 
-describe("Can encode Pseudo Transactions", () => {
-  test("Correctly encodes Pseudo Transaciton", () => {
-    expect(encode(json)).toEqual(binary);
-  });
+describe('Can encode Pseudo Transactions', () => {
+  test('Correctly encodes Pseudo Transaciton', () => {
+    expect(encode(json)).toEqual(binary)
+  })
 
-  test("Can decode account objects", () => {
-    expect(decode(encode(json))).toEqual(json);
-  });
+  test('Can decode account objects', () => {
+    expect(decode(encode(json))).toEqual(json)
+  })
 
-  test("Blank AccountID is ACCOUNT_ZERO", () => {
-    expect(encode(json_blank_acct)).toEqual(binary);
-  });
+  test('Blank AccountID is ACCOUNT_ZERO', () => {
+    expect(encode(json_blank_acct)).toEqual(binary)
+  })
 
-  test("Decodes Blank AccountID", () => {
-    expect(decode(encode(json_blank_acct))).toEqual(json);
-  });
-});
+  test('Decodes Blank AccountID', () => {
+    expect(decode(encode(json_blank_acct))).toEqual(json)
+  })
+})

package/test/quality.test.js

@@ -1,15 +1,15 @@
-const { quality } = require("../dist/coretypes");
+const { quality } = require('../dist/coretypes')
 
-describe("Quality encode/decode", function () {
+describe('Quality encode/decode', function () {
   const bookDirectory =
-    "4627DFFCFF8B5A265EDBD8AE8C14A52325DBFEDAF4F5C32E5D06F4C3362FE1D0";
-  const expectedQuality = "195796912.5171664";
-  test("can decode", function () {
-    const decimal = quality.decode(bookDirectory);
-    expect(decimal.toString()).toBe(expectedQuality);
-  });
-  test("can encode", function () {
-    const bytes = quality.encode(expectedQuality);
-    expect(bytes.toString("hex").toUpperCase()).toBe(bookDirectory.slice(-16));
-  });
-});
+    '4627DFFCFF8B5A265EDBD8AE8C14A52325DBFEDAF4F5C32E5D06F4C3362FE1D0'
+  const expectedQuality = '195796912.5171664'
+  test('can decode', function () {
+    const decimal = quality.decode(bookDirectory)
+    expect(decimal.toString()).toBe(expectedQuality)
+  })
+  test('can encode', function () {
+    const bytes = quality.encode(expectedQuality)
+    expect(bytes.toString('hex').toUpperCase()).toBe(bookDirectory.slice(-16))
+  })
+})

package/test/shamap.test.js

@@ -1,89 +1,89 @@
-const { ShaMap } = require("../dist/shamap.js");
-const { binary, HashPrefix } = require("../dist/coretypes");
-const { coreTypes } = require("../dist/types");
-const { loadFixture } = require("./utils");
-const { Buffer } = require("buffer/");
+const { ShaMap } = require('../dist/shamap.js')
+const { binary, HashPrefix } = require('../dist/coretypes')
+const { coreTypes } = require('../dist/types')
+const { loadFixture } = require('./utils')
+const { Buffer } = require('buffer/')
 
 function now() {
-  return Number(Date.now()) / 1000;
+  return Number(Date.now()) / 1000
 }
 
-const ZERO = "0000000000000000000000000000000000000000000000000000000000000000";
+const ZERO = '0000000000000000000000000000000000000000000000000000000000000000'
 
 function makeItem(indexArg) {
-  let str = indexArg;
+  let str = indexArg
   while (str.length < 64) {
-    str += "0";
+    str += '0'
   }
-  const index = coreTypes.Hash256.from(str);
+  const index = coreTypes.Hash256.from(str)
   const item = {
     toBytesSink(sink) {
-      index.toBytesSink(sink);
+      index.toBytesSink(sink)
     },
     hashPrefix() {
-      return Buffer.from([1, 3, 3, 7]);
+      return Buffer.from([1, 3, 3, 7])
     },
-  };
-  return [index, item];
+  }
+  return [index, item]
 }
 
-describe("ShaMap", () => {
-  now();
+describe('ShaMap', () => {
+  now()
 
-  test("hashes to zero when empty", () => {
-    const map = new ShaMap();
-    expect(map.hash().toHex()).toBe(ZERO);
-  });
-  test("creates the same hash no matter which order items are added", () => {
-    let map = new ShaMap();
+  test('hashes to zero when empty', () => {
+    const map = new ShaMap()
+    expect(map.hash().toHex()).toBe(ZERO)
+  })
+  test('creates the same hash no matter which order items are added', () => {
+    let map = new ShaMap()
     const items = [
-      "0",
-      "1",
-      "11",
-      "7000DE445E22CB9BB7E1717589FA858736BAA5FD192310E20000000000000000",
-      "7000DE445E22CB9BB7E1717589FA858736BAA5FD192310E21000000000000000",
-      "7000DE445E22CB9BB7E1717589FA858736BAA5FD192310E22000000000000000",
-      "7000DE445E22CB9BB7E1717589FA858736BAA5FD192310E23000000000000000",
-      "12",
-      "122",
-    ];
-    items.forEach((i) => map.addItem(...makeItem(i)));
-    const h1 = map.hash();
-    expect(h1.eq(h1)).toBe(true);
-    map = new ShaMap();
-    items.reverse().forEach((i) => map.addItem(...makeItem(i)));
-    expect(map.hash()).toStrictEqual(h1);
-  });
+      '0',
+      '1',
+      '11',
+      '7000DE445E22CB9BB7E1717589FA858736BAA5FD192310E20000000000000000',
+      '7000DE445E22CB9BB7E1717589FA858736BAA5FD192310E21000000000000000',
+      '7000DE445E22CB9BB7E1717589FA858736BAA5FD192310E22000000000000000',
+      '7000DE445E22CB9BB7E1717589FA858736BAA5FD192310E23000000000000000',
+      '12',
+      '122',
+    ]
+    items.forEach((i) => map.addItem(...makeItem(i)))
+    const h1 = map.hash()
+    expect(h1.eq(h1)).toBe(true)
+    map = new ShaMap()
+    items.reverse().forEach((i) => map.addItem(...makeItem(i)))
+    expect(map.hash()).toStrictEqual(h1)
+  })
   function factory(fixture) {
     test(`recreate account state hash from ${fixture}`, () => {
-      const map = new ShaMap();
-      const ledger = loadFixture(fixture);
+      const map = new ShaMap()
+      const ledger = loadFixture(fixture)
       // const t = now();
-      const leafNodePrefix = HashPrefix.accountStateEntry;
+      const leafNodePrefix = HashPrefix.accountStateEntry
       ledger.accountState
         .map((e, i) => {
           if ((i > 1000) & (i % 1000 === 0)) {
-            console.log(e.index);
-            console.log(i);
+            console.log(e.index)
+            console.log(i)
           }
-          const bytes = binary.serializeObject(e);
+          const bytes = binary.serializeObject(e)
           return {
             index: coreTypes.Hash256.from(e.index),
             hashPrefix() {
-              return leafNodePrefix;
+              return leafNodePrefix
             },
             toBytesSink(sink) {
-              sink.put(bytes);
+              sink.put(bytes)
             },
-          };
+          }
         })
-        .forEach((so) => map.addItem(so.index, so));
-      expect(map.hash().toHex()).toBe(ledger.account_hash);
+        .forEach((so) => map.addItem(so.index, so))
+      expect(map.hash().toHex()).toBe(ledger.account_hash)
       // console.log('took seconds: ', (now() - t));
-    });
+    })
   }
-  factory("ledger-full-38129.json");
-  factory("ledger-full-40000.json");
+  factory('ledger-full-38129.json')
+  factory('ledger-full-40000.json')
   // factory('ledger-4320277.json');
   // factory('14280680.json');
-});
+})