@0xpolygonid/js-sdk 1.21.3 → 1.24.1

package/dist/node/esm/iden3comm/utils/accept-profile.js

@@ -0,0 +1,102 @@
+import { MediaType, ProtocolVersion, AcceptAuthCircuits, AcceptJwzAlgorithms, AcceptJwsAlgorithms } from '../constants';
+function isProtocolVersion(value) {
+    return Object.values(ProtocolVersion).includes(value);
+}
+function isMediaType(value) {
+    return Object.values(MediaType).includes(value);
+}
+function isAcceptAuthCircuits(value) {
+    return Object.values(AcceptAuthCircuits).includes(value);
+}
+function isAcceptJwsAlgorithms(value) {
+    return Object.values(AcceptJwsAlgorithms).includes(value);
+}
+function isAcceptJwzAlgorithms(value) {
+    return Object.values(AcceptJwzAlgorithms).includes(value);
+}
+export const buildAccept = (profiles) => {
+    const result = [];
+    for (const profile of profiles) {
+        let accept = `${profile.protocolVersion};env=${profile.env}`;
+        if (profile.circuits?.length) {
+            accept += `;circuitId=${profile.circuits.join(',')}`;
+        }
+        if (profile.alg?.length) {
+            accept += `;alg=${profile.alg.join(',')}`;
+        }
+        result.push(accept);
+    }
+    return result;
+};
+export const parseAcceptProfile = (profile) => {
+    const params = profile.split(';');
+    if (params.length < 2) {
+        throw new Error('Invalid accept profile');
+    }
+    const protocolVersion = params[0].trim();
+    if (!isProtocolVersion(protocolVersion)) {
+        throw new Error(`Protocol version '${protocolVersion}' not supported`);
+    }
+    const envParam = params[1].split('=');
+    if (envParam.length !== 2) {
+        throw new Error(`Invalid accept profile 'env' parameter`);
+    }
+    const env = params[1].split('=')[1].trim();
+    if (!isMediaType(env)) {
+        throw new Error(`Envelop '${env}' not supported`);
+    }
+    const circuitsIndex = params.findIndex((i) => i.includes('circuitId='));
+    if (env !== MediaType.ZKPMessage && circuitsIndex > 0) {
+        throw new Error(`Circuits not supported for env '${env}'`);
+    }
+    let circuits = undefined;
+    if (circuitsIndex > 0) {
+        circuits = params[circuitsIndex]
+            .split('=')[1]
+            .split(',')
+            .map((i) => i.trim())
+            .map((i) => {
+            if (!isAcceptAuthCircuits(i)) {
+                throw new Error(`Circuit '${i}' not supported`);
+            }
+            return i;
+        });
+    }
+    const algIndex = params.findIndex((i) => i.includes('alg='));
+    let alg = undefined;
+    if (algIndex > 0) {
+        if (env === MediaType.ZKPMessage) {
+            alg = params[algIndex]
+                .split('=')[1]
+                .split(',')
+                .map((i) => {
+                i = i.trim();
+                if (!isAcceptJwzAlgorithms(i)) {
+                    throw new Error(`Algorithm '${i}' not supported for '${env}'`);
+                }
+                return i;
+            });
+        }
+        else if (env === MediaType.SignedMessage) {
+            alg = params[algIndex]
+                .split('=')[1]
+                .split(',')
+                .map((i) => {
+                i = i.trim();
+                if (!isAcceptJwsAlgorithms(i)) {
+                    throw new Error(`Algorithm '${i}' not supported for '${env}'`);
+                }
+                return i;
+            });
+        }
+        else {
+            throw new Error(`Algorithm not supported for '${env}'`);
+        }
+    }
+    return {
+        protocolVersion,
+        env,
+        circuits,
+        alg
+    };
+};

package/dist/node/esm/iden3comm/utils/index.js

@@ -1,3 +1,4 @@
 export * from './envelope';
 export * from './message';
 export * from './did';
+export * from './accept-profile';

package/dist/node/esm/storage/blockchain/abi/ERC20.json

