@transia/ripple-binary-codec 1.4.6-alpha.9 → 2.5.1-quantum.0

package/test/binary-serializer.test.js

@@ -1,319 +0,0 @@
-const { binary } = require('../src/coretypes')
-const { encode, decode } = require('../src')
-const { makeParser, BytesList, BinarySerializer } = binary
-const { coreTypes } = require('../src/types')
-const { UInt8, UInt16, UInt32, UInt64, STObject } = coreTypes
-const bigInt = require('big-integer')
-const { Buffer } = require('buffer/')
-
-const { loadFixture } = require('./utils')
-const fixtures = loadFixture('data-driven-tests.json')
-const deliverMinTx = require('./fixtures/delivermin-tx.json')
-const deliverMinTxBinary = require('./fixtures/delivermin-tx-binary.json')
-const SignerListSet = {
-  tx: require('./fixtures/signerlistset-tx.json'),
-  binary: require('./fixtures/signerlistset-tx-binary.json'),
-  meta: require('./fixtures/signerlistset-tx-meta-binary.json'),
-}
-const DepositPreauth = {
-  tx: require('./fixtures/deposit-preauth-tx.json'),
-  binary: require('./fixtures/deposit-preauth-tx-binary.json'),
-  meta: require('./fixtures/deposit-preauth-tx-meta-binary.json'),
-}
-const Escrow = {
-  create: {
-    tx: require('./fixtures/escrow-create-tx.json'),
-    binary: require('./fixtures/escrow-create-binary.json'),
-  },
-  finish: {
-    tx: require('./fixtures/escrow-finish-tx.json'),
-    binary: require('./fixtures/escrow-finish-binary.json'),
-    meta: require('./fixtures/escrow-finish-meta-binary.json'),
-  },
-  cancel: {
-    tx: require('./fixtures/escrow-cancel-tx.json'),
-    binary: require('./fixtures/escrow-cancel-binary.json'),
-  },
-}
-const PaymentChannel = {
-  create: {
-    tx: require('./fixtures/payment-channel-create-tx.json'),
-    binary: require('./fixtures/payment-channel-create-binary.json'),
-  },
-  fund: {
-    tx: require('./fixtures/payment-channel-fund-tx.json'),
-    binary: require('./fixtures/payment-channel-fund-binary.json'),
-  },
-  claim: {
-    tx: require('./fixtures/payment-channel-claim-tx.json'),
-    binary: require('./fixtures/payment-channel-claim-binary.json'),
-  },
-}
-
-const Ticket = {
-  create: {
-    tx: require('./fixtures/ticket-create-tx.json'),
-    binary: require('./fixtures/ticket-create-binary.json'),
-  },
-}
-
-let json_undefined = {
-  TakerPays: '223174650',
-  Account: 'rPk2dXr27rMw9G5Ej9ad2Tt7RJzGy8ycBp',
-  TransactionType: 'OfferCreate',
-  Memos: [
-    {
-      Memo: {
-        MemoType: '584D4D2076616C7565',
-        MemoData: '322E3230393635',
-        MemoFormat: undefined,
-      },
-    },
-  ],
-  Fee: '15',
-  OfferSequence: undefined,
-  TakerGets: {
-    currency: 'XMM',
-    value: '100',
-    issuer: 'rExAPEZvbkZqYPuNcZ7XEBLENEshsWDQc8',
-  },
-  Flags: 524288,
-  Sequence: undefined,
-  LastLedgerSequence: 6220135,
-}
-
-let json_omitted = {
-  TakerPays: '223174650',
-  Account: 'rPk2dXr27rMw9G5Ej9ad2Tt7RJzGy8ycBp',
-  TransactionType: 'OfferCreate',
-  Memos: [
-    {
-      Memo: {
-        MemoType: '584D4D2076616C7565',
-        MemoData: '322E3230393635',
-      },
-    },
-  ],
-  Fee: '15',
-  TakerGets: {
-    currency: 'XMM',
-    value: '100',
-    issuer: 'rExAPEZvbkZqYPuNcZ7XEBLENEshsWDQc8',
-  },
-  Flags: 524288,
-  LastLedgerSequence: 6220135,
-}
-
-const NegativeUNL = require('./fixtures/negative-unl.json')
-const UNLReport = {
-  tx: require('./fixtures/unl-report.json'),
-  binary: require('./fixtures/unl-report-binary.json'),
-  meta: require('./fixtures/unl-report-meta-binary.json'),
-}
-
-const Remit = {
-  tx: require('./fixtures/remit-tx.json'),
-  binary: require('./fixtures/remit-binary.json'),
-}
-
-function bytesListTest() {
-  const list = new BytesList()
-    .put(Buffer.from([0]))
-    .put(Buffer.from([2, 3]))
-    .put(Buffer.from([4, 5]))
-  test('is an Array<Buffer>', function () {
-    expect(Array.isArray(list.bytesArray)).toBe(true)
-    expect(list.bytesArray[0] instanceof Buffer).toBe(true)
-  })
-  test('keeps track of the length itself', function () {
-    expect(list.getLength()).toBe(5)
-  })
-  test('can join all arrays into one via toBytes', function () {
-    const joined = list.toBytes()
-    expect(joined).toHaveLength(5)
-    expect(joined).toEqual(Buffer.from([0, 2, 3, 4, 5]))
-  })
-}
-
-function assertRecycles(blob) {
-  const parser = makeParser(blob)
-  const so = parser.readType(STObject)
-  const out = new BytesList()
-  so.toBytesSink(out)
-  const hex = out.toHex()
-  expect(hex).toEqual(blob)
-  expect(hex + ':').not.toEqual(blob)
-}
-
-function nestedObjectTests() {
-  fixtures.whole_objects.forEach((f, i) => {
-    test(`whole_objects[${i}]: can parse blob and dump out same blob`, () => {
-      assertRecycles(f.blob_with_no_signing)
-    })
-  })
-}
-
-function check(type, n, expected) {
-  test(`Uint${type.width * 8} serializes ${n} as ${expected}`, function () {
-    const bl = new BytesList()
-    const serializer = new BinarySerializer(bl)
-    if (expected === 'throws') {
-      expect(() => serializer.writeType(type, n)).toThrow()
-      return
-    }
-    serializer.writeType(type, n)
-    expect(bl.toBytes()).toEqual(Buffer.from(expected))
-  })
-}
-
-check(UInt8, 5, [5])
-check(UInt16, 5, [0, 5])
-check(UInt32, 5, [0, 0, 0, 5])
-check(UInt32, 0xffffffff, [255, 255, 255, 255])
-check(UInt8, 0xfeffffff, 'throws')
-check(UInt16, 0xfeffffff, 'throws')
-check(UInt16, 0xfeffffff, 'throws')
-check(UInt64, 0xfeffffff, [0, 0, 0, 0, 254, 255, 255, 255])
-check(UInt64, -1, 'throws')
-check(UInt64, 0, [0, 0, 0, 0, 0, 0, 0, 0])
-check(UInt64, 1, [0, 0, 0, 0, 0, 0, 0, 1])
-check(UInt64, bigInt(1), [0, 0, 0, 0, 0, 0, 0, 1])
-
-function deliverMinTest() {
-  test('can serialize DeliverMin', () => {
-    expect(encode(deliverMinTx)).toEqual(deliverMinTxBinary)
-  })
-}
-
-function SignerListSetTest() {
-  test('can serialize SignerListSet', () => {
-    expect(encode(SignerListSet.tx)).toEqual(SignerListSet.binary)
-  })
-  test('can serialize SignerListSet metadata', () => {
-    expect(encode(SignerListSet.tx.meta)).toEqual(SignerListSet.meta)
-  })
-}
-
-function DepositPreauthTest() {
-  test('can serialize DepositPreauth', () => {
-    expect(encode(DepositPreauth.tx)).toEqual(DepositPreauth.binary)
-  })
-  test('can serialize DepositPreauth metadata', () => {
-    expect(encode(DepositPreauth.tx.meta)).toEqual(DepositPreauth.meta)
-  })
-}
-
-function EscrowTest() {
-  test('can serialize EscrowCreate', () => {
-    expect(encode(Escrow.create.tx)).toEqual(Escrow.create.binary)
-  })
-  test('can serialize EscrowFinish', () => {
-    expect(encode(Escrow.finish.tx)).toEqual(Escrow.finish.binary)
-    expect(encode(Escrow.finish.tx.meta)).toEqual(Escrow.finish.meta)
-  })
-  test('can serialize EscrowCancel', () => {
-    expect(encode(Escrow.cancel.tx)).toEqual(Escrow.cancel.binary)
-  })
-}
-
-function PaymentChannelTest() {
-  test('can serialize PaymentChannelCreate', () => {
-    expect(encode(PaymentChannel.create.tx)).toEqual(
-      PaymentChannel.create.binary,
-    )
-  })
-  test('can serialize PaymentChannelFund', () => {
-    expect(encode(PaymentChannel.fund.tx)).toEqual(PaymentChannel.fund.binary)
-  })
-  test('can serialize PaymentChannelClaim', () => {
-    expect(encode(PaymentChannel.claim.tx)).toEqual(PaymentChannel.claim.binary)
-  })
-}
-
-function NegativeUNLTest() {
-  test('can serialize NegativeUNL', () => {
-    expect(encode(NegativeUNL.tx)).toEqual(NegativeUNL.binary)
-  })
-  test('can deserialize NegativeUNL', () => {
-    expect(decode(NegativeUNL.binary)).toEqual(NegativeUNL.tx)
-  })
-}
-
-function UNLReportTest() {
-  test('can serialize UNLReport', () => {
-    expect(encode(UNLReport.tx)).toEqual(UNLReport.binary)
-  })
-  test('can serialize UNLReport metadata', () => {
-    expect(encode(UNLReport.tx.meta)).toEqual(UNLReport.meta)
-  })
-  test('can deserialize UNLReport metadata', () => {
-    expect(decode(UNLReport.meta)).toEqual(UNLReport.tx.meta)
-  })
-}
-
-function omitUndefinedTest() {
-  test('omits fields with undefined value', () => {
-    let encodedOmitted = encode(json_omitted)
-    let encodedUndefined = encode(json_undefined)
-    expect(encodedOmitted).toEqual(encodedUndefined)
-    expect(decode(encodedOmitted)).toEqual(decode(encodedUndefined))
-  })
-}
-
-function ticketTest() {
-  test('can serialize TicketCreate', () => {
-    expect(encode(Ticket.create.tx)).toEqual(Ticket.create.binary)
-  })
-}
-
-function nfTokenTest() {
-  const fixtures = require('./fixtures/nf-token.json')
-
-  for (const txName of Object.keys(fixtures)) {
-    test(`can serialize transaction ${txName}`, () => {
-      expect(encode(fixtures[txName].tx.json)).toEqual(
-        fixtures[txName].tx.binary,
-      )
-    })
-
-    test(`can deserialize transaction ${txName}`, () => {
-      expect(decode(fixtures[txName].tx.binary)).toEqual(
-        fixtures[txName].tx.json,
-      )
-    })
-
-    test(`can serialize meta ${txName}`, () => {
-      expect(encode(fixtures[txName].meta.json)).toEqual(
-        fixtures[txName].meta.binary,
-      )
-    })
-
-    test(`can deserialize meta ${txName}`, () => {
-      expect(decode(fixtures[txName].meta.binary)).toEqual(
-        fixtures[txName].meta.json,
-      )
-    })
-  }
-}
-
-function RemitTest() {
-  test('can serialize Remit', () => {
-    expect(encode(Remit.tx)).toEqual(Remit.binary)
-  })
-}
-
-describe('Binary Serialization', function () {
-  describe('nestedObjectTests', nestedObjectTests)
-  describe('BytesList', bytesListTest)
-  describe('DeliverMin', deliverMinTest)
-  describe('DepositPreauth', DepositPreauthTest)
-  describe('SignerListSet', SignerListSetTest)
-  describe('Escrow', EscrowTest)
-  describe('PaymentChannel', PaymentChannelTest)
-  describe('NegativeUNLTest', NegativeUNLTest)
-  describe('OmitUndefined', omitUndefinedTest)
-  describe('TicketTest', ticketTest)
-  describe('NFToken', nfTokenTest)
-  describe('UNLReport', UNLReportTest)
-  describe('Remit', RemitTest)
-})

