@0xpolygonid/js-sdk 1.23.0 → 1.25.1

package/dist/node/cjs/storage/blockchain/onchain-issuer-adapter/non-merklized/version/v0.0.1/onchain-non-merklized-issuer-adapter.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnchainNonMerklizedIssuerAdapter = void 0;
+const js_iden3_core_1 = require("@iden3/js-iden3-core");
+const onchain_non_merklized_issuer_base_abi_1 = require("@iden3/onchain-non-merklized-issuer-base-abi");
+const verifiable_1 = require("../../../../../../verifiable");
+const js_jsonld_merklization_1 = require("@iden3/js-jsonld-merklization");
+const circuits_1 = require("../../../../../../circuits");
+const js_merkletree_1 = require("@iden3/js-merkletree");
+const ethers_1 = require("ethers");
+const js_iden3_core_2 = require("@iden3/js-iden3-core");
+var NonMerklizedIssuerInterfaces;
+(function (NonMerklizedIssuerInterfaces) {
+    NonMerklizedIssuerInterfaces["InterfaceDetection"] = "0x01ffc9a7";
+    NonMerklizedIssuerInterfaces["InterfaceNonMerklizedIssuer"] = "0x58874949";
+    NonMerklizedIssuerInterfaces["InterfaceGetCredential"] = "0x5d1ca631";
+})(NonMerklizedIssuerInterfaces || (NonMerklizedIssuerInterfaces = {}));
+var ValueHashes;
+(function (ValueHashes) {
+    ValueHashes["BooleanTrue"] = "18586133768512220936620570745912940619677854269274689475585506675881198879027";
+    ValueHashes["BooleanFalse"] = "19014214495641488759237505126948346942972912379615652741039992445865937985820";
+})(ValueHashes || (ValueHashes = {}));
+/**
+ * `OnchainNonMerklizedIssuerAdapter` provides functionality to interact with a non-merklized on-chain credential issuer.
+ * This adapter enables interface detection, credential retrieval, and conversion to the W3C Verifiable Credential format.
+ *
+ * @public
+ * @beta
+ * @class OnchainNonMerklizedIssuerAdapter
+ */
+class OnchainNonMerklizedIssuerAdapter {
+    /**
+     * Initializes an instance of `OnchainNonMerklizedIssuerAdapter`.
+     *
+     * @param ethConnectionConfig The configuration for the Ethereum connection.
+     * @param issuerDid The decentralized identifier (DID) of the issuer.
+     * @param merklizationOptions Optional settings for merklization.
+     */
+    constructor(ethConnectionConfig, issuerDid, options) {
+        if (!ethConnectionConfig.chainId) {
+            throw new Error('Chain ID is required');
+        }
+        this._chainId = ethConnectionConfig.chainId;
+        this._contractAddress = ethers_1.ethers.getAddress(ethers_1.ethers.hexlify(js_iden3_core_1.Id.ethAddressFromId(js_iden3_core_1.DID.idFromDID(issuerDid))));
+        this._contract = onchain_non_merklized_issuer_base_abi_1.NonMerklizedIssuerBase__factory.connect(this._contractAddress, new ethers_1.ethers.JsonRpcProvider(ethConnectionConfig.url));
+        this._issuerDid = issuerDid;
+        this._merklizationOptions = options?.merklizationOptions;
+    }
+    /**
+     * Checks if the contract supports required interfaces.
+     * Throws an error if any required interface is unsupported.
+     *
+     * @throws Error - If required interfaces are not supported.
+     */
+    async isInterfaceSupported() {
+        const supportedInterfaces = [
+            {
+                name: 'Interface detection ERC-165',
+                value: NonMerklizedIssuerInterfaces.InterfaceDetection
+            },
+            {
+                name: 'Interface non-merklized issuer',
+                value: NonMerklizedIssuerInterfaces.InterfaceNonMerklizedIssuer
+            },
+            {
+                name: 'Interface get credential',
+                value: NonMerklizedIssuerInterfaces.InterfaceGetCredential
+            }
+        ];
+        const unsupportedInterfaces = await Promise.all(supportedInterfaces.map(async (interfaceObj) => {
+            const isSupported = await this._contract.supportsInterface(interfaceObj.value);
+            return isSupported ? null : interfaceObj.name;
+        }));
+        const unsupportedInterfacesFiltered = unsupportedInterfaces.filter((interfaceName) => interfaceName !== null);
+        if (unsupportedInterfacesFiltered.length > 0) {
+            throw new Error(`Unsupported interfaces: ${unsupportedInterfacesFiltered.join(', ')}`);
+        }
+    }
+    /**
+     * Retrieves a credential from the on-chain non-merklized contract.
+     * @param userId The user's core.Id.
+     * @param credentialId The unique identifier of the credential.
+     */
+    async getCredential(userId, credentialId) {
+        const [credentialData, coreClaimBigInts, credentialSubjectFields] = await this._contract.getCredential(userId.bigInt(), credentialId);
+        return { credentialData, coreClaimBigInts, credentialSubjectFields };
+    }
+    /**
+     * Retrieves the credential IDs of a user.
+     * @param userId The user's core.Id.
+     * @returns An array of credential IDs.
+     */
+    async getUserCredentialsIds(userId) {
+        return this._contract.getUserCredentialIds(userId.bigInt());
+    }
+    /**
+     * Converts on-chain credential to a verifiable credential.
+     *
+     * @param credentialData Data structure of the credential from the contract.
+     * @param coreClaimBigInts Claim data in bigint format.
+     * @param credentialSubjectFields Subject fields of the credential.
+     */
+    async convertOnChainInfoToW3CCredential(credentialData, coreClaimBigInts, credentialSubjectFields) {
+        const c = new js_iden3_core_1.Claim().unMarshalJson(JSON.stringify(coreClaimBigInts.map((b) => b.toString())));
+        const credentialSubject = await this.convertCredentialSubject(c, credentialData.context, credentialData._type, credentialSubjectFields);
+        const credentialRequest = {
+            id: this.credentialId(credentialData.id),
+            credentialSchema: credentialData.credentialSchema.id,
+            type: credentialData._type,
+            credentialSubject: credentialSubject,
+            expiration: c.getExpirationDate()?.getTime(),
+            displayMethod: this.convertDisplayMethod(credentialData.displayMethod),
+            context: credentialData.context,
+            revocationOpts: {
+                id: this._contractAddress,
+                nonce: Number(c.getRevocationNonce()),
+                type: verifiable_1.CredentialStatusType.Iden3OnchainSparseMerkleTreeProof2023
+            },
+            issuanceDate: (0, js_iden3_core_2.getDateFromUnixTimestamp)(Number(credentialData.issuanceDate)).getTime()
+        };
+        const existenceProof = await this.existenceProof(c);
+        const w3c = verifiable_1.W3CCredential.fromCredentialRequest(this._issuerDid, credentialRequest);
+        w3c.proof = [existenceProof];
+        return w3c;
+    }
+    credentialId(id) {
+        return `urn:iden3:onchain:${this._chainId}:${this._contractAddress}:${id}`;
+    }
+    async convertCredentialSubject(coreClaim, contractContexts, credentialType, credentialSubjectFields) {
+        const contractContextsStr = JSON.stringify({
+            '@context': contractContexts
+        });
+        const credentialSubject = {};
+        for (const f of credentialSubjectFields) {
+            const dataType = await js_jsonld_merklization_1.Path.newTypeFromContext(contractContextsStr, `${credentialType}.${f.key}`, this._merklizationOptions);
+            switch (dataType) {
+                case circuits_1.XSDNS.Boolean: {
+                    switch (f.rawValue.toString()) {
+                        case ValueHashes.BooleanTrue:
+                            credentialSubject[f.key] = true;
+                            break;
+                        case ValueHashes.BooleanFalse:
+                            credentialSubject[f.key] = false;
+                            break;
+                    }
+                    break;
+                }
+                case (circuits_1.XSDNS.NonNegativeInteger,
+                    circuits_1.XSDNS.NonPositiveInteger,
+                    circuits_1.XSDNS.NegativeInteger,
+                    circuits_1.XSDNS.PositiveInteger):
+                    {
+                        credentialSubject[f.key] = f.value.toString();
+                        break;
+                    }
+                case circuits_1.XSDNS.Integer: {
+                    credentialSubject[f.key] = Number(f.value);
+                    break;
+                }
+                case circuits_1.XSDNS.String: {
+                    this.validateSourceValue(dataType, f.value, f.rawValue);
+                    credentialSubject[f.key] = f.rawValue;
+                    break;
+                }
+                case circuits_1.XSDNS.DateTime: {
+                    const timestamp = BigInt(f.rawValue);
+                    const sourceTimestamp = (0, js_iden3_core_2.getDateFromUnixTimestamp)(Number(timestamp)).toISOString();
+                    this.validateSourceValue(dataType, f.value, sourceTimestamp);
+                    credentialSubject[f.key] = sourceTimestamp;
+                    break;
+                }
+                case circuits_1.XSDNS.Double: {
+                    const rawFloat = Number(f.rawValue);
+                    this.validateSourceValue(dataType, f.value, rawFloat);
+                    credentialSubject[f.key] = rawFloat;
+                    break;
+                }
+                default: {
+                    throw new Error(`Unsupported data type ${dataType}`);
+                }
+            }
+        }
+        credentialSubject['type'] = credentialType;
+        const subjectId = coreClaim.getId();
+        const subjectDid = js_iden3_core_1.DID.parseFromId(subjectId);
+        credentialSubject['id'] = subjectDid.string();
+        return credentialSubject;
+    }
+    async existenceProof(coreClaim) {
+        const [mtpProof, stateInfo] = await this._contract.getClaimProofWithStateInfo(coreClaim.hIndex());
+        if (!mtpProof.existence) {
+            throw new Error('Claim does not exist');
+        }
+        const latestStateHash = js_merkletree_1.Hash.fromBigInt(stateInfo.state);
+        const latestClaimsOfRootHash = js_merkletree_1.Hash.fromBigInt(stateInfo.claimsRoot);
+        const latestRevocationOfRootHash = js_merkletree_1.Hash.fromBigInt(stateInfo.revocationsRoot);
+        const latestRootsOfRootHash = js_merkletree_1.Hash.fromBigInt(stateInfo.rootsRoot);
+        const p = new js_merkletree_1.Proof({
+            siblings: mtpProof.siblings.map((s) => js_merkletree_1.Hash.fromBigInt(s)),
+            existence: mtpProof.existence,
+            nodeAux: mtpProof.auxExistence
+                ? {
+                    key: js_merkletree_1.Hash.fromBigInt(mtpProof.auxIndex),
+                    value: js_merkletree_1.Hash.fromBigInt(mtpProof.auxValue)
+                }
+                : undefined
+        });
+        return new verifiable_1.Iden3SparseMerkleTreeProof({
+            issuerData: {
+                id: this._issuerDid,
+                state: {
+                    value: latestStateHash,
+                    claimsTreeRoot: latestClaimsOfRootHash,
+                    revocationTreeRoot: latestRevocationOfRootHash,
+                    rootOfRoots: latestRootsOfRootHash
+                }
+            },
+            mtp: p,
+            coreClaim: coreClaim
+        });
+    }
+    async validateSourceValue(dataType, originHash, source) {
+        const sourceHash = await js_jsonld_merklization_1.Merklizer.hashValue(dataType, source);
+        if (sourceHash !== originHash) {
+            throw new Error(`Invalid source value for ${dataType} type`);
+        }
+    }
+    convertDisplayMethod(onchainDisplayMethod) {
+        if (!onchainDisplayMethod.id || !onchainDisplayMethod._type) {
+            return undefined;
+        }
+        switch (onchainDisplayMethod._type) {
+            case verifiable_1.DisplayMethodType.Iden3BasicDisplayMethodV1: {
+                return {
+                    id: onchainDisplayMethod.id,
+                    type: verifiable_1.DisplayMethodType.Iden3BasicDisplayMethodV1
+                };
+            }
+            default: {
+                throw new Error(`Unsupported display method type ${onchainDisplayMethod._type}`);
+            }
+        }
+    }
+}
+exports.OnchainNonMerklizedIssuerAdapter = OnchainNonMerklizedIssuerAdapter;

