@transia/ripple-binary-codec 1.4.4-alpha.0

package/test/signing-data-encoding.test.js

@@ -0,0 +1,242 @@
+const { throws } = require('assert')
+const {
+  encodeForSigning,
+  encodeForSigningClaim,
+  encodeForMultisigning,
+} = require('../src')
+const { XrplDefinitions } = require('../src/enums/xrpl-definitions')
+
+const normalDefinitions = require('../src/enums/definitions.json')
+
+const tx_json = {
+  Account: 'r9LqNeG6qHxjeUocjvVki2XR35weJ9mZgQ',
+  Amount: '1000',
+  Destination: 'rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh',
+  Fee: '10',
+  Flags: 2147483648,
+  Sequence: 1,
+  TransactionType: 'Payment',
+  TxnSignature:
+    '30440220718D264EF05CAED7C781FF6DE298DCAC68D002562C9BF3A07C1' +
+    'E721B420C0DAB02203A5A4779EF4D2CCC7BC3EF886676D803A9981B928D3B8ACA483B80' +
+    'ECA3CD7B9B',
+  Signature:
+    '30440220718D264EF05CAED7C781FF6DE298DCAC68D002562C9BF3A07C1E72' +
+    '1B420C0DAB02203A5A4779EF4D2CCC7BC3EF886676D803A9981B928D3B8ACA483B80ECA' +
+    '3CD7B9B',
+  SigningPubKey:
+    'ED5F5AC8B98974A3CA843326D9B88CEBD0560177B973EE0B149F782CFAA06DC66A',
+}
+
+describe('Signing data', function () {
+  test('can create single signing blobs', function () {
+    const actual = encodeForSigning(tx_json)
+    expect(actual).toBe(
+      [
+        '53545800', // signingPrefix
+        // TransactionType
+        '12',
+        '0000',
+        // Flags
+        '22',
+        '80000000',
+        // Sequence
+        '24',
+        '00000001',
+        // Amount
+        '61',
+        // native amount
+        '40000000000003E8',
+        // Fee
+        '68',
+        // native amount
+        '400000000000000A',
+        // SigningPubKey
+        '73',
+        // VLLength
+        '21',
+        'ED5F5AC8B98974A3CA843326D9B88CEBD0560177B973EE0B149F782CFAA06DC66A',
+        // Account
+        '81',
+        // VLLength
+        '14',
+        '5B812C9D57731E27A2DA8B1830195F88EF32A3B6',
+        // Destination
+        '83',
+        // VLLength
+        '14',
+        'B5F762798A53D543A014CAF8B297CFF8F2F937E8',
+      ].join(''),
+    )
+  })
+
+  test('can create single signing blobs with modified type', function () {
+    const customPaymentDefinitions = JSON.parse(
+      JSON.stringify(normalDefinitions),
+    )
+    customPaymentDefinitions.TRANSACTION_TYPES.Payment = 31
+
+    const newDefs = new XrplDefinitions(customPaymentDefinitions)
+    const actual = encodeForSigning(tx_json, newDefs)
+    expect(actual).toBe(
+      [
+        '53545800', // signingPrefix
+        // TransactionType
+        '12',
+        '001F',
+        // Flags
+        '22',
+        '80000000',
+        // Sequence
+        '24',
+        '00000001',
+        // Amount
+        '61',
+        // native amount
+        '40000000000003E8',
+        // Fee
+        '68',
+        // native amount
+        '400000000000000A',
+        // SigningPubKey
+        '73',
+        // VLLength
+        '21',
+        'ED5F5AC8B98974A3CA843326D9B88CEBD0560177B973EE0B149F782CFAA06DC66A',
+        // Account
+        '81',
+        // VLLength
+        '14',
+        '5B812C9D57731E27A2DA8B1830195F88EF32A3B6',
+        // Destination
+        '83',
+        // VLLength
+        '14',
+        'B5F762798A53D543A014CAF8B297CFF8F2F937E8',
+      ].join(''),
+    )
+  })
+
+  test('can fail gracefully for invalid TransactionType', function () {
+    const invalidTransactionType = {
+      ...tx_json,
+      TransactionType: 'NotAPayment',
+    }
+
+    throws(() => encodeForSigning(invalidTransactionType), /NotAPayment/u)
+  })
+
+  test('can create multi signing blobs', function () {
+    const signingAccount = 'rJZdUusLDtY9NEsGea7ijqhVrXv98rYBYN'
+    const signingJson = { ...tx_json, SigningPubKey: '' }
+    const actual = encodeForMultisigning(signingJson, signingAccount)
+    expect(actual).toBe(
+      [
+        '534D5400', // signingPrefix
+        // TransactionType
+        '12',
+        '0000',
+        // Flags
+        '22',
+        '80000000',
+        // Sequence
+        '24',
+        '00000001',
+        // Amount
+        '61',
+        // native amount
+        '40000000000003E8',
+        // Fee
+        '68',
+        // native amount
+        '400000000000000A',
+        // SigningPubKey
+        '73',
+        // VLLength
+        '00',
+        // '',
+        // Account
+        '81',
+        // VLLength
+        '14',
+        '5B812C9D57731E27A2DA8B1830195F88EF32A3B6',
+        // Destination
+        '83',
+        // VLLength
+        '14',
+        'B5F762798A53D543A014CAF8B297CFF8F2F937E8',
+        // signingAccount suffix
+        'C0A5ABEF242802EFED4B041E8F2D4A8CC86AE3D1',
+      ].join(''),
+    )
+  })
+
+  test('can create multi signing blobs with custom definitions', function () {
+    const customPaymentDefinitions = JSON.parse(
+      JSON.stringify(normalDefinitions),
+    )
+    customPaymentDefinitions.TRANSACTION_TYPES.Payment = 31
+
+    const newDefs = new XrplDefinitions(customPaymentDefinitions)
+    const signingAccount = 'rJZdUusLDtY9NEsGea7ijqhVrXv98rYBYN'
+    const signingJson = { ...tx_json, SigningPubKey: '' }
+    const actual = encodeForMultisigning(signingJson, signingAccount, newDefs)
+    expect(actual).toBe(
+      [
+        '534D5400', // signingPrefix
+        // TransactionType
+        '12',
+        '001F',
+        // Flags
+        '22',
+        '80000000',
+        // Sequence
+        '24',
+        '00000001',
+        // Amount
+        '61',
+        // native amount
+        '40000000000003E8',
+        // Fee
+        '68',
+        // native amount
+        '400000000000000A',
+        // SigningPubKey
+        '73',
+        // VLLength
+        '00',
+        // '',
+        // Account
+        '81',
+        // VLLength
+        '14',
+        '5B812C9D57731E27A2DA8B1830195F88EF32A3B6',
+        // Destination
+        '83',
+        // VLLength
+        '14',
+        'B5F762798A53D543A014CAF8B297CFF8F2F937E8',
+        // signingAccount suffix
+        'C0A5ABEF242802EFED4B041E8F2D4A8CC86AE3D1',
+      ].join(''),
+    )
+  })
+
+  test('can create claim blob', function () {
+    const channel =
+      '43904CBFCDCEC530B4037871F86EE90BF799DF8D2E0EA564BC8A3F332E4F5FB1'
+    const amount = '1000'
+    const json = { channel, amount }
+    const actual = encodeForSigningClaim(json)
+    expect(actual).toBe(
+      [
+        // hash prefix
+        '434C4D00',
+        // channel ID
+        '43904CBFCDCEC530B4037871F86EE90BF799DF8D2E0EA564BC8A3F332E4F5FB1',
+        // amount as a uint64
+        '00000000000003E8',
+      ].join(''),
+    )
+  })
+})

