@ipld/car 3.2.4 → 4.1.1

package/cjs/node-test/test-buffer-writer.js

@@ -0,0 +1,330 @@
+'use strict';
+
+var bufferWriter = require('../lib/buffer-writer.js');
+var reader = require('../lib/reader.js');
+var encoder = require('../lib/encoder.js');
+var common = require('./common.js');
+var multiformats = require('multiformats');
+var CBOR = require('@ipld/dag-cbor');
+var sha2 = require('multiformats/hashes/sha2');
+var identity = require('multiformats/hashes/identity');
+var raw = require('multiformats/codecs/raw');
+var Block = require('multiformats/block');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var CBOR__namespace = /*#__PURE__*/_interopNamespace(CBOR);
+var raw__namespace = /*#__PURE__*/_interopNamespace(raw);
+var Block__namespace = /*#__PURE__*/_interopNamespace(Block);
+
+describe('CarBufferWriter', () => {
+  const cid = multiformats.CID.parse('bafkreifuosuzujyf4i6psbneqtwg2fhplc2wxptc5euspa2gn3bwhnihfu');
+  describe('calculateHeaderLength', async () => {
+    for (const count of [
+        0,
+        1,
+        10,
+        18,
+        24,
+        48,
+        124,
+        255,
+        258,
+        65536 - 1,
+        65536
+      ]) {
+      it(`calculateHeaderLength(new Array(${ count }).fill(36))`, () => {
+        const roots = new Array(count).fill(cid);
+        const sizes = new Array(count).fill(cid.bytes.byteLength);
+        common.assert.deepEqual(bufferWriter.calculateHeaderLength(sizes), encoder.createHeader(roots).byteLength);
+      });
+      it(`calculateHeaderLength(new Array(${ count }).fill(36))`, () => {
+        const roots = new Array(count).fill(cid);
+        const rootLengths = roots.map(c => c.bytes.byteLength);
+        common.assert.deepEqual(bufferWriter.calculateHeaderLength(rootLengths), encoder.createHeader(roots).byteLength);
+      });
+    }
+    it('estimate on large CIDs', () => {
+      const largeCID = multiformats.CID.parse(`bafkqbbac${ 'a'.repeat(416) }`);
+      common.assert.equal(bufferWriter.calculateHeaderLength([
+        cid.bytes.byteLength,
+        largeCID.bytes.byteLength
+      ]), encoder.createHeader([
+        cid,
+        largeCID
+      ]).byteLength);
+    });
+    it('estimate on large CIDs 2', () => {
+      const largeCID = multiformats.CID.createV1(raw__namespace.code, identity.identity.digest(new Uint8Array(512).fill(1)));
+      common.assert.equal(bufferWriter.calculateHeaderLength([
+        cid.bytes.byteLength,
+        largeCID.bytes.byteLength
+      ]), encoder.createHeader([
+        cid,
+        largeCID
+      ]).byteLength);
+    });
+  });
+  describe('writer', () => {
+    it('estimate header and write blocks', async () => {
+      const headerSize = bufferWriter.estimateHeaderLength(1);
+      const dataSize = 256;
+      const buffer = new ArrayBuffer(headerSize + dataSize);
+      const writer = bufferWriter.createWriter(buffer, { headerSize });
+      const b1 = await Block__namespace.encode({
+        value: { hello: 'world' },
+        codec: CBOR__namespace,
+        hasher: sha2.sha256
+      });
+      writer.write(b1);
+      const b2 = await Block__namespace.encode({
+        value: { bye: 'world' },
+        codec: CBOR__namespace,
+        hasher: sha2.sha256
+      });
+      writer.write(b2);
+      writer.addRoot(b1.cid);
+      const bytes = writer.close();
+      const reader$1 = await reader.CarReader.fromBytes(bytes);
+      common.assert.deepEqual(await reader$1.getRoots(), [b1.cid]);
+      common.assert.deepEqual(reader$1._blocks, [
+        {
+          cid: b1.cid,
+          bytes: b1.bytes
+        },
+        {
+          cid: b2.cid,
+          bytes: b2.bytes
+        }
+      ]);
+    });
+    it('overestimate header', async () => {
+      const headerSize = bufferWriter.estimateHeaderLength(2);
+      const dataSize = 256;
+      const buffer = new ArrayBuffer(headerSize + dataSize);
+      const writer = bufferWriter.createWriter(buffer, { headerSize });
+      const b1 = await Block__namespace.encode({
+        value: { hello: 'world' },
+        codec: CBOR__namespace,
+        hasher: sha2.sha256
+      });
+      writer.write(b1);
+      const b2 = await Block__namespace.encode({
+        value: { bye: 'world' },
+        codec: CBOR__namespace,
+        hasher: sha2.sha256
+      });
+      writer.write(b2);
+      writer.addRoot(b1.cid);
+      common.assert.throws(() => writer.close(), /Header size was overestimate/);
+      const bytes = writer.close({ resize: true });
+      const reader$1 = await reader.CarReader.fromBytes(bytes);
+      common.assert.deepEqual(await reader$1.getRoots(), [b1.cid]);
+      common.assert.deepEqual(reader$1._blocks, [
+        {
+          cid: b1.cid,
+          bytes: b1.bytes
+        },
+        {
+          cid: b2.cid,
+          bytes: b2.bytes
+        }
+      ]);
+    });
+    it('underestimate header', async () => {
+      const headerSize = bufferWriter.estimateHeaderLength(2);
+      const dataSize = 300;
+      const buffer = new ArrayBuffer(headerSize + dataSize);
+      const writer = bufferWriter.createWriter(buffer, { headerSize });
+      const b1 = await Block__namespace.encode({
+        value: { hello: 'world' },
+        codec: CBOR__namespace,
+        hasher: sha2.sha256
+      });
+      writer.write(b1);
+      writer.addRoot(b1.cid);
+      const b2 = await Block__namespace.encode({
+        value: { bye: 'world' },
+        codec: CBOR__namespace,
+        hasher: sha2.sha512
+      });
+      writer.write(b2);
+      common.assert.throws(() => writer.addRoot(b2.cid), /has no capacity/);
+      writer.addRoot(b2.cid, { resize: true });
+      const bytes = writer.close();
+      const reader$1 = await reader.CarReader.fromBytes(bytes);
+      common.assert.deepEqual(await reader$1.getRoots(), [
+        b1.cid,
+        b2.cid
+      ]);
+      common.assert.deepEqual(reader$1._blocks, [
+        {
+          cid: b1.cid,
+          bytes: b1.bytes
+        },
+        {
+          cid: b2.cid,
+          bytes: b2.bytes
+        }
+      ]);
+    });
+  });
+  it('has no space for the root', async () => {
+    const headerSize = bufferWriter.estimateHeaderLength(1);
+    const dataSize = 100;
+    const buffer = new ArrayBuffer(headerSize + dataSize);
+    const writer = bufferWriter.createWriter(buffer, { headerSize });
+    const b1 = await Block__namespace.encode({
+      value: { hello: 'world' },
+      codec: CBOR__namespace,
+      hasher: sha2.sha256
+    });
+    writer.write(b1);
+    writer.addRoot(b1.cid);
+    const b2 = await Block__namespace.encode({
+      value: { bye: 'world' },
+      codec: CBOR__namespace,
+      hasher: sha2.sha256
+    });
+    writer.write(b2);
+    common.assert.throws(() => writer.addRoot(b2.cid), /Buffer has no capacity for a new root/);
+    common.assert.throws(() => writer.addRoot(b2.cid, { resize: true }), /Buffer has no capacity for a new root/);
+    const bytes = writer.close();
+    const reader$1 = await reader.CarReader.fromBytes(bytes);
+    common.assert.deepEqual(await reader$1.getRoots(), [b1.cid]);
+    common.assert.deepEqual(reader$1._blocks, [
+      {
+        cid: b1.cid,
+        bytes: b1.bytes
+      },
+      {
+        cid: b2.cid,
+        bytes: b2.bytes
+      }
+    ]);
+  });
+  it('has no space for the block', async () => {
+    const headerSize = bufferWriter.estimateHeaderLength(1);
+    const dataSize = 58;
+    const buffer = new ArrayBuffer(headerSize + dataSize);
+    const writer = bufferWriter.createWriter(buffer, { headerSize });
+    const b1 = await Block__namespace.encode({
+      value: { hello: 'world' },
+      codec: CBOR__namespace,
+      hasher: sha2.sha256
+    });
+    writer.write(b1);
+    writer.addRoot(b1.cid);
+    const b2 = await Block__namespace.encode({
+      value: { bye: 'world' },
+      codec: CBOR__namespace,
+      hasher: sha2.sha256
+    });
+    common.assert.throws(() => writer.write(b2), /Buffer has no capacity for this block/);
+    const bytes = writer.close();
+    const reader$1 = await reader.CarReader.fromBytes(bytes);
+    common.assert.deepEqual(await reader$1.getRoots(), [b1.cid]);
+    common.assert.deepEqual(reader$1._blocks, [{
+        cid: b1.cid,
+        bytes: b1.bytes
+      }]);
+  });
+  it('provide roots', async () => {
+    const b1 = await Block__namespace.encode({
+      value: { hello: 'world' },
+      codec: CBOR__namespace,
+      hasher: sha2.sha256
+    });
+    const b2 = await Block__namespace.encode({
+      value: { bye: 'world' },
+      codec: CBOR__namespace,
+      hasher: sha2.sha512
+    });
+    const buffer = new ArrayBuffer(300);
+    const writer = bufferWriter.createWriter(buffer, {
+      roots: [
+        b1.cid,
+        b2.cid
+      ]
+    });
+    writer.write(b1);
+    writer.write(b2);
+    const bytes = writer.close();
+    const reader$1 = await reader.CarReader.fromBytes(bytes);
+    common.assert.deepEqual(await reader$1.getRoots(), [
+      b1.cid,
+      b2.cid
+    ]);
+    common.assert.deepEqual(reader$1._blocks, [
+      {
+        cid: b1.cid,
+        bytes: b1.bytes
+      },
+      {
+        cid: b2.cid,
+        bytes: b2.bytes
+      }
+    ]);
+  });
+  it('provide large CID root', async () => {
+    const bytes = new Uint8Array(512).fill(1);
+    const b1 = await Block__namespace.encode({
+      value: { hello: 'world' },
+      codec: CBOR__namespace,
+      hasher: sha2.sha256
+    });
+    const b2 = {
+      cid: multiformats.CID.createV1(raw__namespace.code, identity.identity.digest(bytes)),
+      bytes
+    };
+    const headerSize = CBOR__namespace.encode({
+      version: 1,
+      roots: [
+        b1.cid,
+        b2.cid
+      ]
+    }).byteLength;
+    const bodySize = bufferWriter.blockLength(b1) + bufferWriter.blockLength(b2);
+    const varintSize = multiformats.varint.encodingLength(headerSize);
+    const writer = bufferWriter.createWriter(new ArrayBuffer(varintSize + headerSize + bodySize), {
+      roots: [
+        b1.cid,
+        b2.cid
+      ]
+    });
+    writer.write(b1);
+    writer.write(b2);
+    const car = writer.close();
+    const reader$1 = await reader.CarReader.fromBytes(car);
+    common.assert.deepEqual(await reader$1.getRoots(), [
+      b1.cid,
+      b2.cid
+    ]);
+    common.assert.deepEqual(reader$1._blocks, [
+      {
+        cid: b1.cid,
+        bytes: b1.bytes
+      },
+      {
+        cid: b2.cid,
+        bytes: b2.bytes
+      }
+    ]);
+  });
+});

