@settlemint/sdk-eas 2.3.4 → 2.3.5-prfde1f9e5

package/dist/eas.d.ts

@@ -1,30 +1,11 @@
+import { Abi, Address, Hex } from "viem";
 import { z } from "zod/v4";
 
-//#region src/client-options.schema.d.ts
+//#region src/schema.d.ts
 /**
-* Schema for validating EAS client configuration options.
-* Extends the base Viem client options with EAS-specific requirements.
+* Supported field types for EAS schema fields.
+* Maps to the Solidity types that can be used in EAS schemas.
 */
-/**
- * Schema for validating EAS client configuration options.
- * Extends the base Viem client options with EAS-specific requirements.
- */
-declare const ClientOptionsSchema: z.ZodObject<{
-  schemaRegistryAddress: z.ZodString;
-  attestationAddress: z.ZodString;
-  accessToken: z.ZodString;
-  chainId: z.ZodString;
-  chainName: z.ZodString;
-  rpcUrl: z.ZodString;
-}, z.core.$strip>;
-/**
- * Configuration options for creating an EAS client.
- * Combines EAS-specific options with base Viem client options.
- */
-type ClientOptions = z.infer<typeof ClientOptionsSchema>;
-
-//#endregion
-//#region src/types.d.ts
 /**
  * Supported field types for EAS schema fields.
  * Maps to the Solidity types that can be used in EAS schemas.
@@ -62,36 +43,1030 @@ interface RegisterSchemaOptions {
   resolverAddress: string;
   /** Whether attestations using this schema can be revoked */
   revocable: boolean;
