@0xpolygonid/js-sdk 1.0.0-beta.0

package/dist/types/iden3comm/packers/zkp.d.ts

@@ -0,0 +1,86 @@
+import { AuthDataPrepareFunc, BasicMessage, IPacker, ProvingParams, StateVerificationFunc, VerificationParams, ZKPPackerParams } from '../types';
+import { CircuitId } from '../../circuits/index';
+import { DID } from '@iden3/js-iden3-core';
+import { MediaType } from '../constants';
+/**
+ * Handler to
+ *
+ * @export
+ * @beta
+ * @class DataPrepareHandlerFunc
+ */
+export declare class DataPrepareHandlerFunc {
+    readonly dataPrepareFunc: AuthDataPrepareFunc;
+    /**
+     * Creates an instance of DataPrepareHandlerFunc.
+     * @param {AuthDataPrepareFunc} dataPrepareFunc - function that produces marshaled inputs for auth circuits
+     */
+    constructor(dataPrepareFunc: AuthDataPrepareFunc);
+    /**
+     *
+     *
+     * @param {Uint8Array} hash - challenge that will be signed
+     * @param {DID} did - did of identity that will prepare inputs
+     * @param {Number} profileNonce - nonce for profile (genesis id must be 0)
+     * @param {CircuitId} circuitId - circuit id
+     * @returns `Promise<Uint8Array>`
+     */
+    prepare(hash: Uint8Array, did: DID, profileNonce: number, circuitId: CircuitId): Promise<Uint8Array>;
+}
+/**
+ * Handler to verify public signals of authorization circuits
+ *
+ * @export
+ * @beta
+ * @class VerificationHandlerFunc
+ */
+export declare class VerificationHandlerFunc {
+    readonly stateVerificationFunc: StateVerificationFunc;
+    /**
+     * Creates an instance of VerificationHandlerFunc.
+     * @param {StateVerificationFunc} stateVerificationFunc - state verification function
+     */
+    constructor(stateVerificationFunc: StateVerificationFunc);
+    /**
+     *
+     *
+     * @param {string} id  - id of circuit
+     * @param {Array<string>} pubSignals - signals that must contain user id and state
+     * @returns `Promise<boolean>`
+     */
+    verify(id: string, pubSignals: Array<string>): Promise<boolean>;
+}
+/**
+ * Packer that can pack message to JWZ token,
+ * and unpack and validate JWZ envelope
+ * @exports
+ * @beta
+ * @class ZKPPacker
+ * @implements implements IPacker interface
+ */
+export declare class ZKPPacker implements IPacker {
+    provingParamsMap: Map<string, ProvingParams>;
+    verificationParamsMap: Map<string, VerificationParams>;
+    /**
+     * Creates an instance of ZKPPacker.
+     * @param {Map<string, ProvingParams>} provingParamsMap - string is derived by JSON.parse(ProvingMethodAlg)
+     * @param {Map<string, VerificationParams>} verificationParamsMap - string is derived by JSON.parse(ProvingMethodAlg)
+     */
+    constructor(provingParamsMap: Map<string, ProvingParams>, verificationParamsMap: Map<string, VerificationParams>);
+    /**
+     * creates JSON Web Zeroknowledge token
+     *
+     * @param {Uint8Array} payload - serialized message
+     * @param {ZKPPackerParams} params - sender id and proving alg are required
+     * @returns `Promise<Uint8Array>`
+     */
+    pack(payload: Uint8Array, params: ZKPPackerParams): Promise<Uint8Array>;
+    /**
+     * validate envelope which is jwz token
+     *
+     * @param {Uint8Array} envelope
+     * @returns `Promise<BasicMessage>`
+     */
+    unpack(envelope: Uint8Array): Promise<BasicMessage>;
+    mediaType(): MediaType;
+}

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

