@0xpolygonid/js-sdk 1.10.0 → 1.10.2

package/dist/browser/umd/index.js

@@ -60795,9 +60795,9 @@ var PolygonIdSdk = (function (exports) {
             };
         }
         /** {@inheritdoc IStateStorage.getGISTRootInfo} */
-        async getGISTRootInfo(id) {
+        async getGISTRootInfo(root, id) {
             const { stateContract } = this.getStateContractAndProviderForId(id);
-            const data = await stateContract.getGISTRootInfo(id);
+            const data = await stateContract.getGISTRootInfo(root);
             return {
                 root: BigInt(data.root.toString()),
                 replacedByRoot: BigInt(data.replacedByRoot.toString()),
@@ -63028,7 +63028,11 @@ var PolygonIdSdk = (function (exports) {
         // ContractInvokeRequestMessageType is type for request of contract invoke request
         CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE: IDEN3_PROTOCOL + 'proofs/1.0/contract-invoke-request',
         // CredentialOnchainOfferMessageType is type of message with credential onchain offering
-        CREDENTIAL_ONCHAIN_OFFER_MESSAGE_TYPE: IDEN3_PROTOCOL + 'credentials/1.0/onchain-offer'
+        CREDENTIAL_ONCHAIN_OFFER_MESSAGE_TYPE: IDEN3_PROTOCOL + 'credentials/1.0/onchain-offer',
+        // ProposalRequestMessageType is type for proposal-request message
+        PROPOSAL_REQUEST_MESSAGE_TYPE: IDEN3_PROTOCOL + 'credentials/0.1/proposal-request',
+        // ProposalMessageType is type for proposal message
+        PROPOSAL_MESSAGE_TYPE: IDEN3_PROTOCOL + 'credentials/0.1/proposal'
     });
     /**
      * Media types for iden3 comm communication protocol
@@ -86157,7 +86161,7 @@ var PolygonIdSdk = (function (exports) {
                 this.challenge = authV2PubSignals.challenge;
                 // no query verification
                 // verify state
-                const gist = await this.checkGlobalState(authV2PubSignals.GISTRoot);
+                const gist = await this.checkGlobalState(authV2PubSignals.GISTRoot, this.userId);
                 let acceptedStateTransitionDelay = defaultAuthVerifyOpts;
                 if (opts?.acceptedStateTransitionDelay) {
                     acceptedStateTransitionDelay = opts.acceptedStateTransitionDelay;
@@ -86239,9 +86243,8 @@ var PolygonIdSdk = (function (exports) {
                     throw userStateError;
                 }
             };
-            this.checkGlobalState = async (state) => {
-                const gistStateResolved = await this.rootResolve(state.bigInt());
-                return gistStateResolved;
+            this.checkGlobalState = async (state, id) => {
+                return this.rootResolve(state.bigInt(), id.bigInt());
             };
             this.checkRevocationStateForId = async (issuerId, issuerClaimNonRevState) => {
                 const issuerNonRevStateResolved = await this.resolve(issuerId, issuerClaimNonRevState.bigInt());
@@ -86357,10 +86360,10 @@ var PolygonIdSdk = (function (exports) {
             }
             return { latest: true, transitionTimestamp: 0 };
         }
-        async rootResolve(state) {
+        async rootResolve(state, id) {
             let globalStateInfo;
             try {
-                globalStateInfo = await this._stateStorage.getGISTRootInfo(state);
+                globalStateInfo = await this._stateStorage.getGISTRootInfo(state, id);
             }
             catch (e) {
                 if (e.errorArgs[0] === 'Root does not exist') {
@@ -86629,7 +86632,8 @@ var PolygonIdSdk = (function (exports) {
                 throw new Error(`CircuitId is not supported ${circuitId}`);
             }
             const gistRoot = V$1.fromString(pubSignals[2]).bigInt();
-            const globalStateInfo = await this._stateStorage.getGISTRootInfo(gistRoot);
+            const userId = BigInt(pubSignals[0]);
+            const globalStateInfo = await this._stateStorage.getGISTRootInfo(gistRoot, userId);
             if (globalStateInfo.createdAtTimestamp === 0n) {
                 throw new Error(`gist state doesn't exists in contract`);
             }
@@ -87894,6 +87898,185 @@ var PolygonIdSdk = (function (exports) {
         }
     }
 
+    /**
+     * @beta
+     * createProposalRequest is a function to create protocol proposal-request protocol message
+     * @param {DID} sender - sender did
+     * @param {DID} receiver - receiver did
+     * @param {ProposalRequestCreationOptions} opts - creation options
+     * @returns `Promise<ProposalRequestMessage>`
+     */
+    function createProposalRequest(sender, receiver, opts) {
+        const uuidv4 = v4();
+        const request = {
+            id: uuidv4,
+            thid: uuidv4,
+            from: sender.string(),
+            to: receiver.string(),
+            typ: MediaType.PlainMessage,
+            type: PROTOCOL_MESSAGE_TYPE.PROPOSAL_REQUEST_MESSAGE_TYPE,
+            body: opts
+        };
+        return request;
+    }
+    /**
+     * @beta
+     * createProposal is a function to create protocol proposal protocol message
+     * @param {DID} sender - sender did
+     * @param {DID} receiver - receiver did
+     * @param {Proposal[]} proposals - proposals
+     * @returns `Promise<ProposalRequestMessage>`
+     */
+    function createProposal(sender, receiver, proposals) {
+        const uuidv4 = v4();
+        const request = {
+            id: uuidv4,
+            thid: uuidv4,
+            from: sender.string(),
+            to: receiver.string(),
+            typ: MediaType.PlainMessage,
+            type: PROTOCOL_MESSAGE_TYPE.PROPOSAL_MESSAGE_TYPE,
+            body: {
+                proposals: proposals || []
+            }
+        };
+        return request;
+    }
+    /**
+     *
+     * Allows to process ProposalRequest protocol message
+     * @beta
+     * @class CredentialProposalHandler
+     * @implements implements ICredentialProposalHandler interface
+     */
+    class CredentialProposalHandler {
+        /**
+         * @beta Creates an instance of CredentialProposalHandler.
+         * @param {IPackageManager} _packerMgr - package manager to unpack message envelope
+         * @param {IIdentityWallet} _identityWallet - identity wallet
+         * @param {CredentialProposalHandlerParams} _params - credential proposal handler params
+         *
+         */
+        constructor(_packerMgr, _identityWallet, _params) {
+            this._packerMgr = _packerMgr;
+            this._identityWallet = _identityWallet;
+            this._params = _params;
+        }
+        /**
+         * @inheritdoc ICredentialProposalHandler#parseProposalRequest
+         */
+        async parseProposalRequest(request) {
+            const { unpackedMessage: message } = await this._packerMgr.unpack(request);
+            const proposalRequest = message;
+            if (message.type !== PROTOCOL_MESSAGE_TYPE.PROPOSAL_REQUEST_MESSAGE_TYPE) {
+                throw new Error('Invalid media type');
+            }
+            return proposalRequest;
+        }
+        /**
+         * @inheritdoc ICredentialProposalHandler#handleProposalRequest
+         */
+        async handleProposalRequest(request, 
+        //eslint-disable-next-line @typescript-eslint/no-unused-vars
+        opts) {
+            if (this._params.packerParams.mediaType === MediaType.SignedMessage &&
+                !this._params.packerParams.packerOptions) {
+                throw new Error(`jws packer options are required for ${MediaType.SignedMessage}`);
+            }
+            const proposalRequest = await this.parseProposalRequest(request);
+            if (!proposalRequest.to) {
+                throw new Error(`failed request. empty 'to' field`);
+            }
+            if (!proposalRequest.from) {
+                throw new Error(`failed request. empty 'from' field`);
+            }
+            if (!proposalRequest.body?.credentials?.length) {
+                throw new Error(`failed request. no 'credentials' in body`);
+            }
+            const senderDID = Z$2.parse(proposalRequest.from);
+            let credOfferMessage = undefined;
+            let proposalMessage = undefined;
+            for (let i = 0; i < proposalRequest.body.credentials.length; i++) {
+                const cred = proposalRequest.body.credentials[i];
+                // check if there is credentials in the wallet
+                let credsFromWallet = [];
+                try {
+                    credsFromWallet = await this._identityWallet.findOwnedCredentialsByDID(senderDID, {
+                        type: cred.type,
+                        context: cred.context
+                    });
+                }
+                catch (e) {
+                    if (e.message !== 'no credential satisfied query') {
+                        throw e;
+                    }
+                }
+                if (credsFromWallet.length) {
+                    const guid = v4();
+                    if (!credOfferMessage) {
+                        credOfferMessage = {
+                            id: guid,
+                            typ: this._params.packerParams.mediaType,
+                            type: PROTOCOL_MESSAGE_TYPE.CREDENTIAL_OFFER_MESSAGE_TYPE,
+                            thid: proposalRequest.thid ?? guid,
+                            body: {
+                                url: this._params.agentUrl,
+                                credentials: []
+                            },
+                            from: proposalRequest.to,
+                            to: proposalRequest.from
+                        };
+                    }
+                    credOfferMessage.body.credentials.push(...credsFromWallet.map((c) => ({
+                        id: c.id,
+                        description: ''
+                    })));
+                    continue;
+                }
+                // credential not found in the wallet, prepare proposal protocol message
+                const proposal = await this._params.proposalResolverFn(cred.context, cred.type);
+                if (!proposal) {
+                    throw new Error(`can't resolve Proposal for type: ${cred.type}, context: ${cred.context}`);
+                }
+                if (!proposalMessage) {
+                    const guid = v4();
+                    proposalMessage = {
+                        id: guid,
+                        typ: this._params.packerParams.mediaType,
+                        type: PROTOCOL_MESSAGE_TYPE.PROPOSAL_MESSAGE_TYPE,
+                        thid: proposalRequest.thid ?? guid,
+                        body: {
+                            proposals: []
+                        },
+                        from: proposalRequest.to,
+                        to: proposalRequest.from
+                    };
+                }
+                proposalMessage.body?.proposals.push(proposal);
+            }
+            // if there is credentials in the wallet, return offer protocol message, otherwise proposal
+            const response = byteEncoder.encode(JSON.stringify(proposalMessage ?? credOfferMessage));
+            const packerOpts = this._params.packerParams.mediaType === MediaType.SignedMessage
+                ? this._params.packerParams.packerOptions
+                : {
+                    provingMethodAlg: T.provingMethodGroth16AuthV2Instance.methodAlg
+                };
+            return this._packerMgr.pack(this._params.packerParams.mediaType, response, {
+                senderDID,
+                ...packerOpts
+            });
+        }
+        /**
+         * @inheritdoc ICredentialProposalHandler#handleProposal
+         */
+        async handleProposal(proposal, opts) {
+            if (opts?.proposalRequest && opts.proposalRequest.from !== proposal.to) {
+                throw new Error(`sender of the request is not a target of response - expected ${opts.proposalRequest.from}, given ${proposal.to}`);
+            }
+            return { proposal };
+        }
+    }
+
     exports.AbstractPrivateKeyStore = AbstractPrivateKeyStore;
     exports.AgentResolver = AgentResolver;
     exports.AtomicQueryMTPV2Inputs = AtomicQueryMTPV2Inputs;
@@ -87919,6 +88102,7 @@ var PolygonIdSdk = (function (exports) {
     exports.CircuitClaim = CircuitClaim;
     exports.CircuitStorage = CircuitStorage;
     exports.ContractRequestHandler = ContractRequestHandler;
+    exports.CredentialProposalHandler = CredentialProposalHandler;
     exports.CredentialStatusPublisherRegistry = CredentialStatusPublisherRegistry;
     exports.CredentialStatusResolverRegistry = CredentialStatusResolverRegistry;
     exports.CredentialStorage = CredentialStorage;
@@ -88018,6 +88202,8 @@ var PolygonIdSdk = (function (exports) {
     exports.core = index$1;
     exports.createAuthorizationRequest = createAuthorizationRequest;
     exports.createAuthorizationRequestWithMessage = createAuthorizationRequestWithMessage;
+    exports.createProposal = createProposal;
+    exports.createProposalRequest = createProposalRequest;
     exports.createSchemaHash = createSchemaHash;
     exports.createVerifiablePresentation = createVerifiablePresentation;
     exports.credentialSubjectKey = credentialSubjectKey;