@0xpolygonid/js-sdk 1.7.5 → 1.8.0

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

@@ -25,18 +25,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Parser = void 0;
 const verifiable_1 = require("../../verifiable");
-const js_iden3_core_1 = require("@iden3/js-iden3-core");
-const utils_1 = require("../utils");
-const utils_2 = require("../../utils");
-const js_jsonld_merklization_1 = require("@iden3/js-jsonld-merklization");
 const jsonld = __importStar(require("jsonld/lib"));
 const ldcontext = __importStar(require("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
  *
@@ -45,6 +35,7 @@ const fieldPrefix = 'iden3:v1:';
  */
 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
@@ -52,163 +43,53 @@ class Parser {
      * @returns `Promise<CoreClaim>`
      */
     static async parseClaim(credential, opts) {
-        if (!opts) {
-            opts = {
-                revNonce: 0,
-                version: 0,
-                subjectPosition: verifiable_1.SubjectPosition.Index,
-                merklizedRootPosition: verifiable_1.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 !== verifiable_1.MerklizedRootPosition.None) {
-            throw new Error('merklized root position is not supported for non-merklized claims');
-        }
-        if (!nonMerklized && opts.merklizedRootPosition === verifiable_1.MerklizedRootPosition.None) {
-            opts.merklizedRootPosition = verifiable_1.MerklizedRootPosition.Index;
-        }
-        const schemaHash = (0, utils_1.createSchemaHash)(utils_2.byteEncoder.encode(credentialType));
-        const claim = js_iden3_core_1.Claim.newClaim(schemaHash, js_iden3_core_1.ClaimOptions.withIndexDataBytes(slots.indexA, slots.indexB), js_iden3_core_1.ClaimOptions.withValueDataBytes(slots.valueA, slots.valueB), js_iden3_core_1.ClaimOptions.withRevocationNonce(BigInt(opts.revNonce)), js_iden3_core_1.ClaimOptions.withVersion(opts.version));
-        if (opts.updatable) {
-            claim.setFlagUpdatable(opts.updatable);
-        }
-        if (credential.expirationDate) {
-            claim.setExpirationDate(new Date(credential.expirationDate));
-        }
-        if (subjectId) {
-            const did = js_iden3_core_1.DID.parse(subjectId.toString());
-            const id = js_iden3_core_1.DID.idFromDID(did);
-            switch (opts.subjectPosition) {
-                case '':
-                case verifiable_1.SubjectPosition.Index:
-                    claim.setIndexId(id);
-                    break;
-                case verifiable_1.SubjectPosition.Value:
-                    claim.setValueId(id);
-                    break;
-                default:
-                    throw new Error('unknown subject position');
-            }
-        }
-        switch (opts.merklizedRootPosition) {
-            case verifiable_1.MerklizedRootPosition.Index: {
-                const mk = await credential.merklize(opts.merklizeOpts);
-                claim.setIndexMerklizedRoot((await mk.root()).bigInt());
-                break;
-            }
-            case verifiable_1.MerklizedRootPosition.Value: {
-                const mk = await credential.merklize(opts.merklizeOpts);
-                claim.setValueMerklizedRoot((await mk.root()).bigInt());
-                break;
-            }
-            case verifiable_1.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 js_jsonld_merklization_1.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 js_jsonld_merklization_1.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 (0, verifiable_1.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 (0, verifiable_1.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 (0, verifiable_1.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 (0, verifiable_1.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
@@ -217,30 +98,12 @@ 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 (0, utils_1.fillSlot)(slots.indexA, mz, sPaths.indexAPath);
-        await (0, utils_1.fillSlot)(slots.indexB, mz, sPaths.indexBPath);
-        await (0, utils_1.fillSlot)(slots.valueA, mz, sPaths.valueAPath);
-        await (0, utils_1.fillSlot)(slots.valueB, mz, sPaths.valueBPath);
-        return { slots, nonMerklized: true };
+        const ldCtx = await jsonld.processContext(ldcontext.getInitialContext({}), credential['@context'], mz.options);
+        return (0, verifiable_1.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
@@ -248,29 +111,7 @@ class Parser {
      * @returns `number`
      */
     static async getFieldSlotIndex(field, typeName, schemaBytes) {
-        let ctxDoc = JSON.parse(utils_2.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 (0, verifiable_1.getFieldSlotIndex)(field, typeName, schemaBytes);
     }
     /**
      * ExtractCredentialSubjectProperties return credential subject types from JSON schema

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

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fillSlot = exports.credentialSubjectKey = exports.createSchemaHash = exports.checkDataInField = exports.dataFillsSlot = exports.fieldToByteArray = exports.swapEndianness = void 0;
-const js_crypto_1 = require("@iden3/js-crypto");
+exports.credentialSubjectKey = exports.fillSlot = exports.createSchemaHash = exports.checkDataInField = exports.dataFillsSlot = exports.fieldToByteArray = exports.swapEndianness = void 0;
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
-const js_sha3_1 = require("js-sha3");
+const verifiable_1 = require("../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.
@@ -55,41 +54,29 @@ function checkDataInField(data) {
 }
 exports.checkDataInField = checkDataInField;
 /**
+ *
+ * @deprecated The method should not be used. Use caclulateCoreSchemaHash from verifiable.
  * Calculates schema hash
  *
  * @param {Uint8Array} schemaId
  * @returns {*}  {SchemaHash}
  */
 const createSchemaHash = (schemaId) => {
-    const sHash = js_crypto_1.Hex.decodeString((0, js_sha3_1.keccak256)(schemaId));
-    return new js_iden3_core_1.SchemaHash(sHash.slice(sHash.length - 16, sHash.length));
+    return (0, verifiable_1.caclulateCoreSchemaHash)(schemaId);
 };
 exports.createSchemaHash = createSchemaHash;
-exports.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}
  */
 const fillSlot = async (slotData, mz, path) => {
-    if (!path) {
-        return;
-    }
-    path = exports.credentialSubjectKey + '.' + path;
-    try {
-        const p = await mz.resolveDocPath(path, mz.options);
-        const entry = await mz.entry(p);
-        const intVal = await entry.getValueMtEntry();
-        const bytesVal = js_iden3_core_1.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 (0, verifiable_1.fillCoreClaimSlot)(slotData, mz, path);
 };
 exports.fillSlot = fillSlot;
+exports.credentialSubjectKey = 'credentialSubject';

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

@@ -8,6 +8,7 @@ const ethers_1 = require("ethers");
 const circuits_1 = require("../../circuits");
 const utils_1 = require("../../utils");
 const State_json_1 = __importDefault(require("./abi/State.json"));
+const js_iden3_core_1 = require("@iden3/js-iden3-core");
 exports.defaultEthConnectionConfig = {
     url: 'http://localhost:8545',
     defaultGasLimit: 600000,
@@ -33,14 +34,31 @@ class EthStateStorage {
      * Creates an instance of EthStateStorage.
      * @param {EthConnectionConfig} [ethConfig=defaultEthConnectionConfig]
      */
-    constructor(ethConfig = exports.defaultEthConnectionConfig) {
+    constructor(ethConfig) {
         this.ethConfig = ethConfig;
-        this.provider = new ethers_1.JsonRpcProvider(this.ethConfig.url);
-        this.stateContract = new ethers_1.Contract(this.ethConfig.contractAddress, State_json_1.default, this.provider);
+        const config = Array.isArray(ethConfig) ? ethConfig[0] : ethConfig;
+        this.provider = new ethers_1.JsonRpcProvider(config.url);
+        this.stateContract = new ethers_1.Contract(config.contractAddress, State_json_1.default, 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]),
@@ -54,10 +72,11 @@ class EthStateStorage {
     }
     /** {@inheritdoc IStateStorage.publishState} */
     async publishState(proof, signer) {
-        const contract = this.stateContract.connect(signer);
         const stateTransitionPubSig = new circuits_1.StateTransitionPubSignals();
         stateTransitionPubSig.pubSignalsUnmarshal(utils_1.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(),
@@ -70,7 +89,7 @@ class EthStateStorage {
             ],
             proof.proof.pi_c.slice(0, 2)
         ];
-        const feeData = await this.provider.getFeeData();
+        const feeData = await provider.getFeeData();
         const maxFeePerGas = exports.defaultEthConnectionConfig.maxFeePerGas
             ? BigInt(exports.defaultEthConnectionConfig.maxFeePerGas)
             : feeData.maxFeePerGas;
@@ -100,7 +119,8 @@ 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,
@@ -114,7 +134,8 @@ 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()),
@@ -124,5 +145,29 @@ class EthStateStorage {
             replacedAtBlock: BigInt(data.replacedAtBlock.toString())
         };
     }
+    getStateContractAndProviderForId(id) {
+        const idTyped = js_iden3_core_1.Id.fromBigInt(id);
+        if (!Array.isArray(this.ethConfig)) {
+            return {
+                stateContract: this.stateContract,
+                provider: this.provider
+            };
+        }
+        const chainId = (0, js_iden3_core_1.getChainId)(js_iden3_core_1.DID.blockchainFromId(idTyped), js_iden3_core_1.DID.networkIdFromId(idTyped));
+        const config = this.networkByChainId(chainId);
+        const provider = new ethers_1.JsonRpcProvider(config.url);
+        const stateContract = new ethers_1.Contract(config.contractAddress, State_json_1.default, 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;
+    }
 }
 exports.EthStateStorage = EthStateStorage;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigIntCompare = void 0;
+const bigIntCompare = (a, b) => {
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+};
+exports.bigIntCompare = bigIntCompare;

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

@@ -17,3 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./encoding"), exports);
 __exportStar(require("./object"), exports);
 __exportStar(require("./did-helper"), exports);
+__exportStar(require("./message-bus"), exports);
+__exportStar(require("./compare-func"), exports);

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

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageBus = exports.SDK_EVENTS = void 0;
+const pubsub_js_1 = __importDefault(require("pubsub-js"));
+exports.SDK_EVENTS = {
+    TX_RECEIPT_ACCEPTED: 'TX_RECEIPT_ACCEPTED'
+};
+/**
+ * Represents a message bus that allows publishing and subscribing to topics.
+ */
+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_js_1.default.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_js_1.default.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_js_1.default.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_js_1.default.unsubscribe(topic.toString());
+    }
+}
+exports.MessageBus = MessageBus;