@@ -0,0 +1,15 @@
+export * from './protocol/auth';
+export * from './protocol/credentials';
+export * from './protocol/messages';
+export * from './protocol/proof';
+export * from './protocol/revocation';
+export * from './packer';
+export * from './packageManager';
+/**
+ *  Protocol message type
+ */
+export type ProtocolMessage = string;
+type JSONValue = string | number | boolean | object | Array<object>;
+export type JSONObject = {
+    [x: string]: JSONValue;
+};

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

@@ -0,0 +1,80 @@
+import { IPacker, PackerParams } from './packer';
+import { MediaType } from '../constants';
+import { ProtocolMessage } from '.';
+export type BasicMessage = {
+    id: string;
+    typ?: MediaType;
+    type: ProtocolMessage;
+    thid?: string;
+    body?: unknown;
+    from?: string;
+    to?: string;
+};
+/**
+ * Interface for defining the registry of packers
+ *
+ * @export
+ * @beta
+ * @interface   IPackageManager
+ */
+export interface IPackageManager {
+    /**
+     * Map of packers key is media type, value is packer implementation
+     *
+     * @type {Map<MediaType, IPacker>}
+     */
+    packers: Map<MediaType, IPacker>;
+    /**
+     * registers new packer in the manager
+     *
+     * @param {Array<IPacker>} packers
+     */
+    registerPackers(packers: Array<IPacker>): void;
+    /**
+     * packs payload with a packer that is assigned to media type
+     * forwards packer params to implementation
+     *
+     * @param {MediaType} mediaType
+     * @param {Uint8Array} payload
+     * @param {PackerParams} params
+     * @returns `Promise<Uint8Array>`
+     */
+    pack(mediaType: MediaType, payload: Uint8Array, params: PackerParams): Promise<Uint8Array>;
+    /**
+     * unpacks packed envelope to basic protocol message and returns media type of the envelope
+     *
+     * @param {Uint8Array} envelope - bytes envelope
+     * @returns `Promise<{ unpackedMessage: BasicMessage; unpackedMediaType: MediaType }`
+     */
+    unpack(envelope: Uint8Array): Promise<{
+        unpackedMessage: BasicMessage;
+        unpackedMediaType: MediaType;
+    }>;
+    /**
+     * unpacks an envelope with a known media type
+     *
+     * @param {MediaType} mediaType
+     * @param {Uint8Array} envelope
+     * @returns `Promise<BasicMessage>`
+     */
+    unpackWithType(mediaType: MediaType, envelope: Uint8Array): Promise<BasicMessage>;
+    /**
+     * gets media type from an envelope
+     *
+     * @param {string} envelope
+     * @returns MediaType
+     */
+    getMediaType(envelope: string): MediaType;
+}
+/**
+ * EnvelopeStub is used to stub the jwt based envelops
+ */
+export type EnvelopeStub = {
+    protected: string;
+};
+/**
+ * HeaderStub is used to stub the jwt based envelops
+ */
+export type HeaderStub = {
+    typ: MediaType;
+};

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

@@ -0,0 +1,59 @@
+import { DID } from '@iden3/js-iden3-core';
+import { DataPrepareHandlerFunc, VerificationHandlerFunc } from '../packers';
+import { BasicMessage } from './index';
+import { ProvingMethodAlg } from '@iden3/js-jwz';
+import { CircuitId } from '../../circuits';
+import { MediaType } from '../constants';
+/**
+ *  parameters for any packer
+ */
+export type PackerParams = {
+    [key in string]: any;
+};
+/**
+ *  parameters for zkp packer
+ */
+export type ZKPPackerParams = PackerParams & {
+    senderDID: DID;
+    profileNonce: number;
+    provingMethodAlg: ProvingMethodAlg;
+};
+/**
+ *  parameters for plain packer
+ */
+export type PlainPackerParams = PackerParams;
+/**
+ *  signature of auth signals function preparer
+ */
+export type AuthDataPrepareFunc = (hash: Uint8Array, did: DID, profileNonce: number, circuitId: CircuitId) => Promise<Uint8Array>;
+/**
+ *  signature of state function verifier
+ */
+export type StateVerificationFunc = (id: string, pubSignals: Array<string>) => Promise<boolean>;
+/**
+ * Defines method that must be implemented by any packer
+ *
+ * @export
+ * @beta
+ * @interface   IPacker
+ */
+export interface IPacker {
+    pack(payload: Uint8Array, param: PackerParams): Promise<Uint8Array>;
+    unpack(envelope: Uint8Array): Promise<BasicMessage>;
+    mediaType(): MediaType;
+}
+/**
+ * Params for verification of auth circuit public signals
+ */
+export type VerificationParams = {
+    key: Uint8Array;
+    verificationFn: VerificationHandlerFunc;
+};
+/**
+ * Params for generation of proof for auth circuit
+ */
+export type ProvingParams = {
+    dataPreparer: DataPrepareHandlerFunc;
+    provingKey: Uint8Array;
+    wasm: Uint8Array;
+};

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

