@0xpolygonid/js-sdk 1.7.5 → 1.8.0

package/dist/node/esm/verifiable/core-utils.js

@@ -0,0 +1,200 @@
+import { BytesHelper, SchemaHash } from '@iden3/js-iden3-core';
+import { Path } from '@iden3/js-jsonld-merklization';
+import { byteDecoder } from '../utils';
+import * as jsonld from 'jsonld/lib';
+import * as ldcontext from 'jsonld/lib/context';
+import { Hex } from '@iden3/js-crypto';
+import { keccak256 } from 'js-sha3';
+const credentialSubjectKey = 'credentialSubject';
+const contextFullKey = '@context';
+const serializationFullKey = 'iden3_serialization';
+const fieldPrefix = 'iden3:v1:';
+const credentialSubjectFullKey = 'https://www.w3.org/2018/credentials#credentialSubject';
+const verifiableCredentialFullKey = 'https://www.w3.org/2018/credentials#VerifiableCredential';
+const typeFullKey = '@type';
+/**
+ * GetFieldSlotIndex return index of slot from 0 to 7 (each claim has by default 8 slots) for non-merklized claims
+ *
+ * @param {string} field - field name
+ * @param {Uint8Array} schemaBytes -json schema bytes
+ * @returns `number`
+ */
+export const getFieldSlotIndex = async (field, typeName, schemaBytes) => {
+    let ctxDoc = JSON.parse(byteDecoder.decode(schemaBytes));
+    ctxDoc = ctxDoc[contextFullKey];
+    if (ctxDoc === undefined) {
+        throw new Error('document has no @context');
+    }
+    const ldCtx = await jsonld.processContext(ldcontext.getInitialContext({}), ctxDoc, {});
+    const serAttr = await getSerializationAttrFromParsedContext(ldCtx, typeName);
+    if (!serAttr) {
+        throw new Error('serialization attribute is not set');
+    }
+    const sPaths = parseSerializationAttr(serAttr);
+    switch (field) {
+        case sPaths.indexAPath:
+            return 2;
+        case sPaths.indexBPath:
+            return 3;
+        case sPaths.valueAPath:
+            return 6;
+        case sPaths.valueBPath:
+            return 7;
+        default:
+            throw new Error(`field ${field} not specified in serialization info`);
+    }
+};
+/**
+ * checks if data can fill the slot
+ *
+ * @param {Uint8Array} slotData - slot data
+ * @param {Merklizer} mz - merklizer
+ * @param {string} path - path
+ * @returns {void}
+ */
+export const fillCoreClaimSlot = async (slotData, mz, path) => {
+    if (!path) {
+        return;
+    }
+    path = credentialSubjectKey + '.' + path;
+    try {
+        const p = await mz.resolveDocPath(path, mz.options);
+        const entry = await mz.entry(p);
+        const intVal = await entry.getValueMtEntry();
+        const bytesVal = BytesHelper.intToBytes(intVal);
+        slotData.set(bytesVal, 0);
+    }
+    catch (err) {
+        if (err.toString().includes('entry not found')) {
+            throw new Error(`field not found in credential ${path}`);
+        }
+        throw err;
+    }
+};
+// Get `iden3_serialization` attr definition from context document either using
+// type name like DeliverAddressMultiTestForked or by type id like
+// urn:uuid:ac2ede19-b3b9-454d-b1a9-a7b3d5763100.
+export const getSerializationAttrFromContext = async (context, opts, tp) => {
+    const ldCtx = await jsonld.processContext(ldcontext.getInitialContext({}), context, opts);
+    return getSerializationAttrFromParsedContext(ldCtx, tp);
+};
+export const getSerializationAttrFromParsedContext = async (ldCtx, tp) => {
+    const termDef = ldCtx.mappings;
+    if (!termDef) {
+        throw new Error('terms definitions is not of correct type');
+    }
+    const term = termDef.get(tp) ?? [...termDef.values()].find((value) => value['@id'] === tp);
+    if (!term) {
+        return '';
+    }
+    const termCtx = term[contextFullKey];
+    if (!termCtx) {
+        throw new Error('type @context is not of correct type');
+    }
+    const serStr = termCtx[serializationFullKey] ?? '';
+    return serStr;
+};
+export const parseSerializationAttr = (serAttr) => {
+    if (!serAttr.startsWith(fieldPrefix)) {
+        throw new Error('serialization attribute does not have correct prefix');
+    }
+    const parts = serAttr.slice(fieldPrefix.length).split('&');
+    if (parts.length > 4) {
+        throw new Error('serialization attribute has too many parts');
+    }
+    const paths = {};
+    for (const part of parts) {
+        const kv = part.split('=');
+        if (kv.length !== 2) {
+            throw new Error('serialization attribute part does not have correct format');
+        }
+        switch (kv[0]) {
+            case 'slotIndexA':
+                paths.indexAPath = kv[1];
+                break;
+            case 'slotIndexB':
+                paths.indexBPath = kv[1];
+                break;
+            case 'slotValueA':
+                paths.valueAPath = kv[1];
+                break;
+            case 'slotValueB':
+                paths.valueBPath = kv[1];
+                break;
+            default:
+                throw new Error('unknown serialization attribute slot');
+        }
+    }
+    return paths;
+};
+export const findCredentialType = (mz) => {
+    const opts = mz.options;
+    try {
+        // try to look into credentialSubject.@type to get type of credentials
+        const path1 = new Path([credentialSubjectFullKey, typeFullKey], opts.hasher);
+        const e = mz.rawValue(path1);
+        return e;
+    }
+    catch (err) {
+        // if type of credentials not found in credentialSubject.@type, loop at
+        // top level @types if it contains two elements: type we are looking for
+        // and "VerifiableCredential" type.
+        const path2 = new Path([typeFullKey], opts.hasher);
+        const topLevelTypes = mz.rawValue(path2);
+        if (!Array.isArray(topLevelTypes)) {
+            throw new Error('top level @type expected to be an array');
+        }
+        if (topLevelTypes.length !== 2) {
+            throw new Error('top level @type expected to be of length 2');
+        }
+        switch (verifiableCredentialFullKey) {
+            case topLevelTypes[0]:
+                return topLevelTypes[1];
+            case topLevelTypes[1]:
+                return topLevelTypes[0];
+            default:
+                throw new Error('@type(s) are expected to contain VerifiableCredential type');
+        }
+    }
+};
+/**
+ * parseCoreClaimSlots converts payload to claim slots using provided schema
+ *
+ * @param { { mappings: Map<string, Record<string, unknown>> } } ldCtx - ldCtx
+ * @param {Merklizer} mz - Merklizer
+ * @param {string} credentialType - credential type
+ * @returns `Promise<{ slots: ParsedSlots; nonMerklized: boolean }>`
+ */
+export const parseCoreClaimSlots = async (ldCtx, mz, credentialType) => {
+    // parseSlots converts payload to claim slots using provided schema
+    const slots = {
+        indexA: new Uint8Array(32),
+        indexB: new Uint8Array(32),
+        valueA: new Uint8Array(32),
+        valueB: new Uint8Array(32)
+    };
+    const serAttr = await getSerializationAttrFromParsedContext(ldCtx, credentialType);
+    if (!serAttr) {
+        return { slots, nonMerklized: false };
+    }
+    const sPaths = parseSerializationAttr(serAttr);
+    const isSPathEmpty = !Object.values(sPaths).some(Boolean);
+    if (isSPathEmpty) {
+        return { slots, nonMerklized: true };
+    }
+    await fillCoreClaimSlot(slots.indexA, mz, sPaths.indexAPath);
+    await fillCoreClaimSlot(slots.indexB, mz, sPaths.indexBPath);
+    await fillCoreClaimSlot(slots.valueA, mz, sPaths.valueAPath);
+    await fillCoreClaimSlot(slots.valueB, mz, sPaths.valueBPath);
+    return { slots, nonMerklized: true };
+};
+/**
+ * Calculates core schema hash
+ *
+ * @param {Uint8Array} schemaId
+ * @returns {*}  {SchemaHash}
+ */
+export const caclulateCoreSchemaHash = (schemaId) => {
+    const sHash = Hex.decodeString(keccak256(schemaId));
+    return new SchemaHash(sHash.slice(sHash.length - 16, sHash.length));
+};

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