package/test/definitions.test.js

@@ -1,100 +0,0 @@
-const { encode, decode, XrplDefinitions } = require('../src')
-const normalDefinitionsJson = require('../src/enums/definitions.json')
-const { UInt32 } = require('../dist/types/uint-32')
-
-const txJson = {
-  Account: 'r9LqNeG6qHxjeUocjvVki2XR35weJ9mZgQ',
-  Amount: '1000',
-  Destination: 'rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh',
-  Fee: '10',
-  Flags: 0,
-  Sequence: 1,
-  TransactionType: 'Payment',
-}
-
-describe('encode and decode using new types as a parameter', function () {
-  test('can encode and decode a new TransactionType', function () {
-    const tx = { ...txJson, TransactionType: 'NewTestTransaction' }
-    // Before updating the types, this should not be encodable
-    expect(() => encode(tx)).toThrow()
-
-    // Normally this would be generated directly from rippled with something like `server_definitions`.
-    // Added here to make it easier to see what is actually changing in the definitions.json file.
-    const definitions = JSON.parse(JSON.stringify(normalDefinitionsJson))
-    definitions.TRANSACTION_TYPES['NewTestTransaction'] = 30
-
-    const newDefs = new XrplDefinitions(definitions)
-
-    const encoded = encode(tx, newDefs)
-    expect(() => decode(encoded)).toThrow()
-    const decoded = decode(encoded, newDefs)
-    expect(decoded).toStrictEqual(tx)
-  })
-
-  test('can encode and decode a new Field', function () {
-    const tx = { ...txJson, NewFieldDefinition: 10 }
-
-    // Before updating the types, undefined fields will be ignored on encode
-    expect(decode(encode(tx))).not.toStrictEqual(tx)
-
-    // Normally this would be generated directly from rippled with something like `server_definitions`.
-    // Added here to make it easier to see what is actually changing in the definitions.json file.
-    const definitions = JSON.parse(JSON.stringify(normalDefinitionsJson))
-
-    definitions.FIELDS.push([
-      'NewFieldDefinition',
-      {
-        nth: 101,
-        isVLEncoded: false,
-        isSerialized: true,
-        isSigningField: true,
-        type: 'UInt32',
-      },
-    ])
-
-    const newDefs = new XrplDefinitions(definitions)
-
-    const encoded = encode(tx, newDefs)
-    expect(() => decode(encoded)).toThrow()
-    const decoded = decode(encoded, newDefs)
-    expect(decoded).toStrictEqual(tx)
-  })
-
-  test('can encode and decode a new Type', function () {
-    const tx = {
-      ...txJson,
-      TestField: 10, // Should work the same as a UInt32
-    }
-
-    // Normally this would be generated directly from rippled with something like `server_definitions`.
-    // Added here to make it easier to see what is actually changing in the definitions.json file.
-    const definitions = JSON.parse(JSON.stringify(normalDefinitionsJson))
-    definitions.TYPES.NewType = 24
-    definitions.FIELDS.push([
-      'TestField',
-      {
-        nth: 100,
-        isVLEncoded: true,
-        isSerialized: true,
-        isSigningField: true,
-        type: 'NewType',
-      },
-    ])
-
-    // Test that before updating the types this tx fails to decode correctly. Note that undefined fields are ignored on encode.
-    expect(decode(encode(tx))).not.toStrictEqual(tx)
-
-    class NewType extends UInt32 {
-      // Should be the same as UInt32
-    }
-
-    const extendedCoreTypes = { NewType }
-
-    const newDefs = new XrplDefinitions(definitions, extendedCoreTypes)
-
-    const encoded = encode(tx, newDefs)
-    expect(() => decode(encoded)).toThrow()
-    const decoded = decode(encoded, newDefs)
-    expect(decoded).toStrictEqual(tx)
-  })
-})