@@ -0,0 +1,49 @@
+import { ZKProof } from '@iden3/js-jwz';
+import { MediaType } from '../../constants';
+import { JSONObject, ProtocolMessage } from '../index';
+/** AuthorizationResponseMessage is struct the represents iden3message authorization response */
+export type AuthorizationResponseMessage = {
+    id: string;
+    typ?: MediaType;
+    type: ProtocolMessage;
+    thid?: string;
+    body: AuthorizationMessageResponseBody;
+    from?: string;
+    to?: string;
+};
+/** AuthorizationMessageResponseBody is struct the represents authorization response data */
+export type AuthorizationMessageResponseBody = {
+    did_doc?: JSONObject;
+    message?: string;
+    scope: Array<ZeroKnowledgeProofResponse>;
+};
+/** AuthorizationRequestMessage is struct the represents iden3message authorization request */
+export type AuthorizationRequestMessage = {
+    id: string;
+    typ?: MediaType;
+    type: ProtocolMessage;
+    thid?: string;
+    body?: AuthorizationRequestMessageBody;
+    from?: string;
+    to?: string;
+};
+/** AuthorizationRequestMessageBody is body for authorization request */
+export type AuthorizationRequestMessageBody = {
+    callbackUrl: string;
+    reason?: string;
+    message?: string;
+    did_doc?: JSONObject;
+    scope: Array<ZeroKnowledgeProofRequest>;
+};
+/** ZeroKnowledgeProofRequest represents structure of zkp request object */
+export type ZeroKnowledgeProofRequest = {
+    id: number;
+    circuitId: string;
+    optional?: boolean;
+    query: JSONObject;
+};
+/** ZeroKnowledgeProofResponse represents structure of zkp response */
+export type ZeroKnowledgeProofResponse = {
+    id: number;
+    circuitId: string;
+} & ZKProof;

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

