@0xpolygonid/js-sdk 1.17.7 → 1.18.0

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

@@ -1,6 +1,25 @@
-import { JsonRpcProvider, Contract } from 'ethers';
+import { JsonRpcProvider, Contract, ethers } from 'ethers';
 import abi from './abi/ZkpVerifier.json';
 import { TransactionService } from '../../blockchain';
+import { DID } from '@iden3/js-iden3-core';
+import { AtomicQueryMTPV2OnChainPubSignals, AtomicQuerySigV2OnChainPubSignals, AtomicQueryV3OnChainPubSignals, CircuitId } from '../../circuits';
+import { byteEncoder, DIDDocumentSignature, resolveDidDocument } from '../../utils';
+import { poseidon } from '@iden3/js-crypto';
+const maxGasLimit = 10000000n;
+/**
+ * Supported function signature for SubmitZKPResponse
+ */
+export var FunctionSignatures;
+(function (FunctionSignatures) {
+    /**
+     * solidity identifier for function signature:
+     * function submitZKPResponse(uint64 requestId, uint256[] calldata inputs,
+     * uint256[2] calldata a, uint256[2][2] calldata b, uint256[2] calldata c) public
+     */
+    FunctionSignatures["SumbitZKPResponseV1"] = "b68967e2";
+    //function submitZKPResponseV2(tuple[](uint64 requestId,bytes zkProof,bytes data),bytes crossChainProof)
+    FunctionSignatures["SumbitZKPResponseV2"] = "ade09fcd";
+})(FunctionSignatures || (FunctionSignatures = {}));
 /**
  * OnChainZKPVerifier is a class that allows to interact with the OnChainZKPVerifier contract
  * and submitZKPResponse.
@@ -15,69 +34,301 @@ export class OnChainZKPVerifier {
      * @beta
      * @param {EthConnectionConfig[]} - array of ETH configs
      */