package/dist/node/cjs/storage/blockchain/onchain-issuer.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnchainIssuer = void 0;
+const js_iden3_core_1 = require("@iden3/js-iden3-core");
+const ethers_1 = require("ethers");
+const onchain_non_merklized_issuer_base_abi_1 = require("@iden3/onchain-non-merklized-issuer-base-abi");
+const onchain_non_merklized_issuer_adapter_1 = require("./onchain-issuer-adapter/non-merklized/version/v0.0.1/onchain-non-merklized-issuer-adapter");
+/**
+ * Represents an adapter for interacting with on-chain issuers.
+ *
+ * @public
+ * @beta
+ * @class OnchainIssuer
+ */
+class OnchainIssuer {
+    /**
+     * Initializes an instance of `Adapter`.
+     * @param config The configuration for the Ethereum connection.
+     * @param merklizationOptions Optional settings for merklization.
+     */
+    constructor(config, options) {
+        this._ethConnectionConfig = config;
+        this._onchainIssuerOptions = options;
+    }
+    /**
+     * Retrieves a credential from the on-chain issuer.
+     * @param issuerDID The issuer's core.DID.
+     * @param userId The user's core.Id.
+     * @param credentialId The unique identifier of the credential.
+     */
+    async getCredential(issuerDID, userDID, credentialId) {
+        const { contract, connection } = this.getContractConnection(issuerDID);
+        const response = await contract.getCredentialAdapterVersion();
+        switch (response) {
+            case '0.0.1': {
+                const adapter = new onchain_non_merklized_issuer_adapter_1.OnchainNonMerklizedIssuerAdapter(connection, issuerDID, {
+                    merklizationOptions: this._onchainIssuerOptions?.merklizationOptions
+                });
+                await adapter.isInterfaceSupported();
+                const { credentialData, coreClaimBigInts, credentialSubjectFields } = await adapter.getCredential(js_iden3_core_1.DID.idFromDID(userDID), credentialId);
+                return await adapter.convertOnChainInfoToW3CCredential(credentialData, coreClaimBigInts, credentialSubjectFields);
+            }
+            default:
+                throw new Error(`Unsupported adapter version ${response}`);
+        }
+    }
+    /**
+     * Retrieves the credential identifiers for a user from the on-chain issuer.
+     * @param issuerDID The issuer's core.DID.
+     * @param userId The user's core.Id.
+     */
+    async getUserCredentialIds(issuerDID, userDID) {
+        const { contract, connection } = this.getContractConnection(issuerDID);
+        const response = await contract.getCredentialAdapterVersion();
+        switch (response) {
+            case '0.0.1': {
+                const adapter = new onchain_non_merklized_issuer_adapter_1.OnchainNonMerklizedIssuerAdapter(connection, issuerDID, {
+                    merklizationOptions: this._onchainIssuerOptions?.merklizationOptions
+                });
+                await adapter.isInterfaceSupported();
+                return await adapter.getUserCredentialsIds(js_iden3_core_1.DID.idFromDID(userDID));
+            }
+            default:
+                throw new Error(`Unsupported adapter version ${response}`);
+        }
+    }
+    getContractConnection(did) {
+        const issuerId = js_iden3_core_1.DID.idFromDID(did);
+        const chainId = (0, js_iden3_core_1.chainIDfromDID)(did);
+        const contractAddress = ethers_1.ethers.getAddress(ethers_1.ethers.hexlify(js_iden3_core_1.Id.ethAddressFromId(issuerId)));
+        const connection = this._ethConnectionConfig.find((c) => c.chainId === chainId);
+        if (!connection) {
+            throw new Error(`No connection found for chain ID ${chainId}`);
+        }
+        if (!connection.url) {
+            throw new Error(`No URL found for chain ID ${chainId}`);
+        }
+        const contract = new ethers_1.Contract(contractAddress, onchain_non_merklized_issuer_base_abi_1.INonMerklizedIssuerABI, new ethers_1.ethers.JsonRpcProvider(connection.url));
+        return { contract, connection };
+    }
+}
+exports.OnchainIssuer = OnchainIssuer;