@@ -0,0 +1 @@
+[{ "inputs": [{ "internalType": "uint256", "name": "initialSupply", "type": "uint256" }], "stateMutability": "nonpayable", "type": "constructor" }, { "inputs": [{ "internalType": "address", "name": "spender", "type": "address" }, { "internalType": "uint256", "name": "allowance", "type": "uint256" }, { "internalType": "uint256", "name": "needed", "type": "uint256" }], "name": "ERC20InsufficientAllowance", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "sender", "type": "address" }, { "internalType": "uint256", "name": "balance", "type": "uint256" }, { "internalType": "uint256", "name": "needed", "type": "uint256" }], "name": "ERC20InsufficientBalance", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "approver", "type": "address" }], "name": "ERC20InvalidApprover", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "receiver", "type": "address" }], "name": "ERC20InvalidReceiver", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "sender", "type": "address" }], "name": "ERC20InvalidSender", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "spender", "type": "address" }], "name": "ERC20InvalidSpender", "type": "error" }, { "anonymous": false, "inputs": [{ "indexed": true, "internalType": "address", "name": "owner", "type": "address" }, { "indexed": true, "internalType": "address", "name": "spender", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "Approval", "type": "event" }, { "anonymous": false, "inputs": [{ "indexed": true, "internalType": "address", "name": "from", "type": "address" }, { "indexed": true, "internalType": "address", "name": "to", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "Transfer", "type": "event" }, { "inputs": [{ "internalType": "address", "name": "owner", "type": "address" }, { "internalType": "address", "name": "spender", "type": "address" }], "name": "allowance", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "spender", "type": "address" }, { "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "approve", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "account", "type": "address" }], "name": "balanceOf", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "decimals", "outputs": [{ "internalType": "uint8", "name": "", "type": "uint8" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "name", "outputs": [{ "internalType": "string", "name": "", "type": "string" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "symbol", "outputs": [{ "internalType": "string", "name": "", "type": "string" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "totalSupply", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "to", "type": "address" }, { "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "transfer", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "from", "type": "address" }, { "internalType": "address", "name": "to", "type": "address" }, { "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "transferFrom", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "nonpayable", "type": "function" }]

package/dist/node/esm/storage/blockchain/abi/ERC20Permit.json

@@ -0,0 +1 @@
+[{ "inputs": [], "name": "ECDSAInvalidSignature", "type": "error" }, { "inputs": [{ "internalType": "uint256", "name": "length", "type": "uint256" }], "name": "ECDSAInvalidSignatureLength", "type": "error" }, { "inputs": [{ "internalType": "bytes32", "name": "s", "type": "bytes32" }], "name": "ECDSAInvalidSignatureS", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "spender", "type": "address" }, { "internalType": "uint256", "name": "allowance", "type": "uint256" }, { "internalType": "uint256", "name": "needed", "type": "uint256" }], "name": "ERC20InsufficientAllowance", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "sender", "type": "address" }, { "internalType": "uint256", "name": "balance", "type": "uint256" }, { "internalType": "uint256", "name": "needed", "type": "uint256" }], "name": "ERC20InsufficientBalance", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "approver", "type": "address" }], "name": "ERC20InvalidApprover", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "receiver", "type": "address" }], "name": "ERC20InvalidReceiver", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "sender", "type": "address" }], "name": "ERC20InvalidSender", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "spender", "type": "address" }], "name": "ERC20InvalidSpender", "type": "error" }, { "inputs": [{ "internalType": "uint256", "name": "deadline", "type": "uint256" }], "name": "ERC2612ExpiredSignature", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "signer", "type": "address" }, { "internalType": "address", "name": "owner", "type": "address" }], "name": "ERC2612InvalidSigner", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "account", "type": "address" }, { "internalType": "uint256", "name": "currentNonce", "type": "uint256" }], "name": "InvalidAccountNonce", "type": "error" }, { "inputs": [], "name": "InvalidShortString", "type": "error" }, { "inputs": [{ "internalType": "string", "name": "str", "type": "string" }], "name": "StringTooLong", "type": "error" }, { "anonymous": false, "inputs": [{ "indexed": true, "internalType": "address", "name": "owner", "type": "address" }, { "indexed": true, "internalType": "address", "name": "spender", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "Approval", "type": "event" }, { "anonymous": false, "inputs": [], "name": "EIP712DomainChanged", "type": "event" }, { "anonymous": false, "inputs": [{ "indexed": true, "internalType": "address", "name": "from", "type": "address" }, { "indexed": true, "internalType": "address", "name": "to", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "Transfer", "type": "event" }, { "inputs": [], "name": "DOMAIN_SEPARATOR", "outputs": [{ "internalType": "bytes32", "name": "", "type": "bytes32" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "owner", "type": "address" }, { "internalType": "address", "name": "spender", "type": "address" }], "name": "allowance", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "spender", "type": "address" }, { "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "approve", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "account", "type": "address" }], "name": "balanceOf", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "decimals", "outputs": [{ "internalType": "uint8", "name": "", "type": "uint8" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "eip712Domain", "outputs": [{ "internalType": "bytes1", "name": "fields", "type": "bytes1" }, { "internalType": "string", "name": "name", "type": "string" }, { "internalType": "string", "name": "version", "type": "string" }, { "internalType": "uint256", "name": "chainId", "type": "uint256" }, { "internalType": "address", "name": "verifyingContract", "type": "address" }, { "internalType": "bytes32", "name": "salt", "type": "bytes32" }, { "internalType": "uint256[]", "name": "extensions", "type": "uint256[]" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "name", "outputs": [{ "internalType": "string", "name": "", "type": "string" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "owner", "type": "address" }], "name": "nonces", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "owner", "type": "address" }, { "internalType": "address", "name": "spender", "type": "address" }, { "internalType": "uint256", "name": "value", "type": "uint256" }, { "internalType": "uint256", "name": "deadline", "type": "uint256" }, { "internalType": "uint8", "name": "v", "type": "uint8" }, { "internalType": "bytes32", "name": "r", "type": "bytes32" }, { "internalType": "bytes32", "name": "s", "type": "bytes32" }], "name": "permit", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "symbol", "outputs": [{ "internalType": "string", "name": "", "type": "string" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "totalSupply", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "to", "type": "address" }, { "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "transfer", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "from", "type": "address" }, { "internalType": "address", "name": "to", "type": "address" }, { "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "transferFrom", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "nonpayable", "type": "function" }]

package/dist/node/esm/storage/blockchain/did-resolver-readonly-storage.js

@@ -0,0 +1,68 @@
+import { Hash } from '@iden3/js-merkletree';
+import { resolveDidDocument } from '../../utils';
+import { DID, Id } from '@iden3/js-iden3-core';
+import { JsonRpcProvider } from 'ethers';
+export class DidResolverStateReadonlyStorage {
+    constructor(resolverUrl) {
+        this.resolverUrl = resolverUrl;
+    }
+    async getLatestStateById(id) {
+        return this.getStateInfo(id);
+    }
+    async getStateInfoByIdAndState(id, state) {
+        return this.getStateInfo(id, state);
+    }
+    async getGISTProof(id) {
+        const { didDocument } = await resolveDidDocument(DID.parseFromId(Id.fromBigInt(id)), this.resolverUrl);
+        const { global } = this.getIden3StateInfo2023(didDocument);
+        if (!global) {
+            throw new Error('GIST root not found');
+        }
+        const { proof } = global;
+        if (!proof) {
+            throw new Error('GIST proof not found');
+        }
+        return {
+            root: global.root,
+            existence: proof.existence,
+            siblings: proof.siblings?.map((sibling) => BigInt(sibling)),
+            index: BigInt(0),
+            value: BigInt(0),
+            auxExistence: !!proof.node_aux,
+            auxIndex: proof.node_aux ? BigInt(proof.node_aux.key) : BigInt(0),
+            auxValue: proof.node_aux ? BigInt(proof.node_aux.value) : BigInt(0)
+        };
+    }
+    async getGISTRootInfo(root, userId) {
+        const { didDocument } = await resolveDidDocument(DID.parseFromId(Id.fromBigInt(userId)), this.resolverUrl, {
+            gist: Hash.fromBigInt(root)
+        });
+        const { global } = this.getIden3StateInfo2023(didDocument);
+        if (!global) {
+            throw new Error('GIST root not found');
+        }
+        return global;
+    }
+    getRpcProvider() {
+        return new JsonRpcProvider();
+    }
+    publishState() {
+        throw new Error('publishState method not implemented.');
+    }
+    publishStateGeneric() {
+        throw new Error('publishStateGeneric method not implemented.');
+    }
+    async getStateInfo(id, state) {
+        const opts = state ? { state: Hash.fromBigInt(state) } : undefined;
+        const { didDocument } = await resolveDidDocument(DID.parseFromId(Id.fromBigInt(id)), this.resolverUrl, opts);
+        const { info } = this.getIden3StateInfo2023(didDocument);
+        return { ...info };
+    }
+    getIden3StateInfo2023(didDocument) {
+        const vm = didDocument.verificationMethod?.find((i) => i.type === 'Iden3StateInfo2023');
+        if (!vm) {
+            throw new Error('Iden3StateInfo2023 verification method not found');
+        }
+        return vm;
+    }
+}

package/dist/node/esm/storage/blockchain/erc20-helper.js

@@ -0,0 +1,51 @@
+import { Contract } from 'ethers';
+import permitAbi from './abi/ERC20Permit.json';
+import erc20Abi from './abi/ERC20.json';
+/**
+ * @beta
+ * getPermitSignature is a function to create EIP712 Permit signature
+ * @param {Signer} signer - User who owns the tokens
+ * @param {string} tokenAddress - EIP-2612 contract address
+ * @param {string} spender -  The contract address that will spend tokens
+ * @param {bigint} value - Amount of tokens to approve
+ * @param {number} deadline - Timestamp when the permit expires
+ * @returns {Promise<PaymentRequestMessage>}
+ */
+export async function getPermitSignature(signer, tokenAddress, spender, value, deadline) {
+    const erc20PermitContract = new Contract(tokenAddress, permitAbi, signer);
+    const nonce = await erc20PermitContract.nonces(await signer.getAddress());
+    const domainData = await erc20PermitContract.eip712Domain();
+    const domain = {
+        name: domainData[1],
+        version: domainData[2],
+        chainId: domainData[3],
+        verifyingContract: tokenAddress
+    };
+    const types = {
+        Permit: [
+            { name: 'owner', type: 'address' },
+            { name: 'spender', type: 'address' },
+            { name: 'value', type: 'uint256' },
+            { name: 'nonce', type: 'uint256' },
+            { name: 'deadline', type: 'uint256' }
+        ]
+    };
+    const message = {
+        owner: await signer.getAddress(),
+        spender: spender,
+        value: value,
+        nonce: nonce,
+        deadline: deadline
+    };
+    return signer.signTypedData(domain, types, message);
+}
+/**
+ * @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 async function getERC20Decimals(tokenAddress, runner) {
+    const erc20Contract = new Contract(tokenAddress, erc20Abi, runner);
+    return erc20Contract.decimals();
+}

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

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

package/dist/node/esm/storage/blockchain/onchain-issuer-adapter/non-merklized/version/v0.0.1/onchain-non-merklized-issuer-adapter.js

@@ -0,0 +1,241 @@
+import { Claim, DID, Id } from '@iden3/js-iden3-core';
+import { NonMerklizedIssuerBase__factory } from '@iden3/onchain-non-merklized-issuer-base-abi';
+import { CredentialStatusType, DisplayMethodType, Iden3SparseMerkleTreeProof, W3CCredential } from '../../../../../../verifiable';
+import { Merklizer, Path } from '@iden3/js-jsonld-merklization';
+import { XSDNS } from '../../../../../../circuits';
+import { Hash, Proof } from '@iden3/js-merkletree';
+import { ethers } from 'ethers';
+import { getDateFromUnixTimestamp } from '@iden3/js-iden3-core';
+var NonMerklizedIssuerInterfaces;
+(function (NonMerklizedIssuerInterfaces) {
+    NonMerklizedIssuerInterfaces["InterfaceDetection"] = "0x01ffc9a7";
+    NonMerklizedIssuerInterfaces["InterfaceNonMerklizedIssuer"] = "0x58874949";
+    NonMerklizedIssuerInterfaces["InterfaceGetCredential"] = "0x5d1ca631";
+})(NonMerklizedIssuerInterfaces || (NonMerklizedIssuerInterfaces = {}));
+var ValueHashes;
+(function (ValueHashes) {
+    ValueHashes["BooleanTrue"] = "18586133768512220936620570745912940619677854269274689475585506675881198879027";
+    ValueHashes["BooleanFalse"] = "19014214495641488759237505126948346942972912379615652741039992445865937985820";
+})(ValueHashes || (ValueHashes = {}));
+/**
+ * `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 class OnchainNonMerklizedIssuerAdapter {
+    /**
+     * 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, issuerDid, options) {
+        if (!ethConnectionConfig.chainId) {
+            throw new Error('Chain ID is required');
+        }
+        this._chainId = ethConnectionConfig.chainId;
+        this._contractAddress = ethers.getAddress(ethers.hexlify(Id.ethAddressFromId(DID.idFromDID(issuerDid))));
+        this._contract = NonMerklizedIssuerBase__factory.connect(this._contractAddress, new ethers.JsonRpcProvider(ethConnectionConfig.url));
+        this._issuerDid = issuerDid;
+        this._merklizationOptions = options?.merklizationOptions;
+    }
+    /**
+     * Checks if the contract supports required interfaces.
+     * Throws an error if any required interface is unsupported.
+     *
+     * @throws Error - If required interfaces are not supported.
+     */
+    async isInterfaceSupported() {
+        const supportedInterfaces = [
+            {
+                name: 'Interface detection ERC-165',
+                value: NonMerklizedIssuerInterfaces.InterfaceDetection
+            },
+            {
+                name: 'Interface non-merklized issuer',
+                value: NonMerklizedIssuerInterfaces.InterfaceNonMerklizedIssuer
+            },
+            {
+                name: 'Interface get credential',
+                value: NonMerklizedIssuerInterfaces.InterfaceGetCredential
+            }
+        ];
+        const unsupportedInterfaces = await Promise.all(supportedInterfaces.map(async (interfaceObj) => {
+            const isSupported = await this._contract.supportsInterface(interfaceObj.value);
+            return isSupported ? null : interfaceObj.name;
+        }));
+        const unsupportedInterfacesFiltered = unsupportedInterfaces.filter((interfaceName) => interfaceName !== null);
+        if (unsupportedInterfacesFiltered.length > 0) {
+            throw new Error(`Unsupported interfaces: ${unsupportedInterfacesFiltered.join(', ')}`);
+        }
+    }
+    /**
+     * 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.
+     */
+    async getCredential(userId, credentialId) {
+        const [credentialData, coreClaimBigInts, credentialSubjectFields] = await this._contract.getCredential(userId.bigInt(), credentialId);
+        return { credentialData, coreClaimBigInts, credentialSubjectFields };
+    }
+    /**
+     * Retrieves the credential IDs of a user.
+     * @param userId The user's core.Id.
+     * @returns An array of credential IDs.
+     */
+    async getUserCredentialsIds(userId) {
+        return this._contract.getUserCredentialIds(userId.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.
+     */
+    async convertOnChainInfoToW3CCredential(credentialData, coreClaimBigInts, credentialSubjectFields) {
+        const c = new Claim().unMarshalJson(JSON.stringify(coreClaimBigInts.map((b) => b.toString())));
+        const credentialSubject = await this.convertCredentialSubject(c, credentialData.context, credentialData._type, credentialSubjectFields);
+        const credentialRequest = {
+            id: this.credentialId(credentialData.id),
+            credentialSchema: credentialData.credentialSchema.id,
+            type: credentialData._type,
+            credentialSubject: credentialSubject,
+            expiration: c.getExpirationDate()?.getTime(),
+            displayMethod: this.convertDisplayMethod(credentialData.displayMethod),
+            context: credentialData.context,
+            revocationOpts: {
+                id: this._contractAddress,
+                nonce: Number(c.getRevocationNonce()),
+                type: CredentialStatusType.Iden3OnchainSparseMerkleTreeProof2023
+            },
+            issuanceDate: getDateFromUnixTimestamp(Number(credentialData.issuanceDate)).getTime()
+        };
+        const existenceProof = await this.existenceProof(c);
+        const w3c = W3CCredential.fromCredentialRequest(this._issuerDid, credentialRequest);
+        w3c.proof = [existenceProof];
+        return w3c;
+    }
+    credentialId(id) {
+        return `urn:iden3:onchain:${this._chainId}:${this._contractAddress}:${id}`;
+    }
+    async convertCredentialSubject(coreClaim, contractContexts, credentialType, credentialSubjectFields) {
+        const contractContextsStr = JSON.stringify({
+            '@context': contractContexts
+        });
+        const credentialSubject = {};
+        for (const f of credentialSubjectFields) {
+            const dataType = await Path.newTypeFromContext(contractContextsStr, `${credentialType}.${f.key}`, this._merklizationOptions);
+            switch (dataType) {
+                case XSDNS.Boolean: {
+                    switch (f.rawValue.toString()) {
+                        case ValueHashes.BooleanTrue:
+                            credentialSubject[f.key] = true;
+                            break;
+                        case ValueHashes.BooleanFalse:
+                            credentialSubject[f.key] = false;
+                            break;
+                    }
+                    break;
+                }
+                case (XSDNS.NonNegativeInteger,
+                    XSDNS.NonPositiveInteger,
+                    XSDNS.NegativeInteger,
+                    XSDNS.PositiveInteger):
+                    {
+                        credentialSubject[f.key] = f.value.toString();
+                        break;
+                    }
+                case XSDNS.Integer: {
+                    credentialSubject[f.key] = Number(f.value);
+                    break;
+                }
+                case XSDNS.String: {
+                    this.validateSourceValue(dataType, f.value, f.rawValue);
+                    credentialSubject[f.key] = f.rawValue;
+                    break;
+                }
+                case XSDNS.DateTime: {
+                    const timestamp = BigInt(f.rawValue);
+                    const sourceTimestamp = getDateFromUnixTimestamp(Number(timestamp)).toISOString();
+                    this.validateSourceValue(dataType, f.value, sourceTimestamp);
+                    credentialSubject[f.key] = sourceTimestamp;
+                    break;
+                }
+                case XSDNS.Double: {
+                    const rawFloat = Number(f.rawValue);
+                    this.validateSourceValue(dataType, f.value, rawFloat);
+                    credentialSubject[f.key] = rawFloat;
+                    break;
+                }
+                default: {
+                    throw new Error(`Unsupported data type ${dataType}`);
+                }
+            }
+        }
+        credentialSubject['type'] = credentialType;
+        const subjectId = coreClaim.getId();
+        const subjectDid = DID.parseFromId(subjectId);
+        credentialSubject['id'] = subjectDid.string();
+        return credentialSubject;
+    }
+    async existenceProof(coreClaim) {
+        const [mtpProof, stateInfo] = await this._contract.getClaimProofWithStateInfo(coreClaim.hIndex());
+        if (!mtpProof.existence) {
+            throw new Error('Claim does not exist');
+        }
+        const latestStateHash = Hash.fromBigInt(stateInfo.state);
+        const latestClaimsOfRootHash = Hash.fromBigInt(stateInfo.claimsRoot);
+        const latestRevocationOfRootHash = Hash.fromBigInt(stateInfo.revocationsRoot);
+        const latestRootsOfRootHash = Hash.fromBigInt(stateInfo.rootsRoot);
+        const p = new Proof({
+            siblings: mtpProof.siblings.map((s) => Hash.fromBigInt(s)),
+            existence: mtpProof.existence,
+            nodeAux: mtpProof.auxExistence
+                ? {
+                    key: Hash.fromBigInt(mtpProof.auxIndex),
+                    value: Hash.fromBigInt(mtpProof.auxValue)
+                }
+                : undefined
+        });
+        return new Iden3SparseMerkleTreeProof({
+            issuerData: {
+                id: this._issuerDid,
+                state: {
+                    value: latestStateHash,
+                    claimsTreeRoot: latestClaimsOfRootHash,
+                    revocationTreeRoot: latestRevocationOfRootHash,
+                    rootOfRoots: latestRootsOfRootHash
+                }
+            },
+            mtp: p,
+            coreClaim: coreClaim
+        });
+    }
+    async validateSourceValue(dataType, originHash, source) {
+        const sourceHash = await Merklizer.hashValue(dataType, source);
+        if (sourceHash !== originHash) {
+            throw new Error(`Invalid source value for ${dataType} type`);
+        }
+    }
+    convertDisplayMethod(onchainDisplayMethod) {
+        if (!onchainDisplayMethod.id || !onchainDisplayMethod._type) {
+            return undefined;
+        }
+        switch (onchainDisplayMethod._type) {
+            case DisplayMethodType.Iden3BasicDisplayMethodV1: {
+                return {
+                    id: onchainDisplayMethod.id,
+                    type: DisplayMethodType.Iden3BasicDisplayMethodV1
+                };
+            }
+            default: {
+                throw new Error(`Unsupported display method type ${onchainDisplayMethod._type}`);
+            }
+        }
+    }
+}

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 };
+    }
+}