-    constructor(_configs) {
+    constructor(_configs, _opts) {
         this._configs = _configs;
+        this._opts = _opts;
+        /**
+         * supported circuits
+         */
+        this._supportedCircuits = [
+            CircuitId.AtomicQueryMTPV2OnChain,
+            CircuitId.AtomicQuerySigV2OnChain,
+            CircuitId.AtomicQueryV3OnChain
+        ];
         /**
-         * solidity identifier for function signature:
-         * function submitZKPResponse(uint64 requestId, uint256[] calldata inputs,
-         * uint256[2] calldata a, uint256[2][2] calldata b, uint256[2] calldata c) public
+         * abi coder to encode/decode structures to solidity bytes
          */
-        this._supportedMethodId = 'b68967e2';
+        this._abiCoder = new ethers.AbiCoder();
     }
     /**
-     * Submit ZKP Responses to OnChainZKPVerifier contract.
-     * @beta
-     * @param {Signer} ethSigner - tx signer
-     * @param {txData} ContractInvokeTransactionData - transaction data
-     * @param {ZeroKnowledgeProofResponse[]} zkProofResponses - zkProofResponses
-     * @returns {Promise<Map<string, ZeroKnowledgeProofResponse>>} - map of transaction hash - ZeroKnowledgeProofResponse
+     * {@inheritDoc IOnChainZKPVerifier.prepareTxArgsSubmitV1}
+     */
+    async prepareTxArgsSubmitV1(txData, zkProofResponse) {
+        if (txData.method_id.replace('0x', '') !== FunctionSignatures.SumbitZKPResponseV1) {
+            throw new Error(`prepareTxArgsSubmitV1 function doesn't implement requested method id. Only '0x${FunctionSignatures.SumbitZKPResponseV1}' is supported.`);
+        }
+        const requestID = zkProofResponse.id;
+        const inputs = zkProofResponse.pub_signals;
+        const payload = [
+            requestID,
+            inputs,
+            zkProofResponse.proof.pi_a.slice(0, 2),
+            [
+                [zkProofResponse.proof.pi_b[0][1], zkProofResponse.proof.pi_b[0][0]],
+                [zkProofResponse.proof.pi_b[1][1], zkProofResponse.proof.pi_b[1][0]]
+            ],
+            zkProofResponse.proof.pi_c.slice(0, 2)
+        ];
+        return payload;
+    }
+    /**
+     * {@inheritDoc IOnChainZKPVerifier.submitZKPResponse}
      */
     async submitZKPResponse(ethSigner, txData, zkProofResponses) {
         const chainConfig = this._configs.find((i) => i.chainId == txData.chain_id);
         if (!chainConfig) {
             throw new Error(`config for chain id ${txData.chain_id} was not found`);
         }
-        if (txData.method_id.replace('0x', '') !== this._supportedMethodId) {
-            throw new Error(`submit doesn't implement requested method id. Only '0x${this._supportedMethodId}' is supported.`);
+        if (txData.method_id.replace('0x', '') !== FunctionSignatures.SumbitZKPResponseV1) {
+            throw new Error(`submitZKPResponse function doesn't implement requested method id. Only '0x${FunctionSignatures.SumbitZKPResponseV1}' is supported.`);
         }
         const provider = new JsonRpcProvider(chainConfig.url, chainConfig.chainId);
-        const verifierContract = new Contract(txData.contract_address, abi, provider);
         ethSigner = ethSigner.connect(provider);
-        const contract = verifierContract.connect(ethSigner);
         const response = new Map();
-        for (const zkProof of zkProofResponses) {
-            const requestID = zkProof.id;
-            const inputs = zkProof.pub_signals;
-            const payload = [
-                requestID,
-                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 feeData = await provider.getFeeData();
-            const maxFeePerGas = chainConfig.maxFeePerGas
-                ? BigInt(chainConfig.maxFeePerGas)
-                : feeData.maxFeePerGas;
-            const maxPriorityFeePerGas = chainConfig.maxPriorityFeePerGas
-                ? BigInt(chainConfig.maxPriorityFeePerGas)
-                : feeData.maxPriorityFeePerGas;
-            const gasLimit = await contract.submitZKPResponse.estimateGas(...payload);
-            const txData = await contract.submitZKPResponse.populateTransaction(...payload);
+        const feeData = await provider.getFeeData();
+        const maxFeePerGas = chainConfig.maxFeePerGas
+            ? BigInt(chainConfig.maxFeePerGas)
+            : feeData.maxFeePerGas;
+        const maxPriorityFeePerGas = chainConfig.maxPriorityFeePerGas
+            ? BigInt(chainConfig.maxPriorityFeePerGas)
+            : feeData.maxPriorityFeePerGas;
+        const verifierContract = new Contract(txData.contract_address, abi);
+        for (const zkProofResponse of zkProofResponses) {
+            const txArgs = await this.prepareTxArgsSubmitV1(txData, zkProofResponse);
+            const payload = await verifierContract.submitZKPResponse.populateTransaction(...txArgs);
             const request = {
-                to: txData.to,
-                data: txData.data,
-                gasLimit,
+                to: txData.contract_address,
+                data: payload.data,
                 maxFeePerGas,
                 maxPriorityFeePerGas
             };
+            let gasLimit;
+            try {
+                gasLimit = await ethSigner.estimateGas(request);
+            }
+            catch (e) {
+                gasLimit = maxGasLimit;
+            }
+            request.gasLimit = gasLimit;
             const transactionService = new TransactionService(provider);
             const { txnHash } = await transactionService.sendTransactionRequest(ethSigner, request);
-            response.set(txnHash, zkProof);
+            response.set(txnHash, zkProofResponse);
         }
         return response;
     }
+    /**
+     * {@inheritDoc IOnChainZKPVerifier.submitZKPResponseV2}
+     */
+    async submitZKPResponseV2(ethSigner, txData, zkProofResponses) {
+        const chainConfig = this._configs.find((i) => i.chainId == txData.chain_id);
+        if (!chainConfig) {
+            throw new Error(`config for chain id ${txData.chain_id} was not found`);
+        }
+        if (txData.method_id.replace('0x', '') !== FunctionSignatures.SumbitZKPResponseV2) {
+            throw new Error(`submitZKPResponseV2 function doesn't implement requested method id. Only '0x${FunctionSignatures.SumbitZKPResponseV2}' is supported.`);
+        }
+        if (!this._opts?.didResolverUrl) {
+            throw new Error(`did resolver url required for crosschain verification`);
+        }
+        const provider = new JsonRpcProvider(chainConfig.url, chainConfig.chainId);
+        ethSigner = ethSigner.connect(provider);
+        const txDataArgs = await this.prepareTxArgsSubmitV2(txData, zkProofResponses);
+        const feeData = await provider.getFeeData();
+        const maxFeePerGas = chainConfig.maxFeePerGas
+            ? BigInt(chainConfig.maxFeePerGas)
+            : feeData.maxFeePerGas;
+        const maxPriorityFeePerGas = chainConfig.maxPriorityFeePerGas
+            ? BigInt(chainConfig.maxPriorityFeePerGas)
+            : feeData.maxPriorityFeePerGas;
+        const verifierContract = new Contract(txData.contract_address, abi);
+        const txRequestData = await verifierContract.submitZKPResponseV2.populateTransaction(...txDataArgs);
+        const request = {
+            to: txData.contract_address,
+            data: txRequestData.data,
+            maxFeePerGas,
+            maxPriorityFeePerGas
+        };
+        let gasLimit;
+        try {
+            gasLimit = await ethSigner.estimateGas(request);
+        }
+        catch (e) {
+            gasLimit = maxGasLimit;
+        }
+        request.gasLimit = gasLimit;
+        const transactionService = new TransactionService(provider);
+        const { txnHash } = await transactionService.sendTransactionRequest(ethSigner, request);
+        return new Map().set(txnHash, zkProofResponses);
+    }
+    async prepareTxArgsSubmitV2(txData, zkProofResponses) {
+        if (txData.method_id.replace('0x', '') !== FunctionSignatures.SumbitZKPResponseV2) {
+            throw new Error(`submit cross chain doesn't implement requested method id. Only '0x${FunctionSignatures.SumbitZKPResponseV2}' is supported.`);
+        }
+        if (!this._opts?.didResolverUrl) {
+            throw new Error(`did resolver url required for crosschain verification`);
+        }
+        const gistUpdateArr = [];
+        const stateUpdateArr = [];
+        const payload = [];
+        // Resolved gists and states to avoid duplicate requests
+        const gistUpdateResolutionsPending = [];
+        const stateUpdateResolutionsPending = [];
+        for (const zkProof of zkProofResponses) {
+            const requestID = zkProof.id;
+            const inputs = zkProof.pub_signals;
+            if (!this._supportedCircuits.includes(zkProof.circuitId)) {
+                throw new Error(`Circuit ${zkProof.circuitId} not supported by OnChainZKPVerifier`);
+            }
+            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(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(DID.parseFromId(state.id), this._opts.didResolverUrl, {
+                    state: state.state
+                }));
+            }
+            if (gistUpdateResolutions.length > 0) {
+                gistUpdateArr.push(...(await Promise.all(gistUpdateResolutions)));
+            }
+            if (stateUpdateResolutions.length > 0) {
+                stateUpdateArr.push(...(await Promise.all(stateUpdateResolutions)));
+            }
+            const metadataArr = [];
+            if (zkProof.vp) {
+                for (const key in zkProof.vp.verifiableCredential.credentialSubject) {
+                    if (key === '@type') {
+                        continue;
+                    }
+                    const metadataValue = poseidon.hashBytes(byteEncoder.encode(JSON.stringify(zkProof.vp.verifiableCredential.credentialSubject[key])));
+                    const bytesValue = byteEncoder.encode(metadataValue.toString());
+                    metadataArr.push({
+                        key,
+                        value: bytesValue
+                    });
+                }
+            }
+            const metadata = this.packMetadatas(metadataArr);
+            payload.push({
+                requestId: requestID,
+                zkProof: zkProofEncoded,
+                data: metadata
+            });
+        }
+        const crossChainProofs = this.packCrossChainProofs(gistUpdateArr, stateUpdateArr);
+        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]);
+    }
+    packCrossChainProofs(gistUpdateArr, stateUpdateArr) {
+        const proofs = [];
+        for (const globalStateUpdate of gistUpdateArr) {
+            proofs.push({
+                proofType: 'globalStateProof',
+                proof: this.packGlobalStateMsg(globalStateUpdate)
+            });
+        }
+        for (const stateUpdate of stateUpdateArr) {
+            proofs.push({
+                proofType: 'stateProof',
+                proof: this.packIdentityStateMsg(stateUpdate)
+            });
+        }
+        return this._abiCoder.encode(['tuple(' + 'string proofType,' + 'bytes proof' + ')[]'], [proofs]);
+    }
+    packGlobalStateMsg(msg) {
+        return this._abiCoder.encode([
+            'tuple(' +
+                'tuple(' +
+                'uint256 timestamp,' +
+                'bytes2 idType,' +
+                'uint256 root,' +
+                'uint256 replacedAtTimestamp' +
+                ') globalStateMsg,' +
+                'bytes signature,' +
+                ')'
+        ], [msg]);
+    }
+    packIdentityStateMsg(msg) {
+        return this._abiCoder.encode([
+            'tuple(' +
+                'tuple(' +
+                'uint256 timestamp,' +
+                'uint256 id,' +
+                'uint256 state,' +
+                'uint256 replacedAtTimestamp' +
+                ') idStateMsg,' +
+                'bytes signature,' +
+                ')'
+        ], [msg]);
+    }
+    packMetadatas(metas) {
+        return this._abiCoder.encode(['tuple(' + 'string key,' + 'bytes value' + ')[]'], [metas]);
+    }
+    getOnChainGistRootStatePubSignals(onChainCircuitId, inputs) {
+        let atomicQueryPubSignals;
+        switch (onChainCircuitId) {
+            case CircuitId.AtomicQueryMTPV2OnChain:
+                atomicQueryPubSignals = new AtomicQueryMTPV2OnChainPubSignals();
+                break;
+            case CircuitId.AtomicQuerySigV2OnChain:
+                atomicQueryPubSignals = new AtomicQuerySigV2OnChainPubSignals();
+                break;
+            case CircuitId.AtomicQueryV3OnChain:
+                atomicQueryPubSignals = new AtomicQueryV3OnChainPubSignals();
+                break;
+        }
+        const encodedInputs = byteEncoder.encode(JSON.stringify(inputs));
+        atomicQueryPubSignals.pubSignalsUnmarshal(encodedInputs);
+        return atomicQueryPubSignals.getStatesInfo();
+    }
+    async resolveDidDocumentEip712MessageAndSignature(did, resolverUrl, opts) {
+        const didDoc = await resolveDidDocument(did, resolverUrl, {
+            ...opts,
+            signature: DIDDocumentSignature.EthereumEip712Signature2021
+        });
+        if (!didDoc.didResolutionMetadata.proof?.length) {
+            throw new Error('No proof found in resolved DID document');
+        }
+        const message = didDoc.didResolutionMetadata.proof[0].eip712.message;
+        const signature = didDoc.didResolutionMetadata.proof[0].proofValue;
+        const isGistRequest = opts?.gist && !opts.state;
+        if (isGistRequest) {
+            return {
+                globalStateMsg: {
+                    timestamp: message.timestamp,
+                    idType: message.idType,
+                    root: message.root,
+                    replacedAtTimestamp: message.replacedAtTimestamp
+                },
+                signature
+            };
+        }
+        return {
+            idStateMsg: {
+                timestamp: message.timestamp,
+                id: message.id,
+                state: message.state,
+                replacedAtTimestamp: message.replacedAtTimestamp
+            },
+            signature
+        };
+    }
 }

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