package/test/tx-encode-decode.test.js

@@ -0,0 +1,119 @@
+const { encode, decode } = require('../src')
+
+// Notice: no Amount or Fee
+const tx_json = {
+  Account: 'r9LqNeG6qHxjeUocjvVki2XR35weJ9mZgQ',
+  // Amount: '1000',
+  Destination: 'rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh',
+  // Fee: '10',
+
+  // JavaScript converts operands to 32-bit signed ints after doing bitwise
+  // operations. We need to convert it back to an unsigned int with >>> 0.
+  Flags: (1 << 31) >>> 0, // tfFullyCanonicalSig
+
+  Sequence: 1,
+  TransactionType: 'Payment',
+  // TxnSignature,
+  // Signature,
+  // SigningPubKey
+}
+
+describe('encoding and decoding tx_json', function () {
+  test('can encode tx_json without Amount or Fee', function () {
+    const encoded = encode(tx_json)
+    const decoded = decode(encoded)
+    expect(tx_json).toEqual(decoded)
+  })
+  test('can encode tx_json with Amount and Fee', function () {
+    const my_tx = Object.assign({}, tx_json, {
+      Amount: '1000',
+      Fee: '10',
+    })
+    const encoded = encode(my_tx)
+    const decoded = decode(encoded)
+    expect(my_tx).toEqual(decoded)
+  })
+  test('can encode tx_json with TicketCount', function () {
+    const my_tx = Object.assign({}, tx_json, {
+      TicketCount: 2,
+    })
+    const encoded = encode(my_tx)
+    const decoded = decode(encoded)
+    expect(my_tx).toEqual(decoded)
+  })
+  test('can encode tx_json with TicketSequence', function () {
+    const my_tx = Object.assign({}, tx_json, {
+      Sequence: 0,
+      TicketSequence: 2,
+    })
+    const encoded = encode(my_tx)
+    const decoded = decode(encoded)
+    expect(my_tx).toEqual(decoded)
+  })
+  test('can decode a transaction with an issued currency that evaluates to XRP', function () {
+    // Encoding is done prior, because this is disallowed during encoding with client libraries to avoid scam XRP tokens.
+    const expectedTx = {
+      TransactionType: 'TrustSet',
+      Flags: 0,
+      Sequence: 19,
+      LimitAmount: {
+        value: '200',
+        currency: '0000000000000000000000005852500000000000',
+        issuer: 'r9hEDb4xBGRfBCcX3E4FirDWQBAYtpxC8K',
+      },
+      Fee: '10',
+      SigningPubKey:
+        '023076CBB7A61837F1A23D4A3DD7CE810B694992EB0959AB9D6F4BB6FED6F8CC26',
+      TxnSignature:
+        '304502202D0CD77D8E765E3783C309CD663723B18406B7950A348A6F301492916A990FC70221008A76D586111205304F10ADEFDFDDAF804EF202D8CD1E492DC6E1AA8030EA1844',
+      Account: 'rPtfQWdcdhuL9eNeNv5YfmekSX3K7vJHbG',
+    }
+    const encoded = encode(expectedTx)
+    const decoded = decode(encoded)
+    expect(expectedTx).toEqual(decoded)
+  })
+  test('throws when Amount is invalid', function () {
+    const my_tx = Object.assign({}, tx_json, {
+      Amount: '1000.001',
+      Fee: '10',
+    })
+    expect(() => {
+      encode(my_tx)
+    }).toThrow()
+  })
+  test('throws when Fee is invalid', function () {
+    const my_tx = Object.assign({}, tx_json, {
+      Amount: '1000',
+      Fee: '10.123',
+    })
+    expect(() => {
+      encode(my_tx)
+    }).toThrow()
+  })
+  test('throws when Amount and Fee are invalid', function () {
+    const my_tx = Object.assign({}, tx_json, {
+      Amount: '1000.789',
+      Fee: '10.123',
+    })
+    expect(() => {
+      encode(my_tx)
+    }).toThrow()
+  })
+  test('throws when Amount is a number instead of a string-encoded integer', function () {
+    const my_tx = Object.assign({}, tx_json, {
+      Amount: 1000.789,
+    })
+    expect(() => {
+      encode(my_tx)
+    }).toThrow()
+  })
+
+  test('throws when Fee is a number instead of a string-encoded integer', function () {
+    const my_tx = Object.assign({}, tx_json, {
+      Amount: 1234.56,
+    })
+    expect(() => {
+      encode(my_tx)
+    }).toThrow()
+  })
+})