@@ -1,12 +1,15 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { BJJSignatureProof2021, Iden3SparseMerkleTreeProof } from './proof';
-import { Claim } from '@iden3/js-iden3-core';
-import { ProofType } from './constants';
+import { Claim, DID, MerklizedRootPosition as MerklizedRootPositionCore, IdPosition, ClaimOptions } from '@iden3/js-iden3-core';
 import { Hash, rootFromProof, verifyProof } from '@iden3/js-merkletree';
 import { Merklizer } from '@iden3/js-jsonld-merklization';
 import { PublicKey, poseidon } from '@iden3/js-crypto';
 import { getUserDIDFromCredential } from '../credentials/utils';
-import { validateDIDDocumentAuth } from '../utils';
+import { byteEncoder, validateDIDDocumentAuth } from '../utils';
+import { MerklizedRootPosition, ProofType, SubjectPosition } from './constants';
+import { caclulateCoreSchemaHash, findCredentialType, parseCoreClaimSlots } from './core-utils';
+import * as jsonld from 'jsonld/lib';
+import * as ldcontext from 'jsonld/lib/context';
 /**
  * W3C Verifiable credential
  *
@@ -86,6 +89,77 @@ export class W3CCredential {
         }
         return undefined;
     }
+    /**
+     * gets core claim representation from W3CCredential
+     *
+     * @param {CoreClaimParsingOptions} [opts] - options to create core claim
+     * @returns {*}  {(Promise<Claim>)}
+     */
+    async toCoreClaim(opts) {
+        if (!opts) {
+            opts = {
+                revNonce: 0,
+                version: 0,
+                subjectPosition: SubjectPosition.Index,
+                merklizedRootPosition: MerklizedRootPosition.None,
+                updatable: false,
+                merklizeOpts: {}
+            };
+        }
+        const mz = await this.merklize(opts.merklizeOpts);
+        const credentialType = findCredentialType(mz);
+        const subjectId = this.credentialSubject['id'];
+        const ldCtx = await jsonld.processContext(ldcontext.getInitialContext({}), this['@context'], mz.options);
+        const { slots, nonMerklized } = await parseCoreClaimSlots(ldCtx, mz, credentialType);
+        // if schema is for non merklized credential, root position must be set to none ('')
+        // otherwise default position for merklized position is index.
+        if (nonMerklized && opts.merklizedRootPosition !== MerklizedRootPosition.None) {
+            throw new Error('merklized root position is not supported for non-merklized claims');
+        }
+        if (!nonMerklized && opts.merklizedRootPosition === MerklizedRootPosition.None) {
+            opts.merklizedRootPosition = MerklizedRootPosition.Index;
+        }
+        const schemaHash = caclulateCoreSchemaHash(byteEncoder.encode(credentialType));
+        const claim = Claim.newClaim(schemaHash, ClaimOptions.withIndexDataBytes(slots.indexA, slots.indexB), ClaimOptions.withValueDataBytes(slots.valueA, slots.valueB), ClaimOptions.withRevocationNonce(BigInt(opts.revNonce)), ClaimOptions.withVersion(opts.version));
+        if (opts.updatable) {
+            claim.setFlagUpdatable(opts.updatable);
+        }
+        if (this.expirationDate) {
+            claim.setExpirationDate(new Date(this.expirationDate));
+        }
+        if (subjectId) {
+            const did = DID.parse(subjectId.toString());
+            const id = DID.idFromDID(did);
+            switch (opts.subjectPosition) {
+                case '':
+                case SubjectPosition.Index:
+                    claim.setIndexId(id);
+                    break;
+                case SubjectPosition.Value:
+                    claim.setValueId(id);
+                    break;
+                default:
+                    throw new Error('unknown subject position');
+            }
+        }
+        switch (opts.merklizedRootPosition) {
+            case MerklizedRootPosition.Index: {
+                const mk = await this.merklize(opts.merklizeOpts);
+                claim.setIndexMerklizedRoot((await mk.root()).bigInt());
+                break;
+            }
+            case MerklizedRootPosition.Value: {
+                const mk = await this.merklize(opts.merklizeOpts);
+                claim.setValueMerklizedRoot((await mk.root()).bigInt());
+                break;
+            }
+            case MerklizedRootPosition.None:
+                break;
+            default:
+                throw new Error('unknown merklized root position');
+        }
+        return claim;
+    }
     /**
      * checks BJJSignatureProof2021 in W3C VC
      *
@@ -124,6 +198,7 @@ export class W3CCredential {
         if (!coreClaim) {
             throw new Error(`can't get core claim`);
         }
+        await this.verifyCoreClaimMatch(coreClaim, opts?.merklizeOptions);
         switch (proofType) {
             case ProofType.BJJSignature: {
                 if (!opts?.credStatusResolverRegistry) {
@@ -141,6 +216,46 @@ export class W3CCredential {
             }
         }
     }
+    async verifyCoreClaimMatch(coreClaim, merklizeOpts) {
+        let merklizedRootPosition = '';
+        const merklizedPosition = coreClaim.getMerklizedPosition();
+        switch (merklizedPosition) {
+            case MerklizedRootPositionCore.None:
+                merklizedRootPosition = MerklizedRootPosition.None;
+                break;
+            case MerklizedRootPositionCore.Index:
+                merklizedRootPosition = MerklizedRootPosition.Index;
+                break;
+            case MerklizedRootPositionCore.Value:
+                merklizedRootPosition = MerklizedRootPosition.Value;
+                break;
+        }
+        let subjectPosition = '';
+        const idPosition = coreClaim.getIdPosition();
+        switch (idPosition) {
+            case IdPosition.None:
+                subjectPosition = SubjectPosition.None;
+                break;
+            case IdPosition.Index:
+                subjectPosition = SubjectPosition.Index;
+                break;
+            case IdPosition.Value:
+                subjectPosition = SubjectPosition.Value;
+                break;
+        }
+        const coreClaimOpts = {
+            revNonce: Number(coreClaim.getRevocationNonce()),
+            version: coreClaim.getVersion(),
+            merklizedRootPosition,
+            subjectPosition,
+            updatable: coreClaim.getFlagUpdatable(),
+            merklizeOpts: merklizeOpts
+        };
+        const credentialCoreClaim = await this.toCoreClaim(coreClaimOpts);
+        if (coreClaim.hex() != credentialCoreClaim.hex()) {
+            throw new Error('proof generated for another credential');
+        }
+    }
     async verifyBJJSignatureProof(proof, coreClaim, resolverURL, userDID, credStatusResolverRegistry) {
         // issuer auth claim
         const authClaim = proof.issuerData.authCoreClaim;

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

@@ -3,3 +3,4 @@ export * from './presentation';
 export * from './proof';
 export * from './schema';
 export * from './constants';
+export * from './core-utils';

package/dist/types/credentials/credential-wallet.d.ts

@@ -1,68 +1,10 @@
 import { DID } from '@iden3/js-iden3-core';
 import { IDataStorage } from '../storage/interfaces';
-import { W3CCredential, ProofQuery, SubjectPosition, MerklizedRootPosition, CredentialStatus, RevocationStatus, CredentialStatusType, RefreshService } from './../verifiable';
+import { W3CCredential, ProofQuery, CredentialStatus, RevocationStatus } from './../verifiable';
 import { JSONSchema } from '../schema-processor';
 import { CredentialStatusResolverRegistry } from './status/resolver';
 import { CredentialStatusResolveOptions } from './status/resolver';
-/**
- * Request to core library to create Core Claim from W3C Verifiable Credential
- *
- * @public
- * @interface CredentialRequest
- */
-export interface CredentialRequest {
-    /**
-     * JSON credential schema
-     */
-    credentialSchema: string;
-    /**
-     * Credential type
-     */
-    type: string;
-    /**
-     * Credential subject, usually contains claims and identifier
-     */
-    credentialSubject: {
-        [key: string]: string | object | number | boolean;
-    };
-    /**
-     * expiration time
-     */
-    expiration?: number;
-    /**
-     * refreshService
-     */
-    refreshService?: RefreshService;
-    /**
-     * claim version
-     */
-    version?: number;
-    /**
-     * subject position (index / value / none)
-     */
-    subjectPosition?: SubjectPosition;
-    /**
-     * merklizedRootPosition (index / value / none)
-     */
-    merklizedRootPosition?: MerklizedRootPosition;
-    /**
-     * Revocation options
-     *
-     * @type {{
-     *     id: string;
-     *     nonce?: number;
-     *     type: CredentialStatusType;
-     *     issuerState?: string;
-     *   }}
-     * @memberof CredentialRequest
-     */
-    revocationOpts: {
-        id: string;
-        nonce?: number;
-        type: CredentialStatusType;
-        issuerState?: string;
-    };
-}
+import { CredentialRequest } from './models';
 /**
  * Interface to work with credential wallets
  *

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

@@ -7,3 +7,4 @@ export * from './status/credential-status-publisher';
 export * from './credential-wallet';
 export * from './rhs';
 export * from './utils';
+export * from './models';

package/dist/types/credentials/models.d.ts

@@ -0,0 +1,68 @@
+import { CredentialStatusType, MerklizedRootPosition, RefreshService, SubjectPosition } from '../verifiable';
+/**
+ * Represents the publish mode for identity wallet.
+ * It can be one of the following values: 'sync', 'async', or 'callback'.
+ * 'sync' - publish the status synchronously
+ * 'async' - publish the status asynchronously via message bus
+ * 'callback' - publish the status with a txCallback
+ */
+export type PublishMode = 'sync' | 'async' | 'callback';
+/**
+ * Request to core library to create Core Claim from W3C Verifiable Credential
+ *
+ * @public
+ * @interface CredentialRequest
+ */
+export interface CredentialRequest {
+    /**
+     * JSON credential schema
+     */
+    credentialSchema: string;
+    /**
+     * Credential type
+     */
+    type: string;
+    /**
+     * Credential subject, usually contains claims and identifier
+     */
+    credentialSubject: {
+        [key: string]: string | object | number | boolean;
+    };
+    /**
+     * expiration time
+     */
+    expiration?: number;
+    /**
+     * refreshService
+     */
+    refreshService?: RefreshService;
+    /**
+     * claim version
+     */
+    version?: number;
+    /**
+     * subject position (index / value / none)
+     */
+    subjectPosition?: SubjectPosition;
+    /**
+     * merklizedRootPosition (index / value / none)
+     */
+    merklizedRootPosition?: MerklizedRootPosition;
+    /**
+     * Revocation options
+     *
+     * @type {{
+     *     id: string;
+     *     nonce?: number;
+     *     type: CredentialStatusType;
+     *     issuerState?: string;
+     *   }}
+     * @memberof CredentialRequest
+     */
+    revocationOpts: {
+        id: string;
+        nonce?: number;
+        type: CredentialStatusType;
+        issuerState?: string;
+    };
+}

