@0xpolygonid/js-sdk 1.7.4 → 1.8.0

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
      *

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

@@ -1,3 +1,4 @@
 export * from './proof-service';
-export * from './prover';
+export * from './provers';
 export * from './common';
+export * from './verifiers';

package/dist/types/proof/proof-service.d.ts

@@ -3,25 +3,39 @@ import { CircuitId, Query, TreeState } from '../circuits';
 import { ICredentialWallet } from '../credentials';
 import { IIdentityWallet } from '../identity';
 import { ProofQuery, RevocationStatus, W3CCredential } from '../verifiable';
-import { IZKProver } from './prover';
+import { IZKProver } from './provers/prover';
 import { Options } from '@iden3/js-jsonld-merklization';
 import { ZKProof } from '@iden3/js-jwz';
 import { Signer } from 'ethers';
-import { ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse } from '../iden3comm';
+import { JSONObject, ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse } from '../iden3comm';
 import { ICircuitStorage, IStateStorage } from '../storage';
-import { ProofGenerationOptions } from './inputs-generator';
+import { ProofGenerationOptions } from './provers/inputs-generator';
+import { VerifyOpts } from './verifiers';
 export interface QueryWithFieldName {
     query: Query;
     fieldName: string;
     rawValue?: unknown;
     isSelectiveDisclosure?: boolean;
 }
+/**
+ *  Metadata that returns on verification
+ * @type VerificationResultMetadata
+ */
+export type VerificationResultMetadata = {
+    linkID?: number;
+};
 /**
  *  List of options to customize ProofService
  */
 export type ProofServiceOptions = Options & {
     prover?: IZKProver;
 };
