dkg.js 6.3.0 → 6.4.0

package/examples/paranet-demo.js

@@ -0,0 +1,254 @@
+const jsonld = require('jsonld');
+const DKG = require('../index.js');
+
+const ENVIRONMENT = 'development';
+const OT_NODE_HOSTNAME = 'http://localhost';
+const OT_NODE_PORT = '8900';
+const PUBLIC_KEY = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
+const PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
+
+const DkgClient = new DKG({
+    environment: ENVIRONMENT,
+    endpoint: OT_NODE_HOSTNAME,
+    port: OT_NODE_PORT,
+    blockchain: {
+        name: 'hardhat2',
+        publicKey: PUBLIC_KEY,
+        privateKey: PRIVATE_KEY,
+    },
+    maxNumberOfRetries: 30,
+    frequency: 2,
+    contentType: 'all',
+});
+
+function divider() {
+    console.log('==================================================');
+    console.log('==================================================');
+    console.log('==================================================');
+}
+
+(async () => {
+
+    divider();
+
+    const nodeInfo = await DkgClient.node.info();
+    console.log('======================== NODE INFO RECEIVED');
+    console.log(nodeInfo);
+
+    divider();
+
+    let content = {
+        public: {
+            '@context': ['https://schema.org'],
+            '@id': 'uuid:1',
+            company: 'ParanetOperatorsDAO',
+            user: {
+                '@id': 'uuid:user:1',
+            },
+            city: {
+                '@id': 'uuid:Belgrade',
+            },
+        }
+    };
+
+    divider();
+
+    const paranetAssetResult = await DkgClient.asset.create(content, { epochsNum: 2 });
+    console.log('======================== PARANET KNOWLEDGE ASSET CREATED');
+    console.log(paranetAssetResult);
+
+    divider();
+
+    const paranetOptions = {
+        paranetName: 'FirstParanet',
+        paranetDescription: 'First ever paranet on DKG!',
+        tracToNeuroEmissionMultiplier: 5,
+        incentivizationProposalVotersRewardPercentage: 12.00,
+        operatorRewardPercentage: 10.00,
+    };
+    const paranetRegistered = await DkgClient.paranet.create(paranetAssetResult.UAL, paranetOptions);
+    console.log('======================== PARANET REGISTERED');
+    console.log(paranetRegistered);
+    divider();
+
+    const paranetDeployed = await DkgClient.paranet.deployIncentivesContract(paranetAssetResult.UAL, 'Neuroweb', paranetOptions);
+    console.log('======================== PARANET INCENTIVES POOL DEPLOYED');
+    console.log(paranetDeployed);
+    divider();
+
+    content = {
+        public: {
+            '@context': ['https://schema.org'],
+            '@id': 'uuid:6',
+            company: 'ServiceExample',
+            user: {
+                '@id': 'uuid:user:6',
+            },
+            city: {
+                '@id': 'uuid:Ljubljana',
+            },
+        }
+    };
+    const createServiceKAResult = await DkgClient.asset.create(content, { epochsNum: 2 });
+    console.log('======================== SERVICE KA CREATED');
+    console.log(createServiceKAResult);
+    divider();
+
+    const paranetServiceUAL = await DkgClient.paranet.createService(createServiceKAResult.UAL, {
+        paranetServiceName: 'FKPS',
+        paranetServiceDescription: 'Fast Knowledge Processing Service',
+        paranetServiceAddresses: [],
+    });
+    console.log('======================== SERVICE KA CREATED');
+    console.log(paranetServiceUAL);
+    divider();
+
+    await DkgClient.paranet.addServices(paranetAssetResult.UAL, [ createServiceKAResult.UAL]);
+    console.log('======================== SERVICE ADDED TO PARANET');
+    divider();
+
+    content = {
+        public: {
+            '@context': ['https://schema.org'],
+            '@id': 'uuid:2',
+            company: 'KA-Company',
+            user: {
+                '@id': 'uuid:user:2',
+            },
+            city: {
+                '@id': 'uuid:budapest',
+            },
+        }
+    };
+    const createAssetResult = await DkgClient.asset.create(content, { epochsNum: 2, paranetUAL: paranetAssetResult.UAL });
+    console.log('======================== KNOWLEDGE ASSET CREATED TO PARANET');
+    console.log(createAssetResult);
+    divider();
+
+    content = {
+        public: {
+            '@context': ['https://schema.org'],
+            '@id': 'uuid:3',
+            company: 'KA1-Company',
+            user: {
+                '@id': 'uuid:user:3',
+            },
+            city: {
+                '@id': 'uuid:Belgrade',
+            },
+        }
+    };
+    const createSecondAssetResult = await DkgClient.asset.create(content, { epochsNum: 2 });
+    console.log('======================== SECOND KNOWLEDGE ASSET CREATED');
+    console.log(createSecondAssetResult);
+    divider();
+
+    const submitResult = await DkgClient.asset.submitToParanet(createSecondAssetResult.UAL, paranetAssetResult.UAL);
+    console.log('======================== SECOND KA ADDED TO PARANET');
+    console.log(submitResult);
+    divider();
+
+    console.log('======================== IS MINER : ', await DkgClient.paranet.isKnowledgeMiner(paranetAssetResult.UAL, { roleAddress: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266' }));
+    console.log('======================== IS OPERATOR : ', await DkgClient.paranet.isParanetOperator(paranetAssetResult.UAL));
+    console.log('======================== IS VOTER : ', await DkgClient.paranet.isProposalVoter(paranetAssetResult.UAL, { roleAddress: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266' }));
+    divider();
+
+    let claimable = await DkgClient.paranet.getClaimableMinerReward(paranetAssetResult.UAL);
+    console.log('======================== KA MINER REWARD TO CLAIM')
+    console.log(claimable);
+    divider();
+
+    claimable = await DkgClient.paranet.getClaimableOperatorReward(paranetAssetResult.UAL);
+    console.log('======================== OPERATOR REWARD TO CLAIM');
+    console.log(claimable);
+    divider();
+
+    let claimedResult = await DkgClient.paranet.claimMinerReward(paranetAssetResult.UAL);
+    console.log('======================== KA MINER REWARD CLAIMED');
+    console.log(claimedResult);
+    divider();
+
+    claimedResult = await DkgClient.paranet.claimOperatorReward(paranetAssetResult.UAL);
+    console.log('======================== OPERATOR REWARD CLAIMED');
+    console.log(claimedResult);
+    divider();
+
+    claimable = await DkgClient.paranet.getClaimableMinerReward(paranetAssetResult.UAL);
+    console.log('======================== KA MINER REWARD TO CLAIM');
+    console.log(claimable);
+    divider();
+
+    claimable = await DkgClient.paranet.getClaimableOperatorReward(paranetAssetResult.UAL);
+    console.log('======================== OPERATOR REWARD TO CLAIM');
+    console.log(claimable);
+    divider();
+
+    const updateAssetResult = await DkgClient.asset.update(createSecondAssetResult.UAL, {
+        public: {
+            '@context': ['https://schema.org'],
+            '@id': 'uuid:1',
+            company: 'TL',
+            user: {
+                '@id': 'uuid:user:2',
+            },
+            city: {
+                '@id': 'uuid:Madrid',
+            },
+        },
+    });
+    console.log('========================KNOWLEDGE ASSET UPDATED');
+    console.log(updateAssetResult);
+    divider();
+
+    await DkgClient.asset.waitFinalization(createSecondAssetResult.UAL);
+    console.log('======================== FINALIZATION COMPLETED');
+    divider();
+
+    await DkgClient.paranet.updateClaimableRewards(paranetAssetResult.UAL);
+    console.log('======================== CLAIMABLE REWARDS UPDATED');
+    divider();
+
+    const queryWhereMadrid = `PREFIX schema: <http://schema.org/>
+        SELECT DISTINCT ?graphName
+        WHERE {
+          GRAPH ?graphName {
+            ?s schema:city <uuid:uzice> .
+          }
+        }`;
+
+    let queryResult = await DkgClient.graph.query(
+        queryWhereMadrid,
+        'SELECT',
+        { paranetUAL: paranetAssetResult.UAL },
+    );
+    console.log('======================== QUERY PARANET REPO RESULT');
+    console.log(queryResult.data);
+    divider();
+
+    const federatedQuery = `
+    PREFIX schema: <http://schema.org/>
+        SELECT DISTINCT ?s ?city1 ?user1 ?s2 ?city2 ?user2 ?company1
+        WHERE {
+          ?s schema:city ?city1 .
+          ?s schema:company ?company1 .
+          ?s schema:user ?user1;
+        
+          SERVICE <${createSecondAssetResult.UAL}> {
+            ?s2 schema:city <uuid:Belgrade> .
+            ?s2 schema:city ?city2 .
+            ?s2 schema:user ?user2;
+          }
+        
+          filter(contains(str(?city2), "Belgrade"))
+        }
+    `;
+
+    queryResult = await DkgClient.graph.query(
+        federatedQuery,
+        'SELECT',
+        { graphLocation: paranetAssetResult.UAL },
+    );
+    console.log('======================== FEDERATED QUERY RESULT');
+    console.log(queryResult.data);
+    divider();
+})();

package/index.js

@@ -5,6 +5,7 @@ const BlockchainOperationsManager = require('./managers/blockchain-operations-ma
 const GraphOperationsManager = require('./managers/graph-operations-manager.js');
 const NetworkOperationsManager = require('./managers/network-operations-manager.js');
 const NodeOperationsManager = require('./managers/node-operations-manager.js');
+const ParanetOperationsManager = require('./managers/paranet-operations-manager.js');
 
 const BaseServiceManager = require('./services/base-service-manager.js');
 
@@ -19,6 +20,7 @@ class DkgClient {
         this.node = new NodeOperationsManager(services);
         this.graph = new GraphOperationsManager(services);
         this.network = new NetworkOperationsManager(services);
+        this.paranet = new ParanetOperationsManager(services);
     }
 }
 module.exports = DkgClient;

package/managers/asset-operations-manager.js

@@ -280,6 +280,7 @@ class AssetOperationsManager {
             immutable,
             tokenAmount,
             authToken,
+            paranetUAL,
         } = this.inputService.getAssetCreateArguments(options);
 
         this.validationService.validateAssetCreate(
@@ -295,6 +296,7 @@ class AssetOperationsManager {
             immutable,
             tokenAmount,
             authToken,
+            paranetUAL
         );
 
         const { public: publicAssertion, private: privateAssertion } = await formatGraph(
@@ -330,20 +332,43 @@ class AssetOperationsManager {
                 hashFunctionId,
             ));
 
-        const tokenId = await this.blockchainService.createAsset(
-            {
-                publicAssertionId,
-                assertionSize: publicAssertionSizeInBytes,
-                triplesNumber: assertionMetadata.getAssertionTriplesNumber(publicAssertion),
-                chunksNumber: assertionMetadata.getAssertionChunksNumber(publicAssertion),
-                epochsNum,
-                tokenAmount: tokenAmountInWei,
-                scoreFunctionId: scoreFunctionId ?? 1,
-                immutable_: immutable,
-            },
-            blockchain,
-            stepHooks,
-        );
+        let tokenId;
+        if(paranetUAL == null) {
+            tokenId = await this.blockchainService.createAsset(
+                {
+                    publicAssertionId,
+                    assertionSize: publicAssertionSizeInBytes,
+                    triplesNumber: assertionMetadata.getAssertionTriplesNumber(publicAssertion),
+                    chunksNumber: assertionMetadata.getAssertionChunksNumber(publicAssertion),
+                    epochsNum,
+                    tokenAmount: tokenAmountInWei,
+                    scoreFunctionId: scoreFunctionId ?? 1,
+                    immutable_: immutable,
+                },
+                null,
+                null,
+                blockchain,
+                stepHooks,
+            );
+        } else {
+            const { contract: paranetKaContract, tokenId: paranetTokenId } = resolveUAL(paranetUAL);
+            tokenId = await this.blockchainService.createAsset(
+                {
+                    publicAssertionId,
+                    assertionSize: publicAssertionSizeInBytes,
+                    triplesNumber: assertionMetadata.getAssertionTriplesNumber(publicAssertion),
+                    chunksNumber: assertionMetadata.getAssertionChunksNumber(publicAssertion),
+                    epochsNum,
+                    tokenAmount: tokenAmountInWei,
+                    scoreFunctionId: scoreFunctionId ?? 1,
+                    immutable_: immutable,
+                },
+                paranetKaContract,
+                paranetTokenId,
+                blockchain,
+                stepHooks,
+            );
+        }
 
         const resolvedUAL = {
             blockchain: blockchain.name,
@@ -1349,6 +1374,41 @@ class AssetOperationsManager {
 
         return tokenAmountInWei > 0 ? tokenAmountInWei : 0;
     }
+
+    /**
+     * Add knowledge asset to a paranet.
+     * @async
+     * @param {string} UAL - The Universal Asset Locator of the knowledge asset.
+     * @param {string} paranetUAL - The Universal Asset Locator of the Paranet.
+     * @param {Object} [options={}] - Additional options for adding tokens.
+     * @returns {Object} An object containing the UAL and operation status.
+     */
+    async submitToParanet(UAL, paranetUAL, options = {}) {
+        const blockchain = this.inputService.getBlockchain(options);
+
+        this.validationService.validateSubmitToParanet(
+            UAL,
+            paranetUAL,
+            blockchain,
+        );
+
+        const { contract, tokenId } = resolveUAL(UAL);
+        const { contract: paranetContract, tokenId: paranetTokenId } = resolveUAL(paranetUAL);
+
+        await this.blockchainService.submitToParanet({
+                paranetContract,
+                paranetTokenId,
+                contract,
+                tokenId,
+            },
+            blockchain
+        );
+
+        return {
+            UAL,
+            operation: getOperationStatusObject({ status: 'COMPLETED' }, null),
+        };
+    }
 }
 
 module.exports = AssetOperationsManager;