package/cjs/node-test/test-errors.js

@@ -1,13 +1,13 @@
 'use strict';
 
 var multiformats = require('multiformats');
-var dagCbor = require('@ipld/dag-cbor');
+var CBOR = require('@ipld/dag-cbor');
 var varint = require('varint');
 var reader = require('../lib/reader.js');
 var common = require('./common.js');
 
 function makeHeader(block) {
-  const u = dagCbor.encode(block);
+  const u = CBOR.encode(block);
   const l = varint.encode(u.length);
   const u2 = new Uint8Array(u.length + l.length);
   u2.set(l, 0);
@@ -26,42 +26,65 @@ describe('Misc errors', () => {
     });
   });
   it('bad version', async () => {
-    const buf2 = multiformats.bytes.fromHex('0aa16776657273696f6e02');
-    common.assert.strictEqual(multiformats.bytes.toHex(makeHeader({ version: 2 })), '0aa16776657273696f6e02');
-    await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR version: 2');
+    const buf2 = multiformats.bytes.fromHex('0aa16776657273696f6e03');
+    common.assert.strictEqual(multiformats.bytes.toHex(makeHeader({ version: 3 })), '0aa16776657273696f6e03');
+    await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR version: 3');
   });
-  it('bad header', async () => {
-    let buf2 = makeHeader({
-      version: 1,
-      roots: []
+  describe('bad header', async () => {
+    it('sanity check', async () => {
+      const buf2 = makeHeader({
+        version: 1,
+        roots: []
+      });
+      await common.assert.isFulfilled(reader.CarReader.fromBytes(buf2));
     });
-    await common.assert.isFulfilled(reader.CarReader.fromBytes(buf2));
-    buf2 = makeHeader({ roots: [] });
-    await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR version: undefined');
-    buf2 = makeHeader({
-      version: '1',
-      roots: []
+    it('no \'version\' array', async () => {
+      const buf2 = makeHeader({ roots: [] });
+      await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
     });
-    await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR version: "1"');
-    buf2 = makeHeader({ version: 1 });
-    await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
-    buf2 = makeHeader({
-      version: 1,
-      roots: {}
+    it('bad \'version\' type', async () => {
+      const buf2 = makeHeader({
+        version: '1',
+        roots: []
+      });
+      await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
     });
-    await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
-    buf2 = makeHeader({
-      version: 1,
-      roots: [],
-      blip: true
+    it('no \'roots\' array', async () => {
+      const buf2 = makeHeader({ version: 1 });
+      await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
+    });
+    it('bad \'roots\' type', async () => {
+      const buf2 = makeHeader({
+        version: 1,
+        roots: {}
+      });
+      await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
+    });
+    it('extraneous properties', async () => {
+      const buf2 = makeHeader({
+        version: 1,
+        roots: [],
+        blip: true
+      });
+      await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
+    });
+    it('not an object', async () => {
+      const buf2 = makeHeader([
+        1,
+        []
+      ]);
+      await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
+    });
+    it('not an object', async () => {
+      const buf2 = makeHeader(null);
+      await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
+    });
+    it('recursive v2 header', async () => {
+      const v2Header = common.goCarV2Bytes.slice(0, 51);
+      const buf2 = new Uint8Array(51 * 2);
+      buf2.set(v2Header, 0);
+      buf2.set(v2Header, 51);
+      await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR version: 2 (expected 1)');
     });
-    await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
-    buf2 = makeHeader([
-      1,
-      []
-    ]);
-    await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
-    buf2 = makeHeader(null);
-    await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
   });
 });

package/cjs/node-test/test-indexer.js

@@ -15,6 +15,18 @@ describe('CarIndexer fromBytes()', () => {
     }
     common.assert.deepStrictEqual(indexData, common.goCarIndex);
   });
+  it('v2 complete', async () => {
+    const indexer$1 = await indexer.CarIndexer.fromBytes(common.goCarV2Bytes);
+    const roots = await indexer$1.getRoots();
+    common.assert.strictEqual(roots.length, 1);
+    common.assert.ok(common.goCarV2Roots[0].equals(roots[0]));
+    common.assert.strictEqual(indexer$1.version, 2);
+    const indexData = [];
+    for await (const index of indexer$1) {
+      indexData.push(index);
+    }
+    common.assert.deepStrictEqual(indexData, common.goCarV2Index);
+  });
   it('bad argument', async () => {
     for (const arg of [
         true,

package/cjs/node-test/test-reader.js

@@ -2,11 +2,16 @@
 
 var reader = require('../lib/reader.js');
 var writer = require('../lib/writer.js');
+var decoder = require('../lib/decoder.js');
 var Block = require('multiformats/block');
 var sha2 = require('multiformats/hashes/sha2');
 var raw = require('multiformats/codecs/raw');
+var base64 = require('multiformats/bases/base64');
+var dagPb = require('@ipld/dag-pb');
 var common = require('./common.js');
 var verifyStoreReader = require('./verify-store-reader.js');
+var fixtures = require('./fixtures.js');
+var fixturesExpectations = require('./fixtures-expectations.js');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -28,6 +33,7 @@ function _interopNamespace(e) {
 
 var Block__namespace = /*#__PURE__*/_interopNamespace(Block);
 var raw__namespace = /*#__PURE__*/_interopNamespace(raw);
+var dagPb__namespace = /*#__PURE__*/_interopNamespace(dagPb);
 
 describe('CarReader fromBytes()', () => {
   it('complete', async () => {
@@ -66,6 +72,29 @@ describe('CarReader fromBytes()', () => {
       message: 'Unexpected end of data'
     });
   });
+  it('v2 complete', async () => {
+    const reader$1 = await reader.CarReader.fromBytes(common.goCarV2Bytes);
+    const roots = await reader$1.getRoots();
+    common.assert.strictEqual(roots.length, 1);
+    common.assert.ok(common.goCarV2Roots[0].equals(roots[0]));
+    common.assert.strictEqual(reader$1.version, 2);
+    for (const {cid} of common.goCarV2Index) {
+      const block = await reader$1.get(cid);
+      common.assert.isDefined(block);
+      if (block) {
+        common.assert.ok(cid.equals(block.cid));
+        let content;
+        if (cid.code === dagPb__namespace.code) {
+          content = dagPb__namespace.decode(block.bytes);
+        } else if (cid.code === 85) {
+          content = new TextDecoder().decode(block.bytes);
+        } else {
+          common.assert.fail('Unexpected codec');
+        }
+        common.assert.deepStrictEqual(content, common.goCarV2Contents[cid.toString()]);
+      }
+    }
+  });
   it('decode error - trailing null bytes', async () => {
     const bytes = new Uint8Array(common.carBytes.length + 5);
     bytes.set(common.carBytes);
@@ -192,4 +221,58 @@ describe('CarReader fromIterable()', () => {
       message: 'Unexpected end of data'
     });
   });
+  it('v2 decode error - truncated', async () => {
+    const bytes = common.goCarV2Bytes.slice();
+    const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    dv.setBigUint64(35, BigInt(448 - 10), true);
+    await common.assert.isRejected(reader.CarReader.fromIterable(common.makeIterable(bytes, 64)), {
+      name: 'Error',
+      message: 'Unexpected end of data'
+    });
+  });
+});
+describe('Shared fixtures', () => {
+  describe('Header', () => {
+    for (const [name, {
+            version: expectedVersion,
+            err: expectedError
+          }] of Object.entries(fixturesExpectations.expectations)) {
+      it(name, async () => {
+        const data = base64.base64.baseDecode(fixtures.data[name]);
+        let header;
+        try {
+          header = await decoder.readHeader(decoder.bytesReader(data));
+        } catch (err) {
+          if (expectedError != null) {
+            common.assert.equal(err.message, expectedError);
+            return;
+          }
+          common.assert.ifError(err);
+        }
+        if (expectedError != null) {
+          common.assert.fail(`Expected error: ${ expectedError }`);
+        }
+        common.assert.isDefined(header, 'did not decode header');
+        if (expectedVersion != null && header != null) {
+          common.assert.strictEqual(header.version, expectedVersion);
+        }
+      });
+    }
+  });
+  describe('Contents', () => {
+    for (const [name, {cids: expectedCids}] of Object.entries(fixturesExpectations.expectations)) {
+      if (expectedCids == null) {
+        continue;
+      }
+      it(name, async () => {
+        const data = base64.base64.baseDecode(fixtures.data[name]);
+        const reader$1 = await reader.CarReader.fromBytes(data);
+        let i = 0;
+        for await (const cid of reader$1.cids()) {
+          common.assert.strictEqual(cid.toString(), expectedCids[i++]);
+        }
+        common.assert.strictEqual(i, expectedCids.length);
+      });
+    }
+  });
 });

package/cjs/node-test/test-writer.js

@@ -182,9 +182,9 @@ describe('CarWriter', () => {
     const rawBytes = await append(0);
     const pbBytes = await append(1);
     const cborBytes = await append(2);
-    common.assert(rawBytes.length > 0);
-    common.assert(pbBytes.length > 0);
-    common.assert(cborBytes.length > 0);
+    common.assert.ok(rawBytes.length > 0);
+    common.assert.ok(pbBytes.length > 0);
+    common.assert.ok(cborBytes.length > 0);
     const reassembled = concatBytes([
       headerBytes,
       rawBytes,

package/esm/browser-test/common.js

@@ -186,6 +186,77 @@ const goCarIndex = [
     blockLength: 18
   }
 ];
+const goCarV2Bytes = bytes.fromHex('0aa16776657273696f6e02000000000000000000000000000000003300000000000000c001000000000000f30100000000000038a265726f6f747381d82a5823001220fb16f5083412ef1371d031ed4aa239903d84efdadf1ba3cd678e6475b1a232f86776657273696f6e01511220fb16f5083412ef1371d031ed4aa239903d84efdadf1ba3cd678e6475b1a232f8122d0a221220d9c0d5376d26f1931f7ad52d7acc00fc1090d2edb0808bf61eeb0a152826f6261204f09f8da418a40185011220d9c0d5376d26f1931f7ad52d7acc00fc1090d2edb0808bf61eeb0a152826f62612310a221220d745b7757f5b4593eeab7820306c7bc64eb496a7410a0d07df7a34ffec4b97f1120962617272656c657965183a122e0a2401551220a2e1c40da1ae335d4dffe729eb4d5ca23b74b9e51fc535f4a804a261080c294d1204f09f90a11807581220d745b7757f5b4593eeab7820306c7bc64eb496a7410a0d07df7a34ffec4b97f112340a2401551220b474a99a2705e23cf905a484ec6d14ef58b56bbe62e9292783466ec363b5072d120a666973686d6f6e67657218042801551220b474a99a2705e23cf905a484ec6d14ef58b56bbe62e9292783466ec363b5072d666973682b01551220a2e1c40da1ae335d4dffe729eb4d5ca23b74b9e51fc535f4a804a261080c294d6c6f62737465720100000028000000c800000000000000a2e1c40da1ae335d4dffe729eb4d5ca23b74b9e51fc535f4a804a261080c294d9401000000000000b474a99a2705e23cf905a484ec6d14ef58b56bbe62e9292783466ec363b5072d6b01000000000000d745b7757f5b4593eeab7820306c7bc64eb496a7410a0d07df7a34ffec4b97f11201000000000000d9c0d5376d26f1931f7ad52d7acc00fc1090d2edb0808bf61eeb0a152826f6268b00000000000000fb16f5083412ef1371d031ed4aa239903d84efdadf1ba3cd678e6475b1a232f83900000000000000');
+const goCarV2Roots = [CID.parse('QmfEoLyB5NndqeKieExd1rtJzTduQUPEV8TwAYcUiy3H5Z')];
+const goCarV2Index = [
+  {
+    blockLength: 47,
+    blockOffset: 143,
+    cid: CID.parse('QmfEoLyB5NndqeKieExd1rtJzTduQUPEV8TwAYcUiy3H5Z'),
+    length: 82,
+    offset: 108
+  },
+  {
+    blockLength: 99,
+    blockOffset: 226,
+    cid: CID.parse('QmczfirA7VEH7YVvKPTPoU69XM3qY4DC39nnTsWd4K3SkM'),
+    length: 135,
+    offset: 190
+  },
+  {
+    blockLength: 54,
+    blockOffset: 360,
+    cid: CID.parse('Qmcpz2FHJD7VAhg1fxFXdYJKePtkx1BsHuCrAgWVnaHMTE'),
+    length: 89,
+    offset: 325
+  },
+  {
+    blockLength: 4,
+    blockOffset: 451,
+    cid: CID.parse('bafkreifuosuzujyf4i6psbneqtwg2fhplc2wxptc5euspa2gn3bwhnihfu'),
+    length: 41,
+    offset: 414
+  },
+  {
+    blockLength: 7,
+    blockOffset: 492,
+    cid: CID.parse('bafkreifc4hca3inognou377hfhvu2xfchn2ltzi7yu27jkaeujqqqdbjju'),
+    length: 44,
+    offset: 455
+  }
+];
+const goCarV2Contents = {
+  QmfEoLyB5NndqeKieExd1rtJzTduQUPEV8TwAYcUiy3H5Z: {
+    Links: [{
+        Hash: CID.parse('QmczfirA7VEH7YVvKPTPoU69XM3qY4DC39nnTsWd4K3SkM'),
+        Name: '\uD83C\uDF64',
+        Tsize: 164
+      }]
+  },
+  QmczfirA7VEH7YVvKPTPoU69XM3qY4DC39nnTsWd4K3SkM: {
+    Links: [
+      {
+        Hash: CID.parse('Qmcpz2FHJD7VAhg1fxFXdYJKePtkx1BsHuCrAgWVnaHMTE'),
+        Name: 'barreleye',
+        Tsize: 58
+      },
+      {
+        Hash: CID.parse('bafkreifc4hca3inognou377hfhvu2xfchn2ltzi7yu27jkaeujqqqdbjju'),
+        Name: '\uD83D\uDC21',
+        Tsize: 7
+      }
+    ]
+  },
+  Qmcpz2FHJD7VAhg1fxFXdYJKePtkx1BsHuCrAgWVnaHMTE: {
+    Links: [{
+        Hash: CID.parse('bafkreifuosuzujyf4i6psbneqtwg2fhplc2wxptc5euspa2gn3bwhnihfu'),
+        Name: 'fishmonger',
+        Tsize: 4
+      }]
+  },
+  bafkreifuosuzujyf4i6psbneqtwg2fhplc2wxptc5euspa2gn3bwhnihfu: 'fish',
+  bafkreifc4hca3inognou377hfhvu2xfchn2ltzi7yu27jkaeujqqqdbjju: 'lobster'
+};
 export {
   toBlock,
   assert,
@@ -195,5 +266,9 @@ export {
   carBytes,
   goCarBytes,
   goCarRoots,
-  goCarIndex
+  goCarIndex,
+  goCarV2Bytes,
+  goCarV2Roots,
+  goCarV2Index,
+  goCarV2Contents
 };