@0xpolygonid/js-sdk 1.23.0 → 1.24.1

package/dist/node/esm/storage/blockchain/onchain-issuer.js

@@ -0,0 +1,78 @@
+import { DID, Id, chainIDfromDID } from '@iden3/js-iden3-core';
+import { Contract, ethers } from 'ethers';
+import { INonMerklizedIssuerABI as abi } from '@iden3/onchain-non-merklized-issuer-base-abi';
+import { OnchainNonMerklizedIssuerAdapter } from './onchain-issuer-adapter/non-merklized/version/v0.0.1/onchain-non-merklized-issuer-adapter';
+/**
+ * Represents an adapter for interacting with on-chain issuers.
+ *
+ * @public
+ * @beta
+ * @class OnchainIssuer
+ */
+export class OnchainIssuer {
+    /**
+     * Initializes an instance of `Adapter`.
+     * @param config The configuration for the Ethereum connection.
+     * @param merklizationOptions Optional settings for merklization.
+     */
+    constructor(config, options) {
+        this._ethConnectionConfig = config;
+        this._onchainIssuerOptions = options;
+    }
+    /**
+     * Retrieves a credential from the on-chain issuer.
+     * @param issuerDID The issuer's core.DID.
+     * @param userId The user's core.Id.
+     * @param credentialId The unique identifier of the credential.
+     */
+    async getCredential(issuerDID, userDID, credentialId) {
+        const { contract, connection } = this.getContractConnection(issuerDID);
+        const response = await contract.getCredentialAdapterVersion();
+        switch (response) {
+            case '0.0.1': {
+                const adapter = new OnchainNonMerklizedIssuerAdapter(connection, issuerDID, {
+                    merklizationOptions: this._onchainIssuerOptions?.merklizationOptions
+                });
+                await adapter.isInterfaceSupported();
+                const { credentialData, coreClaimBigInts, credentialSubjectFields } = await adapter.getCredential(DID.idFromDID(userDID), credentialId);
+                return await adapter.convertOnChainInfoToW3CCredential(credentialData, coreClaimBigInts, credentialSubjectFields);
+            }
+            default:
+                throw new Error(`Unsupported adapter version ${response}`);
+        }
+    }
+    /**
+     * Retrieves the credential identifiers for a user from the on-chain issuer.
+     * @param issuerDID The issuer's core.DID.
+     * @param userId The user's core.Id.
+     */
+    async getUserCredentialIds(issuerDID, userDID) {
+        const { contract, connection } = this.getContractConnection(issuerDID);
+        const response = await contract.getCredentialAdapterVersion();
+        switch (response) {
+            case '0.0.1': {
+                const adapter = new OnchainNonMerklizedIssuerAdapter(connection, issuerDID, {
+                    merklizationOptions: this._onchainIssuerOptions?.merklizationOptions
+                });
+                await adapter.isInterfaceSupported();
+                return await adapter.getUserCredentialsIds(DID.idFromDID(userDID));
+            }
+            default:
+                throw new Error(`Unsupported adapter version ${response}`);
+        }
+    }
+    getContractConnection(did) {
+        const issuerId = DID.idFromDID(did);
+        const chainId = chainIDfromDID(did);
+        const contractAddress = ethers.getAddress(ethers.hexlify(Id.ethAddressFromId(issuerId)));
+        const connection = this._ethConnectionConfig.find((c) => c.chainId === chainId);
+        if (!connection) {
+            throw new Error(`No connection found for chain ID ${chainId}`);
+        }
+        if (!connection.url) {
+            throw new Error(`No URL found for chain ID ${chainId}`);
+        }
+        const contract = new Contract(contractAddress, abi, new ethers.JsonRpcProvider(connection.url));
+        return { contract, connection };
+    }
+}

package/dist/node/esm/storage/blockchain/onchain-zkp-verifier.js