package/test/types.test.js

@@ -0,0 +1,34 @@
+const { coreTypes } = require('../src/types')
+const { SerializedType } = require('../src/types/serialized-type')
+
+describe('SerializedType interfaces', () => {
+  Object.entries(coreTypes).forEach(([name, Value]) => {
+    test(`${name} has a \`from\` static constructor`, () => {
+      expect(Value.from && Value.from !== Array.from).toBe(true)
+    })
+    test(`${name} has a default constructor`, () => {
+      expect(new Value()).not.toBe(undefined)
+    })
+    test(`${name}.from will return the same object`, () => {
+      const instance = new Value()
+      expect(Value.from(instance) === instance).toBe(true)
+    })
+    test(`${name} instances have toBytesSink`, () => {
+      expect(new Value().toBytesSink).not.toBe(undefined)
+    })
+    test(`${name} instances have toJSON`, () => {
+      expect(new Value().toJSON).not.toBe(undefined)
+    })
+    test(`${name}.from(json).toJSON() == json`, () => {
+      const newJSON = new Value().toJSON()
+      expect(Value.from(newJSON).toJSON()).toEqual(newJSON)
+    })
+    describe(`${name} supports all methods of the SerializedType mixin`, () => {
+      Object.keys(SerializedType.prototype).forEach((k) => {
+        test(`new ${name}.prototype.${k} !== undefined`, () => {
+          expect(Value.prototype[k]).not.toBe(undefined)
+        })
+      })
+    })
+  })
+})