@@ -0,0 +1,74 @@
+import { ProtocolMessage } from '../index';
+import { JSONObject } from '../index';
+import { W3CCredential } from '../../../verifiable';
+import { MediaType } from '../../constants';
+/** CredentialIssuanceRequestMessage represent Iden3message for credential request */
+export type CredentialIssuanceRequestMessage = {
+    id: string;
+    typ?: MediaType;
+    type: ProtocolMessage;
+    thid?: string;
+    body?: CredentialIssuanceRequestMessage;
+    from?: string;
+    to?: string;
+};
+/** CredentialIssuanceRequestMessageBody represents data for credential issuance request */
+export type CredentialIssuanceRequestMessageBody = {
+    schema: Schema;
+    data: JSONObject;
+    expiration: number;
+};
+/** CredentialsOfferMessage represent Iden3message for credential offer */
+export type CredentialsOfferMessage = {
+    id: string;
+    typ?: MediaType;
+    type: ProtocolMessage;
+    thid?: string;
+    body?: CredentialsOfferMessageBody;
+    from?: string;
+    to?: string;
+};
+/** CredentialsOfferMessageBody is struct the represents offer message */
+export type CredentialsOfferMessageBody = {
+    url: string;
+    credentials: Array<CredentialOffer>;
+};
+/** CredentialOffer is structure to fetch credential */
+export type CredentialOffer = {
+    id: string;
+    description: string;
+};
+/** CredentialIssuanceMessage represent Iden3message for credential issuance */
+export type CredentialIssuanceMessage = {
+    id: string;
+    typ?: MediaType;
+    type: ProtocolMessage;
+    threadID?: string;
+    body?: IssuanceMessageBody;
+    from?: string;
+    to?: string;
+};
+/** IssuanceMessageBody is struct the represents message when credential is issued */
+export type IssuanceMessageBody = {
+    credential: W3CCredential;
+};
+/** CredentialFetchRequestMessage represent Iden3message for credential fetch request */
+export type CredentialFetchRequestMessage = {
+    id: string;
+    typ?: MediaType;
+    type: ProtocolMessage;
+    thid?: string;
+    body?: CredentialFetchRequestMessageBody;
+    from?: string;
+    to?: string;
+};
+/** CredentialFetchRequestMessageBody is msg body for fetch request */
+export type CredentialFetchRequestMessageBody = {
+    id: string;
+};
+/** Schema represents location and type where it's stored */
+export type Schema = {
+    hash?: string;
+    url: string;
+    type: string;
+};

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

@@ -0,0 +1,16 @@
+import { ProtocolMessage } from '../';
+import { MediaType } from '../../constants';
+/**  MessageFetchRequestMessage represent Iden3message for message fetch request. */
+export type MessageFetchRequestMessage = {
+    id: string;
+    typ?: MediaType;
+    type: ProtocolMessage;
+    thid?: string;
+    body?: MessageFetchRequestMessageBody;
+    from?: string;
+    to?: string;
+};
+/** MessageFetchRequestMessageBody is struct the represents body for message fetch request. */
+export type MessageFetchRequestMessageBody = {
+    id: string;
+};

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

@@ -0,0 +1,31 @@
+import { ProtocolMessage } from '../';
+import { MediaType } from '../../constants';
+import { ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse } from './auth';
+/** ProofGenerationRequestMessage is struct the represents body for proof generation request */
+export type ProofGenerationRequestMessage = {
+    id: string;
+    typ?: MediaType;
+    type: ProtocolMessage;
+    thid?: string;
+    body?: ProofGenerationRequestMessageBody;
+    from?: string;
+    to?: string;
+};
+/** ProofGenerationRequestMessageBody is struct the represents body for proof generation request */
+export type ProofGenerationRequestMessageBody = {
+    scope: Array<ZeroKnowledgeProofRequest>;
+};
+/** ProofGenerationResponseMessage is struct the represents body for proof generation request */
+export type ProofGenerationResponseMessage = {
+    id: string;
+    typ?: MediaType;
+    type: ProtocolMessage;
+    thid?: string;
+    body?: ResponseMessageBody;
+    from?: string;
+    to?: string;
+};
+/** ResponseMessageBody is struct the represents request for revocation status */
+export type ResponseMessageBody = {
+    scope: Array<ZeroKnowledgeProofResponse>;
+};

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

@@ -0,0 +1,28 @@
+import { ProtocolMessage } from '../';
+import { RevocationStatus } from '../../../verifiable';
+import { MediaType } from '../../constants';
+/** RevocationStatusRequestMessage is struct the represents body for proof generation request */
+export type RevocationStatusRequestMessage = {
+    id: string;
+    typ?: MediaType;
+    type: RTCIceProtocol;
+    body?: RevocationStatusRequestMessageBody;
+    from?: string;
+    to?: string;
+};
+/** RevocationStatusRequestMessageBody is struct the represents request for revocation status */
+export type RevocationStatusRequestMessageBody = {
+    revocation_nonce: number;
+};
+/** RevocationStatusResponseMessage is struct the represents body for proof generation request */
+export type RevocationStatusResponseMessage = {
+    id: string;
+    typ?: MediaType;
+    type: ProtocolMessage;
+    thid?: string;
+    body?: RevocationStatusResponseMessageBody;
+    from?: string;
+    to?: string;
+};
+/** RevocationStatusResponseMessageBody is struct the represents request for revocation status */
+export type RevocationStatusResponseMessageBody = RevocationStatus;

