@settlemint/sdk-eas 2.3.14-prbb564ea5 → 2.3.14-prc7b089e8

package/dist/browser/eas.js

@@ -1,8 +1,7 @@
-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";
+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";
 
 //#region rolldown:runtime
 var __defProp = Object.defineProperty;
@@ -13,6 +12,79 @@ 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) {
@@ -10778,194 +10850,524 @@ var classic_default = external_exports;
 var v4_default = classic_default;
 
 //#endregion
-//#region src/client-options.schema.ts
+//#region src/utils/validation.ts
+const ethAddressSchema = custom((val) => typeof val === "string" && isAddress(val), "Invalid Ethereum address");
 /**
-* Schema for validating EAS client configuration options.
-* Extends the base Viem client options with EAS-specific requirements.
+* @description Zod schema for EASClientOptions.
 */
-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
+const EASClientOptionsSchema = object({
+	instance: string$1().url("Invalid instance URL"),
+	accessToken: ApplicationAccessTokenSchema.optional(),
+	easContractAddress: ethAddressSchema.optional(),
+	schemaRegistryContractAddress: ethAddressSchema.optional(),
+	debug: boolean$1().optional()
 });
 
 //#endregion
-//#region src/ethers-adapter.ts
+//#region src/eas.ts
+const LOGGER = createLogger();
 /**
-* Converts a viem PublicClient to an ethers JsonRpcProvider
+* 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);
+* ```
 */
-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;
+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");
 			}
-		}).filter((provider) => provider != null);
-		if (providers.length === 0) throw new Error("No valid RPC URLs found");
-		return providers[0];
+			return {
+				hash: transactionHash,
+				success: true
+			};
+		} catch (err) {
+			const error$37 = err;
+			throw new Error(`Failed to register schema: ${error$37.message}`);
+		}
 	}
-	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");
+	/**
+	* 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}`);
+		}
 	}
-	if (name.includes(" ")) {
-		throw new Error("Field name cannot contain spaces");
+	/**
+	* 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");
+			}
+			return {
+				hash: transactionHash,
+				success: true
+			};
+		} catch (err) {
+			const error$37 = err;
+			throw new Error(`Failed to revoke attestation: ${error$37.message}`);
+		}
 	}
-	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 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}`);
 	}
-}
-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(", ")}`);
+	/**
+	* 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.");
 	}
-}
-function validateSchemaFields(fields) {
-	if (!fields || fields.length === 0) {
-		throw new Error("Schema must have at least one field");
+	/**
+	* 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}`);
 	}
-	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}`);
+	/**
+	* 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.");
+	}
+	/**
+	* Get client configuration
+	*/
+	getOptions() {
+		return { ...this.options };
+	}
+	/**
+	* Get the Portal client instance for advanced operations
+	*/
+	getPortalClient() {
+		return this.portalClient;
+	}
+	/**
+	* Get current contract addresses
+	*/
+	getContractAddresses() {
+		return {
+			easAddress: this.options.easContractAddress || this.deployedAddresses?.easAddress,
+			schemaRegistryAddress: this.options.schemaRegistryContractAddress || this.deployedAddresses?.schemaRegistryAddress
+		};
+	}
+	getEASAddress() {
+		if (this.options.easContractAddress) {
+			return this.options.easContractAddress;
+		}
+		if (this.deployedAddresses?.easAddress) {
+			return this.deployedAddresses.easAddress;
 		}
-		seenNames.add(field.name);
+		throw new Error("EAS contract address not available. Please provide it in options or deploy contracts first.");
 	}
-}
-function buildSchemaString(fields) {
-	validateSchemaFields(fields);
-	return fields.map((field) => `${field.type} ${field.name}`).join(", ");
-}
-
-//#endregion
-//#region src/eas.ts
+	getSchemaRegistryAddress() {
+		if (this.options.schemaRegistryContractAddress) {
+			return this.options.schemaRegistryContractAddress;
+		}
+		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(", ");
+	}
+};
 /**
-* Creates an EAS client for interacting with the Ethereum Attestation Service.
+* Create an 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
+* @param options - Configuration options for the EAS client
+* @returns EAS client instance
 *
 * @example
-* ```ts
-* import { createEASClient } from '@settlemint/sdk-eas';
+* ```typescript
+* import { createEASClient } from "@settlemint/sdk-eas";
 *
-* const client = createEASClient({
-*   schemaRegistryAddress: "0x1234567890123456789012345678901234567890",
-*   attestationAddress: "0x1234567890123456789012345678901234567890",
-*   accessToken: "your-access-token",
-*   chainId: "1",
-*   chainName: "Ethereum",
-*   rpcUrl: "http://localhost:8545"
+* const easClient = createEASClient({
+*   instance: "https://your-portal-instance.settlemint.com",
+*   accessToken: "your-access-token"
 * });
+*
+* // Use the client
+* const deployment = await easClient.deploy("0x1234...deployer-address");
 * ```
 */
 function createEASClient(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
-	};
+	return new EASClient(options);
 }
 
 //#endregion
-export { EAS_FIELD_TYPES, createEASClient };
+export { EASClient, EASClientOptionsSchema, EAS_FIELD_TYPES, GraphQLOperations, ZERO_ADDRESS, ZERO_BYTES32, createEASClient };
 //# sourceMappingURL=eas.js.map