@0xpolygonid/js-sdk 1.10.0 → 1.10.1

package/dist/browser/umd/index.js

@@ -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
@@ -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;