package/dist/types/credentials/status/credential-status-publisher.d.ts

@@ -3,6 +3,7 @@ import { JSONObject } from '../../iden3comm';
 import { OnChainRevocationStorage } from '../../storage';
 import { CredentialStatusType } from '../../verifiable';
 import { ProofNode } from './reverse-sparse-merkle-tree';
+import { PublishMode } from '../models';
 /**
  * Represents a credential status publisher.
  */
@@ -47,6 +48,7 @@ export declare class Iden3OnchainSmtCredentialStatusPublisher implements ICreden
         credentialStatusType: CredentialStatusType;
         onChain?: {
             txCallback?: (tx: TransactionReceipt) => Promise<void>;
+            publishMode?: PublishMode;
         };
     }): Promise<void>;
 }

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

@@ -16,6 +16,7 @@ export declare const PROTOCOL_MESSAGE_TYPE: Readonly<{
     REVOCATION_STATUS_REQUEST_MESSAGE_TYPE: string;
     REVOCATION_STATUS_RESPONSE_MESSAGE_TYPE: string;
     CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE: string;
+    CREDENTIAL_ONCHAIN_OFFER_MESSAGE_TYPE: string;
 }>;
 /**
  * Media types for iden3 comm communication protocol

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

@@ -2,6 +2,34 @@ import { MediaType } from '../constants';
 import { IProofService } from '../../proof/proof-service';
 import { AuthorizationRequestMessage, AuthorizationResponseMessage, IPackageManager, JWSPackerParams } from '../types';
 import { DID } from '@iden3/js-iden3-core';
+/**
+ *  createAuthorizationRequest is a function to create protocol authorization request
+ * @param {string} reason - reason to request proof
+ * @param {string} sender - sender did
+ * @param {string} callbackUrl - callback that user should use to send response
+ * @returns `Promise<AuthorizationRequestMessage>`
+ */
+export declare function createAuthorizationRequest(reason: string, sender: string, callbackUrl: string): AuthorizationRequestMessage;
+/**
+ *  createAuthorizationRequestWithMessage is a function to create protocol authorization request with explicit message to sign
+ * @param {string} reason - reason to request proof
+ * @param {string} message - message to sign in the response
+ * @param {string} sender - sender did
+ * @param {string} callbackUrl - callback that user should use to send response
+ * @returns `Promise<AuthorizationRequestMessage>`
+ */
+export declare function createAuthorizationRequestWithMessage(reason: string, message: string, sender: string, callbackUrl: string): AuthorizationRequestMessage;
+/**
+ *
+ * Options to pass to auth response handler
+ *
+ * @public
+ * @interface AuthResponseHandlerOptions
+ */
+export interface AuthResponseHandlerOptions {
+    acceptedStateTransitionDelay?: number;
+    acceptedProofGenerationDelay?: number;
+}
 /**
  * Interface that allows the processing of the authorization request in the raw format for given identifier
  *
@@ -32,6 +60,21 @@ export interface IAuthHandler {
         authRequest: AuthorizationRequestMessage;
         authResponse: AuthorizationResponseMessage;
     }>;
+    /**
+       * handle authorization response
+       * @public
+       * @param {AuthorizationResponseMessage} response  - auth response
+       * @param {AuthorizationRequestMessage} request  - auth request
+       * @param {AuthResponseHandlerOptions} opts - options
+       * @returns `Promise<{
+        request: AuthorizationRequestMessage;
+        response: AuthorizationResponseMessage;
+      }>`
+       */
+    handleAuthorizationResponse(response: AuthorizationResponseMessage, request: AuthorizationRequestMessage, opts?: AuthResponseHandlerOptions): Promise<{
+        request: AuthorizationRequestMessage;
+        response: AuthorizationResponseMessage;
+    }>;
 }
 /**
  *
@@ -64,26 +107,23 @@ export declare class AuthHandler implements IAuthHandler {
      */
     constructor(_packerMgr: IPackageManager, _proofService: IProofService);
     /**
-     * unpacks authorization request
-     * @public
-     * @param {Uint8Array} request - raw byte message
-     * @returns `Promise<AuthorizationRequestMessage>`
+     * @inheritdoc IAuthHandler#parseAuthorizationRequest
      */
     parseAuthorizationRequest(request: Uint8Array): Promise<AuthorizationRequestMessage>;
     /**
-     * unpacks authorization request and packs authorization response
-     * @public
-     * @param {did} did  - sender DID
-     * @param {Uint8Array} request - raw byte message
-     * @returns `Promise<{
-      token: string;
-      authRequest: AuthorizationRequestMessage;
-      authResponse: AuthorizationResponseMessage;
-    }>`
+     * @inheritdoc IAuthHandler#handleAuthorizationRequest
      */
     handleAuthorizationRequest(did: DID, request: Uint8Array, opts?: AuthHandlerOptions): Promise<{
         token: string;
         authRequest: AuthorizationRequestMessage;
         authResponse: AuthorizationResponseMessage;
     }>;
