@xyo-network/modules 2.46.1 → 2.46.3

package/package.json

@@ -10,14 +10,14 @@
     "url": "https://github.com/XYOracleNetwork/sdk-xyo-client-js/issues"
   },
   "dependencies": {
-    "@xyo-network/archivist": "^2.46.1",
-    "@xyo-network/bridge": "^2.46.1",
-    "@xyo-network/diviner": "^2.46.1",
-    "@xyo-network/module": "^2.46.1",
-    "@xyo-network/node": "^2.46.1",
-    "@xyo-network/panel": "^2.46.1",
-    "@xyo-network/sentinel": "^2.46.1",
-    "@xyo-network/witness": "^2.46.1"
+    "@xyo-network/archivist": "^2.46.3",
+    "@xyo-network/bridge": "^2.46.3",
+    "@xyo-network/diviner": "^2.46.3",
+    "@xyo-network/module": "^2.46.3",
+    "@xyo-network/node": "^2.46.3",
+    "@xyo-network/panel": "^2.46.3",
+    "@xyo-network/sentinel": "^2.46.3",
+    "@xyo-network/witness": "^2.46.3"
   },
   "devDependencies": {
     "@xylabs/ts-scripts-yarn3": "^2.14.15",
@@ -57,5 +57,5 @@
   },
   "sideEffects": false,
   "types": "dist/types/index.d.ts",
-  "version": "2.46.1"
+  "version": "2.46.3"
 }

package/src/spec/VariousNodeConfigurations.spec.ts