+} //#endregion
+//#region src/portal-types.d.ts
+/**
+ * Simple transaction event type for EAS Portal integration
+ */
+interface TransactionEvent {
+  /** The name of the event that was emitted */
+  eventName: string;
+  /** The arguments emitted by the event */
+  args: Record<string, unknown>;
+  /** Indexed event parameters used for filtering and searching */
+  topics: Hex[];
+}
+/**
+ * Simple transaction receipt type for EAS Portal integration
+ */
+interface TransactionReceipt {
+  /** The transaction hash */
+  transactionHash: string;
+  /** The block hash */
+  blockHash: string;
+  /** The block number */
+  blockNumber: string;
+  /** Transaction status */
+  status: "Success" | "Reverted";
+  /** Gas used */
+  gasUsed: string;
+  /** From address */
+  from: string;
+  /** To address */
+  to?: string;
+  /** Contract address (if contract deployment) */
+  contractAddress?: string;
+  /** Array of events emitted during the transaction */
+  events: TransactionEvent[];
+  /** The raw reason for transaction reversion, if applicable */
+  revertReason?: string;
+  /** Human-readable version of the revert reason */
+  revertReasonDecoded?: string;
+}
+/**
+ * Enhanced schema registration options for Portal integration
+ */
+interface PortalRegisterSchemaOptions {
+  /** Array of fields that make up the schema */
+  fields: SchemaField[];
+  /** Address of the resolver contract that will handle attestations */
+  resolverAddress: Address;
+  /** Whether attestations using this schema can be revoked */
+  revocable: boolean;
+  /** The address to send the transaction from */
+  from: Address;
+  /** Optional gas limit for the transaction */
+  gasLimit?: string;
+  /** Optional gas price for the transaction */
+  gasPrice?: string;
+  /** Optional metadata to store with the transaction */
+  metadata?: Record<string, unknown>;
+  /** Whether to simulate the transaction before sending */
+  simulate?: boolean;
+}
+/**
+ * Enhanced attestation creation options for Portal integration
+ */
+interface PortalCreateAttestationOptions {
+  /** The schema UID to attest against */
+  schemaUID: string;
+  /** The recipient of the attestation */
+  recipient: Address;
+  /** The attestation data (encoded) */
+  data: string;
+  /** Optional expiration time (timestamp) */
+  expirationTime?: number;
+  /** Whether this attestation can be revoked */
+  revocable?: boolean;
+  /** Optional reference to another attestation */
+  refUID?: string;
+  /** Optional value to send with the attestation */
+  value?: string;
+  /** The address to send the transaction from */
+  from: Address;
+  /** Optional gas limit for the transaction */
+  gasLimit?: string;
+  /** Optional gas price for the transaction */
+  gasPrice?: string;
+  /** Optional metadata to store with the transaction */
+  metadata?: Record<string, unknown>;
+  /** Whether to simulate the transaction before sending */
+  simulate?: boolean;
+}
+/**
+ * Enhanced revocation options for Portal integration
+ */
+interface PortalRevokeAttestationOptions {
+  /** The UID of the attestation to revoke */
+  uid: string;
+  /** The schema UID of the attestation */
+  schemaUID: string;
+  /** Optional value to send with the revocation */
+  value?: string;
+  /** The address to send the transaction from */
+  from: Address;
+  /** Optional gas limit for the transaction */
+  gasLimit?: string;
+  /** Optional gas price for the transaction */
+  gasPrice?: string;
+  /** Optional metadata to store with the transaction */
+  metadata?: Record<string, unknown>;
+  /** Whether to simulate the transaction before sending */
+  simulate?: boolean;
+}
+/**
+ * Result of a schema registration operation
+ */
+interface SchemaRegistrationResult {
+  /** The transaction hash */
+  transactionHash: string;
+  /** The schema UID (available after transaction confirmation) */
+  schemaUID?: string;
+  /** The transaction receipt (available after confirmation) */
+  receipt?: TransactionReceipt;
+  /** Events emitted during the transaction */
+  events?: TransactionEvent[];
+}
+/**
+ * Result of an attestation creation operation
+ */
+interface AttestationResult {
+  /** The transaction hash */
+  transactionHash: string;
+  /** The attestation UID (available after transaction confirmation) */
+  attestationUID?: string;
+  /** The transaction receipt (available after confirmation) */
+  receipt?: TransactionReceipt;
+  /** Events emitted during the transaction */
+  events?: TransactionEvent[];
+}
+/**
+ * Result of an attestation revocation operation
+ */
+interface RevocationResult {
+  /** The transaction hash */
+  transactionHash: string;
+  /** The transaction receipt (available after confirmation) */
+  receipt?: TransactionReceipt;
+  /** Events emitted during the transaction */
+  events?: TransactionEvent[];
+}
+/**
+ * Detailed schema information from Portal
+ */
+interface SchemaDetails {
+  /** The schema UID */
+  uid: string;
+  /** The resolver address */
+  resolver: Address;
+  /** Whether attestations can be revoked */
+  revocable: boolean;
+  /** The schema string */
+  schema: string;
+  /** Registration transaction hash */
+  registrationTxHash?: string;
+  /** Registration block number */
+  registrationBlock?: number;
+  /** Number of attestations using this schema */
+  attestationCount?: number;
+}
+/**
+ * Detailed attestation information from Portal
+ */
+interface AttestationDetails {
+  /** The attestation UID */
+  uid: string;
+  /** The schema UID */
+  schema: string;
+  /** Creation timestamp */
+  time: number;
+  /** Expiration timestamp (0 if no expiration) */
+  expirationTime: number;
+  /** Revocation timestamp (0 if not revoked) */
+  revocationTime: number;
+  /** Reference UID */
+  refUID: string;
+  /** Recipient address */
+  recipient: Address;
+  /** Attester address */
+  attester: Address;
+  /** Whether this attestation is revocable */
+  revocable: boolean;
+  /** The attestation data */
+  data: string;
+  /** Creation transaction hash */
+  creationTxHash?: string;
+  /** Revocation transaction hash (if revoked) */
+  revocationTxHash?: string;
+}
+/**
+ * Transaction status for real-time monitoring
+ */
+interface TransactionStatus {
+  /** The transaction hash */
+  transactionHash: string;
+  /** Current status */
+  status: "pending" | "confirmed" | "failed";
+  /** Transaction receipt (if confirmed) */
+  receipt?: TransactionReceipt;
+  /** Events emitted (if confirmed) */
+  events?: TransactionEvent[];
+  /** Error message (if failed) */
+  error?: string;
+}
+/**
+ * EAS-specific error codes
+ */
+declare enum EASErrorCode {
+  INVALID_SCHEMA = "INVALID_SCHEMA",
+  SCHEMA_NOT_FOUND = "SCHEMA_NOT_FOUND",
+  ATTESTATION_NOT_FOUND = "ATTESTATION_NOT_FOUND",
+  UNAUTHORIZED = "UNAUTHORIZED",
+  TRANSACTION_FAILED = "TRANSACTION_FAILED",
+  INVALID_SIGNATURE = "INVALID_SIGNATURE",
+  EXPIRED_ATTESTATION = "EXPIRED_ATTESTATION",
+  NON_REVOCABLE = "NON_REVOCABLE",
+  ALREADY_REVOKED = "ALREADY_REVOKED",
+  PORTAL_ERROR = "PORTAL_ERROR",
+}
+/**
+ * Enhanced error class for EAS Portal operations
+ */
+declare class EASPortalError extends Error {
+  readonly code: EASErrorCode;
+  readonly transactionHash?: string;
+  readonly revertReason?: string;
+  readonly gasEstimate?: bigint;
+  constructor(message: string, code: EASErrorCode, options?: {
+    transactionHash?: string;
+    revertReason?: string;
+    gasEstimate?: bigint;
+    cause?: Error;
+  });
+}
+/**
+ * Options for watching transaction status
+ */
+interface WatchTransactionOptions {
+  /** Timeout in milliseconds */
+  timeout?: number;
+  /** Polling interval in milliseconds */
+  interval?: number;
+}
+/**
+ * Configuration options for the EAS Portal client
+ */
+interface PortalClientOptions {
+  /** Portal instance URL or path */
+  instance: string;
+  /** Access token for Portal authentication */
+  accessToken: string;
+  /** The address of the EAS Attestation contract */
+  easContractAddress: string;
+  /** The address of the EAS Schema Registry contract */
+  schemaRegistryContractAddress: string;
+  /** ABI source configuration */
+  abiSource: AbiSource$1;
+  /** Optional WebSocket URL for real-time transaction monitoring */
+  wsUrl?: string;
+  /** Request timeout in milliseconds */
+  timeout?: number;
+  /** Enable debug logging */
+  debug?: boolean;
+  /** Optional cache configuration for GraphQL requests */
+  cache?: "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload";
+}
+/**
+ * ABI source configuration for EAS contracts
+ */
+type AbiSource$1 = {
+  type: "hardcoded";
+} | {
+  type: "custom";
+  easAbi: Abi;
+  schemaRegistryAbi: Abi;
+} | {
+  type: "predeployed";
+  abiNames?: string[];
+};
+/**
+ * Attestation request data structure
+ */
+interface AttestationRequest {
+  /** The schema UID to attest against */
+  schema: Hex;
+  /** The attestation data */
+  data: {
+    /** The recipient of the attestation */
+    recipient: Address;
+    /** Expiration time (0 for no expiration) */
+    expirationTime: bigint;
+    /** Whether this attestation is revocable */
+    revocable: boolean;
+    /** Reference UID (0x0 for no reference) */
+    refUID: Hex;
+    /** The attestation data (encoded) */
+    data: Hex;
+    /** Value to send with the attestation */
+    value: bigint;
+  };
+}
+/**
+ * Schema registration request data structure
+ * Supports both schema string and schema fields for enhanced developer experience
+ */
+interface SchemaRequest {
+  /** The schema string OR schema fields (one of these is required) */
+  schema?: string;
+  /** Array of schema fields (alternative to schema string) */
+  fields?: SchemaField[];
+  /** The resolver address */
+  resolver: Address;
+  /** Whether attestations using this schema can be revoked */
+  revocable: boolean;
+}
+/**
+ * Transaction result from Portal operations
+ */
+interface TransactionResult {
+  /** The transaction hash */
+  hash: Hex;
+  /** Whether the transaction was successful */
+  success: boolean;
+  /** Optional error message */
+  error?: string;
+}
+/**
+ * Attestation data structure returned from queries
+ */
+interface AttestationData {
+  /** The attestation UID */
+  uid: Hex;
+  /** The schema UID */
+  schema: Hex;
+  /** The attester address */
+  attester: Address;
+  /** The recipient address */
+  recipient: Address;
+  /** Creation timestamp */
+  time: bigint;
+  /** Expiration timestamp (0 if no expiration) */
+  expirationTime: bigint;
+  /** Whether this attestation is revocable */
+  revocable: boolean;
+  /** Reference UID */
+  refUID: Hex;
+  /** The attestation data */
+  data: Hex;
+  /** Value sent with the attestation */
+  value: bigint;
+}
+/**
+ * Schema data structure returned from queries
+ */
+interface SchemaData {
+  /** The schema UID */
+  uid: Hex;
+  /** The resolver address */
+  resolver: Address;
+  /** Whether attestations can be revoked */
+  revocable: boolean;
+  /** The schema string */
+  schema: string;
+} //#endregion
+//#region src/eas-portal-client.d.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).
+ */
+declare class EASPortalClient {
+  private portalClient;
+  private options;
+  private easAbi;
+  private 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: PortalClientOptions);
+  /**
+   * Sets the ABIs based on the configured source priority.
+   * Priority: hardcoded (default) > custom (user override) > predeployed (Portal's ABIs)
+   */
+  private setAbis;
+  /**
+   * Creates a new attestation on-chain.
+   *
+   * @param request - The attestation request data
+   * @returns Promise resolving to transaction result
+   * @throws EASPortalError if the operation fails
+   */
+  attest(request: AttestationRequest): Promise<TransactionResult>;
+  /**
+   * 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
+   */
+  multiAttest(requests: AttestationRequest[]): Promise<TransactionResult>;
+  /**
+   * 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
+   */
+  revoke(uid: Hex, value?: bigint): Promise<TransactionResult>;
+  /**
+   * 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,
+   * });
+   * ```
+   */
+  registerSchema(request: SchemaRequest): Promise<TransactionResult>;
+  /**
+   * 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
+   */
+  getAttestation(uid: Hex): Promise<AttestationData>;
+  /**
+   * 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
+   */
+  getSchema(uid: Hex): Promise<SchemaData>;
+  /**
+   * Checks if an attestation is valid (exists and not revoked).
+   *
+   * @param uid - The UID of the attestation
+   * @returns Promise resolving to boolean indicating validity
+   */
+  isValidAttestation(uid: Hex): Promise<boolean>;
+  /**
+   * Gets the current timestamp from the EAS contract.
+   *
+   * @returns Promise resolving to current timestamp
+   */
+  getTimestamp(): Promise<bigint>;
+  /**
+   * 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
+   */
+  private executeContractWrite;
+  /**
+   * 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
+   */
+  private executeSchemaRegistryWrite;
+  /**
+   * 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
+   */
+  private executeContractRead;
+  /**
+   * 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
+   */
+  private executeSchemaRegistryRead;
+  /**
+   * Creates a standardized EAS Portal error.
+   *
+   * @param code - Error code
+   * @param message - Error message
+   * @returns EASPortalError instance
+   */
+  private createError;
+  /**
+   * Gets the Portal client instance for advanced operations.
+   *
+   * @returns The underlying Portal client
+   */
+  getPortalClient(): unknown;
+  /**
+   * Gets the current configuration options.
+   *
+   * @returns The client configuration
+   */
+  getOptions(): PortalClientOptions;
+  /**
+   * Gets the currently configured ABIs.
+   *
+   * @returns Object containing the EAS and Schema Registry ABIs
+   */
+  getAbis(): {
+    easAbi: Abi;
+    schemaRegistryAbi: Abi;
+  };
 }
 