+    /**
+     * @inheritdoc IAuthHandler#handleAuthorizationResponse
+     */
+    handleAuthorizationResponse(response: AuthorizationResponseMessage, request: AuthorizationRequestMessage, opts?: AuthResponseHandlerOptions | undefined): Promise<{
+        request: AuthorizationRequestMessage;
+        response: AuthorizationResponseMessage;
+    }>;
+    private verifyAuthRequest;
 }

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

@@ -1,6 +1,7 @@
 import { W3CCredential } from '../../../verifiable';
 import { MediaType } from '../../constants';
 import { JSONObject, ProtocolMessage } from '../packer';
+import { ContractInvokeTransactionData } from './contract-request';
 /** CredentialIssuanceRequestMessageBody represents data for credential issuance request */
 export type CredentialIssuanceRequestMessageBody = {
     schema: Schema;
@@ -32,6 +33,21 @@ export type CredentialsOfferMessageBody = {
     url: string;
     credentials: Array<CredentialOffer>;
 };
+/** CredentialsOnchainOfferMessage represent Iden3message for credential onhcain offer message */
+export type CredentialsOnchainOfferMessage = {
+    id: string;
+    typ: MediaType;
+    type: ProtocolMessage;
+    thid?: string;
+    body: CredentialsOnchainOfferMessageBody;
+    from: string;
+    to: string;
+};
+/** CredentialsOnchainOfferMessageBody is struct the represents onchain offer message body */
+export type CredentialsOnchainOfferMessageBody = {
+    credentials: Array<CredentialOffer>;
+    transaction_data: ContractInvokeTransactionData;
+};
 /** CredentialOffer is structure to fetch credential */
 export type CredentialOffer = {
     id: string;

package/dist/types/identity/identity-wallet.d.ts

@@ -3,7 +3,7 @@ import { Claim, DID } from '@iden3/js-iden3-core';
 import { Signature } from '@iden3/js-crypto';
 import { IDataStorage, Profile } from '../storage';
 import { W3CCredential, MerkleTreeProofWithTreeState, CredentialStatusType, ProofQuery } from '../verifiable';
-import { CredentialRequest, ICredentialWallet, TreesModel } from '../credentials';
+import { CredentialRequest, ICredentialWallet, PublishMode, TreesModel } from '../credentials';
 import { TreeState } from '../circuits';
 import { Options } from '@iden3/js-jsonld-merklization';
 import { TransactionReceipt } from 'ethers';
@@ -25,6 +25,7 @@ export type IdentityCreationOptions = {
         nonce?: number;
         onChain?: {
             txCallback?: (tx: TransactionReceipt) => Promise<void>;
+            publishMode?: PublishMode;
         };
     };
     seed?: Uint8Array;
@@ -38,6 +39,7 @@ export type RevocationInfoOptions = {
     rhsUrl?: string;
     onChain?: {
         txCallback?: (tx: TransactionReceipt) => Promise<void>;
+        publishMode?: PublishMode;
     };
 };
 /**

package/dist/types/kms/key-providers/sec256k1-provider.d.ts

@@ -25,7 +25,7 @@ export declare class Sec256k1Provider implements IKeyProvider {
      * @param {Uint8Array} seed - byte array seed
      * @returns kms key identifier
      */
-    newPrivateKeyFromSeed(): Promise<KmsKeyId>;
+    newPrivateKeyFromSeed(seed: Uint8Array): Promise<KmsKeyId>;
     /**
      * Gets public key by kmsKeyId
      *