@@ -3,6 +3,13 @@ import { Id, buildDIDType, genesisFromEthAddress, DID } from '@iden3/js-iden3-co
 import { Hash } from '@iden3/js-merkletree';
 import { keccak256 } from 'js-sha3';
 import { hexToBytes } from './encoding';
+/**
+ * Supported DID Document Signatures
+ */
+export var DIDDocumentSignature;
+(function (DIDDocumentSignature) {
+    DIDDocumentSignature["EthereumEip712Signature2021"] = "EthereumEip712Signature2021";
+})(DIDDocumentSignature || (DIDDocumentSignature = {}));
 /**
  * Checks if state is genesis state
  *
@@ -66,6 +73,34 @@ export const resolveDIDDocumentAuth = async (did, resolveURL, state) => {
     const didResolutionRes = (await resp.json());
     return didResolutionRes.didDocument?.verificationMethod?.find((i) => i.type === 'Iden3StateInfo2023');
 };
+function emptyStateDID(did) {
+    const id = DID.idFromDID(did);
+    const didType = buildDIDType(DID.methodFromId(id), DID.blockchainFromId(id), DID.networkIdFromId(id));
+    const identifier = Id.idGenesisFromIdenState(didType, 0n);
+    const emptyDID = DID.parseFromId(identifier);
+    return emptyDID;
+}
+export const resolveDidDocument = async (did, resolverUrl, opts) => {
+    let didString = did.string().replace(/:/g, '%3A');
+    // 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();
+    }
+    let url = `${resolverUrl}/1.0/identifiers/${didString}`;
+    if (opts?.signature) {
+        url += `?signature=${opts.signature}`;
+    }
+    if (opts?.state) {
+        url += `${url.includes('?') ? '&' : '?'}state=${opts.state.hex()}`;
+    }
+    if (opts?.gist) {
+        url += `${url.includes('?') ? '&' : '?'}gist=${opts.gist.hex()}`;
+    }
+    const resp = await fetch(url);
+    const data = await resp.json();
+    return data;
+};
 export const buildDIDFromEthPubKey = (didType, pubKeyEth) => {
     // Use Keccak-256 hash function to get public key hash
     const hashOfPublicKey = keccak256(hexToBytes(pubKeyEth));

package/dist/node/esm/verifiable/credential.js

@@ -50,7 +50,7 @@ export class W3CCredential {
     }
     static fromJSON(obj) {
         const w = new W3CCredential();
-        Object.assign(w, obj);
+        Object.assign(w, structuredClone(obj));
         w.proof = Array.isArray(w.proof)
             ? w.proof.map(W3CCredential.proofFromJSON)
             : W3CCredential.proofFromJSON(w.proof);

package/dist/types/circuits/atomic-query-mtp-v2-on-chain.d.ts

@@ -2,7 +2,7 @@ import { Id, Claim } from '@iden3/js-iden3-core';
 import { Signature } from '@iden3/js-crypto';
 import { Query, TreeState, GISTProof, ClaimWithMTPProof } from './models';
 import { Hash, Proof } from '@iden3/js-merkletree';
-import { BaseConfig } from './common';
+import { BaseConfig, IStateInfoPubSignals, StatesInfo } from './common';
 /**
  * AtomicQueryMTPV2OnChainInputs ZK private inputs for credentialAtomicQueryMTPV2OnChain.circom
  *
@@ -45,7 +45,7 @@ export declare class AtomicQueryMTPV2OnChainInputs extends BaseConfig {
  * @class AtomicQueryMTPV2OnChainPubSignals
  * @extends {BaseConfig}
  */
