test: node listener

Author: tchardin

examples/src/index.tsx

@@ -31,8 +31,7 @@ function fileIterator(file: File): AsyncIterable<Uint8Array> {
       }
 
       return new Promise((resolve, reject) => {
-        const chunk = file.slice(index, MAX_CHUNK_SIZE);
-        index += MAX_CHUNK_SIZE;
+        const chunk = file.slice(index, (index += MAX_CHUNK_SIZE));
 
         const reader = new global.FileReader();
 
@@ -144,12 +143,11 @@ function App() {
       client.store,
       {
         cidVersion: 1,
-        maxChunkSize: 256 * 1024,
         rawLeaves: true,
         wrapWithDirectory: true,
       }
     )) {
-      console.log(chunk.path, chunk.cid);
+      console.log(chunk);
       if (chunk.path === "") {
         setUproot(chunk.cid);
       }

package.json

@@ -3,14 +3,28 @@
   "version": "0.1.0",
   "description": "JS implementation of GraphSync and DataTransfer protocols",
   "main": "dist/src/index.js",
+  "files": [
+    "src",
+    "dist"
+  ],
   "scripts": {
     "build": "aegir build",
     "test": "aegir test",
+    "test:node": "npm run test -- -t node",
     "check": "aegir check"
   },
   "author": "Myel <thomas@myel.dev>",
   "license": "MIT",
+  "engines": {
+    "node": ">=16.0.0",
+    "npm": ">=7.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/myelnet/js-graphsync.git"
+  },
   "devDependencies": {
+    "@chainsafe/libp2p-noise": "5.0.0",
     "@types/bl": "^5.0.2",
     "@types/mime": "^2.0.3",
     "@types/uuid": "^8.3.4",
@@ -20,6 +34,8 @@
     "ipfs-unixfs-importer": "^9.0.6",
     "it-pair": "^1.0.0",
     "libp2p-interfaces": "^2.0.1",
+    "libp2p-mplex": "^0.10.5",
+    "libp2p-tcp": "^0.17.2",
     "prettier": "^2.6.1"
   },
   "dependencies": {
@@ -42,5 +58,9 @@
     "uuid": "^8.3.2",
     "varint": "^6.0.0",
     "varint-decoder": "^1.0.0"
+  },
+  "types": "dist/src/index.d.ts",
+  "publishConfig": {
+    "access": "public"
   }
 }

src/messages.ts

@@ -140,7 +140,7 @@ export function newRequest(
     req.ext = ext;
   }
   return lp.encode.single(
-    new Buffer(
+    Buffer.from(
       dagCBOR.encode<GraphSyncMessageRoot>({
         gs2: {
           req: [req],

test/graphsync.spec.ts

@@ -8,6 +8,7 @@ import {importer} from "ipfs-unixfs-importer";
 import {resolve, unixfsPathSelector} from "../src/resolver";
 
 describe("graphsync", () => {
+  // this test mocks libp2p so it can run in the browser.
   it("e2e", async () => {
     const store1 = new MemoryBlockstore();
     const net1 = new MockLibp2p(

test/listening.node.ts

@@ -0,0 +1,78 @@
+import {expect} from "aegir/utils/chai.js";
+import {create as createLibp2p, Libp2p} from "libp2p";
+import PeerId from "peer-id";
+import Mplex from "libp2p-mplex";
+import TCP from "libp2p-tcp";
+import {NOISE} from "@chainsafe/libp2p-noise";
+import {MemoryBlockstore} from "blockstore-core/memory";
+import {importer} from "ipfs-unixfs-importer";
+import {GraphSync} from "../src/graphsync";
+import {unixfsPathSelector, resolve} from "../src/resolver";
+import {concatChunkIterator} from "./mock-libp2p";
+
+async function createNode(): Promise<Libp2p> {
+  const node = await createLibp2p({
+    addresses: {
+      listen: ["/ip4/0.0.0.0/tcp/0"],
+    },
+    modules: {
+      transport: [TCP],
+      connEncryption: [NOISE],
+      streamMuxer: [Mplex],
+    },
+  });
+  await node.start();
+  return node;
+}
+
+describe("listening", () => {
+  it("reified transfer", async () => {
+    const store1 = new MemoryBlockstore();
+    const net1 = await createNode();
+
+    const first = new Uint8Array(5 * 256);
+    const second = new Uint8Array(3 * 256);
+
+    // chunk and dagify it then get the root cid
+    let cid;
+    for await (const chunk of importer(
+      [
+        {path: "first", content: first},
+        {path: "second", content: second},
+      ],
+      store1,
+      {
+        cidVersion: 1,
+        maxChunkSize: 256,
+        rawLeaves: true,
+        wrapWithDirectory: true,
+      }
+    )) {
+      if (chunk.path === "") {
+        cid = chunk.cid;
+      }
+    }
+
+    if (!cid) {
+      throw new Error("failed to add DAG");
+    }
+
+    const store2 = new MemoryBlockstore();
+    const net2 = await createNode();
+
+    net2.peerStore.addressBook.add(net1.peerId, net1.multiaddrs);
+
+    const provider = new GraphSync(net1, store1);
+    provider.start();
+
+    const client = new GraphSync(net2, store2);
+    client.start();
+    const {root, selector} = unixfsPathSelector(cid.toString() + "/first");
+
+    const request = client.request(root, selector);
+    request.open(net1.peerId);
+
+    const buf = await concatChunkIterator(resolve(cid, selector, request));
+    expect(buf).to.deep.equal(first);
+  });
+});