@@ -8,12 +8,14 @@ describe('MultiNodeConfiguration', () => {
   let primaryArchivist: AbstractModule
   let primaryNode: MemoryNode
 
-  let leftArchivist: AbstractModule
+  let leftInternalArchivist: AbstractModule
+  let leftExternalArchivist: AbstractModule
   let leftDiviner: AbstractModule
   let leftNode: MemoryNode
 
   let rightNode: MemoryNode
-  let rightArchivist: AbstractModule
+  let rightInternalArchivist: AbstractModule
+  let rightExternalArchivist: AbstractModule
   let rightWitness: AbstractModule
 
   beforeAll(async () => {
@@ -22,17 +24,21 @@ describe('MultiNodeConfiguration', () => {
     await primaryNode.register(primaryArchivist).attach(primaryArchivist.address, true)
 
     rightNode = await MemoryNode.create({ config: { name: 'rightNode', schema: NodeConfigSchema } })
-    rightArchivist = await MemoryArchivist.create()
+    rightInternalArchivist = await MemoryArchivist.create({ config: { name: 'rightInternalArchivist', schema: MemoryArchivistConfigSchema } })
+    rightExternalArchivist = await MemoryArchivist.create({ config: { name: 'archivist', schema: MemoryArchivistConfigSchema } })
     rightWitness = await IdWitness.create({ config: { name: 'rightWitness', salt: 'test', schema: IdWitnessConfigSchema } })
-    await rightNode.register(rightArchivist).attach(rightArchivist.address, true)
+    await rightNode.register(rightInternalArchivist).attach(rightInternalArchivist.address)
+    await rightNode.register(rightExternalArchivist).attach(rightExternalArchivist.address, true)
     await rightNode.register(rightWitness).attach(rightWitness.address, true)
 
     leftNode = await MemoryNode.create({ config: { name: 'leftNode', schema: NodeConfigSchema } })
-    leftArchivist = await MemoryArchivist.create({ config: { name: 'leftArchivist', schema: MemoryArchivistConfigSchema } })
+    leftInternalArchivist = await MemoryArchivist.create({ config: { name: 'leftInternalArchivist', schema: MemoryArchivistConfigSchema } })
+    leftExternalArchivist = await MemoryArchivist.create({ config: { name: 'archivist', schema: MemoryArchivistConfigSchema } })
     leftDiviner = await MemoryAddressHistoryDiviner.create({
       config: { address: leftNode.address, name: 'leftDiviner', schema: MemoryAddressHistoryDivinerConfigSchema },
     })
-    await leftNode.register(leftArchivist).attach(leftArchivist.address, true)
+    await leftNode.register(leftInternalArchivist).attach(leftInternalArchivist.address)
+    await leftNode.register(leftExternalArchivist).attach(leftExternalArchivist.address, true)
     await leftNode.register(leftDiviner).attach(leftDiviner.address, true)
 
     primaryNode.register(leftNode)
@@ -47,9 +53,23 @@ describe('MultiNodeConfiguration', () => {
     expect((await leftNode.resolve({ address: [leftDiviner.address] })).length).toBe(1)
     expect((await leftNode.resolve({ name: ['leftDiviner'] })).length).toBe(1)
 
+    // internal: should be resolvable by leftNode
+    expect((await leftNode.resolve({ address: [leftInternalArchivist.address] })).length).toBe(1)
+    expect((await leftNode.resolve({ name: ['leftInternalArchivist'] })).length).toBe(1)
+
+    expect((await leftNode.resolve({ address: [leftExternalArchivist.address] })).length).toBe(1)
+    expect((await leftNode.resolve({ name: ['archivist'] })).length).toBe(1)
+
     expect((await rightNode.resolve({ address: [rightWitness.address] })).length).toBe(1)
     expect((await rightNode.resolve({ name: ['rightWitness'] })).length).toBe(1)
 
+    // internal: should be resolvable by rightNode
+    expect((await rightNode.resolve({ address: [rightInternalArchivist.address] })).length).toBe(1)
+    expect((await rightNode.resolve({ name: ['rightInternalArchivist'] })).length).toBe(1)
+
+    expect((await rightNode.resolve({ address: [rightExternalArchivist.address] })).length).toBe(1)
+    expect((await rightNode.resolve({ name: ['archivist'] })).length).toBe(1)
+
     expect((await primaryNode.resolve({ address: [leftNode.address] })).length).toBe(1)
     expect((await primaryNode.resolve({ name: ['leftNode'] })).length).toBe(1)
 
@@ -61,6 +81,24 @@ describe('MultiNodeConfiguration', () => {
 
     expect((await primaryNode.resolve({ address: [rightWitness.address] })).length).toBe(0)
     expect((await primaryNode.resolve({ name: ['rightWitness'] })).length).toBe(0)
+
+    // internal: should NOT be resolvable by primaryNode
+    expect((await primaryNode.resolve({ address: [leftInternalArchivist.address] })).length).toBe(0)
+    expect((await primaryNode.resolve({ name: ['leftInternalArchivist'] })).length).toBe(0)
+
+    // internal: should NOT be resolvable by node
+    expect((await primaryNode.resolve({ address: [rightInternalArchivist.address] })).length).toBe(0)
+    expect((await primaryNode.resolve({ name: ['rightInternalArchivist'] })).length).toBe(0)
+
+    // external: should be resolvable by primaryNode
+    expect((await primaryNode.resolve({ address: [leftExternalArchivist.address] })).length).toBe(1)
+
+    // external: should be NOT be resolvable by node
+    expect((await primaryNode.resolve({ address: [rightExternalArchivist.address] })).length).toBe(0)
+
+    // external: should be resolvable by node
+    expect((await primaryNode.resolve({ name: ['archivist'] })).length).toBe(1)
+    expect((await primaryNode.resolve({ name: ['archivist'] }))[0].address).toBe(leftExternalArchivist.address)
   })
 
   test('rightNode', async () => {
@@ -73,5 +111,31 @@ describe('MultiNodeConfiguration', () => {
     expect((await primaryNode.resolve({ address: [leftNode.address] })).length).toBe(0)
     expect((await primaryNode.resolve({ address: [rightWitness.address] })).length).toBe(1)
     expect((await primaryNode.resolve({ address: [leftDiviner.address] })).length).toBe(0)
+    expect((await primaryNode.resolve({ name: ['archivist'] })).length).toBe(1)
+    expect((await primaryNode.resolve({ name: ['archivist'] }))[0].address).toBe(rightExternalArchivist.address)
+  })
+
+  test('leftNode', async () => {
+    primaryNode.detach(leftNode.address)
+    primaryNode.detach(rightNode.address)
+    await primaryNode.attach(leftNode.address, true)
+    await primaryNode.attach(rightNode.address, true)
+
+    // internal: should NOT be resolvable by primaryNode
+    expect((await primaryNode.resolve({ address: [leftInternalArchivist.address] })).length).toBe(0)
+    expect((await primaryNode.resolve({ name: ['leftInternalArchivist'] })).length).toBe(0)
+
+    // internal: should NOT be resolvable by node
+    expect((await primaryNode.resolve({ address: [rightInternalArchivist.address] })).length).toBe(0)
+    expect((await primaryNode.resolve({ name: ['rightInternalArchivist'] })).length).toBe(0)
+
+    // external: should be resolvable by primaryNode
+    expect((await primaryNode.resolve({ address: [leftExternalArchivist.address] })).length).toBe(1)
+
+    // external: should be resolvable by node
+    expect((await primaryNode.resolve({ address: [rightExternalArchivist.address] })).length).toBe(1)
+
+    // external: should be resolvable by node
+    expect((await primaryNode.resolve({ name: ['archivist'] })).length).toBe(2)
   })
 })