+export interface ProofVerifyOpts {
+    query: ProofQuery;
+    sender: string;
+    opts?: VerifyOpts;
+    params?: JSONObject;
+}
 export interface IProofService {
     /**
      * Verification of zkp proof for given circuit id
@@ -31,6 +45,14 @@ export interface IProofService {
      * @returns `{Promise<boolean>}`
      */
     verifyProof(zkp: ZKProof, circuitName: CircuitId): Promise<boolean>;
+    /**
+     * Verification of zkp proof and pub signals for given circuit id
+     *
+     * @param {ZeroKnowledgeProofResponse} response  - zero knowledge proof response
+     * @param {ProofVerifyOpts} opts - proof verification options
+     * @returns `{Promise<VerificationResultMetadata>}`
+     */
+    verifyZKPResponse(proofResp: ZeroKnowledgeProofResponse, opts: ProofVerifyOpts): Promise<VerificationResultMetadata>;
     /**
      * Generate proof from given identity and credential for protocol proof request
      *
@@ -95,6 +117,7 @@ export declare class ProofService implements IProofService {
     private readonly _prover;
     private readonly _ldOptions;
     private readonly _inputsGenerator;
+    private readonly _pubSignalsVerifier;
     /**
      * Creates an instance of ProofService.
      * @param {IIdentityWallet} _identityWallet - identity wallet
@@ -105,6 +128,8 @@ export declare class ProofService implements IProofService {
     constructor(_identityWallet: IIdentityWallet, _credentialWallet: ICredentialWallet, _circuitStorage: ICircuitStorage, _stateStorage: IStateStorage, opts?: ProofServiceOptions);
     /** {@inheritdoc IProofService.verifyProof} */
     verifyProof(zkp: ZKProof, circuitId: CircuitId): Promise<boolean>;
+    /** {@inheritdoc IProofService.verify} */
+    verifyZKPResponse(proofResp: ZeroKnowledgeProofResponse, opts: ProofVerifyOpts): Promise<VerificationResultMetadata>;
     /** {@inheritdoc IProofService.generateProof} */
     generateProof(proofReq: ZeroKnowledgeProofRequest, identifier: DID, opts?: ProofGenerationOptions): Promise<ZeroKnowledgeProofResponse>;
     /** {@inheritdoc IProofService.transitState} */

package/dist/types/proof/provers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './inputs-generator';
+export * from './prover';
+export * from './witness_calculator';

package/dist/types/proof/{inputs-generator.d.ts → provers/inputs-generator.d.ts}

@@ -1,11 +1,11 @@
 import { DID } from '@iden3/js-iden3-core';
-import { RevocationStatus, W3CCredential } from '../verifiable';
-import { ZeroKnowledgeProofRequest } from '../iden3comm';
-import { CircuitClaim, Query, TreeState } from '../circuits';
-import { PreparedAuthBJJCredential, PreparedCredential } from './common';
-import { IIdentityWallet } from '../identity';
-import { IStateStorage } from '../storage';
-import { ICredentialWallet } from '../credentials';
+import { RevocationStatus, W3CCredential } from '../../verifiable';
+import { ZeroKnowledgeProofRequest } from '../../iden3comm';
+import { CircuitClaim, CircuitId, Operators, Query, TreeState } from '../../circuits';
+import { PreparedAuthBJJCredential, PreparedCredential } from '../common';
+import { IIdentityWallet } from '../../identity';
+import { IStateStorage } from '../../storage';
+import { ICredentialWallet } from '../../credentials';
 export type DIDProfileMetadata = {
     authProfileNonce: number;
     credentialSubjectProfileNonce: number;
@@ -26,6 +26,12 @@ type InputContext = {
     params: ProofInputsParams;
     circuitQueries: Query[];
 };
+export declare const circuitValidator: {
+    [k in CircuitId]: {
+        maxQueriesCount: number;
+        supportedOperations: Operators[];
+    };
+};
 export declare class InputGenerator {
     private readonly _identityWallet;
     private readonly _credentialWallet;
@@ -40,7 +46,7 @@ export declare class InputGenerator {
     private credentialAtomicQuerySigV2OnChainPrepareInputs;
     private credentialAtomicQueryV3PrepareInputs;
     private credentialAtomicQueryV3OnChainPrepareInputs;
-    private linkedNullifierPrepareInputs;
-    linkedMultiQuery10PrepareInputs: ({ preparedCredential, proofReq, params, circuitQueries }: InputContext) => Promise<Uint8Array>;
+    private linkedMultiQuery10PrepareInputs;
+    private transformV2QueryOperator;
 }
 export {};

package/dist/types/proof/{prover.d.ts → provers/prover.d.ts}

@@ -1,6 +1,6 @@
 import { ZKProof } from '@iden3/js-jwz';
-import { CircuitId } from '../circuits';
-import { ICircuitStorage } from '../storage/interfaces/circuits';
+import { ICircuitStorage } from '../../storage';
+import { CircuitId } from '../../circuits';
 /**
  * ZKProver is responsible for proof generation and verification
  *

package/dist/types/proof/verifiers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './pub-signals-verifier';
+export * from './query';

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

@@ -0,0 +1,58 @@
+import { Id } from '@iden3/js-iden3-core';
+import { DocumentLoader } from '@iden3/js-jsonld-merklization';
+import { JSONObject } from '../../iden3comm';
+import { IStateStorage } from '../../storage';
+import { ProofQuery } from '../../verifiable';
+import { BaseConfig } from '../../circuits/common';
+import { VerifyOpts } from './query';
+/**
+ *  Verify Context - params for pub signal verification
+ * @type VerifyContext
+ */
+export type VerifyContext = {
+    pubSignals: string[];
+    query: ProofQuery;
+    verifiablePresentation?: JSON;
+    sender: string;
+    challenge: bigint;
+    opts?: VerifyOpts;
+    params?: JSONObject;
+};
+export declare const userStateError: Error;
+/**
+ * PubSignalsVerifier provides verify method
+ * @public
+ * @class PubSignalsVerifier
+ */
+export declare class PubSignalsVerifier {
+    private readonly _documentLoader;
+    private readonly _stateStorage;
+    userId: Id;
+    challenge: bigint;
+    /**
+     * Creates an instance of PubSignalsVerifier.
+     * @param {DocumentLoader} _documentLoader document loader
+     * @param {IStateStorage} _stateStorage state storage
+     */
+    constructor(_documentLoader: DocumentLoader, _stateStorage: IStateStorage);
+    /**
+     * verify public signals
+     *
+     * @param {string} circuitId circuit id
+     * @param {VerifyContext} ctx verification parameters
+     * @returns `Promise<BaseConfig>`
+     */
+    verify(circuitId: string, ctx: VerifyContext): Promise<BaseConfig>;
+    private credentialAtomicQueryMTPV2Verify;
+    private credentialAtomicQuerySigV2Verify;
+    private credentialAtomicQueryV3Verify;
+    private authV2Verify;
+    private linkedMultiQuery10Verify;
+    private verifyIdOwnership;
+    private resolve;
+    private rootResolve;
+    private checkStateExistenceForId;
+    private checkGlobalState;
+    private checkRevocationStateForId;
+    private checkRevocationState;
+}

package/dist/types/proof/verifiers/query.d.ts

@@ -0,0 +1,25 @@
+import { Id, SchemaHash } from '@iden3/js-iden3-core';
+import { DocumentLoader } from '@iden3/js-jsonld-merklization';
+import { CircuitId } from '../../circuits/models';
+import { ProofQuery } from '../../verifiable';
+/**
+ * Options to verify state
+ */
+export type VerifyOpts = {
+    acceptedStateTransitionDelay?: number;
+    acceptedProofGenerationDelay?: number;
+};
+export interface ClaimOutputs {
+    issuerId: Id;
+    schemaHash: SchemaHash;
+    slotIndex?: number;
+    operator: number;
+    value: bigint[];
+    timestamp: number;
+    merklized: number;
+    claimPathKey?: bigint;
+    claimPathNotExists?: number;
+    valueArraySize: number;
+    isRevocationChecked: number;
+}
+export declare function checkQueryRequest(query: ProofQuery, outputs: ClaimOutputs, circuitId: CircuitId, schemaLoader?: DocumentLoader, verifiablePresentation?: JSON, opts?: VerifyOpts): Promise<void>;

package/dist/types/schema-processor/json/parser.d.ts

@@ -1,24 +1,27 @@
-import { W3CCredential } from '../../verifiable';
+import { W3CCredential, CoreClaimCreationOptions, CoreClaimParsedSlots, CoreClaimSlotsPaths } from '../../verifiable';
 import { Claim as CoreClaim } from '@iden3/js-iden3-core';
 import { Merklizer, Options } from '@iden3/js-jsonld-merklization';
 /**
+ *
+ * @deprecated The interface should not be used. Use CoreClaimParsingOptions from verifiable package instead.
+ * CoreClaimOptions is params for core claim parsing
+ *
+ * @public
+ * @interface   CoreClaimOptions
+ */
+export type CoreClaimOptions = CoreClaimCreationOptions;
+/**
+ * @deprecated The interface should not be used. Use CoreClaimParsedSlots from verifiable package instead.
  * Parsed slots of core.Claim
  *
  * @public
  * @interface   ParsedSlots
  */
-export interface ParsedSlots {
-    indexA: Uint8Array;
-    indexB: Uint8Array;
-    valueA: Uint8Array;
-    valueB: Uint8Array;
-}
-interface SlotsPaths {
-    indexAPath: string;
-    indexBPath: string;
-    valueAPath: string;
-    valueBPath: string;
-}
+export type ParsedSlots = CoreClaimParsedSlots;
+/**
+ * @deprecated The interface should not be used. Use CoreClaimSlotsPaths from verifiable package instead.
+ */
+export type SlotsPaths = CoreClaimSlotsPaths;
 /**
  * Serialization of data slots for the fields non-merklized claims
  *
@@ -54,20 +57,6 @@ export interface JSONSchema {
     $schema: string;
     type: string;
 }
-/**
- * CoreClaimOptions is params for core claim parsing
- *
- * @public
- * @interface   CoreClaimOptions
- */
-export interface CoreClaimOptions {
-    revNonce: number;
-    version: number;
-    subjectPosition: string;
-    merklizedRootPosition: string;
-    updatable: boolean;
-    merklizeOpts?: Options;
-}
 /**
  * Parser can parse claim and schema data according to specification
  *
@@ -76,6 +65,7 @@ export interface CoreClaimOptions {
  */
 export declare class Parser {
     /**
+     *  @deprecated The method should not be used. Use credential.toCoreClaim instead.
      *  ParseClaim creates core.Claim object from W3CCredential
      *
      * @param {W3CCredential} credential - Verifiable Credential
@@ -83,14 +73,42 @@ export declare class Parser {
      * @returns `Promise<CoreClaim>`
      */
     static parseClaim(credential: W3CCredential, opts?: CoreClaimOptions): Promise<CoreClaim>;
+    /**
+     * @deprecated The method should not be used. Use findCredentialType from verifiable.
+     */
     static findCredentialType(mz: Merklizer): string;
+    /**
+     *  @deprecated The method should not be used. Use credential.getSerializationAttr instead.
+     *
+     *  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.
+     *  */
     static getSerializationAttr(credential: W3CCredential, opts: Options, tp: string): Promise<string>;
+    /**
+     * @deprecated The method should not be used. Use getSerializationAttrFromContext from verifiable.
+     *
+     *  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.
+     *
+     */
     static getSerializationAttrFromContext(context: object, opts: Options, tp: string): Promise<string>;
+    /**
+     * @deprecated The method should not be used. Use getSerializationAttrFromParsedContext from verifiable.
+     *
+     * */
     static getSerializationAttrFromParsedContext(ldCtx: {
         mappings: Map<string, Record<string, unknown>>;
     }, tp: string): Promise<string>;
+    /**
+     * @deprecated The method should not be used. Use parseSerializationAttr from verifiable.
+     *
+     */
     static parseSerializationAttr(serAttr: string): SlotsPaths;
     /**
+     *
+     * @deprecated The method should not be used. Use credential.parseSlots instead.
      * ParseSlots converts payload to claim slots using provided schema
      *
      * @param {Merklizer} mz - Merklizer
@@ -103,6 +121,8 @@ export declare class Parser {
         nonMerklized: boolean;
     }>;
     /**
+     * @deprecated The method should not be used. Use getFieldSlotIndex from verifiable.
+     *
      * 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
@@ -118,4 +138,3 @@ export declare class Parser {
      */
     static extractCredentialSubjectProperties(schema: string): Promise<Array<string>>;
 }
-export {};

package/dist/types/schema-processor/utils.d.ts

@@ -31,18 +31,23 @@ export declare function dataFillsSlot(slot: Uint8Array, newData: Uint8Array): bo
  */
 export declare function checkDataInField(data: Uint8Array): boolean;
 /**
+ *
+ * @deprecated The method should not be used. Use caclulateCoreSchemaHash from verifiable.
  * Calculates schema hash
  *
  * @param {Uint8Array} schemaId
  * @returns {*}  {SchemaHash}
  */
 export declare const createSchemaHash: (schemaId: Uint8Array) => SchemaHash;
-export declare const credentialSubjectKey = "credentialSubject";
 /**
+ *
+ * @deprecated The method should not be used. Use fillCoreClaimSlot from verifiable.
  * checks if data can fill the slot
  *
- * @param {*} data - object that contains field
- * @param {string} fieldName - field name
- * @returns Uint8Array - filled slot
+ * @param {Uint8Array} slotData - slot data
+ * @param {Merklizer} mz - merklizer
+ * @param {string} path - path
+ * @returns {void}
  */
 export declare const fillSlot: (slotData: Uint8Array, mz: Merklizer, path: string) => Promise<void>;
+export declare const credentialSubjectKey = "credentialSubject";

package/dist/types/storage/blockchain/state.d.ts

@@ -41,13 +41,17 @@ export declare class EthStateStorage implements IStateStorage {
      * Creates an instance of EthStateStorage.
      * @param {EthConnectionConfig} [ethConfig=defaultEthConnectionConfig]
      */
-    constructor(ethConfig?: EthConnectionConfig);
+    constructor(ethConfig: EthConnectionConfig | EthConnectionConfig[]);
     /** {@inheritdoc IStateStorage.getLatestStateById} */
     getLatestStateById(id: bigint): Promise<StateInfo>;
+    /** {@inheritdoc IStateStorage.getStateInfoByIdAndState} */
+    getStateInfoByIdAndState(id: bigint, state: bigint): Promise<StateInfo>;
     /** {@inheritdoc IStateStorage.publishState} */
     publishState(proof: ZKProof, signer: Signer): Promise<string>;
     /** {@inheritdoc IStateStorage.getGISTProof} */
     getGISTProof(id: bigint): Promise<StateProof>;
     /** {@inheritdoc IStateStorage.getGISTRootInfo} */
     getGISTRootInfo(id: bigint): Promise<RootInfo>;
+    private getStateContractAndProviderForId;
+    private networkByChainId;
 }

package/dist/types/storage/interfaces/state.d.ts

@@ -15,6 +15,14 @@ export interface IStateStorage {
      * @returns `Promise<StateInfo>`
      */
     getLatestStateById(id: bigint): Promise<StateInfo>;
+    /**
+     * gets state info of identity by id and state
+     *
+     * @param {bigint} id - id to check
+     * @param {bigint} state - state to check
+     * @returns `Promise<StateInfo>`
+     */
+    getStateInfoByIdAndState(id: bigint, state: bigint): Promise<StateInfo>;
     /**
      * method to publish state onchain
      *

package/dist/types/utils/compare-func.d.ts

@@ -0,0 +1 @@
+export declare const bigIntCompare: (a: bigint, b: bigint) => number;

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

@@ -1,3 +1,5 @@
 export * from './encoding';
 export * from './object';
 export * from './did-helper';
+export * from './message-bus';
+export * from './compare-func';

package/dist/types/utils/message-bus.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Represents an event in the SDK.
+ */
+type SdkEvent = string;
+export declare const SDK_EVENTS: {
+    [k: SdkEvent]: SdkEvent;
+};
+/**
+ * Represents a topic in the SDK message bus.
+ */
+export type SdkTopic = keyof typeof SDK_EVENTS;
+/**
+ * Represents a message bus that allows publishing and subscribing to topics.
+ */
+export declare class MessageBus {
+    /**
+     * The singleton instance of the MessageBus class.
+     */
+    private static instance;
+    /**
+     * Private constructor for the MessageBus class.
+     */
+    private constructor();
+    /**
+     * Returns the singleton instance of the MessageBus class.
+     * If the instance doesn't exist, it creates a new one.
+     * @returns The singleton instance of the MessageBus class.
+     */
+    static getInstance(): MessageBus;
+    /**
+     * Publishes a message to the specified topic.
+     *
+     * @template T - The type of data being published.
+     * @param {SdkTopic} topic - The topic to publish the message to.
+     * @param {T} data - The data to be published.
+     * @returns {boolean} - Returns true if the message was successfully published, false otherwise.
+     */
+    publish<T>(topic: SdkTopic, data: T): boolean;
+    /**
+     * Subscribes to a specific topic and registers a callback function to be executed when a message is published.
+     *
+     * @param topic - The topic to subscribe to.
+     * @param callback - The callback function to be executed when a message is published.
+     */
+    subscribe<T>(topic: SdkTopic, callback: (data: T) => void): string;
+    /**
+     * Subscribes to a specific topic and registers a callback function to be executed when a message is published.
+     * The callback function is executed only once.
+     *
+     * @param topic - The topic to subscribe to.
+     * @param callback - The callback function to be executed when a message is published.
+     */
+    subscribeOnce<T>(topic: SdkTopic, callback: (data: T) => void): void;
+    /**
+     * Unsubscribes from a specific topic in the message bus.
+     *
+     * @param topic - The topic to unsubscribe from.
+     * @returns A string or boolean indicating the success of the unsubscribe operation.
+     */
+    unsubscribe(topic: SdkTopic): string | boolean;
+}
+export {};

package/dist/types/verifiable/core-utils.d.ts

@@ -0,0 +1,84 @@
+import { SchemaHash } from '@iden3/js-iden3-core';
+import { Merklizer, Options } from '@iden3/js-jsonld-merklization';
+/**
+ * CoreClaimCreationOptions is params for core claim creation
+ *
+ * @public
+ * @interface   CoreClaimCreationOptions
+ */
+export interface CoreClaimCreationOptions {
+    revNonce: number;
+    version: number;
+    subjectPosition: string;
+    merklizedRootPosition: string;
+    updatable: boolean;
+    merklizeOpts?: Options;
+}
+/**
+ * Parsed slots of core.Claim
+ *
+ * @public
+ * @interface   CoreClaimParsedSlots
+ */
+export interface CoreClaimParsedSlots {
+    indexA: Uint8Array;
+    indexB: Uint8Array;
+    valueA: Uint8Array;
+    valueB: Uint8Array;
+}
+/**
+ * Slots paths of core.Claim
+ *
+ * @public
+ * @interface   CoreClaimSlotsPaths
+ */
+export interface CoreClaimSlotsPaths {
+    indexAPath: string;
+    indexBPath: string;
+    valueAPath: string;
+    valueBPath: string;
+}
+/**
+ * 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 declare const getFieldSlotIndex: (field: string, typeName: string, schemaBytes: Uint8Array) => Promise<number>;
+/**
+ * checks if data can fill the slot
+ *
+ * @param {Uint8Array} slotData - slot data
+ * @param {Merklizer} mz - merklizer
+ * @param {string} path - path
+ * @returns {void}
+ */
+export declare const fillCoreClaimSlot: (slotData: Uint8Array, mz: Merklizer, path: string) => Promise<void>;
+export declare const getSerializationAttrFromContext: (context: object, opts: Options, tp: string) => Promise<string>;
+export declare const getSerializationAttrFromParsedContext: (ldCtx: {
+    mappings: Map<string, Record<string, unknown>>;
+}, tp: string) => Promise<string>;
+export declare const parseSerializationAttr: (serAttr: string) => CoreClaimSlotsPaths;
+export declare const findCredentialType: (mz: Merklizer) => string;
+/**
+ * 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 declare const parseCoreClaimSlots: (ldCtx: {
+    mappings: Map<string, Record<string, unknown>>;
+}, mz: Merklizer, credentialType: string) => Promise<{
+    slots: CoreClaimParsedSlots;
+    nonMerklized: boolean;
+}>;
+/**
+ * Calculates core schema hash
+ *
+ * @param {Uint8Array} schemaId
+ * @returns {*}  {SchemaHash}
+ */
+export declare const caclulateCoreSchemaHash: (schemaId: Uint8Array) => SchemaHash;