package/dist/node/cjs/storage/blockchain/onchain-zkp-verifier.js

@@ -11,6 +11,7 @@ const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const circuits_1 = require("../../circuits");
 const utils_1 = require("../../utils");
 const js_crypto_1 = require("@iden3/js-crypto");
+const js_merkletree_1 = require("@iden3/js-merkletree");
 const maxGasLimit = 10000000n;
 /**
  * Supported function signature for SubmitZKPResponse
@@ -43,23 +44,8 @@ class OnChainZKPVerifier {
     constructor(_configs, _opts) {
         this._configs = _configs;
         this._opts = _opts;
-        /**
-         * supported circuits
-         */
-        this._supportedCircuits = [
-            circuits_1.CircuitId.AtomicQueryMTPV2OnChain,
-            circuits_1.CircuitId.AtomicQuerySigV2OnChain,
-            circuits_1.CircuitId.AtomicQueryV3OnChain
-        ];
-        /**
-         * abi coder to encode/decode structures to solidity bytes
-         */
-        this._abiCoder = new ethers_1.ethers.AbiCoder();
     }
-    /**
-     * {@inheritDoc IOnChainZKPVerifier.prepareTxArgsSubmitV1}
-     */
-    async prepareTxArgsSubmitV1(txData, zkProofResponse) {
+    static async prepareTxArgsSubmitV1(txData, zkProofResponse) {
         if (txData.method_id.replace('0x', '') !== FunctionSignatures.SubmitZKPResponseV1) {
             throw new Error(`prepareTxArgsSubmitV1 function doesn't implement requested method id. Only '0x${FunctionSignatures.SubmitZKPResponseV1}' is supported.`);
         }
@@ -77,6 +63,12 @@ class OnChainZKPVerifier {
         ];
         return payload;
     }
+    /**
+     * {@inheritDoc IOnChainZKPVerifier.prepareTxArgsSubmitV1}
+     */
+    async prepareTxArgsSubmitV1(txData, zkProofResponse) {
+        return OnChainZKPVerifier.prepareTxArgsSubmitV1(txData, zkProofResponse);
+    }
     /**
      * {@inheritDoc IOnChainZKPVerifier.submitZKPResponse}
      */
@@ -166,55 +158,60 @@ class OnChainZKPVerifier {
         const { txnHash } = await transactionService.sendTransactionRequest(ethSigner, request);
         return new Map().set(txnHash, zkProofResponses);
     }
-    async prepareTxArgsSubmitV2(txData, zkProofResponses) {
+    static getCrossChainResolvers(source, txDataChainId, type, didResolverUrl) {
+        return [
+            ...new Set(source.map((info) => JSON.stringify({
+                id: info.id.string(),
+                [type]: type === 'gist' ? info.root?.string() : info.state?.string()
+            })))
+        ].reduce((acc, s) => {
+            const info = JSON.parse(s);
+            const id = js_iden3_core_1.Id.fromString(info.id);
+            const chainId = (0, js_iden3_core_1.chainIDfromDID)(js_iden3_core_1.DID.parseFromId(id));
+            if (txDataChainId === chainId) {
+                return acc;
+            }
+            const promise = this.resolveDidDocumentEip712MessageAndSignature(js_iden3_core_1.DID.parseFromId(js_iden3_core_1.Id.fromString(info.id)), didResolverUrl, {
+                [type]: js_merkletree_1.Hash.fromString(info[type])
+            });
+            return [...acc, promise];
+        }, []);
+    }
+    static async prepareTxArgsSubmitV2(resolverUrl, txData, zkProofResponses) {
         if (txData.method_id.replace('0x', '') !== FunctionSignatures.SubmitZKPResponseV2) {
             throw new Error(`submit cross chain doesn't implement requested method id. Only '0x${FunctionSignatures.SubmitZKPResponseV2}' is supported.`);
         }
-        if (!this._opts?.didResolverUrl) {
-            throw new Error(`did resolver url required for crosschain verification`);
-        }
-        const gistUpdateArr = [];
-        const stateUpdateArr = [];
+        const gistUpdates = [];
+        const stateUpdates = [];
         const payload = [];
-        // Resolved gists and states to avoid duplicate requests
-        const gistUpdateResolutionsPending = [];
-        const stateUpdateResolutionsPending = [];
+        const emptyBytes = '0x';
         for (const zkProof of zkProofResponses) {
-            const requestID = zkProof.id;
-            const inputs = zkProof.pub_signals;
-            if (!this._supportedCircuits.includes(zkProof.circuitId)) {
+            const { id: requestId, pub_signals: inputs } = zkProof;
+            const proofCircuitId = zkProof.circuitId;
+            if (!this._supportedCircuits.includes(proofCircuitId)) {
                 throw new Error(`Circuit ${zkProof.circuitId} not supported by OnChainZKPVerifier`);
             }
+            if (inputs.length === 0) {
+                payload.push({
+                    requestId: requestId,
+                    zkProof: emptyBytes,
+                    data: emptyBytes
+                });
+                continue;
+            }
             const zkProofEncoded = this.packZkpProof(inputs, zkProof.proof.pi_a.slice(0, 2), [
                 [zkProof.proof.pi_b[0][1], zkProof.proof.pi_b[0][0]],
                 [zkProof.proof.pi_b[1][1], zkProof.proof.pi_b[1][0]]
             ], zkProof.proof.pi_c.slice(0, 2));
-            const stateInfo = this.getOnChainGistRootStatePubSignals(zkProof.circuitId, zkProof.pub_signals);
-            const gistUpdateResolutions = [];
-            for (const gist of stateInfo.gists) {
-                const gistResolutionPending = gistUpdateResolutionsPending.find((g) => g == JSON.stringify(gist));
-                if (gistResolutionPending) {
-                    continue;
-                }
-                gistUpdateResolutionsPending.push(JSON.stringify(gist));
-                gistUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(js_iden3_core_1.DID.parseFromId(gist.id), this._opts.didResolverUrl, { gist: gist.root }));
-            }
-            const stateUpdateResolutions = [];
-            for (const state of stateInfo.states) {
-                const stateResolutionPending = stateUpdateResolutionsPending.find((s) => s == JSON.stringify(state));
-                if (stateResolutionPending) {
-                    continue;
-                }
-                stateUpdateResolutionsPending.push(JSON.stringify(state));
-                stateUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(js_iden3_core_1.DID.parseFromId(state.id), this._opts.didResolverUrl, {
-                    state: state.state
-                }));
-            }
+            const stateInfo = this.getOnChainGistRootStatePubSignals(proofCircuitId, inputs);
+            const chainId = txData.chain_id;
+            const gistUpdateResolutions = this.getCrossChainResolvers(stateInfo.gists, chainId, 'gist', resolverUrl);
+            const stateUpdateResolutions = this.getCrossChainResolvers(stateInfo.states, chainId, 'state', resolverUrl);
             if (gistUpdateResolutions.length > 0) {
-                gistUpdateArr.push(...(await Promise.all(gistUpdateResolutions)));
+                gistUpdates.push(...(await Promise.all(gistUpdateResolutions)));
             }
             if (stateUpdateResolutions.length > 0) {
-                stateUpdateArr.push(...(await Promise.all(stateUpdateResolutions)));
+                stateUpdates.push(...(await Promise.all(stateUpdateResolutions)));
             }
             const metadataArr = [];
             if (zkProof.vp) {
@@ -230,20 +227,28 @@ class OnChainZKPVerifier {
                     });
                 }
             }
-            const metadata = metadataArr.length ? this.packMetadatas(metadataArr) : '0x';
+            const metadata = metadataArr.length ? this.packMetadatas(metadataArr) : emptyBytes;
             payload.push({
-                requestId: requestID,
+                requestId: requestId,
                 zkProof: zkProofEncoded,
                 data: metadata
             });
         }