@@ -37,23 +37,8 @@ export class OnChainZKPVerifier {
     constructor(_configs, _opts) {
         this._configs = _configs;
         this._opts = _opts;
-        /**
-         * supported circuits
-         */
-        this._supportedCircuits = [
-            CircuitId.AtomicQueryMTPV2OnChain,
-            CircuitId.AtomicQuerySigV2OnChain,
-            CircuitId.AtomicQueryV3OnChain
-        ];
-        /**
-         * abi coder to encode/decode structures to solidity bytes
-         */
-        this._abiCoder = new ethers.AbiCoder();
     }
-    /**
-     * {@inheritDoc IOnChainZKPVerifier.prepareTxArgsSubmitV1}
-     */
-    async prepareTxArgsSubmitV1(txData, zkProofResponse) {
+    static async prepareTxArgsSubmitV1(txData, zkProofResponse) {
         if (txData.method_id.replace('0x', '') !== FunctionSignatures.SubmitZKPResponseV1) {
             throw new Error(`prepareTxArgsSubmitV1 function doesn't implement requested method id. Only '0x${FunctionSignatures.SubmitZKPResponseV1}' is supported.`);
         }
@@ -71,6 +56,12 @@ export class OnChainZKPVerifier {
         ];
         return payload;
     }
+    /**
+     * {@inheritDoc IOnChainZKPVerifier.prepareTxArgsSubmitV1}
+     */
+    async prepareTxArgsSubmitV1(txData, zkProofResponse) {
+        return OnChainZKPVerifier.prepareTxArgsSubmitV1(txData, zkProofResponse);
+    }
     /**
      * {@inheritDoc IOnChainZKPVerifier.submitZKPResponse}
      */
@@ -160,13 +151,10 @@ export class OnChainZKPVerifier {
         const { txnHash } = await transactionService.sendTransactionRequest(ethSigner, request);
         return new Map().set(txnHash, zkProofResponses);
     }
-    async prepareTxArgsSubmitV2(txData, zkProofResponses) {
+    static async prepareTxArgsSubmitV2(resolverUrl, txData, zkProofResponses) {
         if (txData.method_id.replace('0x', '') !== FunctionSignatures.SubmitZKPResponseV2) {
             throw new Error(`submit cross chain doesn't implement requested method id. Only '0x${FunctionSignatures.SubmitZKPResponseV2}' is supported.`);
         }
-        if (!this._opts?.didResolverUrl) {
-            throw new Error(`did resolver url required for crosschain verification`);
-        }
         const gistUpdateArr = [];
         const stateUpdateArr = [];
         const payload = [];
@@ -191,7 +179,9 @@ export class OnChainZKPVerifier {
                     continue;
                 }
                 gistUpdateResolutionsPending.push(JSON.stringify(gist));
-                gistUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(DID.parseFromId(gist.id), this._opts.didResolverUrl, { gist: gist.root }));
+                gistUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(DID.parseFromId(gist.id), resolverUrl, {
+                    gist: gist.root
+                }));
             }
             const stateUpdateResolutions = [];
             for (const state of stateInfo.states) {
@@ -200,7 +190,7 @@ export class OnChainZKPVerifier {
                     continue;
                 }
                 stateUpdateResolutionsPending.push(JSON.stringify(state));
-                stateUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(DID.parseFromId(state.id), this._opts.didResolverUrl, {
+                stateUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(DID.parseFromId(state.id), resolverUrl, {
                     state: state.state
                 }));
             }
@@ -234,10 +224,16 @@ export class OnChainZKPVerifier {
         const crossChainProofs = this.packCrossChainProofs(gistUpdateArr, stateUpdateArr);
         return [payload, crossChainProofs];
     }
-    packZkpProof(inputs, a, b, c) {
-        return this._abiCoder.encode(['uint256[] inputs', 'uint256[2]', 'uint256[2][2]', 'uint256[2]'], [inputs, a, b, c]);
+    async prepareTxArgsSubmitV2(txData, zkProofResponses) {
+        if (!this._opts?.didResolverUrl) {
+            throw new Error(`did resolver url required for crosschain verification`);
+        }
+        return OnChainZKPVerifier.prepareTxArgsSubmitV2(this._opts.didResolverUrl, txData, zkProofResponses);
+    }
+    static packZkpProof(inputs, a, b, c) {
+        return new ethers.AbiCoder().encode(['uint256[] inputs', 'uint256[2]', 'uint256[2][2]', 'uint256[2]'], [inputs, a, b, c]);
     }
-    packCrossChainProofs(gistUpdateArr, stateUpdateArr) {
+    static packCrossChainProofs(gistUpdateArr, stateUpdateArr) {
         const proofs = [];
         for (const globalStateUpdate of gistUpdateArr) {
             proofs.push({
@@ -251,10 +247,10 @@ export class OnChainZKPVerifier {
                 proof: this.packIdentityStateMsg(stateUpdate)
             });
         }
-        return this._abiCoder.encode(['tuple(' + 'string proofType,' + 'bytes proof' + ')[]'], [proofs]);
+        return new ethers.AbiCoder().encode(['tuple(' + 'string proofType,' + 'bytes proof' + ')[]'], [proofs]);
     }
-    packGlobalStateMsg(msg) {
-        return this._abiCoder.encode([
+    static packGlobalStateMsg(msg) {
+        return new ethers.AbiCoder().encode([
             'tuple(' +
                 'tuple(' +
                 'uint256 timestamp,' +
@@ -266,8 +262,8 @@ export class OnChainZKPVerifier {
                 ')'
         ], [msg]);
     }
-    packIdentityStateMsg(msg) {
-        return this._abiCoder.encode([
+    static packIdentityStateMsg(msg) {
+        return new ethers.AbiCoder().encode([
             'tuple(' +
                 'tuple(' +
                 'uint256 timestamp,' +
@@ -279,10 +275,10 @@ export class OnChainZKPVerifier {
                 ')'
         ], [msg]);
     }
-    packMetadatas(metas) {
-        return this._abiCoder.encode(['tuple(' + 'string key,' + 'bytes value' + ')[]'], [metas]);
+    static packMetadatas(metas) {
+        return new ethers.AbiCoder().encode(['tuple(' + 'string key,' + 'bytes value' + ')[]'], [metas]);
     }
-    getOnChainGistRootStatePubSignals(onChainCircuitId, inputs) {
+    static getOnChainGistRootStatePubSignals(onChainCircuitId, inputs) {
         let atomicQueryPubSignals;
         switch (onChainCircuitId) {
             case CircuitId.AtomicQueryMTPV2OnChain:
@@ -299,7 +295,7 @@ export class OnChainZKPVerifier {
         atomicQueryPubSignals.pubSignalsUnmarshal(encodedInputs);
         return atomicQueryPubSignals.getStatesInfo();
     }
-    async resolveDidDocumentEip712MessageAndSignature(did, resolverUrl, opts) {
+    static async resolveDidDocumentEip712MessageAndSignature(did, resolverUrl, opts) {
         const didDoc = await resolveDidDocument(did, resolverUrl, {
             ...opts,
             signature: DIDDocumentSignature.EthereumEip712Signature2021
@@ -332,3 +328,11 @@ export class OnChainZKPVerifier {
         };
     }
 }
+/**
+ * supported circuits
+ */
+OnChainZKPVerifier._supportedCircuits = [
+    CircuitId.AtomicQueryMTPV2OnChain,
+    CircuitId.AtomicQuerySigV2OnChain,
+    CircuitId.AtomicQueryV3OnChain
+];

package/dist/node/esm/storage/interfaces/index.js

@@ -7,3 +7,4 @@ export * from './data-source';
 export * from './circuits';
 export * from './onchain-zkp-verifier';
 export * from './onchain-revocation';
+export * from './onchain-issuer';

package/dist/node/esm/storage/interfaces/onchain-issuer.js

@@ -0,0 +1 @@
+export {};

package/dist/node/esm/utils/did-helper.js

@@ -65,7 +65,7 @@ export const validateDIDDocumentAuth = async (did, resolverURL, state) => {
     }
 };
 export const resolveDIDDocumentAuth = async (did, resolveURL, state) => {
-    let url = `${resolveURL}/${did.string().replace(/:/g, '%3A')}`;
+    let url = `${resolveURL}/${encodeURIComponent(did.string())}`;
     if (state) {
         url += `?state=${state.hex()}`;
     }
@@ -81,11 +81,11 @@ function emptyStateDID(did) {
     return emptyDID;
 }
 export const resolveDidDocument = async (did, resolverUrl, opts) => {
-    let didString = did.string().replace(/:/g, '%3A');
+    let didString = encodeURIComponent(did.string());
     // for gist resolve we have to `hide` user did (look into resolver implementation)
     const isGistRequest = opts?.gist && !opts.state;
     if (isGistRequest) {
-        didString = emptyStateDID(did).string();
+        didString = encodeURIComponent(emptyStateDID(did).string());
     }
     let url = `${resolverUrl}/1.0/identifiers/${didString}`;
     if (opts?.signature) {

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

@@ -154,6 +154,7 @@ export var SupportedCurrencies;
     SupportedCurrencies["ETH_WEI"] = "ETHWEI";
     SupportedCurrencies["ETH_GWEI"] = "ETHGWEI";
     SupportedCurrencies["MATIC"] = "MATIC";
+    SupportedCurrencies["POL"] = "POL";
     SupportedCurrencies["USDT"] = "USDT";
     SupportedCurrencies["USDC"] = "USDC";
 })(SupportedCurrencies || (SupportedCurrencies = {}));

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

@@ -1,12 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { BJJSignatureProof2021, Iden3SparseMerkleTreeProof } from './proof';
-import { Claim, DID, MerklizedRootPosition as MerklizedRootPositionCore, IdPosition, ClaimOptions } from '@iden3/js-iden3-core';
+import { Claim, DID, MerklizedRootPosition as MerklizedRootPositionCore, IdPosition, ClaimOptions, getChainId } 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 { byteEncoder, validateDIDDocumentAuth } from '../utils';
-import { MerklizedRootPosition, ProofType, SubjectPosition } from './constants';
+import { CredentialStatusType, MerklizedRootPosition, ProofType, SubjectPosition, VerifiableConstants } from './constants';
 import { calculateCoreSchemaHash, findCredentialType, parseCoreClaimSlots } from './core-utils';
 import * as jsonld from 'jsonld/lib';
 import * as ldcontext from 'jsonld/lib/context';
@@ -25,6 +25,92 @@ export class W3CCredential {
         this.credentialSubject = {};
         this.issuer = '';
     }
+    /**
+     *
+     * @param issuer - DID of the issuer
+     * @param request - Credential request
+     * @returns - W3C Credential
+     */
+    static fromCredentialRequest(issuer, request) {
+        if (!request.id) {
+            throw new Error('Credential id is required');
+        }
+        if (!request.context) {
+            throw new Error('Credential context is required');
+        }
+        const context = [
+            VerifiableConstants.JSONLD_SCHEMA.W3C_CREDENTIAL_2018,
+            VerifiableConstants.JSONLD_SCHEMA.IDEN3_CREDENTIAL,
+            ...request.context
+        ];
+        const credentialType = [
+            VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_CREDENTIAL,
+            request.type
+        ];
+        const credentialSubject = request.credentialSubject;
+        credentialSubject['type'] = request.type;
+        const cr = new W3CCredential();
+        cr.id = request.id;
+        cr['@context'] = context;
+        cr.type = credentialType;
+        cr.credentialSubject = credentialSubject;
+        cr.issuer = issuer.string();
+        cr.credentialSchema = {
+            id: request.credentialSchema,
+            type: VerifiableConstants.JSON_SCHEMA_VALIDATOR
+        };
+        cr.credentialStatus = W3CCredential.buildCredentialStatus(request, issuer);
+        request.expiration && (cr.expirationDate = new Date(request.expiration).toISOString());
+        request.refreshService && (cr.refreshService = request.refreshService);
+        request.displayMethod && (cr.displayMethod = request.displayMethod);
+        request.issuanceDate && (cr.issuanceDate = new Date(request.issuanceDate).toISOString());
+        return cr;
+    }
+    /**
+     * Builds credential status
+     * @param {CredentialRequest} request
+     * @returns `CredentialStatus`
+     */
+    static buildCredentialStatus(request, issuer) {
+        const credentialStatus = {
+            id: request.revocationOpts.id,
+            type: request.revocationOpts.type,
+            revocationNonce: request.revocationOpts.nonce
+        };
+        switch (request.revocationOpts.type) {
+            case CredentialStatusType.SparseMerkleTreeProof:
+                return {
+                    ...credentialStatus,
+                    id: `${credentialStatus.id.replace(/\/$/, '')}/${credentialStatus.revocationNonce}`
+                };
+            case CredentialStatusType.Iden3ReverseSparseMerkleTreeProof:
+                return {
+                    ...credentialStatus,
+                    id: request.revocationOpts.issuerState
+                        ? `${credentialStatus.id.replace(/\/$/, '')}/node?state=${request.revocationOpts.issuerState}`
+                        : `${credentialStatus.id.replace(/\/$/, '')}`
+                };
+            case CredentialStatusType.Iden3OnchainSparseMerkleTreeProof2023: {
+                const issuerId = DID.idFromDID(issuer);
+                const chainId = getChainId(DID.blockchainFromId(issuerId), DID.networkIdFromId(issuerId));
+                const searchParams = [
+                    ['revocationNonce', request.revocationOpts.nonce?.toString() || ''],
+                    ['contractAddress', `${chainId}:${request.revocationOpts.id}`],
+                    ['state', request.revocationOpts.issuerState || '']
+                ]
+                    .filter(([, value]) => Boolean(value))
+                    .map(([key, value]) => `${key}=${value}`)
+                    .join('&');
+                return {
+                    ...credentialStatus,
+                    // `[did]:[methodid]:[chain]:[network]:[id]/credentialStatus?(revocationNonce=value)&[contractAddress=[chainID]:[contractAddress]]&(state=issuerState)`
+                    id: `${issuer.string()}/credentialStatus?${searchParams}`
+                };
+            }
+            default:
+                return credentialStatus;
+        }
+    }
     toJSON() {
         return {
             ...this,

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

@@ -160,12 +160,6 @@ export declare class CredentialWallet implements ICredentialWallet {
      * {@inheritDoc ICredentialWallet.createCredential}
      */
     createCredential: (issuer: DID, request: CredentialRequest, schema: JSONSchema) => W3CCredential;
-    /**
-     * Builds credential status
-     * @param {CredentialRequest} request
-     * @returns `CredentialStatus`
-     */
-    private buildCredentialStatus;
     /**
      * {@inheritDoc ICredentialWallet.findById}
      */

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

@@ -4,6 +4,7 @@ export * from './status/sparse-merkle-tree';
 export * from './status/resolver';
 export * from './status/agent-revocation';
 export * from './status/credential-status-publisher';
+export * from './status/did-resolver-revocation';
 export * from './credential-wallet';
 export * from './rhs';
 export * from './utils';

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

@@ -15,6 +15,10 @@ export type PublishMode = 'sync' | 'async' | 'callback';
  * @interface CredentialRequest
  */
 export interface CredentialRequest {
+    /**
+     * Credential ID
+     */
+    id?: string;
     /**
      * JSON credential schema
      */
@@ -55,6 +59,10 @@ export interface CredentialRequest {
      * merklizedRootPosition (index / value / none)
      */
     merklizedRootPosition?: MerklizedRootPosition;
+    /**
+     * issuance Date
+     */
+    issuanceDate?: number;
     /**
      * Revocation options
      *

package/dist/types/credentials/status/did-resolver-revocation.d.ts

@@ -0,0 +1,7 @@
+import { CredentialStatus, RevocationStatus } from '../../verifiable';
+import { CredentialStatusResolveOptions, CredentialStatusResolver } from './resolver';
+export declare class DidDocumentCredentialStatusResolver implements CredentialStatusResolver {
+    private readonly didResolverUrl;
+    constructor(didResolverUrl: string);
+    resolve(credentialStatus: CredentialStatus, opts?: CredentialStatusResolveOptions | undefined): Promise<RevocationStatus>;
+}

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

@@ -3,6 +3,7 @@ import { BasicMessage, IPackageManager, JWSPackerParams } from '../types';
 import { W3CCredential } from '../../verifiable';
 import { ICredentialWallet } from '../../credentials';
 import { AbstractMessageHandler, BasicHandlerOptions, IProtocolMessageHandler } from './message-handler';
+import { IOnchainIssuer } from '../../storage';
 /**
  *
  * Options to pass to fetch handler
@@ -91,8 +92,10 @@ export declare class FetchHandler extends AbstractMessageHandler implements IFet
      */
     constructor(_packerMgr: IPackageManager, opts?: {
         credentialWallet: ICredentialWallet;
+        onchainIssuer?: IOnchainIssuer | undefined;
     } | undefined);
     handle(message: BasicMessage, ctx: FetchMessageHandlerOptions): Promise<BasicMessage | null>;
+    private handleOnchainOfferMessage;
     private handleOfferMessage;
     /**
      * Handles only messages with credentials/1.0/offer type
@@ -104,6 +107,11 @@ export declare class FetchHandler extends AbstractMessageHandler implements IFet
      * @returns `Promise<W3CCredential[]>`
      */
     handleCredentialOffer(offer: Uint8Array, opts?: FetchHandlerOptions): Promise<W3CCredential[]>;
+    /**
+     * Handles only messages with credentials/1.0/onchain-offer type
+     * @beta
+     */
+    handleOnchainOffer(offer: Uint8Array): Promise<W3CCredential[]>;
     private handleFetchRequest;
     /**
      * @inheritdoc IFetchHandler#handleCredentialFetchRequest

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

@@ -24,6 +24,7 @@ export type PaymentCreationOptions = {
  */
 export declare function createPaymentRequest(sender: DID, receiver: DID, agent: string, payments: PaymentRequestInfo[], opts?: PaymentRequestCreationOptions): PaymentRequestMessage;
 export declare function verifyEIP712TypedData(data: Iden3PaymentRailsRequestV1 | Iden3PaymentRailsERC20RequestV1, resolver: Resolvable): Promise<string>;
+export declare function convertPaymentAmount(amount: string, currency: SupportedCurrencies): Promise<bigint>;
 /**
  * @beta
  * PaymentRailsInfo represents payment info for payment rails
@@ -42,10 +43,10 @@ export type PaymentRailsInfo = {
  */
 export type PaymentRailsChainInfo = {
     nonce: bigint;
-    amount: bigint;
+    amount: string;
     currency: SupportedCurrencies | string;
     chainId: string;
-    expirationDate?: string;
+    expirationDate?: Date;
     features?: PaymentFeatures[];
     type: PaymentRequestDataType.Iden3PaymentRailsRequestV1 | PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1;
 };

package/dist/types/storage/blockchain/did-resolver-readonly-storage.d.ts

@@ -0,0 +1,16 @@
+import { RootInfo, StateInfo, StateProof } from '../entities';
+import { IStateStorage } from '../interfaces';
+import { JsonRpcProvider } from 'ethers';
+export declare class DidResolverStateReadonlyStorage implements IStateStorage {
+    private readonly resolverUrl;
+    constructor(resolverUrl: string);
+    getLatestStateById(id: bigint): Promise<StateInfo>;
+    getStateInfoByIdAndState(id: bigint, state: bigint): Promise<StateInfo>;
+    getGISTProof(id: bigint): Promise<StateProof>;
+    getGISTRootInfo(root: bigint, userId: bigint): Promise<RootInfo>;
+    getRpcProvider(): JsonRpcProvider;
+    publishState(): Promise<string>;
+    publishStateGeneric(): Promise<string>;
+    private getStateInfo;
+    private getIden3StateInfo2023;
+}

package/dist/types/storage/blockchain/{erc20-permit-sig.d.ts → erc20-helper.d.ts}

@@ -1,4 +1,4 @@
-import { Signer } from 'ethers';
+import { Signer, ethers } from 'ethers';
 /**
  * @beta
  * getPermitSignature is a function to create EIP712 Permit signature
@@ -10,3 +10,10 @@ import { Signer } from 'ethers';
  * @returns {Promise<PaymentRequestMessage>}
  */
 export declare function getPermitSignature(signer: Signer, tokenAddress: string, spender: string, value: bigint, deadline: number): Promise<string>;
+/**
+ * @beta
+ * getERC20Decimals is a function to retrieve the number of decimals of an ERC20 token
+ * @param {string} tokenAddress - Token address
+ * @param {ethers.ContractRunner} runner - Contract runner
+ */
+export declare function getERC20Decimals(tokenAddress: string, runner: ethers.ContractRunner): Promise<number>;

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

@@ -1,4 +1,6 @@
 export * from './state';
 export * from './onchain-zkp-verifier';
 export * from './onchain-revocation';
-export * from './erc20-permit-sig';
+export * from './onchain-issuer';
+export * from './did-resolver-readonly-storage';
+export * from './erc20-helper';

package/dist/types/storage/blockchain/onchain-issuer-adapter/non-merklized/version/v0.0.1/onchain-non-merklized-issuer-adapter.d.ts

@@ -0,0 +1,66 @@
+import { DID, Id } from '@iden3/js-iden3-core';
+import { INonMerklizedIssuer } from '@iden3/onchain-non-merklized-issuer-base-abi';
+import { W3CCredential } from '../../../../../../verifiable';
+import { Options } from '@iden3/js-jsonld-merklization';
+import { EthConnectionConfig } from '../../../../state';
+/**
+ * `OnchainNonMerklizedIssuerAdapter` provides functionality to interact with a non-merklized on-chain credential issuer.
+ * This adapter enables interface detection, credential retrieval, and conversion to the W3C Verifiable Credential format.
+ *
+ * @public
+ * @beta
+ * @class OnchainNonMerklizedIssuerAdapter
+ */
+export declare class OnchainNonMerklizedIssuerAdapter {
+    private readonly _contract;
+    private readonly _contractAddress;
+    private readonly _chainId;
+    private readonly _issuerDid;
+    private readonly _merklizationOptions?;
+    /**
+     * Initializes an instance of `OnchainNonMerklizedIssuerAdapter`.
+     *
+     * @param ethConnectionConfig The configuration for the Ethereum connection.
+     * @param issuerDid The decentralized identifier (DID) of the issuer.
+     * @param merklizationOptions Optional settings for merklization.
+     */
+    constructor(ethConnectionConfig: EthConnectionConfig, issuerDid: DID, options?: {
+        merklizationOptions?: Options;
+    });
+    /**
+     * Checks if the contract supports required interfaces.
+     * Throws an error if any required interface is unsupported.
+     *
+     * @throws Error - If required interfaces are not supported.
+     */
+    isInterfaceSupported(): Promise<void>;
+    /**
+     * Retrieves a credential from the on-chain non-merklized contract.
+     * @param userId The user's core.Id.
+     * @param credentialId The unique identifier of the credential.
+     */
+    getCredential(userId: Id, credentialId: bigint): Promise<{
+        credentialData: INonMerklizedIssuer.CredentialDataStructOutput;
+        coreClaimBigInts: bigint[];
+        credentialSubjectFields: INonMerklizedIssuer.SubjectFieldStructOutput[];
+    }>;
+    /**
+     * Retrieves the credential IDs of a user.
+     * @param userId The user's core.Id.
+     * @returns An array of credential IDs.
+     */
+    getUserCredentialsIds(userId: Id): Promise<bigint[]>;
+    /**
+     * Converts on-chain credential to a verifiable credential.
+     *
+     * @param credentialData Data structure of the credential from the contract.
+     * @param coreClaimBigInts Claim data in bigint format.
+     * @param credentialSubjectFields Subject fields of the credential.
+     */
+    convertOnChainInfoToW3CCredential(credentialData: INonMerklizedIssuer.CredentialDataStructOutput, coreClaimBigInts: bigint[], credentialSubjectFields: INonMerklizedIssuer.SubjectFieldStructOutput[]): Promise<W3CCredential>;
+    private credentialId;
+    private convertCredentialSubject;
+    private existenceProof;
+    private validateSourceValue;
+    private convertDisplayMethod;
+}

package/dist/types/storage/blockchain/onchain-issuer.d.ts

@@ -0,0 +1,40 @@
+import { DID } from '@iden3/js-iden3-core';
+import { Options } from '@iden3/js-jsonld-merklization';
+import { W3CCredential } from '../../verifiable';
+import { EthConnectionConfig } from './state';
+import { IOnchainIssuer } from '../interfaces/onchain-issuer';
+interface OnchainIssuerOptions {
+    merklizationOptions?: Options;
+}
+/**
+ * Represents an adapter for interacting with on-chain issuers.
+ *
+ * @public
+ * @beta
+ * @class OnchainIssuer
+ */
+export declare class OnchainIssuer implements IOnchainIssuer {
+    private readonly _ethConnectionConfig;
+    private readonly _onchainIssuerOptions?;
+    /**
+     * Initializes an instance of `Adapter`.
+     * @param config The configuration for the Ethereum connection.
+     * @param merklizationOptions Optional settings for merklization.
+     */
+    constructor(config: EthConnectionConfig[], options?: OnchainIssuerOptions);
+    /**
+     * Retrieves a credential from the on-chain issuer.
+     * @param issuerDID The issuer's core.DID.
+     * @param userId The user's core.Id.
+     * @param credentialId The unique identifier of the credential.
+     */
+    getCredential(issuerDID: DID, userDID: DID, credentialId: bigint): Promise<W3CCredential>;
+    /**
+     * Retrieves the credential identifiers for a user from the on-chain issuer.
+     * @param issuerDID The issuer's core.DID.
+     * @param userId The user's core.Id.
+     */
+    getUserCredentialIds(issuerDID: DID, userDID: DID): Promise<bigint[]>;
+    private getContractConnection;
+}
+export {};