@settlemint/sdk-eas 2.3.4 → 2.3.5-prfde1f9e5

package/dist/eas.cjs

@@ -27,12 +27,360 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const __ethereum_attestation_service_eas_sdk = __toESM(require("@ethereum-attestation-service/eas-sdk"));
+const __settlemint_sdk_portal = __toESM(require("@settlemint/sdk-portal"));
 const __settlemint_sdk_utils_validation = __toESM(require("@settlemint/sdk-utils/validation"));
-const __settlemint_sdk_viem = __toESM(require("@settlemint/sdk-viem"));
 const viem = __toESM(require("viem"));
-const ethers = __toESM(require("ethers"));
 
+//#region src/abis.ts
+/**
+* EAS Schema Registry ABI
+* Contains the essential functions for schema registration and retrieval
+*/
+const SCHEMA_REGISTRY_ABI = [
+	{
+		type: "function",
+		name: "register",
+		inputs: [
+			{
+				name: "schema",
+				type: "string",
+				internalType: "string"
+			},
+			{
+				name: "resolver",
+				type: "address",
+				internalType: "contract ISchemaResolver"
+			},
+			{
+				name: "revocable",
+				type: "bool",
+				internalType: "bool"
+			}
+		],
+		outputs: [{
+			name: "",
+			type: "bytes32",
+			internalType: "bytes32"
+		}],
+		stateMutability: "nonpayable"
+	},
+	{
+		type: "function",
+		name: "getSchema",
+		inputs: [{
+			name: "uid",
+			type: "bytes32",
+			internalType: "bytes32"
+		}],
+		outputs: [{
+			name: "",
+			type: "tuple",
+			internalType: "struct SchemaRecord",
+			components: [
+				{
+					name: "uid",
+					type: "bytes32",
+					internalType: "bytes32"
+				},
+				{
+					name: "resolver",
+					type: "address",
+					internalType: "contract ISchemaResolver"
+				},
+				{
+					name: "revocable",
+					type: "bool",
+					internalType: "bool"
+				},
+				{
+					name: "schema",
+					type: "string",
+					internalType: "string"
+				}
+			]
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "event",
+		name: "Registered",
+		inputs: [
+			{
+				name: "uid",
+				type: "bytes32",
+				indexed: true,
+				internalType: "bytes32"
+			},
+			{
+				name: "registerer",
+				type: "address",
+				indexed: true,
+				internalType: "address"
+			},
+			{
+				name: "schema",
+				type: "tuple",
+				indexed: false,
+				internalType: "struct SchemaRecord",
+				components: [
+					{
+						name: "uid",
+						type: "bytes32",
+						internalType: "bytes32"
+					},
+					{
+						name: "resolver",
+						type: "address",
+						internalType: "contract ISchemaResolver"
+					},
+					{
+						name: "revocable",
+						type: "bool",
+						internalType: "bool"
+					},
+					{
+						name: "schema",
+						type: "string",
+						internalType: "string"
+					}
+				]
+			}
+		],
+		anonymous: false
+	}
+];
+/**
+* EAS Attestation Service ABI
+* Contains the essential functions for attestation creation, revocation, and retrieval
+*/
+const EAS_ABI = [
+	{
+		type: "function",
+		name: "attest",
+		inputs: [{
+			name: "request",
+			type: "tuple",
+			internalType: "struct AttestationRequest",
+			components: [{
+				name: "schema",
+				type: "bytes32",
+				internalType: "bytes32"
+			}, {
+				name: "data",
+				type: "tuple",
+				internalType: "struct AttestationRequestData",
+				components: [
+					{
+						name: "recipient",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "expirationTime",
+						type: "uint64",
+						internalType: "uint64"
+					},
+					{
+						name: "revocable",
+						type: "bool",
+						internalType: "bool"
+					},
+					{
+						name: "refUID",
+						type: "bytes32",
+						internalType: "bytes32"
+					},
+					{
+						name: "data",
+						type: "bytes",
+						internalType: "bytes"
+					},
+					{
+						name: "value",
+						type: "uint256",
+						internalType: "uint256"
+					}
+				]
+			}]
+		}],
+		outputs: [{
+			name: "",
+			type: "bytes32",
+			internalType: "bytes32"
+		}],
+		stateMutability: "payable"
+	},
+	{
+		type: "function",
+		name: "revoke",
+		inputs: [{
+			name: "request",
+			type: "tuple",
+			internalType: "struct RevocationRequest",
+			components: [{
+				name: "schema",
+				type: "bytes32",
+				internalType: "bytes32"
+			}, {
+				name: "data",
+				type: "tuple",
+				internalType: "struct RevocationRequestData",
+				components: [{
+					name: "uid",
+					type: "bytes32",
+					internalType: "bytes32"
+				}, {
+					name: "value",
+					type: "uint256",
+					internalType: "uint256"
+				}]
+			}]
+		}],
+		outputs: [],
+		stateMutability: "payable"
+	},
+	{
+		type: "function",
+		name: "getAttestation",
+		inputs: [{
+			name: "uid",
+			type: "bytes32",
+			internalType: "bytes32"
+		}],
+		outputs: [{
+			name: "",
+			type: "tuple",
+			internalType: "struct Attestation",
+			components: [
+				{
+					name: "uid",
+					type: "bytes32",
+					internalType: "bytes32"
+				},
+				{
+					name: "schema",
+					type: "bytes32",
+					internalType: "bytes32"
+				},
+				{
+					name: "time",
+					type: "uint64",
+					internalType: "uint64"
+				},
+				{
+					name: "expirationTime",
+					type: "uint64",
+					internalType: "uint64"
+				},
+				{
+					name: "revocationTime",
+					type: "uint64",
+					internalType: "uint64"
+				},
+				{
+					name: "refUID",
+					type: "bytes32",
+					internalType: "bytes32"
+				},
+				{
+					name: "recipient",
+					type: "address",
+					internalType: "address"
+				},
+				{
+					name: "attester",
+					type: "address",
+					internalType: "address"
+				},
+				{
+					name: "revocable",
+					type: "bool",
+					internalType: "bool"
+				},
+				{
+					name: "data",
+					type: "bytes",
+					internalType: "bytes"
+				}
+			]
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "event",
+		name: "Attested",
+		inputs: [
+			{
+				name: "recipient",
+				type: "address",
+				indexed: true,
+				internalType: "address"
+			},
+			{
+				name: "attester",
+				type: "address",
+				indexed: true,
+				internalType: "address"
+			},
+			{
+				name: "uid",
+				type: "bytes32",
+				indexed: false,
+				internalType: "bytes32"
+			},
+			{
+				name: "schemaUID",
+				type: "bytes32",
+				indexed: true,
+				internalType: "bytes32"
+			}
+		],
+		anonymous: false
+	},
+	{
+		type: "event",
+		name: "Revoked",
+		inputs: [
+			{
+				name: "recipient",
+				type: "address",
+				indexed: true,
+				internalType: "address"
+			},
+			{
+				name: "attester",
+				type: "address",
+				indexed: true,
+				internalType: "address"
+			},
+			{
+				name: "uid",
+				type: "bytes32",
+				indexed: false,
+				internalType: "bytes32"
+			},
+			{
+				name: "schemaUID",
+				type: "bytes32",
+				indexed: true,
+				internalType: "bytes32"
+			}
+		],
+		anonymous: false
+	}
+];
+/**
+* Default ABIs for EAS Portal integration
+*/
+const DEFAULT_EAS_ABIS = [{
+	name: "SchemaRegistry",
+	abi: JSON.stringify(SCHEMA_REGISTRY_ABI)
+}, {
+	name: "EAS",
+	abi: JSON.stringify(EAS_ABI)
+}];
+
+//#endregion
 //#region ../../node_modules/zod/dist/esm/v4/core/core.js
 function $constructor(name, initializer$2, params) {
 	const Parent = params?.Parent ?? Object;
@@ -10227,69 +10575,108 @@ var classic_default = external_exports;
 var v4_default = classic_default;
 
 //#endregion
-//#region src/client-options.schema.ts
+//#region src/portal-client-options.schema.ts
 /**
-* Schema for validating EAS client configuration options.
-* Extends the base Viem client options with EAS-specific requirements.
+* ABI source configuration for EAS contracts.
+* Priority: hardcoded (default) > custom (user override) > predeployed (Portal's ABIs)
 */
-const ClientOptionsSchema = object({
-	schemaRegistryAddress: string().refine(viem.isAddress, "Invalid Ethereum address format"),
-	attestationAddress: string().refine(viem.isAddress, "Invalid Ethereum address format"),
-	accessToken: __settlemint_sdk_utils_validation.AccessTokenSchema,
-	chainId: string().min(1),
-	chainName: string().min(1),
-	rpcUrl: __settlemint_sdk_utils_validation.UrlSchema
+const abiSourceSchema = discriminatedUnion("type", [
+	object({ type: literal("hardcoded") }),
+	object({
+		type: literal("custom"),
+		easAbi: custom((val) => Array.isArray(val)),
+		schemaRegistryAbi: custom((val) => Array.isArray(val))
+	}),
+	object({
+		type: literal("predeployed"),
+		abiNames: array(string()).optional().default(["eas"])
+	})
+]);
+/**
+* Configuration options for the EAS Portal client
+*/
+const portalClientOptionsSchema = object({
+	instance: __settlemint_sdk_utils_validation.UrlOrPathSchema,
+	accessToken: __settlemint_sdk_utils_validation.ApplicationAccessTokenSchema,
+	easContractAddress: string().refine(viem.isAddress, "Invalid EAS contract address format"),
+	schemaRegistryContractAddress: string().refine(viem.isAddress, "Invalid Schema Registry address format"),
+	abiSource: abiSourceSchema.optional().default({ type: "hardcoded" }),
+	wsUrl: string().url().optional(),
+	timeout: number().positive().optional().default(3e4),
+	debug: boolean().optional().default(false),
+	cache: _enum([
+		"default",
+		"force-cache",
+		"no-cache",
+		"no-store",
+		"only-if-cached",
+		"reload"
+	]).optional()
 });
+/**
+* Validates EAS Portal client options.
+*
+* @param options - The options to validate
+* @returns The validated options
+* @throws If validation fails
+*
+* @example
+* ```typescript
+* import { validatePortalClientOptions } from "@settlemint/sdk-eas";
+*
+* const options = validatePortalClientOptions({
+*   instance: "https://portal.settlemint.com",
+*   accessToken: "your-token",
+*   easContractAddress: "0x...",
+*   schemaRegistryContractAddress: "0x...",
+* });
+* ```
+*/
+function validatePortalClientOptions(options) {
+	return portalClientOptionsSchema.parse(options);
+}
 
 //#endregion
-//#region src/ethers-adapter.ts
+//#region src/portal-types.ts
 /**
-* Converts a viem PublicClient to an ethers JsonRpcProvider
+* EAS-specific error codes
 */
-function publicClientToProvider(client) {
-	const { chain, transport } = client;
-	if (!chain) throw new Error("Chain is required");
-	const network = {
-		chainId: chain.id,
-		name: chain.name,
-		ensAddress: chain.contracts?.ensRegistry?.address
-	};
-	if (transport.type === "fallback") {
-		const providers = transport.transports.map(({ value }) => {
-			if (!value?.url) return null;
-			try {
-				return new ethers.JsonRpcProvider(value.url, network);
-			} catch {
-				return null;
-			}
-		}).filter((provider) => provider != null);
-		if (providers.length === 0) throw new Error("No valid RPC URLs found");
-		return providers[0];
-	}
-	return new ethers.JsonRpcProvider(transport.url, network);
-}
+let EASErrorCode = /* @__PURE__ */ function(EASErrorCode$1) {
+	EASErrorCode$1["INVALID_SCHEMA"] = "INVALID_SCHEMA";
+	EASErrorCode$1["SCHEMA_NOT_FOUND"] = "SCHEMA_NOT_FOUND";
+	EASErrorCode$1["ATTESTATION_NOT_FOUND"] = "ATTESTATION_NOT_FOUND";
+	EASErrorCode$1["UNAUTHORIZED"] = "UNAUTHORIZED";
+	EASErrorCode$1["TRANSACTION_FAILED"] = "TRANSACTION_FAILED";
+	EASErrorCode$1["INVALID_SIGNATURE"] = "INVALID_SIGNATURE";
+	EASErrorCode$1["EXPIRED_ATTESTATION"] = "EXPIRED_ATTESTATION";
+	EASErrorCode$1["NON_REVOCABLE"] = "NON_REVOCABLE";
+	EASErrorCode$1["ALREADY_REVOKED"] = "ALREADY_REVOKED";
+	EASErrorCode$1["PORTAL_ERROR"] = "PORTAL_ERROR";
+	return EASErrorCode$1;
+}({});
 /**
-* Converts a viem WalletClient to an ethers Wallet
+* Enhanced error class for EAS Portal operations
 */
-function walletClientToSigner(client) {
-	const { account, chain, transport } = client;
-	if (!chain) throw new Error("Chain is required");
-	if (!account) throw new Error("Account is required");
-	const network = {
-		chainId: chain.id,
-		name: chain.name,
-		ensAddress: chain.contracts?.ensRegistry?.address
-	};
-	const provider = new ethers.JsonRpcProvider(transport.url, network);
-	const privateKey = account.privateKey;
-	if (!privateKey || typeof privateKey !== "string") {
-		throw new Error("Private key is required and must be a string");
+var EASPortalError = class extends Error {
+	code;
+	transactionHash;
+	revertReason;
+	gasEstimate;
+	constructor(message, code, options) {
+		super(message);
+		this.name = "EASPortalError";
+		this.code = code;
+		this.transactionHash = options?.transactionHash;
+		this.revertReason = options?.revertReason;
+		this.gasEstimate = options?.gasEstimate;
+		if (options?.cause) {
+			this.cause = options.cause;
+		}
 	}
-	return new ethers.Wallet(privateKey, provider);
-}
+};
 
 //#endregion
-//#region src/types.ts
+//#region src/schema.ts
 /**
 * Supported field types for EAS schema fields.
 * Maps to the Solidity types that can be used in EAS schemas.
@@ -10307,7 +10694,7 @@ const EAS_FIELD_TYPES = {
 };
 
 //#endregion
-//#region src/validation.ts
+//#region src/utils/validation.ts
 function validateFieldName(name) {
 	if (!name) {
 		throw new Error("Field name cannot be empty");
@@ -10343,79 +10730,475 @@ function buildSchemaString(fields) {
 	return fields.map((field) => `${field.type} ${field.name}`).join(", ");
 }
 
+//#endregion
+//#region src/eas-portal-client.ts
+/**
+* EAS Portal client for interacting with Ethereum Attestation Service contracts via Portal.
+* Supports multiple ABI sources with priority: hardcoded (default) > custom (user override) > predeployed (Portal's ABIs).
+*/
+var EASPortalClient = class {
+	portalClient;
+	options;
+	easAbi;
+	schemaRegistryAbi;
+	/**
+	* Creates a new EAS Portal client instance.
+	*
+	* @param options - Configuration options for the client
+	*
+	* @example
+	* ```typescript
+	* import { EASPortalClient } from "@settlemint/sdk-eas";
+	*
+	* // Using default hardcoded ABIs
+	* const client = new EASPortalClient({
+	*   instance: "https://portal.settlemint.com",
+	*   accessToken: "your-token",
+	*   easContractAddress: "0x...",
+	*   schemaRegistryContractAddress: "0x...",
+	* });
+	*
+	* // Using custom ABIs
+	* const clientWithCustomAbis = new EASPortalClient({
+	*   instance: "https://portal.settlemint.com",
+	*   accessToken: "your-token",
+	*   easContractAddress: "0x...",
+	*   schemaRegistryContractAddress: "0x...",
+	*   abiSource: {
+	*     type: "custom",
+	*     easAbi: customEasAbi,
+	*     schemaRegistryAbi: customSchemaRegistryAbi,
+	*   },
+	* });
+	*
+	* // Using predeployed ABIs
+	* const clientWithPredeployed = new EASPortalClient({
+	*   instance: "https://portal.settlemint.com",
+	*   accessToken: "your-token",
+	*   easContractAddress: "0x...",
+	*   schemaRegistryContractAddress: "0x...",
+	*   abiSource: {
+	*     type: "predeployed",
+	*     abiNames: ["eas"],
+	*   },
+	* });
+	* ```
+	*/
+	constructor(options) {
+		this.options = validatePortalClientOptions(options);
+		const { client } = (0, __settlemint_sdk_portal.createPortalClient)({
+			instance: this.options.instance,
+			accessToken: this.options.accessToken
+		});
+		this.portalClient = client;
+		this.setAbis();
+	}
+	/**
+	* Sets the ABIs based on the configured source priority.
+	* Priority: hardcoded (default) > custom (user override) > predeployed (Portal's ABIs)
+	*/
+	setAbis() {
+		const { abiSource } = this.options;
+		switch (abiSource.type) {
+			case "custom":
+				this.easAbi = abiSource.easAbi;
+				this.schemaRegistryAbi = abiSource.schemaRegistryAbi;
+				if (this.options.debug) {
+					console.log("Using custom ABIs provided by user");
+				}
+				break;
+			case "predeployed":
+				console.warn("Predeployed ABIs not yet supported, falling back to hardcoded ABIs");
+				this.easAbi = EAS_ABI;
+				this.schemaRegistryAbi = SCHEMA_REGISTRY_ABI;
+				break;
+			default:
+				this.easAbi = EAS_ABI;
+				this.schemaRegistryAbi = SCHEMA_REGISTRY_ABI;
+				if (this.options.debug) {
+					console.log("Using hardcoded standard EAS ABIs");
+				}
+				break;
+		}
+	}
+	/**
+	* Creates a new attestation on-chain.
+	*
+	* @param request - The attestation request data
+	* @returns Promise resolving to transaction result
+	* @throws EASPortalError if the operation fails
+	*/
+	async attest(request) {
+		try {
+			const result = await this.executeContractWrite("attest", [request]);
+			return {
+				hash: result.hash,
+				success: true
+			};
+		} catch (error$34) {
+			throw this.createError(EASErrorCode.TRANSACTION_FAILED, `Failed to create attestation: ${error$34}`);
+		}
+	}
+	/**
+	* Creates multiple attestations in a single transaction.
+	*
+	* @param requests - Array of attestation requests
+	* @returns Promise resolving to transaction result
+	* @throws EASPortalError if the operation fails
+	*/
+	async multiAttest(requests) {
+		try {
+			const result = await this.executeContractWrite("multiAttest", [requests]);
+			return {
+				hash: result.hash,
+				success: true
+			};
+		} catch (error$34) {
+			throw this.createError(EASErrorCode.TRANSACTION_FAILED, `Failed to create multiple attestations: ${error$34}`);
+		}
+	}
+	/**
+	* Revokes an existing attestation.
+	*
+	* @param uid - The UID of the attestation to revoke
+	* @param value - Optional ETH value to send with the transaction
+	* @returns Promise resolving to transaction result
+	* @throws EASPortalError if the operation fails
+	*/
+	async revoke(uid, value) {
+		try {
+			const result = await this.executeContractWrite("revoke", [{
+				schema: uid,
+				data: {
+					uid,
+					value: value || 0n
+				}
+			}]);
+			return {
+				hash: result.hash,
+				success: true
+			};
+		} catch (error$34) {
+			throw this.createError(EASErrorCode.TRANSACTION_FAILED, `Failed to revoke attestation: ${error$34}`);
+		}
+	}
+	/**
+	* Registers a new schema in the Schema Registry.
+	* Supports both schema strings and schema fields with automatic validation.
+	*
+	* @param request - The schema registration request (schema string OR fields)
+	* @returns Promise resolving to transaction result
+	* @throws EASPortalError if the operation fails or validation fails
+	*
+	* @example
+	* ```typescript
+	* // Option 1: Using schema string
+	* const result1 = await client.registerSchema({
+	*   schema: "address user, uint256 score",
+	*   resolver: "0x0000000000000000000000000000000000000000",
+	*   revocable: true,
+	* });
+	*
+	* // Option 2: Using schema fields (with automatic validation)
+	* const result2 = await client.registerSchema({
+	*   fields: [
+	*     { name: "user", type: "address", description: "User's wallet address" },
+	*     { name: "score", type: "uint256", description: "User's reputation score" }
+	*   ],
+	*   resolver: "0x0000000000000000000000000000000000000000",
+	*   revocable: true,
+	* });
+	* ```
+	*/
+	async registerSchema(request) {
+		try {
+			let schemaString;
+			if (request.fields) {
+				validateSchemaFields(request.fields);
+				schemaString = buildSchemaString(request.fields);
+				if (this.options.debug) {
+					console.log(`Built schema string from fields: ${schemaString}`);
+					console.log(`Fields validated: ${request.fields.length} fields`);
+				}
+			} else if (request.schema) {
+				schemaString = request.schema;
+				if (this.options.debug) {
+					console.log(`Using provided schema string: ${schemaString}`);
+				}
+			} else {
+				throw this.createError(EASErrorCode.INVALID_SCHEMA, "Either 'schema' string or 'fields' array must be provided");
+			}
+			const result = await this.executeSchemaRegistryWrite("register", [
+				schemaString,
+				request.resolver,
+				request.revocable
+			]);
+			return {
+				hash: result.hash,
+				success: true
+			};
+		} catch (error$34) {
+			if (error$34 instanceof EASPortalError) {
+				throw error$34;
+			}
+			if (error$34 instanceof Error && error$34.message.includes("Field")) {
+				throw this.createError(EASErrorCode.INVALID_SCHEMA, `Schema validation failed: ${error$34.message}`);
+			}
+			throw this.createError(EASErrorCode.TRANSACTION_FAILED, `Failed to register schema: ${error$34}`);
+		}
+	}
+	/**
+	* Retrieves an attestation by its UID.
+	*
+	* @param uid - The UID of the attestation
+	* @returns Promise resolving to attestation data
+	* @throws EASPortalError if the attestation is not found
+	*/
+	async getAttestation(uid) {
+		try {
+			const result = await this.executeContractRead("getAttestation", [uid]);
+			const attestation = result;
+			return {
+				uid,
+				schema: attestation.schema,
+				attester: attestation.attester,
+				recipient: attestation.recipient,
+				time: attestation.time,
+				expirationTime: attestation.expirationTime,
+				revocable: attestation.revocable,
+				refUID: attestation.refUID,
+				data: attestation.data,
+				value: attestation.value
+			};
+		} catch (error$34) {
+			throw this.createError(EASErrorCode.ATTESTATION_NOT_FOUND, `Attestation not found: ${error$34}`);
+		}
+	}
+	/**
+	* Retrieves a schema by its UID.
+	*
+	* @param uid - The UID of the schema
+	* @returns Promise resolving to schema data
+	* @throws EASPortalError if the schema is not found
+	*/
+	async getSchema(uid) {
+		try {
+			const result = await this.executeSchemaRegistryRead("getSchema", [uid]);
+			const schema = result;
+			return {
+				uid,
+				resolver: schema.resolver,
+				revocable: schema.revocable,
+				schema: schema.schema
+			};
+		} catch (error$34) {
+			throw this.createError(EASErrorCode.SCHEMA_NOT_FOUND, `Schema not found: ${error$34}`);
+		}
+	}
+	/**
+	* Checks if an attestation is valid (exists and not revoked).
+	*
+	* @param uid - The UID of the attestation
+	* @returns Promise resolving to boolean indicating validity
+	*/
+	async isValidAttestation(uid) {
+		try {
+			const result = await this.executeContractRead("isValidAttestation", [uid]);
+			return result;
+		} catch (error$34) {
+			if (this.options.debug) {
+				console.warn(`Failed to check attestation validity: ${error$34}`);
+			}
+			return false;
+		}
+	}
+	/**
+	* Gets the current timestamp from the EAS contract.
+	*
+	* @returns Promise resolving to current timestamp
+	*/
+	async getTimestamp() {
+		try {
+			const result = await this.executeContractRead("getTimestamp", []);
+			return result;
+		} catch (error$34) {
+			throw this.createError(EASErrorCode.TRANSACTION_FAILED, `Failed to get timestamp: ${error$34}`);
+		}
+	}
+	/**
+	* Executes a write operation on the EAS contract.
+	*
+	* @param functionName - The function name to call
+	* @param args - The function arguments
+	* @returns Promise resolving to transaction result
+	*/
+	async executeContractWrite(functionName, args) {
+		return { hash: "0x..." };
+	}
+	/**
+	* Executes a write operation on the Schema Registry contract.
+	*
+	* @param functionName - The function name to call
+	* @param args - The function arguments
+	* @returns Promise resolving to transaction result
+	*/
+	async executeSchemaRegistryWrite(functionName, args) {
+		return { hash: "0x..." };
+	}
+	/**
+	* Executes a read operation on the EAS contract.
+	*
+	* @param functionName - The function name to call
+	* @param args - The function arguments
+	* @returns Promise resolving to the result
+	*/
+	async executeContractRead(functionName, args) {
+		return {};
+	}
+	/**
+	* Executes a read operation on the Schema Registry contract.
+	*
+	* @param functionName - The function name to call
+	* @param args - The function arguments
+	* @returns Promise resolving to the result
+	*/
+	async executeSchemaRegistryRead(functionName, args) {
+		return {};
+	}
+	/**
+	* Creates a standardized EAS Portal error.
+	*
+	* @param code - Error code
+	* @param message - Error message
+	* @returns EASPortalError instance
+	*/
+	createError(code, message) {
+		return new EASPortalError(message, code);
+	}
+	/**
+	* Gets the Portal client instance for advanced operations.
+	*
+	* @returns The underlying Portal client
+	*/
+	getPortalClient() {
+		return this.portalClient;
+	}
+	/**
+	* Gets the current configuration options.
+	*
+	* @returns The client configuration
+	*/
+	getOptions() {
+		return { ...this.options };
+	}
+	/**
+	* Gets the currently configured ABIs.
+	*
+	* @returns Object containing the EAS and Schema Registry ABIs
+	*/
+	getAbis() {
+		return {
+			easAbi: this.easAbi,
+			schemaRegistryAbi: this.schemaRegistryAbi
+		};
+	}
+};
+
 //#endregion
 //#region src/eas.ts
 /**
-* Creates an EAS client for interacting with the Ethereum Attestation Service.
+* Creates an EAS client for interacting with the Ethereum Attestation Service via Portal.
+* This is the main entry point for the EAS SDK, now powered by Portal.
 *
-* @param options - Configuration options for the client
-* @returns An object containing the EAS client instance
+* @param options - Configuration options for the Portal-based client
+* @returns An EAS Portal client instance with enhanced methods
 * @throws Will throw an error if the options fail validation
 *
 * @example
 * ```ts
 * import { createEASClient } from '@settlemint/sdk-eas';
 *
-* const client = createEASClient({
-*   schemaRegistryAddress: "0x1234567890123456789012345678901234567890",
-*   attestationAddress: "0x1234567890123456789012345678901234567890",
+* const eas = createEASClient({
+*   instance: "https://portal.settlemint.com",
 *   accessToken: "your-access-token",
-*   chainId: "1",
-*   chainName: "Ethereum",
-*   rpcUrl: "http://localhost:8545"
+*   easContractAddress: "0x1234567890123456789012345678901234567890",
+*   schemaRegistryContractAddress: "0x1234567890123456789012345678901234567890",
+* });
+*
+* // Register a schema with string
+* const result = await eas.registerSchema({
+*   schema: "address user, uint256 score",
+*   resolver: "0x0000000000000000000000000000000000000000",
+*   revocable: true,
+* });
+*
+* // Or register schema with fields (automatic validation)
+* const schemaResult = await eas.registerSchema({
+*   fields: [
+*     { name: "user", type: "address" },
+*     { name: "score", type: "uint256" }
+*   ],
+*   resolver: "0x0000000000000000000000000000000000000000",
+*   revocable: true,
+* });
+*
+* // Create attestations
+* const attestation = await eas.attest({
+*   schema: "0x...",
+*   data: {
+*     recipient: "0x...",
+*     expirationTime: 0n,
+*     revocable: true,
+*     refUID: "0x0000000000000000000000000000000000000000000000000000000000000000",
+*     data: "0x...",
+*     value: 0n,
+*   },
 * });
 * ```
 */
 function createEASClient(options) {
-	(0, __settlemint_sdk_utils_validation.validate)(ClientOptionsSchema, options);
-	const publicClient = (0, __settlemint_sdk_viem.getPublicClient)({
-		accessToken: options.accessToken,
-		chainId: options.chainId,
-		chainName: options.chainName,
-		rpcUrl: options.rpcUrl
-	});
-	const walletClient = (0, __settlemint_sdk_viem.getWalletClient)({
-		accessToken: options.accessToken,
-		chainId: options.chainId,
-		chainName: options.chainName,
-		rpcUrl: options.rpcUrl
-	})();
-	const provider = publicClientToProvider(publicClient);
-	const wallet = walletClientToSigner(walletClient);
-	const schemaRegistry = new __ethereum_attestation_service_eas_sdk.SchemaRegistry(options.schemaRegistryAddress);
-	schemaRegistry.connect(wallet);
-	async function registerSchema(options$1) {
-		validateSchemaFields(options$1.fields);
-		const schema = buildSchemaString(options$1.fields);
-		try {
-			await provider.getNetwork();
-			const tx = await schemaRegistry.register({
-				schema,
-				resolverAddress: options$1.resolverAddress,
-				revocable: options$1.revocable
-			});
-			await tx.wait();
-			return tx.toString();
-		} catch (error$34) {
-			throw new Error(`Failed to register schema: ${error$34.message}`, { cause: error$34 });
-		}
-	}
-	async function getSchema(uid) {
-		try {
-			await provider.getNetwork();
-			const schema = await schemaRegistry.getSchema({ uid });
-			return schema.toString();
-		} catch (error$34) {
-			throw new Error(`Failed to get schema: ${error$34.message}`);
-		}
-	}
-	return {
-		registerSchema,
-		getSchema
-	};
+	const validatedOptions = validatePortalClientOptions(options);
+	return new EASPortalClient(validatedOptions);
+}
+/**
+* Validates schema fields and builds a schema string without requiring a client instance.
+* Useful for pre-validation or building schema strings for external use.
+*
+* @param fields - Array of schema fields to validate
+* @returns The validated schema string
+* @throws Error if validation fails
+*
+* @example
+* ```typescript
+* import { validateAndBuildSchema } from "@settlemint/sdk-eas";
+*
+* try {
+*   const schemaString = validateAndBuildSchema([
+*     { name: "user", type: "address", description: "User's wallet address" },
+*     { name: "score", type: "uint256", description: "User's reputation score" }
+*   ]);
+*   console.log("Schema is valid:", schemaString); // "address user, uint256 score"
+* } catch (error) {
+*   console.error("Schema validation failed:", error.message);
+* }
+* ```
+*/
+function validateAndBuildSchema(fields) {
+	validateSchemaFields(fields);
+	return buildSchemaString(fields);
 }
 
 //#endregion
+exports.DEFAULT_EAS_ABIS = DEFAULT_EAS_ABIS;
+exports.EASErrorCode = EASErrorCode;
+exports.EASPortalClient = EASPortalClient;
+exports.EASPortalError = EASPortalError;
+exports.EAS_ABI = EAS_ABI;
 exports.EAS_FIELD_TYPES = EAS_FIELD_TYPES;
+exports.SCHEMA_REGISTRY_ABI = SCHEMA_REGISTRY_ABI;
+exports.buildSchemaString = buildSchemaString;
 exports.createEASClient = createEASClient;
+exports.validateAndBuildSchema = validateAndBuildSchema;
+exports.validatePortalClientOptions = validatePortalClientOptions;
+exports.validateSchemaFields = validateSchemaFields;
 //# sourceMappingURL=eas.cjs.map