-        const crossChainProofs = this.packCrossChainProofs(gistUpdateArr, stateUpdateArr);
+        const crossChainProofs = gistUpdates.length || stateUpdates.length
+            ? this.packCrossChainProofs(gistUpdates, stateUpdates)
+            : emptyBytes;
         return [payload, crossChainProofs];
     }
-    packZkpProof(inputs, a, b, c) {
-        return this._abiCoder.encode(['uint256[] inputs', 'uint256[2]', 'uint256[2][2]', 'uint256[2]'], [inputs, a, b, c]);
+    async prepareTxArgsSubmitV2(txData, zkProofResponses) {
+        if (!this._opts?.didResolverUrl) {
+            throw new Error(`did resolver url required for crosschain verification`);
+        }
+        return OnChainZKPVerifier.prepareTxArgsSubmitV2(this._opts.didResolverUrl, txData, zkProofResponses);
+    }
+    static packZkpProof(inputs, a, b, c) {
+        return new ethers_1.ethers.AbiCoder().encode(['uint256[] inputs', 'uint256[2]', 'uint256[2][2]', 'uint256[2]'], [inputs, a, b, c]);
     }
-    packCrossChainProofs(gistUpdateArr, stateUpdateArr) {
+    static packCrossChainProofs(gistUpdateArr, stateUpdateArr) {
         const proofs = [];
         for (const globalStateUpdate of gistUpdateArr) {
             proofs.push({
@@ -257,10 +262,10 @@ class OnChainZKPVerifier {
                 proof: this.packIdentityStateMsg(stateUpdate)
             });
         }
-        return this._abiCoder.encode(['tuple(' + 'string proofType,' + 'bytes proof' + ')[]'], [proofs]);
+        return new ethers_1.ethers.AbiCoder().encode(['tuple(' + 'string proofType,' + 'bytes proof' + ')[]'], [proofs]);
     }
-    packGlobalStateMsg(msg) {
-        return this._abiCoder.encode([
+    static packGlobalStateMsg(msg) {
+        return new ethers_1.ethers.AbiCoder().encode([
             'tuple(' +
                 'tuple(' +
                 'uint256 timestamp,' +
@@ -272,8 +277,8 @@ class OnChainZKPVerifier {
                 ')'
         ], [msg]);
     }
-    packIdentityStateMsg(msg) {
-        return this._abiCoder.encode([
+    static packIdentityStateMsg(msg) {
+        return new ethers_1.ethers.AbiCoder().encode([
             'tuple(' +
                 'tuple(' +
                 'uint256 timestamp,' +
@@ -285,27 +290,20 @@ class OnChainZKPVerifier {
                 ')'
         ], [msg]);
     }
-    packMetadatas(metas) {
-        return this._abiCoder.encode(['tuple(' + 'string key,' + 'bytes value' + ')[]'], [metas]);
+    static packMetadatas(metas) {
+        return new ethers_1.ethers.AbiCoder().encode(['tuple(' + 'string key,' + 'bytes value' + ')[]'], [metas]);
     }
-    getOnChainGistRootStatePubSignals(onChainCircuitId, inputs) {
-        let atomicQueryPubSignals;
-        switch (onChainCircuitId) {
-            case circuits_1.CircuitId.AtomicQueryMTPV2OnChain:
-                atomicQueryPubSignals = new circuits_1.AtomicQueryMTPV2OnChainPubSignals();
-                break;
-            case circuits_1.CircuitId.AtomicQuerySigV2OnChain:
-                atomicQueryPubSignals = new circuits_1.AtomicQuerySigV2OnChainPubSignals();
-                break;
-            case circuits_1.CircuitId.AtomicQueryV3OnChain:
-                atomicQueryPubSignals = new circuits_1.AtomicQueryV3OnChainPubSignals();
-                break;
+    static getOnChainGistRootStatePubSignals(onChainCircuitId, inputs) {
+        const PubSignals = this._supportedCircuitsPubSignalsMap[onChainCircuitId];
+        if (!PubSignals) {
+            throw new Error(`Circuit ${onChainCircuitId} not supported by OnChainZKPVerifier`);
         }
+        const atomicQueryPubSignals = new PubSignals();
         const encodedInputs = utils_1.byteEncoder.encode(JSON.stringify(inputs));
         atomicQueryPubSignals.pubSignalsUnmarshal(encodedInputs);
         return atomicQueryPubSignals.getStatesInfo();
     }
-    async resolveDidDocumentEip712MessageAndSignature(did, resolverUrl, opts) {
+    static async resolveDidDocumentEip712MessageAndSignature(did, resolverUrl, opts) {
         const didDoc = await (0, utils_1.resolveDidDocument)(did, resolverUrl, {
             ...opts,
             signature: utils_1.DIDDocumentSignature.EthereumEip712Signature2021
@@ -339,3 +337,18 @@ class OnChainZKPVerifier {
     }
 }
 exports.OnChainZKPVerifier = OnChainZKPVerifier;
+/**
+ * supported circuits
+ */
+OnChainZKPVerifier._supportedCircuits = [
+    circuits_1.CircuitId.AuthV2,
+    circuits_1.CircuitId.AtomicQueryMTPV2OnChain,
+    circuits_1.CircuitId.AtomicQuerySigV2OnChain,
+    circuits_1.CircuitId.AtomicQueryV3OnChain
+];
+OnChainZKPVerifier._supportedCircuitsPubSignalsMap = {
+    [circuits_1.CircuitId.AtomicQueryMTPV2OnChain]: circuits_1.AtomicQueryMTPV2OnChainPubSignals,
+    [circuits_1.CircuitId.AtomicQuerySigV2OnChain]: circuits_1.AtomicQuerySigV2OnChainPubSignals,
+    [circuits_1.CircuitId.AtomicQueryV3OnChain]: circuits_1.AtomicQueryV3OnChainPubSignals,
+    [circuits_1.CircuitId.AuthV2]: circuits_1.AuthV2PubSignals
+};

package/dist/node/cjs/storage/interfaces/index.js

@@ -23,3 +23,4 @@ __exportStar(require("./data-source"), exports);
 __exportStar(require("./circuits"), exports);
 __exportStar(require("./onchain-zkp-verifier"), exports);
 __exportStar(require("./onchain-revocation"), exports);
+__exportStar(require("./onchain-issuer"), exports);

package/dist/node/cjs/storage/interfaces/onchain-issuer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/node/cjs/utils/did-helper.js

@@ -72,7 +72,7 @@ const validateDIDDocumentAuth = async (did, resolverURL, state) => {
 };
 exports.validateDIDDocumentAuth = validateDIDDocumentAuth;
 const resolveDIDDocumentAuth = async (did, resolveURL, state) => {
-    let url = `${resolveURL}/${did.string().replace(/:/g, '%3A')}`;
+    let url = `${resolveURL}/${encodeURIComponent(did.string())}`;
     if (state) {
         url += `?state=${state.hex()}`;
     }
@@ -89,11 +89,11 @@ function emptyStateDID(did) {
     return emptyDID;
 }
 const resolveDidDocument = async (did, resolverUrl, opts) => {
-    let didString = did.string().replace(/:/g, '%3A');
+    let didString = encodeURIComponent(did.string());
     // for gist resolve we have to `hide` user did (look into resolver implementation)
     const isGistRequest = opts?.gist && !opts.state;
     if (isGistRequest) {
-        didString = emptyStateDID(did).string();
+        didString = encodeURIComponent(emptyStateDID(did).string());
     }
     let url = `${resolverUrl}/1.0/identifiers/${didString}`;
     if (opts?.signature) {
@@ -105,9 +105,14 @@ const resolveDidDocument = async (did, resolverUrl, opts) => {
     if (opts?.gist) {
         url += `${url.includes('?') ? '&' : '?'}gist=${opts.gist.hex()}`;
     }
-    const resp = await fetch(url);
-    const data = await resp.json();
-    return data;
+    try {
+        const resp = await fetch(url);
+        const data = await resp.json();
+        return data;
+    }
+    catch (e) {
+        throw new Error(`Failed to resolve DID document for ${did} ${e}`);
+    }
 };
 exports.resolveDidDocument = resolveDidDocument;
 const buildDIDFromEthPubKey = (didType, pubKeyEth) => {

package/dist/node/cjs/verifiable/constants.js

@@ -149,6 +149,7 @@ var SupportedPaymentProofType;
 /**
  * Media types for Payment supported currencies
  * @beta
+ * @deprecated
  * @enum {string}
  */
 var SupportedCurrencies;
@@ -157,8 +158,7 @@ var SupportedCurrencies;
     SupportedCurrencies["ETH_WEI"] = "ETHWEI";
     SupportedCurrencies["ETH_GWEI"] = "ETHGWEI";
     SupportedCurrencies["MATIC"] = "MATIC";
-    SupportedCurrencies["USDT"] = "USDT";
-    SupportedCurrencies["USDC"] = "USDC";
+    SupportedCurrencies["POL"] = "POL";
 })(SupportedCurrencies = exports.SupportedCurrencies || (exports.SupportedCurrencies = {}));
 /**
  * Supported features for payment-request