@settlemint/sdk-eas 2.3.14-pr77cf5949 → 2.3.14-pr84e01ac3

package/dist/eas.js

@@ -1,8 +1,9 @@
 import "node:module";
-import { createPortalClient, waitForTransactionReceipt } from "@settlemint/sdk-portal";
-import { createLogger, requestLogger } from "@settlemint/sdk-utils/logging";
-import { ApplicationAccessTokenSchema, validate } from "@settlemint/sdk-utils/validation";
-import { isAddress, zeroAddress } from "viem";
+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;
@@ -13,79 +14,6 @@ var __export = (target, all) => {
 	});
 };
 
-//#endregion
-//#region src/portal/operations.ts
-const GraphQLOperations = { mutations: {
-	deploySchemaRegistry: (graphql) => graphql(`
-        mutation DeployContractEASSchemaRegistry(
-          $from: String!
-          $constructorArguments: DeployContractEASSchemaRegistryInput!
-          $gasLimit: String!
-        ) {
-          DeployContractEASSchemaRegistry(from: $from, constructorArguments: $constructorArguments, gasLimit: $gasLimit) {
-            transactionHash
-          }
-        }`),
-	deployEAS: (graphql) => graphql(`
-        mutation DeployContractEAS($from: String!, $constructorArguments: DeployContractEASInput!, $gasLimit: String!) {
-          DeployContractEAS(from: $from, constructorArguments: $constructorArguments, gasLimit: $gasLimit) {
-            transactionHash
-          }
-        }`),
-	registerSchema: (graphql) => graphql(`
-        mutation EASSchemaRegistryRegister(
-          $address: String!
-          $from: String!
-          $input: EASSchemaRegistryRegisterInput!
-          $gasLimit: String!
-        ) {
-          EASSchemaRegistryRegister(address: $address, from: $from, input: $input, gasLimit: $gasLimit) {
-            transactionHash
-          }
-        }`),
-	attest: (graphql) => graphql(`
-        mutation EASAttest($address: String!, $from: String!, $input: EASAttestInput!, $gasLimit: String!) {
-          EASAttest(address: $address, from: $from, input: $input, gasLimit: $gasLimit) {
-            transactionHash
-          }
-        }`),
-	multiAttest: (graphql) => graphql(`
-        mutation EASMultiAttest($address: String!, $from: String!, $input: EASMultiAttestInput!, $gasLimit: String!) {
-          EASMultiAttest(address: $address, from: $from, input: $input, gasLimit: $gasLimit) {
-            transactionHash
-          }
-        }`),
-	revoke: (graphql) => graphql(`
-        mutation EASRevoke($address: String!, $from: String!, $input: EASRevokeInput!, $gasLimit: String!) {
-          EASRevoke(address: $address, from: $from, input: $input, gasLimit: $gasLimit) {
-            transactionHash
-          }
-        }`)
-} };
-
-//#endregion
-//#region src/schema.ts
-/**
-* Common address constants
-*/
-const ZERO_ADDRESS = zeroAddress;
-const ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
-/**
-* Supported field types for EAS schema fields.
-* Maps to the Solidity types that can be used in EAS schemas.
-*/
-const EAS_FIELD_TYPES = {
-	string: "string",
-	address: "address",
-	bool: "bool",
-	bytes: "bytes",
-	bytes32: "bytes32",
-	uint256: "uint256",
-	int256: "int256",
-	uint8: "uint8",
-	int8: "int8"
-};
-
 //#endregion
 //#region ../../node_modules/zod/dist/esm/v4/core/core.js
 function $constructor(name, initializer$2, params) {
@@ -10851,524 +10779,194 @@ var classic_default = external_exports;
 var v4_default = classic_default;
 
 //#endregion
-//#region src/utils/validation.ts
-const ethAddressSchema = custom((val) => typeof val === "string" && isAddress(val), "Invalid Ethereum address");
+//#region src/client-options.schema.ts
 /**
-* @description Zod schema for EASClientOptions.
+* Schema for validating EAS client configuration options.
+* Extends the base Viem client options with EAS-specific requirements.
 */
-const EASClientOptionsSchema = object({
-	instance: string$1().url("Invalid instance URL"),
-	accessToken: ApplicationAccessTokenSchema.optional(),
-	easContractAddress: ethAddressSchema.optional(),
-	schemaRegistryContractAddress: ethAddressSchema.optional(),
-	debug: boolean$1().optional()
+const ClientOptionsSchema = object({
+	schemaRegistryAddress: string$1().refine(isAddress, "Invalid Ethereum address format"),
+	attestationAddress: string$1().refine(isAddress, "Invalid Ethereum address format"),
+	accessToken: AccessTokenSchema,
+	chainId: string$1().min(1),
+	chainName: string$1().min(1),
+	rpcUrl: UrlSchema
 });
 
 //#endregion
-//#region src/eas.ts
-const LOGGER = createLogger();
+//#region src/ethers-adapter.ts
 /**
-* Main EAS client class for interacting with Ethereum Attestation Service via Portal
-*
-* @example
-* ```typescript
-* import { createEASClient } from "@settlemint/sdk-eas";
-*
-* const easClient = createEASClient({
-*   instance: "https://your-portal-instance.settlemint.com",
-*   accessToken: "your-access-token"
-* });
-*
-* // Deploy EAS contracts
-* const deployment = await easClient.deploy("0x1234...deployer-address");
-* console.log("EAS deployed at:", deployment.easAddress);
-* ```
+* Converts a viem PublicClient to an ethers JsonRpcProvider
 */
-var EASClient = class {
-	options;
-	portalClient;
-	portalGraphql;
-	deployedAddresses;
-	constructor(options) {
-		this.options = validate(EASClientOptionsSchema, options);
-		const { client: portalClient, graphql: portalGraphql } = createPortalClient({
-			instance: this.options.instance,
-			accessToken: this.options.accessToken
-		}, { fetch: requestLogger(LOGGER, "portal", fetch) });
-		this.portalClient = portalClient;
-		this.portalGraphql = portalGraphql;
-	}
-	/**
-	* Deploy EAS contracts via Portal
-	*
-	* @param deployerAddress - The address that will deploy the contracts
-	* @param forwarderAddress - Optional trusted forwarder address (defaults to zero address)
-	* @param gasLimit - Optional gas limit for deployment transactions (defaults to "0x7a1200")
-	* @returns Promise resolving to deployment result with contract addresses and transaction hashes
-	*
-	* @example
-	* ```typescript
-	* import { createEASClient } from "@settlemint/sdk-eas";
-	*
-	* const easClient = createEASClient({
-	*   instance: "https://your-portal-instance.settlemint.com",
-	*   accessToken: "your-access-token"
-	* });
-	*
-	* const deployment = await easClient.deploy(
-	*   "0x1234567890123456789012345678901234567890", // deployer address
-	*   "0x0000000000000000000000000000000000000000", // forwarder (optional)
-	*   "0x7a1200" // gas limit (optional)
-	* );
-	*
-	* console.log("Schema Registry:", deployment.schemaRegistryAddress);
-	* console.log("EAS Contract:", deployment.easAddress);
-	* ```
-	*/
-	async deploy(deployerAddress, forwarderAddress, gasLimit) {
-		const defaultForwarder = forwarderAddress || ZERO_ADDRESS;
-		const defaultGasLimit = gasLimit || "0x7a1200";
-		try {
-			const schemaRegistryResult = await this.portalClient.request(GraphQLOperations.mutations.deploySchemaRegistry(this.portalGraphql), {
-				from: deployerAddress,
-				constructorArguments: { forwarder: defaultForwarder },
-				gasLimit: defaultGasLimit
-			});
-			const schemaRegistryResponse = schemaRegistryResult;
-			if (!schemaRegistryResponse.DeployContractEASSchemaRegistry?.transactionHash) {
-				throw new Error("Schema Registry deployment failed - no transaction hash returned");
-			}
-			const schemaRegistryTxHash = schemaRegistryResponse.DeployContractEASSchemaRegistry.transactionHash;
-			const schemaRegistryTransaction = await waitForTransactionReceipt(schemaRegistryTxHash, {
-				portalGraphqlEndpoint: this.options.instance,
-				accessToken: this.options.accessToken,
-				timeout: 6e4
-			});
-			if (!schemaRegistryTransaction?.receipt?.contractAddress) {
-				throw new Error("Schema Registry deployment failed - could not get contract address from transaction receipt.");
-			}
-			const schemaRegistryAddress = schemaRegistryTransaction.receipt.contractAddress;
-			const easResponse = await this.portalClient.request(GraphQLOperations.mutations.deployEAS(this.portalGraphql), {
-				from: deployerAddress,
-				constructorArguments: {
-					registry: schemaRegistryAddress,
-					forwarder: defaultForwarder
-				},
-				gasLimit: defaultGasLimit
-			});
-			const easResult = easResponse;
-			if (!easResult.DeployContractEAS?.transactionHash) {
-				throw new Error("EAS deployment failed - no transaction hash returned");
-			}
-			const easTxHash = easResult.DeployContractEAS.transactionHash;
-			const easTransaction = await waitForTransactionReceipt(easTxHash, {
-				portalGraphqlEndpoint: this.options.instance,
-				accessToken: this.options.accessToken,
-				timeout: 6e4
-			});
-			if (!easTransaction?.receipt?.contractAddress) {
-				throw new Error("EAS deployment failed - could not get contract address from transaction receipt.");
-			}
-			const easAddress = easTransaction.receipt.contractAddress;
-			this.deployedAddresses = {
-				easAddress,
-				schemaRegistryAddress,
-				easTransactionHash: easTxHash,
-				schemaRegistryTransactionHash: schemaRegistryTxHash
-			};
-			return this.deployedAddresses;
-		} catch (err) {
-			const error$37 = err;
-			throw new Error(`Failed to deploy EAS contracts: ${error$37.message}`);
-		}
-	}
-	/**
-	* Register a new schema in the EAS Schema Registry
-	*
-	* @param request - Schema registration request containing schema definition
-	* @param fromAddress - Address that will register the schema
-	* @param gasLimit - Optional gas limit for the transaction (defaults to "0x3d0900")
-	* @returns Promise resolving to transaction result
-	*
-	* @example
-	* ```typescript
-	* import { createEASClient } from "@settlemint/sdk-eas";
-	*
-	* const easClient = createEASClient({
-	*   instance: "https://your-portal-instance.settlemint.com",
-	*   accessToken: "your-access-token"
-	* });
-	*
-	* const schemaResult = await easClient.registerSchema(
-	*   {
-	*     schema: "uint256 eventId, uint8 voteIndex",
-	*     resolver: "0x0000000000000000000000000000000000000000",
-	*     revocable: true
-	*   },
-	*   "0x1234567890123456789012345678901234567890" // from address
-	* );
-	*
-	* console.log("Schema registered:", schemaResult.hash);
-	* ```
-	*/
-	async registerSchema(request, fromAddress, gasLimit) {
-		const schemaRegistryAddress = this.getSchemaRegistryAddress();
-		let schemaString = request.schema;
-		if (request.fields && !schemaString) {
-			schemaString = this.buildSchemaString(request.fields);
-		}
-		if (!schemaString) {
-			throw new Error("Schema string is required. Provide either 'schema' or 'fields'.");
-		}
-		try {
-			const result = await this.portalClient.request(GraphQLOperations.mutations.registerSchema(this.portalGraphql), {
-				address: schemaRegistryAddress,
-				from: fromAddress,
-				input: {
-					schema: schemaString,
-					resolver: request.resolver,
-					revocable: request.revocable
-				},
-				gasLimit: gasLimit || "0x3d0900"
-			});
-			const response = result;
-			const transactionHash = response.EASSchemaRegistryRegister?.transactionHash;
-			if (!transactionHash) {
-				throw new Error("No transaction hash returned from Portal");
-			}
-			return {
-				hash: transactionHash,
-				success: true
-			};
-		} catch (err) {
-			const error$37 = err;
-			throw new Error(`Failed to register schema: ${error$37.message}`);
-		}
-	}
-	/**
-	* Create an attestation
-	*
-	* @param request - Attestation request containing schema and data
-	* @param fromAddress - Address that will create the attestation
-	* @param gasLimit - Optional gas limit for the transaction (defaults to "0x3d0900")
-	* @returns Promise resolving to transaction result
-	*
-	* @example
-	* ```typescript
-	* import { createEASClient } from "@settlemint/sdk-eas";
-	*
-	* const easClient = createEASClient({
-	*   instance: "https://your-portal-instance.settlemint.com",
-	*   accessToken: "your-access-token"
-	* });
-	*
-	* const attestationResult = await easClient.attest(
-	*   {
-	*     schema: "0x1234567890123456789012345678901234567890123456789012345678901234",
-	*     data: {
-	*       recipient: "0x1234567890123456789012345678901234567890",
-	*       expirationTime: BigInt(0), // No expiration
-	*       revocable: true,
-	*       refUID: "0x0000000000000000000000000000000000000000000000000000000000000000",
-	*       data: "0x1234", // ABI-encoded data
-	*       value: BigInt(0)
-	*     }
-	*   },
-	*   "0x1234567890123456789012345678901234567890" // from address
-	* );
-	*
-	* console.log("Attestation created:", attestationResult.hash);
-	* ```
-	*/
-	async attest(request, fromAddress, gasLimit) {
-		const easAddress = this.getEASAddress();
-		try {
-			const result = await this.portalClient.request(GraphQLOperations.mutations.attest(this.portalGraphql), {
-				address: easAddress,
-				from: fromAddress,
-				input: { request: {
-					schema: request.schema,
-					data: {
-						recipient: request.data.recipient,
-						expirationTime: request.data.expirationTime.toString(),
-						revocable: request.data.revocable,
-						refUID: request.data.refUID,
-						data: request.data.data,
-						value: request.data.value?.toString() || "0"
-					}
-				} },
-				gasLimit: gasLimit || "0x3d0900"
-			});
-			const response = result;
-			const transactionHash = response.EASAttest?.transactionHash;
-			if (!transactionHash) {
-				throw new Error("No transaction hash returned from Portal");
-			}
-			return {
-				hash: transactionHash,
-				success: true
-			};
-		} catch (err) {
-			const error$37 = err;
-			throw new Error(`Failed to create attestation: ${error$37.message}`);
-		}
-	}
-	/**
-	* Create multiple attestations in a single transaction
-	*
-	* @param requests - Array of attestation requests
-	* @param fromAddress - Address that will create the attestations
-	* @param gasLimit - Optional gas limit for the transaction (defaults to "0x3d0900")
-	* @returns Promise resolving to transaction result
-	*
-	* @example
-	* ```typescript
-	* import { createEASClient } from "@settlemint/sdk-eas";
-	*
-	* const easClient = createEASClient({
-	*   instance: "https://your-portal-instance.settlemint.com",
-	*   accessToken: "your-access-token"
-	* });
-	*
-	* const multiAttestResult = await easClient.multiAttest(
-	*   [
-	*     {
-	*       schema: "0x1234567890123456789012345678901234567890123456789012345678901234",
-	*       data: {
-	*         recipient: "0x1234567890123456789012345678901234567890",
-	*         expirationTime: BigInt(0),
-	*         revocable: true,
-	*         refUID: "0x0000000000000000000000000000000000000000000000000000000000000000",
-	*         data: "0x1234",
-	*         value: BigInt(0)
-	*       }
-	*     },
-	*     {
-	*       schema: "0x5678901234567890123456789012345678901234567890123456789012345678",
-	*       data: {
-	*         recipient: "0x5678901234567890123456789012345678901234",
-	*         expirationTime: BigInt(0),
-	*         revocable: false,
-	*         refUID: "0x0000000000000000000000000000000000000000000000000000000000000000",
-	*         data: "0x5678",
-	*         value: BigInt(0)
-	*       }
-	*     }
-	*   ],
-	*   "0x1234567890123456789012345678901234567890" // from address
-	* );
-	*
-	* console.log("Multiple attestations created:", multiAttestResult.hash);
-	* ```
-	*/
-	async multiAttest(requests, fromAddress, gasLimit) {
-		if (requests.length === 0) {
-			throw new Error("At least one attestation request is required");
-		}
-		const easAddress = this.getEASAddress();
-		try {
-			const result = await this.portalClient.request(GraphQLOperations.mutations.multiAttest(this.portalGraphql), {
-				address: easAddress,
-				from: fromAddress,
-				input: { multiRequests: requests.map((req) => ({
-					schema: req.schema,
-					data: [{
-						recipient: req.data.recipient,
-						expirationTime: req.data.expirationTime.toString(),
-						revocable: req.data.revocable,
-						refUID: req.data.refUID,
-						data: req.data.data,
-						value: req.data.value?.toString() || "0"
-					}]
-				})) },
-				gasLimit: gasLimit || "0x3d0900"
-			});
-			const response = result;
-			const transactionHash = response.EASMultiAttest?.transactionHash;
-			if (!transactionHash) {
-				throw new Error("No transaction hash returned from Portal");
-			}
-			return {
-				hash: transactionHash,
-				success: true
-			};
-		} catch (err) {
-			const error$37 = err;
-			throw new Error(`Failed to create multiple attestations: ${error$37.message}`);
-		}
-	}
-	/**
-	* Revoke an existing attestation
-	*
-	* @param schemaUID - UID of the schema used for the attestation
-	* @param attestationUID - UID of the attestation to revoke
-	* @param fromAddress - Address that will revoke the attestation
-	* @param value - Optional ETH value to send with the revocation
-	* @param gasLimit - Optional gas limit for the transaction (defaults to "0x3d0900")
-	* @returns Promise resolving to transaction result
-	*
-	* @example
-	* ```typescript
-	* import { createEASClient } from "@settlemint/sdk-eas";
-	*
-	* const easClient = createEASClient({
-	*   instance: "https://your-portal-instance.settlemint.com",
-	*   accessToken: "your-access-token"
-	* });
-	*
-	* const revokeResult = await easClient.revoke(
-	*   "0x1234567890123456789012345678901234567890123456789012345678901234", // schema UID
-	*   "0x5678901234567890123456789012345678901234567890123456789012345678", // attestation UID
-	*   "0x1234567890123456789012345678901234567890", // from address
-	*   BigInt(0) // value (optional)
-	* );
-	*
-	* console.log("Attestation revoked:", revokeResult.hash);
-	* ```
-	*/
-	async revoke(schemaUID, attestationUID, fromAddress, value, gasLimit) {
-		const easAddress = this.getEASAddress();
-		try {
-			const result = await this.portalClient.request(GraphQLOperations.mutations.revoke(this.portalGraphql), {
-				address: this.getEASAddress(),
-				from: fromAddress,
-				input: { request: {
-					schema: schemaUID,
-					data: {
-						uid: attestationUID,
-						value: value?.toString() || "0"
-					}
-				} },
-				gasLimit: gasLimit || "0x3d0900"
-			});
-			const response = result;
-			const transactionHash = response.EASRevoke?.transactionHash;
-			if (!transactionHash) {
-				throw new Error("No transaction hash returned from Portal");
+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;
 			}
-			return {
-				hash: transactionHash,
-				success: true
-			};
-		} catch (err) {
-			const error$37 = err;
-			throw new Error(`Failed to revoke attestation: ${error$37.message}`);
-		}
-	}
-	/**
-	* Get a schema by UID
-	*
-	* TODO: Implement using The Graph subgraph for EAS data queries
-	*/
-	async getSchema(uid) {
-		throw new Error(`Schema queries not implemented yet. Use The Graph subgraph for reading schema data. Schema UID: ${uid}`);
-	}
-	/**
-	* Get all schemas with pagination
-	*
-	* TODO: Implement using The Graph subgraph for EAS data queries
-	*/
-	async getSchemas(options) {
-		throw new Error("Schema listing not implemented yet. Use The Graph subgraph for reading schema data.");
-	}
-	/**
-	* Get an attestation by UID
-	*
-	* TODO: Implement using The Graph subgraph for EAS data queries
-	*/
-	async getAttestation(uid) {
-		throw new Error(`Attestation queries not implemented yet. Use The Graph subgraph for reading attestation data. Attestation UID: ${uid}`);
+		}).filter((provider) => provider != null);
+		if (providers.length === 0) throw new Error("No valid RPC URLs found");
+		return providers[0];
 	}
-	/**
-	* Get attestations with pagination and filtering
-	*
-	* TODO: Implement using The Graph subgraph for EAS data queries
-	*/
-	async getAttestations(options) {
-		throw new Error("Attestation listing not implemented yet. Use The Graph subgraph for reading attestation data.");
-	}
-	/**
-	* Check if an attestation is valid
-	*
-	* TODO: Implement using The Graph subgraph for EAS data queries
-	*/
-	async isValidAttestation(uid) {
-		return false;
-	}
-	/**
-	* Get the current timestamp from the contract
-	*
-	* TODO: Fix Portal GraphQL query parameter encoding or use The Graph subgraph
-	*/
-	async getTimestamp() {
-		throw new Error("Timestamp query not implemented yet. Fix Portal query parameters or use The Graph subgraph.");
+	return new JsonRpcProvider(transport.url, network);
+}
+/**
+* Converts a viem WalletClient to an ethers Wallet
+*/
+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/types.ts
+/**
+* Supported field types for EAS schema fields.
+* Maps to the Solidity types that can be used in EAS schemas.
+*/
+const EAS_FIELD_TYPES = {
+	string: "string",
+	address: "address",
+	bool: "bool",
+	bytes: "bytes",
+	bytes32: "bytes32",
+	uint256: "uint256",
+	int256: "int256",
+	uint8: "uint8",
+	int8: "int8"
+};
+
+//#endregion
+//#region src/validation.ts
+function validateFieldName(name) {
+	if (!name) {
+		throw new Error("Field name cannot be empty");
 	}
-	/**
-	* Get client configuration
-	*/
-	getOptions() {
-		return { ...this.options };
+	if (name.includes(" ")) {
+		throw new Error("Field name cannot contain spaces");
 	}
-	/**
-	* Get the Portal client instance for advanced operations
-	*/
-	getPortalClient() {
-		return this.portalClient;
+	if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+		throw new Error("Field name must start with a letter or underscore and contain only alphanumeric characters and underscores");
 	}
-	/**
-	* Get current contract addresses
-	*/
-	getContractAddresses() {
-		return {
-			easAddress: this.options.easContractAddress || this.deployedAddresses?.easAddress,
-			schemaRegistryAddress: this.options.schemaRegistryContractAddress || this.deployedAddresses?.schemaRegistryAddress
-		};
+}
+function validateFieldType(type) {
+	if (!(type in EAS_FIELD_TYPES)) {
+		throw new Error(`Invalid field type: ${type}. Must be one of: ${Object.keys(EAS_FIELD_TYPES).join(", ")}`);
 	}
-	getEASAddress() {
-		if (this.options.easContractAddress) {
-			return this.options.easContractAddress;
-		}
-		if (this.deployedAddresses?.easAddress) {
-			return this.deployedAddresses.easAddress;
-		}
-		throw new Error("EAS contract address not available. Please provide it in options or deploy contracts first.");
+}
+function validateSchemaFields(fields) {
+	if (!fields || fields.length === 0) {
+		throw new Error("Schema must have at least one field");
 	}
-	getSchemaRegistryAddress() {
-		if (this.options.schemaRegistryContractAddress) {
-			return this.options.schemaRegistryContractAddress;
+	const seenNames = new Set();
+	for (const field of fields) {
+		validateFieldName(field.name);
+		validateFieldType(field.type);
+		if (seenNames.has(field.name)) {
+			throw new Error(`Duplicate field name: ${field.name}`);
 		}
-		if (this.deployedAddresses?.schemaRegistryAddress) {
-			return this.deployedAddresses.schemaRegistryAddress;
-		}
-		throw new Error("Schema Registry contract address not available. Please provide it in options or deploy contracts first.");
-	}
-	buildSchemaString(fields) {
-		return fields.map((field) => `${field.type} ${field.name}`).join(", ");
+		seenNames.add(field.name);
 	}
-};
+}
+function buildSchemaString(fields) {
+	validateSchemaFields(fields);
+	return fields.map((field) => `${field.type} ${field.name}`).join(", ");
+}
+
+//#endregion
+//#region src/eas.ts
 /**
-* Create an EAS client instance
+* Creates an EAS client for interacting with the Ethereum Attestation Service.
 *
-* @param options - Configuration options for the EAS client
-* @returns EAS client instance
+* @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
-* ```typescript
-* import { createEASClient } from "@settlemint/sdk-eas";
+* ```ts
+* import { createEASClient } from '@settlemint/sdk-eas';
 *
-* const easClient = createEASClient({
-*   instance: "https://your-portal-instance.settlemint.com",
-*   accessToken: "your-access-token"
+* const client = createEASClient({
+*   schemaRegistryAddress: "0x1234567890123456789012345678901234567890",
+*   attestationAddress: "0x1234567890123456789012345678901234567890",
+*   accessToken: "your-access-token",
+*   chainId: "1",
+*   chainName: "Ethereum",
+*   rpcUrl: "http://localhost:8545"
 * });
-*
-* // Use the client
-* const deployment = await easClient.deploy("0x1234...deployer-address");
 * ```
 */
 function createEASClient(options) {
-	return new EASClient(options);
+	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$37) {
+			throw new Error(`Failed to register schema: ${error$37.message}`, { cause: error$37 });
+		}
+	}
+	async function getSchema(uid) {
+		try {
+			await provider.getNetwork();
+			const schema = await schemaRegistry.getSchema({ uid });
+			return schema.toString();
+		} catch (error$37) {
+			throw new Error(`Failed to get schema: ${error$37.message}`);
+		}
+	}
+	return {
+		registerSchema,
+		getSchema
+	};
 }
 
 //#endregion
-export { EASClient, EASClientOptionsSchema, EAS_FIELD_TYPES, GraphQLOperations, ZERO_ADDRESS, ZERO_BYTES32, createEASClient };
+export { EAS_FIELD_TYPES, createEASClient };
 //# sourceMappingURL=eas.js.map