@settlemint/sdk-eas 2.3.5-prfde1f9e5 → 2.3.6

package/dist/eas.js

@@ -1,7 +1,9 @@
 import "node:module";
-import { createPortalClient } from "@settlemint/sdk-portal";
-import { ApplicationAccessTokenSchema, UrlOrPathSchema } from "@settlemint/sdk-utils/validation";
+import { SchemaRegistry } from "@ethereum-attestation-service/eas-sdk";
+import { AccessTokenSchema, UrlSchema, validate } from "@settlemint/sdk-utils/validation";
+import { getPublicClient, getWalletClient } from "@settlemint/sdk-viem";
 import { isAddress } from "viem";
+import { JsonRpcProvider, Wallet } from "ethers";
 
 //#region rolldown:runtime
 var __defProp = Object.defineProperty;
@@ -12,356 +14,6 @@ var __export = (target, all) => {
 	});
 };
 
-//#endregion
-//#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) {
@@ -10557,108 +10209,69 @@ var classic_default = external_exports;
 var v4_default = classic_default;
 
 //#endregion
-//#region src/portal-client-options.schema.ts
+//#region src/client-options.schema.ts
 /**
-* ABI source configuration for EAS contracts.
-* Priority: hardcoded (default) > custom (user override) > predeployed (Portal's ABIs)
+* Schema for validating EAS client configuration options.
+* Extends the base Viem client options with EAS-specific requirements.
 */
-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: UrlOrPathSchema,
-	accessToken: ApplicationAccessTokenSchema,
-	easContractAddress: string().refine(isAddress, "Invalid EAS contract address format"),
-	schemaRegistryContractAddress: string().refine(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()
+const ClientOptionsSchema = object({
+	schemaRegistryAddress: string().refine(isAddress, "Invalid Ethereum address format"),
+	attestationAddress: string().refine(isAddress, "Invalid Ethereum address format"),
+	accessToken: AccessTokenSchema,
+	chainId: string().min(1),
+	chainName: string().min(1),
+	rpcUrl: UrlSchema
 });
-/**
-* 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/portal-types.ts
+//#region src/ethers-adapter.ts
 /**
-* EAS-specific error codes
+* Converts a viem PublicClient to an ethers JsonRpcProvider
 */
-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;
-}({});
+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 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 JsonRpcProvider(transport.url, network);
+}
 /**
-* Enhanced error class for EAS Portal operations
+* Converts a viem WalletClient to an ethers Wallet
 */
-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;
-		}
+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 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");
 	}
-};
+	return new Wallet(privateKey, provider);
+}
 
 //#endregion
-//#region src/schema.ts
+//#region src/types.ts
 /**
 * Supported field types for EAS schema fields.
 * Maps to the Solidity types that can be used in EAS schemas.
@@ -10676,7 +10289,7 @@ const EAS_FIELD_TYPES = {
 };
 
 //#endregion
-//#region src/utils/validation.ts
+//#region src/validation.ts
 function validateFieldName(name) {
 	if (!name) {
 		throw new Error("Field name cannot be empty");
@@ -10712,464 +10325,78 @@ 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 } = 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 via Portal.
-* This is the main entry point for the EAS SDK, now powered by Portal.
+* Creates an EAS client for interacting with the Ethereum Attestation Service.
 *
-* @param options - Configuration options for the Portal-based client
-* @returns An EAS Portal client instance with enhanced methods
+* @param options - Configuration options for the client
+* @returns An object containing the EAS client instance
 * @throws Will throw an error if the options fail validation
 *
 * @example
 * ```ts
 * import { createEASClient } from '@settlemint/sdk-eas';
 *
-* const eas = createEASClient({
-*   instance: "https://portal.settlemint.com",
+* const client = createEASClient({
+*   schemaRegistryAddress: "0x1234567890123456789012345678901234567890",
+*   attestationAddress: "0x1234567890123456789012345678901234567890",
 *   accessToken: "your-access-token",
-*   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,
-*   },
+*   chainId: "1",
+*   chainName: "Ethereum",
+*   rpcUrl: "http://localhost:8545"
 * });
 * ```
 */
 function createEASClient(options) {
-	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);
+	validate(ClientOptionsSchema, options);
+	const publicClient = getPublicClient({
+		accessToken: options.accessToken,
+		chainId: options.chainId,
+		chainName: options.chainName,
+		rpcUrl: options.rpcUrl
+	});
+	const walletClient = getWalletClient({
+		accessToken: options.accessToken,
+		chainId: options.chainId,
+		chainName: options.chainName,
+		rpcUrl: options.rpcUrl
+	})();
+	const provider = publicClientToProvider(publicClient);
+	const wallet = walletClientToSigner(walletClient);
+	const schemaRegistry = new 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
+	};
 }
 
 //#endregion
-export { DEFAULT_EAS_ABIS, EASErrorCode, EASPortalClient, EASPortalError, EAS_ABI, EAS_FIELD_TYPES, SCHEMA_REGISTRY_ABI, buildSchemaString, createEASClient, validateAndBuildSchema, validatePortalClientOptions, validateSchemaFields };
+export { EAS_FIELD_TYPES, createEASClient };
 //# sourceMappingURL=eas.js.map