-export declare class AtomicQueryMTPV2OnChainPubSignals extends BaseConfig {
+export declare class AtomicQueryMTPV2OnChainPubSignals extends BaseConfig implements IStateInfoPubSignals {
     requestID: bigint;
     userID: Id;
     issuerID: Id;
@@ -64,4 +64,6 @@ export declare class AtomicQueryMTPV2OnChainPubSignals extends BaseConfig {
      * @returns AtomicQuerySigV2PubSignals
      */
     pubSignalsUnmarshal(data: Uint8Array): AtomicQueryMTPV2OnChainPubSignals;
+    /** {@inheritDoc IStateInfoPubSignals.getStatesInfo} */
+    getStatesInfo(): StatesInfo;
 }

package/dist/types/circuits/atomic-query-sig-v2-on-chain.d.ts

@@ -2,7 +2,7 @@ import { Id, Claim } from '@iden3/js-iden3-core';
 import { Signature } from '@iden3/js-crypto';
 import { Query, ClaimWithSigProof, TreeState, GISTProof } from './models';
 import { Hash, Proof } from '@iden3/js-merkletree';
-import { BaseConfig } from './common';
+import { BaseConfig, IStateInfoPubSignals, StatesInfo } from './common';
 /**
  * AtomicQuerySigV2OnChainInputs ZK private inputs for credentialAtomicQuerySig.circom
  *
@@ -112,7 +112,7 @@ export declare class AtomicQuerySigV2OnChainCircuitInputs {
  * @class AtomicQuerySigV2OnChainPubSignals
  * @extends {BaseConfig}
  */
-export declare class AtomicQuerySigV2OnChainPubSignals extends BaseConfig {
+export declare class AtomicQuerySigV2OnChainPubSignals extends BaseConfig implements IStateInfoPubSignals {
     requestID: bigint;
     userID: Id;
     issuerID: Id;
@@ -131,4 +131,6 @@ export declare class AtomicQuerySigV2OnChainPubSignals extends BaseConfig {
      * @returns AtomicQuerySigV2PubSignals
      */
     pubSignalsUnmarshal(data: Uint8Array): AtomicQuerySigV2OnChainPubSignals;
+    /** {@inheritDoc IStateInfoPubSignals.getStatesInfo} */
+    getStatesInfo(): StatesInfo;
 }

package/dist/types/circuits/atomic-query-v3-on-chain.d.ts

@@ -1,5 +1,5 @@
 import { Claim, Id } from '@iden3/js-iden3-core';
-import { BaseConfig } from './common';
+import { BaseConfig, IStateInfoPubSignals, StatesInfo } from './common';
 import { GISTProof, Query, TreeState } from './models';
 import { Hash, Proof } from '@iden3/js-merkletree';
 import { ClaimWithSigAndMTPProof } from './atomic-query-v3';
@@ -118,7 +118,7 @@ interface AtomicQueryV3OnChainCircuitInputs {
  * @beta
  * AtomicQueryV3OnChainPubSignals public inputs
  */
-export declare class AtomicQueryV3OnChainPubSignals extends BaseConfig {
+export declare class AtomicQueryV3OnChainPubSignals extends BaseConfig implements IStateInfoPubSignals {
     requestID: bigint;
     userID: Id;
     issuerID: Id;
@@ -134,5 +134,7 @@ export declare class AtomicQueryV3OnChainPubSignals extends BaseConfig {
     operatorOutput: bigint;
     isBJJAuthEnabled: number;
     pubSignalsUnmarshal(data: Uint8Array): AtomicQueryV3OnChainPubSignals;
+    /** {@inheritDoc IStateInfoPubSignals.getStatesInfo} */
+    getStatesInfo(): StatesInfo;
 }
 export {};

package/dist/types/circuits/common.d.ts

@@ -1,5 +1,6 @@
 import { Hash, Proof } from '@iden3/js-merkletree';
 import { TreeState } from './models';
+import { Id } from '@iden3/js-iden3-core';
 export declare const defaultMTLevels = 40;
 export declare const defaultValueArraySize = 64;
 export declare const defaultMTLevelsOnChain = 64;
@@ -119,3 +120,33 @@ export declare const existenceToInt: (b: boolean) => number;
  * @returns object
  */
 export declare function getProperties(obj: object): object;
+/**
+ * states info from pub signals
+ *
+ * @public
+ * @type   StatesInfo
+ */
+export type StatesInfo = {
+    states: {
+        id: Id;
+        state: Hash;
+    }[];
+    gists: {
+        id: Id;
+        root: Hash;
+    }[];
+};
+/**
+ * state pub signals
+ *
+ * @public
+ * @interface   IStatePubSignals
+ */
+export interface IStateInfoPubSignals {
+    /**
+     * return object with state params
+     *
+     * @returns {OnChainStateInfo}
+     */
+    getStatesInfo(): StatesInfo;
+}

package/dist/types/iden3comm/constants.d.ts

@@ -16,6 +16,7 @@ export declare const PROTOCOL_MESSAGE_TYPE: Readonly<{
     REVOCATION_STATUS_REQUEST_MESSAGE_TYPE: "https://iden3-communication.io/revocation/1.0/request-status";
     REVOCATION_STATUS_RESPONSE_MESSAGE_TYPE: "https://iden3-communication.io/revocation/1.0/status";
     CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE: "https://iden3-communication.io/proofs/1.0/contract-invoke-request";
+    CONTRACT_INVOKE_RESPONSE_MESSAGE_TYPE: "https://iden3-communication.io/proofs/1.0/contract-invoke-response";
     CREDENTIAL_ONCHAIN_OFFER_MESSAGE_TYPE: "https://iden3-communication.io/credentials/1.0/onchain-offer";
     PROPOSAL_REQUEST_MESSAGE_TYPE: "https://iden3-communication.io/credentials/0.1/proposal-request";
     PROPOSAL_MESSAGE_TYPE: "https://iden3-communication.io/credentials/0.1/proposal";

package/dist/types/iden3comm/handlers/contract-request.d.ts

@@ -13,14 +13,14 @@ import { AbstractMessageHandler, IProtocolMessageHandler } from './message-handl
  */
 export interface IContractRequestHandler {
     /**
-     * unpacks contract invoker request
+     * unpacks contract invoke request
      * @beta
      * @param {Uint8Array} request - raw byte message
      * @returns `Promise<ContractInvokeRequest>`
      */
     parseContractInvokeRequest(request: Uint8Array): Promise<ContractInvokeRequest>;
     /**
-     * handle contract invoker request
+     * handle contract invoke request
      * @beta
      * @param {did} did  - sender DID
      * @param {Uint8Array} request - raw byte message
@@ -71,8 +71,19 @@ export declare class ContractRequestHandler extends AbstractMessageHandler imple
      */
     parseContractInvokeRequest(request: Uint8Array): Promise<ContractInvokeRequest>;
     /**
-     * handle contract invoker request
+     * creates contract invoke response
+     * @private
      * @beta
+     * @param {ContractInvokeRequest} request - ContractInvokeRequest
+     * @param { Map<string, ZeroKnowledgeProofResponse[]>} responses - map tx hash to array of ZeroKnowledgeProofResponses
+     * @returns `Promise<ContractInvokeResponse>`
+     */
+    private createContractInvokeResponse;
+    /**
+     * handle contract invoke request
+     * supports only 0xb68967e2 method id
+     * @beta
+     * @deprecated
      * @param {did} did  - sender DID
      * @param {ContractInvokeRequest} request  - contract invoke request
      * @param {ContractInvokeHandlerOptions} opts - handler options

package/dist/types/iden3comm/types/protocol/auth.d.ts

@@ -42,5 +42,15 @@ export type ZeroKnowledgeProofRequest = {
 export type ZeroKnowledgeProofResponse = {
     id: number;
     circuitId: string;
-    vp?: object;
+    vp?: VerifiablePresentation;
 } & ZKProof;
+/** VerifiablePresentation represents structure of Verifiable Presentation */
+export type VerifiablePresentation = {
+    '@context': string | (string | object)[];
+    '@type': string;
+    verifiableCredential: {
+        '@context': string | string[];
+        '@type': string | string[];
+        credentialSubject: JsonDocumentObject;
+    };
+};

package/dist/types/iden3comm/types/protocol/contract-request.d.ts

@@ -1,6 +1,6 @@
 import { PROTOCOL_MESSAGE_TYPE } from '../../constants';
 import { BasicMessage } from '../packer';
-import { ZeroKnowledgeProofRequest } from './auth';
+import { ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse } from './auth';
 /** ContractInvokeRequest represents structure of contract invoke request object */
 export type ContractInvokeRequest = BasicMessage & {
     body: ContractInvokeRequestBody;
@@ -12,6 +12,21 @@ export type ContractInvokeRequestBody = {
     transaction_data: ContractInvokeTransactionData;
     scope: Array<ZeroKnowledgeProofRequest>;
 };
+/** ContractInvokeResponse represents structure of contract invoke response object */
+export type ContractInvokeResponse = BasicMessage & {
+    body: ContractInvokeResponseBody;
+    type: typeof PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_RESPONSE_MESSAGE_TYPE;
+};
+/** ContractInvokeResponseBody represents structure of contract invoke response body object */
+export type ContractInvokeResponseBody = {
+    scope: Array<OnChainZeroKnowledgeProofResponse>;
+    transaction_data: ContractInvokeTransactionData;
+    reason: string;
+};
+/** OnChainZeroKnowledgeProofResponse represents structure of onchain zero knowledge proof response */
+export type OnChainZeroKnowledgeProofResponse = ZeroKnowledgeProofResponse & {
+    txHash: string;
+};
 /** ContractInvokeTransactionData represents structure of contract invoke transaction data object */
 export type ContractInvokeTransactionData = {
     contract_address: string;

package/dist/types/proof/verifiers/pub-signals-verifier.d.ts

@@ -4,7 +4,7 @@ import { IStateStorage } from '../../storage';
 import { ProofQuery } from '../../verifiable';
 import { BaseConfig } from '../../circuits/common';
 import { VerifyOpts } from './query';
-import { JSONObject } from '../../iden3comm';
+import { JSONObject, VerifiablePresentation } from '../../iden3comm';
 /**
  *  Verify Context - params for pub signal verification
  * @type VerifyContext
@@ -12,7 +12,7 @@ import { JSONObject } from '../../iden3comm';
 export type VerifyContext = {
     pubSignals: string[];
     query: ProofQuery;
-    verifiablePresentation?: JSON;
+    verifiablePresentation?: VerifiablePresentation;
     sender: string;
     challenge: bigint;
     opts?: VerifyOpts;