@0xpolygonid/js-sdk 1.7.5 → 1.8.1

package/dist/node/esm/schema-processor/json/parser.js

@@ -1,16 +1,6 @@
-import { MerklizedRootPosition, SubjectPosition } from '../../verifiable';
-import { Claim as CoreClaim, ClaimOptions, DID } from '@iden3/js-iden3-core';
-import { createSchemaHash, fillSlot } from '../utils';
-import { byteDecoder, byteEncoder } from '../../utils';
-import { Path } from '@iden3/js-jsonld-merklization';
+import { getSerializationAttrFromContext, parseSerializationAttr, getFieldSlotIndex, findCredentialType, getSerializationAttrFromParsedContext, parseCoreClaimSlots } from '../../verifiable';
 import * as jsonld from 'jsonld/lib';
 import * as ldcontext from 'jsonld/lib/context';
-const credentialSubjectFullKey = 'https://www.w3.org/2018/credentials#credentialSubject';
-const verifiableCredentialFullKey = 'https://www.w3.org/2018/credentials#VerifiableCredential';
-const typeFullKey = '@type';
-const contextFullKey = '@context';
-const serializationFullKey = 'iden3_serialization';
-const fieldPrefix = 'iden3:v1:';
 /**
  * Parser can parse claim and schema data according to specification
  *
@@ -19,6 +9,7 @@ const fieldPrefix = 'iden3:v1:';
  */
 export class Parser {
     /**
+     *  @deprecated The method should not be used. Use credential.toCoreClaim instead.
      *  ParseClaim creates core.Claim object from W3CCredential
      *
      * @param {W3CCredential} credential - Verifiable Credential
@@ -26,163 +17,53 @@ export class Parser {
      * @returns `Promise<CoreClaim>`
      */
     static async parseClaim(credential, opts) {
-        if (!opts) {
-            opts = {
-                revNonce: 0,
-                version: 0,
-                subjectPosition: SubjectPosition.Index,
-                merklizedRootPosition: MerklizedRootPosition.None,
-                updatable: false,
-                merklizeOpts: {}
-            };
-        }
-        const mz = await credential.merklize(opts.merklizeOpts);
-        const credentialType = Parser.findCredentialType(mz);
-        const subjectId = credential.credentialSubject['id'];
-        const { slots, nonMerklized } = await this.parseSlots(mz, credential, credentialType);
-        // if schema is for non merklized credential, root position must be set to none ('')
-        // otherwise default position for merklized position is index.
-        if (nonMerklized && opts.merklizedRootPosition !== MerklizedRootPosition.None) {
-            throw new Error('merklized root position is not supported for non-merklized claims');
-        }
-        if (!nonMerklized && opts.merklizedRootPosition === MerklizedRootPosition.None) {
-            opts.merklizedRootPosition = MerklizedRootPosition.Index;
-        }
-        const schemaHash = createSchemaHash(byteEncoder.encode(credentialType));
-        const claim = CoreClaim.newClaim(schemaHash, ClaimOptions.withIndexDataBytes(slots.indexA, slots.indexB), ClaimOptions.withValueDataBytes(slots.valueA, slots.valueB), ClaimOptions.withRevocationNonce(BigInt(opts.revNonce)), ClaimOptions.withVersion(opts.version));
-        if (opts.updatable) {
-            claim.setFlagUpdatable(opts.updatable);
-        }
-        if (credential.expirationDate) {
-            claim.setExpirationDate(new Date(credential.expirationDate));
-        }
-        if (subjectId) {
-            const did = DID.parse(subjectId.toString());
-            const id = DID.idFromDID(did);
-            switch (opts.subjectPosition) {
-                case '':
-                case SubjectPosition.Index:
-                    claim.setIndexId(id);
-                    break;
-                case SubjectPosition.Value:
-                    claim.setValueId(id);
-                    break;
-                default:
-                    throw new Error('unknown subject position');
-            }
-        }
-        switch (opts.merklizedRootPosition) {
-            case MerklizedRootPosition.Index: {
-                const mk = await credential.merklize(opts.merklizeOpts);
-                claim.setIndexMerklizedRoot((await mk.root()).bigInt());
-                break;
-            }
-            case MerklizedRootPosition.Value: {
-                const mk = await credential.merklize(opts.merklizeOpts);
-                claim.setValueMerklizedRoot((await mk.root()).bigInt());
-                break;
-            }
-            case MerklizedRootPosition.None:
-                break;
-            default:
-                throw new Error('unknown merklized root position');
-        }
-        return claim;
+        return credential.toCoreClaim(opts);
     }
+    /**
+     * @deprecated The method should not be used. Use findCredentialType from verifiable.
+     */
     static findCredentialType(mz) {
-        const opts = mz.options;
-        try {
-            // try to look into credentialSubject.@type to get type of credentials
-            const path1 = new Path([credentialSubjectFullKey, typeFullKey], opts.hasher);
-            const e = mz.rawValue(path1);
-            return e;
-        }
-        catch (err) {
-            // if type of credentials not found in credentialSubject.@type, loop at
-            // top level @types if it contains two elements: type we are looking for
-            // and "VerifiableCredential" type.
-            const path2 = new Path([typeFullKey], opts.hasher);
-            const topLevelTypes = mz.rawValue(path2);
-            if (!Array.isArray(topLevelTypes)) {
-                throw new Error('top level @type expected to be an array');
-            }
-            if (topLevelTypes.length !== 2) {
-                throw new Error('top level @type expected to be of length 2');
-            }
-            switch (verifiableCredentialFullKey) {
-                case topLevelTypes[0]:
-                    return topLevelTypes[1];
-                case topLevelTypes[1]:
-                    return topLevelTypes[0];
-                default:
-                    throw new Error('@type(s) are expected to contain VerifiableCredential type');
-            }
-        }
+        return findCredentialType(mz);
     }
-    // Get `iden3_serialization` attr definition from context document either using
-    // type name like DeliverAddressMultiTestForked or by type id like
-    // urn:uuid:ac2ede19-b3b9-454d-b1a9-a7b3d5763100.
+    /**
+     *  @deprecated The method should not be used. Use credential.getSerializationAttr instead.
+     *
+     *  Get `iden3_serialization` attr definition from context document either using
+     *  type name like DeliverAddressMultiTestForked or by type id like
+     *  urn:uuid:ac2ede19-b3b9-454d-b1a9-a7b3d5763100.
+     *  */
     static async getSerializationAttr(credential, opts, tp) {
         const ldCtx = await jsonld.processContext(ldcontext.getInitialContext({}), credential['@context'], opts);
         return Parser.getSerializationAttrFromParsedContext(ldCtx, tp);
     }
-    // Get `iden3_serialization` attr definition from context document either using
-    // type name like DeliverAddressMultiTestForked or by type id like
-    // urn:uuid:ac2ede19-b3b9-454d-b1a9-a7b3d5763100.
+    /**
+     * @deprecated The method should not be used. Use getSerializationAttrFromContext from verifiable.
+     *
+     *  Get `iden3_serialization` attr definition from context document either using
+     *  type name like DeliverAddressMultiTestForked or by type id like
+     *  urn:uuid:ac2ede19-b3b9-454d-b1a9-a7b3d5763100.
+     *
+     */
     static async getSerializationAttrFromContext(context, opts, tp) {
-        const ldCtx = await jsonld.processContext(ldcontext.getInitialContext({}), context, opts);
-        return Parser.getSerializationAttrFromParsedContext(ldCtx, tp);
+        return getSerializationAttrFromContext(context, opts, tp);
     }
+    /**
+     * @deprecated The method should not be used. Use getSerializationAttrFromParsedContext from verifiable.
+     *
+     * */
     static async getSerializationAttrFromParsedContext(ldCtx, tp) {
-        const termDef = ldCtx.mappings;
-        if (!termDef) {
-            throw new Error('terms definitions is not of correct type');
-        }
-        const term = termDef.get(tp) ?? [...termDef.values()].find((value) => value['@id'] === tp);
-        if (!term) {
-            return '';
-        }
-        const termCtx = term[contextFullKey];
-        if (!termCtx) {
-            throw new Error('type @context is not of correct type');
-        }
-        const serStr = termCtx[serializationFullKey] ?? '';
-        return serStr;
+        return getSerializationAttrFromParsedContext(ldCtx, tp);
     }
+    /**
+     * @deprecated The method should not be used. Use parseSerializationAttr from verifiable.
+     *
+     */
     static parseSerializationAttr(serAttr) {
-        if (!serAttr.startsWith(fieldPrefix)) {
-            throw new Error('serialization attribute does not have correct prefix');
-        }
-        const parts = serAttr.slice(fieldPrefix.length).split('&');
-        if (parts.length > 4) {
-            throw new Error('serialization attribute has too many parts');
-        }
-        const paths = {};
-        for (const part of parts) {
-            const kv = part.split('=');
-            if (kv.length !== 2) {
-                throw new Error('serialization attribute part does not have correct format');
-            }
-            switch (kv[0]) {
-                case 'slotIndexA':
-                    paths.indexAPath = kv[1];
-                    break;
-                case 'slotIndexB':
-                    paths.indexBPath = kv[1];
-                    break;
-                case 'slotValueA':
-                    paths.valueAPath = kv[1];
-                    break;
-                case 'slotValueB':
-                    paths.valueBPath = kv[1];
-                    break;
-                default:
-                    throw new Error('unknown serialization attribute slot');
-            }
-        }
-        return paths;
+        return parseSerializationAttr(serAttr);
     }
     /**
+     *
+     * @deprecated The method should not be used. Use credential.parseSlots instead.
      * ParseSlots converts payload to claim slots using provided schema
      *
      * @param {Merklizer} mz - Merklizer
@@ -191,30 +72,12 @@ export class Parser {
      * @returns `ParsedSlots`
      */
     static async parseSlots(mz, credential, credentialType) {
-        // parseSlots converts payload to claim slots using provided schema
-        const slots = {
-            indexA: new Uint8Array(32),
-            indexB: new Uint8Array(32),
-            valueA: new Uint8Array(32),
-            valueB: new Uint8Array(32)
-        };
-        const jsonLDOpts = mz.options;
-        const serAttr = await Parser.getSerializationAttr(credential, jsonLDOpts, credentialType);
-        if (!serAttr) {
-            return { slots, nonMerklized: false };
-        }
-        const sPaths = Parser.parseSerializationAttr(serAttr);
-        const isSPathEmpty = !Object.values(sPaths).some(Boolean);
-        if (isSPathEmpty) {
-            return { slots, nonMerklized: true };
-        }
-        await fillSlot(slots.indexA, mz, sPaths.indexAPath);
-        await fillSlot(slots.indexB, mz, sPaths.indexBPath);
-        await fillSlot(slots.valueA, mz, sPaths.valueAPath);
-        await fillSlot(slots.valueB, mz, sPaths.valueBPath);
-        return { slots, nonMerklized: true };
+        const ldCtx = await jsonld.processContext(ldcontext.getInitialContext({}), credential['@context'], mz.options);
+        return parseCoreClaimSlots(ldCtx, mz, credentialType);
     }
     /**
+     * @deprecated The method should not be used. Use getFieldSlotIndex from verifiable.
+     *
      * GetFieldSlotIndex return index of slot from 0 to 7 (each claim has by default 8 slots) for non-merklized claims
      *
      * @param {string} field - field name
@@ -222,29 +85,7 @@ export class Parser {
      * @returns `number`
      */
     static async getFieldSlotIndex(field, typeName, schemaBytes) {
-        let ctxDoc = JSON.parse(byteDecoder.decode(schemaBytes));
-        ctxDoc = ctxDoc[contextFullKey];
-        if (ctxDoc === undefined) {
-            throw new Error('document has no @context');
-        }
-        const ldCtx = await jsonld.processContext(ldcontext.getInitialContext({}), ctxDoc, {});
-        const serAttr = await Parser.getSerializationAttrFromParsedContext(ldCtx, typeName);
-        if (!serAttr) {
-            throw new Error('serialization attribute is not set');
-        }
-        const sPaths = Parser.parseSerializationAttr(serAttr);
-        switch (field) {
-            case sPaths.indexAPath:
-                return 2;
-            case sPaths.indexBPath:
-                return 3;
-            case sPaths.valueAPath:
-                return 6;
-            case sPaths.valueBPath:
-                return 7;
-            default:
-                throw new Error(`field ${field} not specified in serialization info`);
-        }
+        return getFieldSlotIndex(field, typeName, schemaBytes);
     }
     /**
      * ExtractCredentialSubjectProperties return credential subject types from JSON schema

package/dist/node/esm/schema-processor/utils.js

@@ -1,6 +1,5 @@
-import { Hex } from '@iden3/js-crypto';
-import { BytesHelper, checkBigIntInField, SchemaHash } from '@iden3/js-iden3-core';
-import { keccak256 } from 'js-sha3';
+import { BytesHelper, checkBigIntInField } from '@iden3/js-iden3-core';
+import { caclulateCoreSchemaHash, fillCoreClaimSlot } from '../verifiable';
 /**
  * SwapEndianness swaps the endianness of the value encoded in buf. If buf is
  * Big-Endian, the result will be Little-Endian and vice-versa.
@@ -48,39 +47,27 @@ export function checkDataInField(data) {
     return checkBigIntInField(BytesHelper.bytesToInt(data));
 }
 /**
+ *
+ * @deprecated The method should not be used. Use caclulateCoreSchemaHash from verifiable.
  * Calculates schema hash
  *
  * @param {Uint8Array} schemaId
  * @returns {*}  {SchemaHash}
  */
 export const createSchemaHash = (schemaId) => {
-    const sHash = Hex.decodeString(keccak256(schemaId));
-    return new SchemaHash(sHash.slice(sHash.length - 16, sHash.length));
+    return caclulateCoreSchemaHash(schemaId);
 };
-export const credentialSubjectKey = 'credentialSubject';
 /**
+ *
+ * @deprecated The method should not be used. Use fillCoreClaimSlot from verifiable.
  * checks if data can fill the slot
  *
- * @param {*} data - object that contains field
- * @param {string} fieldName - field name
- * @returns Uint8Array - filled slot
+ * @param {Uint8Array} slotData - slot data
+ * @param {Merklizer} mz - merklizer
+ * @param {string} path - path
+ * @returns {void}
  */
 export const fillSlot = async (slotData, mz, path) => {
-    if (!path) {
-        return;
-    }
-    path = credentialSubjectKey + '.' + path;
-    try {
-        const p = await mz.resolveDocPath(path, mz.options);
-        const entry = await mz.entry(p);
-        const intVal = await entry.getValueMtEntry();
-        const bytesVal = BytesHelper.intToBytes(intVal);
-        slotData.set(bytesVal, 0);
-    }
-    catch (err) {
-        if (err.toString().includes('entry not found')) {
-            throw new Error(`field not found in credential ${path}`);
-        }
-        throw err;
-    }
+    return fillCoreClaimSlot(slotData, mz, path);
 };
+export const credentialSubjectKey = 'credentialSubject';

package/dist/node/esm/storage/blockchain/state.js

@@ -2,6 +2,7 @@ import { Contract, JsonRpcProvider } from 'ethers';
 import { StateTransitionPubSignals } from '../../circuits';
 import { byteEncoder } from '../../utils';
 import abi from './abi/State.json';
+import { DID, getChainId, Id } from '@iden3/js-iden3-core';
 export /** @type {EthConnectionConfig} - default configuration for EthConnectionConfig */ const defaultEthConnectionConfig = {
     url: 'http://localhost:8545',
     defaultGasLimit: 600000,
@@ -27,14 +28,31 @@ export class EthStateStorage {
      * Creates an instance of EthStateStorage.
      * @param {EthConnectionConfig} [ethConfig=defaultEthConnectionConfig]
      */
-    constructor(ethConfig = defaultEthConnectionConfig) {
+    constructor(ethConfig) {
         this.ethConfig = ethConfig;
-        this.provider = new JsonRpcProvider(this.ethConfig.url);
-        this.stateContract = new Contract(this.ethConfig.contractAddress, abi, this.provider);
+        const config = Array.isArray(ethConfig) ? ethConfig[0] : ethConfig;
+        this.provider = new JsonRpcProvider(config.url);
+        this.stateContract = new Contract(config.contractAddress, abi, this.provider);
     }
     /** {@inheritdoc IStateStorage.getLatestStateById} */
     async getLatestStateById(id) {
-        const rawData = await this.stateContract.getStateInfoById(id);
+        const { stateContract } = this.getStateContractAndProviderForId(id);
+        const rawData = await stateContract.getStateInfoById(id);
+        const stateInfo = {
+            id: BigInt(rawData[0]),
+            state: BigInt(rawData[1]),
+            replacedByState: BigInt(rawData[2]),
+            createdAtTimestamp: BigInt(rawData[3]),
+            replacedAtTimestamp: BigInt(rawData[4]),
+            createdAtBlock: BigInt(rawData[5]),
+            replacedAtBlock: BigInt(rawData[6])
+        };
+        return stateInfo;
+    }
+    /** {@inheritdoc IStateStorage.getStateInfoByIdAndState} */
+    async getStateInfoByIdAndState(id, state) {
+        const { stateContract } = this.getStateContractAndProviderForId(id);
+        const rawData = await stateContract.getStateInfoByIdAndState(id, state);
         const stateInfo = {
             id: BigInt(rawData[0]),
             state: BigInt(rawData[1]),
@@ -48,10 +66,11 @@ export class EthStateStorage {
     }
     /** {@inheritdoc IStateStorage.publishState} */
     async publishState(proof, signer) {
-        const contract = this.stateContract.connect(signer);
         const stateTransitionPubSig = new StateTransitionPubSignals();
         stateTransitionPubSig.pubSignalsUnmarshal(byteEncoder.encode(JSON.stringify(proof.pub_signals)));
         const { userId, oldUserState, newUserState, isOldStateGenesis } = stateTransitionPubSig;
+        const { stateContract, provider } = this.getStateContractAndProviderForId(userId.bigInt());
+        const contract = stateContract.connect(signer);
         const payload = [
             userId.bigInt().toString(),
             oldUserState.bigInt().toString(),
@@ -64,7 +83,7 @@ export class EthStateStorage {
             ],
             proof.proof.pi_c.slice(0, 2)
         ];
-        const feeData = await this.provider.getFeeData();
+        const feeData = await provider.getFeeData();
         const maxFeePerGas = defaultEthConnectionConfig.maxFeePerGas
             ? BigInt(defaultEthConnectionConfig.maxFeePerGas)
             : feeData.maxFeePerGas;
@@ -94,7 +113,8 @@ export class EthStateStorage {
     }
     /** {@inheritdoc IStateStorage.getGISTProof} */
     async getGISTProof(id) {
-        const data = await this.stateContract.getGISTProof(id);
+        const { stateContract } = this.getStateContractAndProviderForId(id);
+        const data = await stateContract.getGISTProof(id);
         return {
             root: BigInt(data.root.toString()),
             existence: data.existence,
@@ -108,7 +128,8 @@ export class EthStateStorage {
     }
     /** {@inheritdoc IStateStorage.getGISTRootInfo} */
     async getGISTRootInfo(id) {
-        const data = await this.stateContract.getGISTRootInfo(id);
+        const { stateContract } = this.getStateContractAndProviderForId(id);
+        const data = await stateContract.getGISTRootInfo(id);
         return {
             root: BigInt(data.root.toString()),
             replacedByRoot: BigInt(data.replacedByRoot.toString()),
@@ -118,4 +139,28 @@ export class EthStateStorage {
             replacedAtBlock: BigInt(data.replacedAtBlock.toString())
         };
     }
+    getStateContractAndProviderForId(id) {
+        const idTyped = Id.fromBigInt(id);
+        if (!Array.isArray(this.ethConfig)) {
+            return {
+                stateContract: this.stateContract,
+                provider: this.provider
+            };
+        }
+        const chainId = getChainId(DID.blockchainFromId(idTyped), DID.networkIdFromId(idTyped));
+        const config = this.networkByChainId(chainId);
+        const provider = new JsonRpcProvider(config.url);
+        const stateContract = new Contract(config.contractAddress, abi, this.provider);
+        return { stateContract, provider };
+    }
+    networkByChainId(chainId) {
+        if (Array.isArray(this.ethConfig)) {
+            const network = this.ethConfig.find((c) => c.chainId === chainId);
+            if (!network) {
+                throw new Error(`chainId "${chainId}" not supported`);
+            }
+            return network;
+        }
+        return this.ethConfig;
+    }
 }

package/dist/node/esm/utils/compare-func.js

@@ -0,0 +1,7 @@
+export const bigIntCompare = (a, b) => {
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+};

package/dist/node/esm/utils/index.js

@@ -1,3 +1,5 @@
 export * from './encoding';
 export * from './object';
 export * from './did-helper';
+export * from './message-bus';
+export * from './compare-func';

package/dist/node/esm/utils/message-bus.js

@@ -0,0 +1,66 @@
+import PubSub from 'pubsub-js';
+export const SDK_EVENTS = {
+    TX_RECEIPT_ACCEPTED: 'TX_RECEIPT_ACCEPTED'
+};
+/**
+ * Represents a message bus that allows publishing and subscribing to topics.
+ */
+export class MessageBus {
+    /**
+     * Private constructor for the MessageBus class.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    constructor() { }
+    /**
+     * Returns the singleton instance of the MessageBus class.
+     * If the instance doesn't exist, it creates a new one.
+     * @returns The singleton instance of the MessageBus class.
+     */
+    static getInstance() {
+        // If the instance doesn't exist, create it
+        if (!MessageBus.instance) {
+            MessageBus.instance = new MessageBus();
+        }
+        // Return the instance
+        return MessageBus.instance;
+    }
+    /**
+     * Publishes a message to the specified topic.
+     *
+     * @template T - The type of data being published.
+     * @param {SdkTopic} topic - The topic to publish the message to.
+     * @param {T} data - The data to be published.
+     * @returns {boolean} - Returns true if the message was successfully published, false otherwise.
+     */
+    publish(topic, data) {
+        return PubSub.publish(topic.toString(), data);
+    }
+    /**
+     * Subscribes to a specific topic and registers a callback function to be executed when a message is published.
+     *
+     * @param topic - The topic to subscribe to.
+     * @param callback - The callback function to be executed when a message is published.
+     */
+    subscribe(topic, callback) {
+        return PubSub.subscribe(topic.toString(), (_, data) => callback(data));
+    }
+    /**
+     * Subscribes to a specific topic and registers a callback function to be executed when a message is published.
+     * The callback function is executed only once.
+     *
+     * @param topic - The topic to subscribe to.
+     * @param callback - The callback function to be executed when a message is published.
+     */
+    subscribeOnce(topic, callback) {
+        PubSub.subscribeOnce(topic.toString(), (_, data) => callback(data));
+    }
+    /**
+     * Unsubscribes from a specific topic in the message bus.
+     *
+     * @param topic - The topic to unsubscribe from.
+     * @returns A string or boolean indicating the success of the unsubscribe operation.
+     */
+    unsubscribe(topic) {
+        return PubSub.unsubscribe(topic.toString());
+    }
+}