package/test/uint.test.js

@@ -0,0 +1,148 @@
+const { coreTypes } = require('../src/types')
+const { UInt8, UInt64 } = coreTypes
+
+const { encode } = require('../src')
+
+const binary =
+  '11007222000300003700000000000000003800000000000000006280000000000000000000000000000000000000005553440000000000000000000000000000000000000000000000000166D5438D7EA4C680000000000000000000000000005553440000000000AE123A8556F3CF91154711376AFB0F894F832B3D67D5438D7EA4C680000000000000000000000000005553440000000000F51DFC2A09D62CBBA1DFBDD4691DAC96AD98B90F'
+const json = {
+  Balance: {
+    currency: 'USD',
+    issuer: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+    value: '0',
+  },
+  Flags: 196608,
+  HighLimit: {
+    currency: 'USD',
+    issuer: 'rPMh7Pi9ct699iZUTWaytJUoHcJ7cgyziK',
+    value: '1000',
+  },
+  HighNode: '0',
+  LedgerEntryType: 'RippleState',
+  LowLimit: {
+    currency: 'USD',
+    issuer: 'rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn',
+    value: '1000',
+  },
+  LowNode: '0',
+}
+
+const binaryEntry0 =
+  '11007222001100002501EC24873700000000000000003800000000000000A35506FC7DE374089D50F81AAE13E7BBF3D0E694769331E14F55351B38D0148018EA62D44BF89AC2A40B800000000000000000000000004A50590000000000000000000000000000000000000000000000000166D6C38D7EA4C680000000000000000000000000004A5059000000000047C1258B4B79774B28176324068F759EDE226F686780000000000000000000000000000000000000004A505900000000005BBC0F22F61D9224A110650CFE21CC0C4BE13098'
+const jsonEntry0 = {
+  Balance: {
+    currency: 'JPY',
+    issuer: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+    value: '0.3369568318',
+  },
+  Flags: 1114112,
+  HighLimit: {
+    currency: 'JPY',
+    issuer: 'r94s8px6kSw1uZ1MV98dhSRTvc6VMPoPcN',
+    value: '0',
+  },
+  HighNode: 'a3',
+  LedgerEntryType: 'RippleState',
+  LowLimit: {
+    currency: 'JPY',
+    issuer: 'rfYQMgj3g3Qp8VLoZNvvU35mEuuJC8nCmY',
+    value: '1000000000',
+  },
+  LowNode: '0',
+  PreviousTxnID:
+    '06FC7DE374089D50F81AAE13E7BBF3D0E694769331E14F55351B38D0148018EA',
+  PreviousTxnLgrSeq: 32253063,
+  index: '000319BAE0A618A7D3BB492F17E98E5D92EA0C6458AFEBED44206B5B4798A840',
+}
+
+const binaryEntry1 =
+  '1100642200000000320000000000000002580CB3C1AD2C371136AEA434246D971C5FCCD32CBF520667E131AB7B10D706E7528214BA53D10260FFCC968ACD16BA30F7CEABAD6E5D92011340A3454ACED87177146EABD5E4A256021D836D1E3617618B1EB362D10B0D1BAC6AE1ED9E8D280BBE0B6656748FD647231851C6C650794D5E6852DFA1E35E68630F'
+const jsonEntry1 = {
+  Flags: 0,
+  IndexPrevious: '2',
+  Indexes: [
+    'A3454ACED87177146EABD5E4A256021D836D1E3617618B1EB362D10B0D1BAC6A',
+    'E1ED9E8D280BBE0B6656748FD647231851C6C650794D5E6852DFA1E35E68630F',
+  ],
+  LedgerEntryType: 'DirectoryNode',
+  Owner: 'rHzDaMNybxQppiE3uWyt2N265KvAKdiRdP',
+  RootIndex: '0CB3C1AD2C371136AEA434246D971C5FCCD32CBF520667E131AB7B10D706E752',
+  index: '0B4A2E68C111F7E42FAEEE405F7344560C8240840B151D9D04131EB79D080167',
+}
+
+const binaryEntry2 =
+  '1100722200210000250178D1CA37000000000000000038000000000000028355C0C37CE200B509E0A529880634F7841A9EF4CB65F03C12E6004CFAD9718D66946280000000000000000000000000000000000000004743420000000000000000000000000000000000000000000000000166D6071AFD498D000000000000000000000000000047434200000000002599D1D255BCA61189CA64C84528F2FCBE4BFC3867800000000000000000000000000000000000000047434200000000006EEBB1D1852CE667876A0B3630861FB6C6AB358E'
+const jsonEntry2 = {
+  Balance: {
+    currency: 'GCB',
+    issuer: 'rrrrrrrrrrrrrrrrrrrrBZbvji',
+    value: '0',
+  },
+  Flags: 2162688,
+  HighLimit: {
+    currency: 'GCB',
+    issuer: 'rBfVgTnsdh8ckC19RM8aVGNuMZnpwrMP6n',
+    value: '0',
+  },
+  HighNode: '283',
+  LedgerEntryType: 'RippleState',
+  LowLimit: {
+    currency: 'GCB',
+    issuer: 'rhRFGCy2RJTA8oxkjjtYTvofPVGqcgvXWj',
+    value: '2000000',
+  },
+  LowNode: '0',
+  PreviousTxnID:
+    'C0C37CE200B509E0A529880634F7841A9EF4CB65F03C12E6004CFAD9718D6694',
+  PreviousTxnLgrSeq: 24695242,
+  index: '0000041EFD027808D3F78C8352F97E324CB816318E00B977C74ECDDC7CD975B2',
+}
+
+test('compareToTests[0]', () => {
+  expect(UInt8.from(124).compareTo(UInt64.from(124))).toBe(0)
+})
+
+test('compareToTest[1]', () => {
+  expect(UInt64.from(124).compareTo(UInt8.from(124))).toBe(0)
+})
+
+test('compareToTest[2]', () => {
+  expect(UInt64.from(124).compareTo(UInt8.from(123))).toBe(1)
+})
+
+test('compareToTest[3]', () => {
+  expect(UInt8.from(124).compareTo(UInt8.from(13))).toBe(1)
+})
+
+test('compareToTest[4]', () => {
+  expect(UInt8.from(124).compareTo(124)).toBe(0)
+})
+
+test('compareToTest[5]', () => {
+  expect(UInt64.from(124).compareTo(124)).toBe(0)
+})
+
+test('compareToTest[6]', () => {
+  expect(UInt64.from(124).compareTo(123)).toBe(1)
+})
+
+test('compareToTest[7]', () => {
+  expect(UInt8.from(124).compareTo(13)).toBe(1)
+})
+
+test('UInt64 from string zero', () => {
+  expect(UInt64.from('0')).toEqual(UInt64.from(0))
+  expect(encode(json)).toEqual(binary)
+})
+
+test('UInt64 from non 16 length hex', () => {
+  expect(encode(jsonEntry0)).toEqual(binaryEntry0)
+  expect(encode(jsonEntry1)).toEqual(binaryEntry1)
+  expect(encode(jsonEntry2)).toEqual(binaryEntry2)
+})
+
+test('valueOfTests', () => {
+  let val = UInt8.from(1)
+  val |= 0x2
+  expect(val).toBe(3)
+})

package/test/utils.js

@@ -0,0 +1,30 @@
+const fs = require("fs");
+const { Buffer } = require('buffer/')
+
+function hexOnly(hex) {
+  return hex.replace(/[^a-fA-F0-9]/g, "");
+}
+
+function unused() {}
+
+function parseHexOnly(hex) {
+  return Buffer.from(hexOnly(hex), "hex");
+}
+
+function loadFixture(relativePath) {
+  const fn = __dirname + "/fixtures/" + relativePath;
+  return require(fn);
+}
+
+function loadFixtureText(relativePath) {
+  const fn = __dirname + "/fixtures/" + relativePath;
+  return fs.readFileSync(fn).toString("utf8");
+}
+
+module.exports = {
+  hexOnly,
+  parseHexOnly,
+  loadFixture,
+  loadFixtureText,
+  unused,
+};