package/dist/types/iden3comm/utils/bytes.d.ts

@@ -0,0 +1,8 @@
+/**
+ * converts bytes array to ut8 string
+ *
+ * @param {Uint8Array} b - bytes array
+ * @returns {string}
+ */
+export declare const bytesToString: (b: Uint8Array) => string;
+export declare const stringToBytes: (str: string) => Uint8Array;

package/dist/types/iden3comm/utils/envelope.d.ts

@@ -0,0 +1,31 @@
+import { BasicMessage, EnvelopeStub, HeaderStub } from '../types';
+/**
+ *
+ * @param {Uint8Array} e
+ * @returns Promise<BasicMessage>
+ */
+export declare const envelopeToProtocolMessage: (e: Uint8Array) => Promise<BasicMessage>;
+/**
+ * helper function to convert serialized JSON bytes to protocol message
+ *
+ * @param {Uint8Array} bytes
+ * @returns  {BasicMessage}
+ */
+export declare const bytesToProtocolMessage: (bytes: Uint8Array) => BasicMessage;
+/**
+ * helper function to convert serialized JSON bytes to envelop stub
+ * so we can work with protected field of jwt token
+ *
+ *
+ * @param {Uint8Array} envelope
+ * @returns {EnvelopeStub}
+ */
+export declare const bytesToEnvelopeStub: (envelope: Uint8Array) => EnvelopeStub;
+/**
+ * helper function to convert serialized JSON bytes to header stub
+ * so we can work with know the media type of the message
+ *
+ * @param {Uint8Array} envelope
+ * @returns {HeaderStub}
+ */
+export declare const bytesToHeaderStub: (envelope: Uint8Array) => HeaderStub;

package/dist/types/iden3comm/utils/index.d.ts

@@ -0,0 +1,2 @@
+export declare const byteEncoder: TextEncoder;
+export declare const byteDecoder: TextDecoder;

package/dist/types/iden3comm/utils/message.d.ts

@@ -0,0 +1,19 @@
+import { BasicMessage, EnvelopeStub, HeaderStub } from '../types';
+/**
+ * creates empty basic message
+ *
+ * @returns BasicMessage
+ */
+export declare const basicMessageFactory: () => BasicMessage;
+/**
+ * create empty envelope stub
+ *
+ * @returns EnvelopeStub
+ */
+export declare const envelopeStubFactory: () => EnvelopeStub;
+/**
+ * create empty header stub
+ *
+ * @returns {HeaderStub}
+ */
+export declare const headerStubFactory: () => HeaderStub;

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

@@ -0,0 +1,18 @@
+import { IdPosition, MerklizedRootPosition } from '@iden3/js-iden3-core';
+import { SchemaMetadata } from '../schema-processor';
+import { SubjectPosition } from '../verifiable';
+/**
+ * Determines subject position
+ *
+ * @param {IdPosition} idPosition - index / none / value
+ * @returns {SubjectPosition}
+ */
+export declare const subjectPositionIndex: (idPosition: IdPosition) => SubjectPosition;
+/**
+ * Returns merklized root position based on schema serialization metadata and expected position
+ *
+ * @param {SchemaMetadata} [metadata] - schema metadata
+ * @param {MerklizedRootPosition} [position] - expected mt root position
+ * @returns {MerklizedRootPosition}
+ */
+export declare const defineMerklizedRootPosition: (metadata?: SchemaMetadata, position?: MerklizedRootPosition) => MerklizedRootPosition;