+//#endregion
+//#region src/portal-client-options.schema.d.ts
+/**
+ * ABI source configuration for EAS contracts.
+ * Priority: hardcoded (default) > custom (user override) > predeployed (Portal's ABIs)
+ */
+declare const abiSourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"hardcoded">;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"custom">;
+  easAbi: z.ZodCustom<Abi, Abi>;
+  schemaRegistryAbi: z.ZodCustom<Abi, Abi>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"predeployed">;
+  abiNames: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>]>;
+/**
+ * Configuration options for the EAS Portal client
+ */
+declare const portalClientOptionsSchema: z.ZodObject<{
+  instance: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+  accessToken: z.ZodString;
+  easContractAddress: z.ZodString;
+  schemaRegistryContractAddress: z.ZodString;
+  abiSource: z.ZodDefault<z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"hardcoded">;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"custom">;
+    easAbi: z.ZodCustom<Abi, Abi>;
+    schemaRegistryAbi: z.ZodCustom<Abi, Abi>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"predeployed">;
+    abiNames: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+  }, z.core.$strip>]>>>;
+  wsUrl: z.ZodOptional<z.ZodString>;
+  timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+  debug: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+  cache: z.ZodOptional<z.ZodEnum<{
+    default: "default";
+    "force-cache": "force-cache";
+    "no-cache": "no-cache";
+    "no-store": "no-store";
+    "only-if-cached": "only-if-cached";
+    reload: "reload";
+  }>>;
+}, z.core.$strip>;
+type PortalClientOptions$1 = z.infer<typeof portalClientOptionsSchema>;
+type AbiSource = z.infer<typeof abiSourceSchema>;
+/**
+ * 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...",
+ * });
+ * ```
+ */
+declare function validatePortalClientOptions(options: unknown): PortalClientOptions$1;
+
+//#endregion
+//#region src/utils/validation.d.ts
+declare function validateFieldName(name: string): void;
+declare function validateFieldType(type: string): asserts type is EASFieldType;
+declare function validateSchemaFields(fields: SchemaField[]): void;
+declare function buildSchemaString(fields: SchemaField[]): string;
+
+//#endregion
+//#region src/abis.d.ts
+/**
+ * EAS Schema Registry ABI
+ * Contains the essential functions for schema registration and retrieval
+ */
+declare const SCHEMA_REGISTRY_ABI: readonly [{
+  readonly type: "function";
+  readonly name: "register";
+  readonly inputs: readonly [{
+    readonly name: "schema";
+    readonly type: "string";
+    readonly internalType: "string";
+  }, {
+    readonly name: "resolver";
+    readonly type: "address";
+    readonly internalType: "contract ISchemaResolver";
+  }, {
+    readonly name: "revocable";
+    readonly type: "bool";
+    readonly internalType: "bool";
+  }];
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly type: "bytes32";
+    readonly internalType: "bytes32";
+  }];
+  readonly stateMutability: "nonpayable";
+}, {
+  readonly type: "function";
+  readonly name: "getSchema";
+  readonly inputs: readonly [{
+    readonly name: "uid";
+    readonly type: "bytes32";
+    readonly internalType: "bytes32";
+  }];
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly type: "tuple";
+    readonly internalType: "struct SchemaRecord";
+    readonly components: readonly [{
+      readonly name: "uid";
+      readonly type: "bytes32";
+      readonly internalType: "bytes32";
+    }, {
+      readonly name: "resolver";
+      readonly type: "address";
+      readonly internalType: "contract ISchemaResolver";
+    }, {
+      readonly name: "revocable";
+      readonly type: "bool";
+      readonly internalType: "bool";
+    }, {
+      readonly name: "schema";
+      readonly type: "string";
+      readonly internalType: "string";
+    }];
+  }];
+  readonly stateMutability: "view";
+}, {
+  readonly type: "event";
+  readonly name: "Registered";
+  readonly inputs: readonly [{
+    readonly name: "uid";
+    readonly type: "bytes32";
+    readonly indexed: true;
+    readonly internalType: "bytes32";
+  }, {
+    readonly name: "registerer";
+    readonly type: "address";
+    readonly indexed: true;
+    readonly internalType: "address";
+  }, {
+    readonly name: "schema";
+    readonly type: "tuple";
+    readonly indexed: false;
+    readonly internalType: "struct SchemaRecord";
+    readonly components: readonly [{
+      readonly name: "uid";
+      readonly type: "bytes32";
+      readonly internalType: "bytes32";
+    }, {
+      readonly name: "resolver";
+      readonly type: "address";
+      readonly internalType: "contract ISchemaResolver";
+    }, {
+      readonly name: "revocable";
+      readonly type: "bool";
+      readonly internalType: "bool";
+    }, {
+      readonly name: "schema";
+      readonly type: "string";
+      readonly internalType: "string";
+    }];
+  }];
+  readonly anonymous: false;
+}];
+/**
+ * EAS Attestation Service ABI
+ * Contains the essential functions for attestation creation, revocation, and retrieval
+ */
+declare const EAS_ABI: readonly [{
+  readonly type: "function";
+  readonly name: "attest";
+  readonly inputs: readonly [{
+    readonly name: "request";
+    readonly type: "tuple";
+    readonly internalType: "struct AttestationRequest";
+    readonly components: readonly [{
+      readonly name: "schema";
+      readonly type: "bytes32";
+      readonly internalType: "bytes32";
+    }, {
+      readonly name: "data";
+      readonly type: "tuple";
+      readonly internalType: "struct AttestationRequestData";
+      readonly components: readonly [{
+        readonly name: "recipient";
+        readonly type: "address";
+        readonly internalType: "address";
+      }, {
+        readonly name: "expirationTime";
+        readonly type: "uint64";
+        readonly internalType: "uint64";
+      }, {
+        readonly name: "revocable";
+        readonly type: "bool";
+        readonly internalType: "bool";
+      }, {
+        readonly name: "refUID";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+      }, {
+        readonly name: "data";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+      }, {
+        readonly name: "value";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+      }];
+    }];
+  }];
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly type: "bytes32";
+    readonly internalType: "bytes32";
+  }];
+  readonly stateMutability: "payable";
+}, {
+  readonly type: "function";
+  readonly name: "revoke";
+  readonly inputs: readonly [{
+    readonly name: "request";
+    readonly type: "tuple";
+    readonly internalType: "struct RevocationRequest";
+    readonly components: readonly [{
+      readonly name: "schema";
+      readonly type: "bytes32";
+      readonly internalType: "bytes32";
+    }, {
+      readonly name: "data";
+      readonly type: "tuple";
+      readonly internalType: "struct RevocationRequestData";
+      readonly components: readonly [{
+        readonly name: "uid";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+      }, {
+        readonly name: "value";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+      }];
+    }];
+  }];
+  readonly outputs: readonly [];
+  readonly stateMutability: "payable";
+}, {
+  readonly type: "function";
+  readonly name: "getAttestation";
+  readonly inputs: readonly [{
+    readonly name: "uid";
+    readonly type: "bytes32";
+    readonly internalType: "bytes32";
+  }];
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly type: "tuple";
+    readonly internalType: "struct Attestation";
+    readonly components: readonly [{
+      readonly name: "uid";
+      readonly type: "bytes32";
+      readonly internalType: "bytes32";
+    }, {
+      readonly name: "schema";
+      readonly type: "bytes32";
+      readonly internalType: "bytes32";
+    }, {
+      readonly name: "time";
+      readonly type: "uint64";
+      readonly internalType: "uint64";
+    }, {
+      readonly name: "expirationTime";
+      readonly type: "uint64";
+      readonly internalType: "uint64";
+    }, {
+      readonly name: "revocationTime";
+      readonly type: "uint64";
+      readonly internalType: "uint64";
+    }, {
+      readonly name: "refUID";
+      readonly type: "bytes32";
+      readonly internalType: "bytes32";
+    }, {
+      readonly name: "recipient";
+      readonly type: "address";
+      readonly internalType: "address";
+    }, {
+      readonly name: "attester";
+      readonly type: "address";
+      readonly internalType: "address";
+    }, {
+      readonly name: "revocable";
+      readonly type: "bool";
+      readonly internalType: "bool";
+    }, {
+      readonly name: "data";
+      readonly type: "bytes";
+      readonly internalType: "bytes";
+    }];
+  }];
+  readonly stateMutability: "view";
+}, {
+  readonly type: "event";
+  readonly name: "Attested";
+  readonly inputs: readonly [{
+    readonly name: "recipient";
+    readonly type: "address";
+    readonly indexed: true;
+    readonly internalType: "address";
+  }, {
+    readonly name: "attester";
+    readonly type: "address";
+    readonly indexed: true;
+    readonly internalType: "address";
+  }, {
+    readonly name: "uid";
+    readonly type: "bytes32";
+    readonly indexed: false;
+    readonly internalType: "bytes32";
+  }, {
+    readonly name: "schemaUID";
+    readonly type: "bytes32";
+    readonly indexed: true;
+    readonly internalType: "bytes32";
+  }];
+  readonly anonymous: false;
+}, {
+  readonly type: "event";
+  readonly name: "Revoked";
+  readonly inputs: readonly [{
+    readonly name: "recipient";
+    readonly type: "address";
+    readonly indexed: true;
+    readonly internalType: "address";
+  }, {
+    readonly name: "attester";
+    readonly type: "address";
+    readonly indexed: true;
+    readonly internalType: "address";
+  }, {
+    readonly name: "uid";
+    readonly type: "bytes32";
+    readonly indexed: false;
+    readonly internalType: "bytes32";
+  }, {
+    readonly name: "schemaUID";
+    readonly type: "bytes32";
+    readonly indexed: true;
+    readonly internalType: "bytes32";
+  }];
+  readonly anonymous: false;
+}];
+/**
+ * Default ABIs for EAS Portal integration
+ */
+declare const DEFAULT_EAS_ABIS: readonly [{
+  readonly name: "SchemaRegistry";
+  readonly abi: string;
+}, {
+  readonly name: "EAS";
+  readonly abi: string;
+}];
+
 //#endregion
 //#region src/eas.d.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,
+ *   },
  * });
  * ```
  */
-declare function createEASClient(options: ClientOptions): {
-  registerSchema: (options: RegisterSchemaOptions) => Promise<string>;
-  getSchema: (uid: string) => Promise<string>;
-};
+declare function createEASClient(options: PortalClientOptions): EASPortalClient;
+/**
+ * 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);
+ * }
+ * ```
+ */
+declare function validateAndBuildSchema(fields: SchemaField[]): string;
 
 //#endregion
-export { ClientOptions, ClientOptionsSchema, EASFieldType, EAS_FIELD_TYPES, RegisterSchemaOptions, SchemaField, createEASClient };
+export { PortalClientOptions as ClientOptions, DEFAULT_EAS_ABIS, EASErrorCode, EASFieldType, EASPortalClient, EASPortalError, EAS_ABI, EAS_FIELD_TYPES, RegisterSchemaOptions, SCHEMA_REGISTRY_ABI, SchemaField, buildSchemaString, createEASClient, validateAndBuildSchema, validatePortalClientOptions, validateSchemaFields };
 //# sourceMappingURL=eas.d.ts.map