@settlemint/sdk-eas 2.2.2-pr75b59b5f → 2.2.2-pr8fc22dc7

package/README.md

@@ -27,12 +27,378 @@
 ## Table of Contents
 
 - [About](#about)
+- [API Reference](#api-reference)
+  - [Functions](#functions)
+    - [buildSchemaString()](#buildschemastring)
+    - [registerSchema()](#registerschema)
+    - [validateEthereumAddress()](#validateethereumaddress)
+    - [validateFieldName()](#validatefieldname)
+    - [validateFieldType()](#validatefieldtype)
+    - [validateSchemaFields()](#validateschemafields)
+  - [Interfaces](#interfaces)
+    - [RegisterSchemaOptions](#registerschemaoptions)
+    - [SchemaField](#schemafield)
+  - [Type Aliases](#type-aliases)
+    - [EASFieldType](#easfieldtype)
+  - [Variables](#variables)
+    - [EAS\_FIELD\_TYPES](#eas_field_types)
 - [Contributing](#contributing)
 - [License](#license)
 
 ## About
 
 The SettleMint EAS SDK provides a lightweight wrapper for the Ethereum Attestation Service (EAS), enabling developers to easily create, manage, and verify attestations within their applications. It simplifies the process of working with EAS by handling contract interactions, schema management, and The Graph integration, while ensuring proper integration with the SettleMint platform. This allows developers to quickly implement document verification, identity attestation, and other EAS-based features without manual setup.
+
+## API Reference
+
+### Functions
+
+#### buildSchemaString()
+
+> **buildSchemaString**(`fields`): `string`
+
+Defined in: [schema.ts:166](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L166)
+
+Builds an EAS schema string from an array of fields.
+
+##### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `fields` | [`SchemaField`](#schemafield)[] | The fields to include in the schema |
+
+##### Returns
+
+`string`
+
+The EAS-compatible schema string
+
+##### Throws
+
+Error if any field is invalid
+
+##### Example
+
+```ts
+import { buildSchemaString, SchemaField } from '@settlemint/sdk-eas';
+
+const fields: SchemaField[] = [
+  { name: "userAddress", type: "address" },
+  { name: "age", type: "uint8" },
+  { name: "isActive", type: "bool" }
+];
+
+const schemaString = buildSchemaString(fields);
+// Result: "address userAddress, uint8 age, bool isActive"
+```
+
+***
+
+#### registerSchema()
+
+> **registerSchema**(`options`): `Promise`\<`string`\>
+
+Defined in: [schema.ts:246](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L246)
+
+Registers a new schema with EAS.
+
+##### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `options` | [`RegisterSchemaOptions`](#registerschemaoptions) | The schema registration options |
+
+##### Returns
+
+`Promise`\<`string`\>
+
+A promise that resolves to the schema UID
+
+##### Throws
+
+Error if the schema registration fails
+
+##### Example
+
+```ts
+import { registerSchema, SchemaField } from '@settlemint/sdk-eas';
+
+const fields: SchemaField[] = [
+  { name: "userAddress", type: "address" },
+  { name: "age", type: "uint8" }
+];
+
+const schemaUID = await registerSchema({
+  fields,
+  resolverAddress: "0x1234567890123456789012345678901234567890",
+  revocable: true
+});
+
+console.log(`Schema registered with UID: ${schemaUID}`);
+```
+
+***
+
+#### validateEthereumAddress()
+
+> **validateEthereumAddress**(`address`): `void`
+
+Defined in: [schema.ts:214](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L214)
+
+Validates an Ethereum address.
+
+##### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `address` | `string` | The address to validate |
+
+##### Returns
+
+`void`
+
+##### Throws
+
+Error if the address is invalid
+
+##### Example
+
+```ts
+import { validateEthereumAddress } from '@settlemint/sdk-eas';
+
+// Valid address
+validateEthereumAddress("0x1234567890123456789012345678901234567890"); // OK
+
+// Invalid addresses
+validateEthereumAddress("0x123"); // Throws: "Invalid Ethereum address format"
+validateEthereumAddress(""); // Throws: "Resolver address cannot be empty"
+```
+
+***
+
+#### validateFieldName()
+
+> **validateFieldName**(`name`): `void`
+
+Defined in: [schema.ts:71](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L71)
+
+Validates a schema field name.
+
+##### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `name` | `string` | The field name to validate |
+
+##### Returns
+
+`void`
+
+##### Throws
+
+Error if the name is invalid
+
+##### Example
+
+```ts
+import { validateFieldName } from '@settlemint/sdk-eas';
+
+// Valid names
+validateFieldName("userAddress"); // OK
+validateFieldName("user_address"); // OK
+
+// Invalid names
+validateFieldName("user address"); // Throws: "Field name cannot contain spaces"
+validateFieldName("123user"); // Throws: "Field name must start with a letter or underscore"
+```
+
+***
+
+#### validateFieldType()
+
+> **validateFieldType**(`type`): asserts type is "string" \| "address" \| "bool" \| "bytes" \| "bytes32" \| "uint256" \| "int256" \| "uint8" \| "int8"
+
+Defined in: [schema.ts:101](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L101)
+
+Validates a schema field type.
+
+##### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `type` | `string` | The field type to validate |
+
+##### Returns
+
+asserts type is "string" \| "address" \| "bool" \| "bytes" \| "bytes32" \| "uint256" \| "int256" \| "uint8" \| "int8"
+
+##### Throws
+
+Error if the type is invalid
+
+##### Example
+
+```ts
+import { validateFieldType } from '@settlemint/sdk-eas';
+
+// Valid types
+validateFieldType("string"); // OK
+validateFieldType("address"); // OK
+
+// Invalid types
+validateFieldType("invalidType"); // Throws: "Invalid field type: invalidType"
+```
+
+***
+
+#### validateSchemaFields()
+
+> **validateSchemaFields**(`fields`): `void`
+
+Defined in: [schema.ts:130](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L130)
+
+Validates an array of schema fields.
+
+##### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `fields` | [`SchemaField`](#schemafield)[] | The fields to validate |
+
+##### Returns
+
+`void`
+
+##### Throws
+
+Error if any field is invalid
+
+##### Example
+
+```ts
+import { validateSchemaFields, SchemaField } from '@settlemint/sdk-eas';
+
+const fields: SchemaField[] = [
+  { name: "userAddress", type: "address" },
+  { name: "age", type: "uint8" }
+];
+
+validateSchemaFields(fields); // OK
+
+// Invalid fields
+validateSchemaFields([]); // Throws: "Schema must have at least one field"
+validateSchemaFields([
+  { name: "userAddress", type: "address" },
+  { name: "userAddress", type: "uint8" }
+]); // Throws: "Duplicate field name: userAddress"
+```
+
+### Interfaces
+
+#### RegisterSchemaOptions
+
+Defined in: [schema.ts:187](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L187)
+
+Options for registering a schema.
+
+##### Example
+
+```ts
+import { RegisterSchemaOptions, SchemaField } from '@settlemint/sdk-eas';
+
+const options: RegisterSchemaOptions = {
+  fields: [
+    { name: "userAddress", type: "address" },
+    { name: "age", type: "uint8" }
+  ],
+  resolverAddress: "0x1234567890123456789012345678901234567890",
+  revocable: true
+};
+```
+
+##### Properties
+
+| Property | Type | Description | Defined in |
+| ------ | ------ | ------ | ------ |
+| <a id="fields"></a> `fields` | [`SchemaField`](#schemafield)[] | The fields that make up the schema | [schema.ts:189](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L189) |
+| <a id="resolveraddress"></a> `resolverAddress` | `string` | The Ethereum address of the resolver | [schema.ts:191](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L191) |
+| <a id="revocable"></a> `revocable` | `boolean` | Whether attestations using this schema can be revoked | [schema.ts:193](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L193) |
+
+***
+
+#### SchemaField
+
+Defined in: [schema.ts:45](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L45)
+
+Interface for defining a schema field.
+
+##### Example
+
+```ts
+import { SchemaField } from '@settlemint/sdk-eas';
+
+const field: SchemaField = {
+  name: "userAddress",
+  type: "address",
+  description: "The Ethereum address of the user"
+};
+```
+
+##### Properties
+
+| Property | Type | Description | Defined in |
+| ------ | ------ | ------ | ------ |
+| <a id="description"></a> `description?` | `string` | Optional description of the field | [schema.ts:51](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L51) |
+| <a id="name"></a> `name` | `string` | The name of the field | [schema.ts:47](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L47) |
+| <a id="type"></a> `type` | `"string"` \| `"address"` \| `"bool"` \| `"bytes"` \| `"bytes32"` \| `"uint256"` \| `"int256"` \| `"uint8"` \| `"int8"` | The type of the field | [schema.ts:49](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L49) |
+
+### Type Aliases
+
+#### EASFieldType
+
+> **EASFieldType** = keyof *typeof* [`EAS_FIELD_TYPES`](#eas_field_types)
+
+Defined in: [schema.ts:30](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L30)
+
+Type representing all valid EAS field types.
+
+### Variables
+
+#### EAS\_FIELD\_TYPES
+
+> `const` **EAS\_FIELD\_TYPES**: `object`
+
+Defined in: [schema.ts:15](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L15)
+
+Supported EAS schema field types.
+Maps user-friendly type names to EAS-compatible type strings.
+
+##### Type declaration
+
+| Name | Type | Default value | Defined in |
+| ------ | ------ | ------ | ------ |
+| <a id="address"></a> `address` | `"address"` | `"address"` | [schema.ts:17](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L17) |
+| <a id="bool"></a> `bool` | `"bool"` | `"bool"` | [schema.ts:18](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L18) |
+| <a id="bytes"></a> `bytes` | `"bytes"` | `"bytes"` | [schema.ts:19](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L19) |
+| <a id="bytes32"></a> `bytes32` | `"bytes32"` | `"bytes32"` | [schema.ts:20](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L20) |
+| <a id="int256"></a> `int256` | `"int256"` | `"int256"` | [schema.ts:22](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L22) |
+| <a id="int8"></a> `int8` | `"int8"` | `"int8"` | [schema.ts:24](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L24) |
+| <a id="string"></a> `string` | `"string"` | `"string"` | [schema.ts:16](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L16) |
+| <a id="uint256"></a> `uint256` | `"uint256"` | `"uint256"` | [schema.ts:21](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L21) |
+| <a id="uint8"></a> `uint8` | `"uint8"` | `"uint8"` | [schema.ts:23](https://github.com/settlemint/sdk/blob/v2.2.2/sdk/eas/src/schema.ts#L23) |
+
+##### Example
+
+```ts
+import { EAS_FIELD_TYPES } from '@settlemint/sdk-eas';
+
+// Use in type definitions
+type MyFieldType = keyof typeof EAS_FIELD_TYPES;
+
+// Check if a type is supported
+const isValidType = "string" in EAS_FIELD_TYPES;
+```
+
 ## Contributing
 
 We welcome contributions from the community! Please check out our [Contributing](https://github.com/settlemint/sdk/blob/main/.github/CONTRIBUTING.md) guide to learn how you can help improve the SettleMint SDK through bug reports, feature requests, documentation updates, or code contributions.

package/dist/eas.cjs

@@ -0,0 +1,2 @@
+'use strict';var viem=require('viem');var o={string:"string",address:"address",bool:"bool",bytes:"bytes",bytes32:"bytes32",uint256:"uint256",int256:"int256",uint8:"uint8",int8:"int8"};function a(e){if(!e)throw new Error("Field name cannot be empty");if(e.includes(" "))throw new Error("Field name cannot contain spaces");if(!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(e))throw new Error("Field name must start with a letter or underscore and contain only alphanumeric characters and underscores")}function c(e){if(!(e in o))throw new Error(`Invalid field type: ${e}. Must be one of: ${Object.keys(o).join(", ")}`)}function r(e){if(!e||e.length===0)throw new Error("Schema must have at least one field");let t=new Set;for(let n of e){if(a(n.name),c(n.type),t.has(n.name))throw new Error(`Duplicate field name: ${n.name}`);t.add(n.name);}}function l(e){return r(e),e.map(t=>`${t.type} ${t.name}`).join(", ")}function m(e){if(!e)throw new Error("Resolver address cannot be empty");if(!viem.isAddress(e))throw new Error("Invalid Ethereum address format")}async function p(e){let{fields:t,resolverAddress:n,revocable:i}=e;r(t),m(n);let s=l(t);return console.log(`[EAS] Registering schema: ${s}`),console.log(`[EAS] Resolver: ${n}`),console.log(`[EAS] Revocable: ${i}`),`0x${"0".repeat(64)}`}function S(){return {submitAttestation(){console.log("[EAS] Submitting attestation");},parseAttestation(){console.log("[EAS] Parsing attestation");},createSchema(){console.log("[EAS] Creating schema");},getSchema(){console.log("[EAS] Getting schema");},getAttestations(){console.log("[EAS] Getting attestations");}}}exports.EAS_FIELD_TYPES=o;exports.buildSchemaString=l;exports.createEASClient=S;exports.registerSchema=p;exports.validateEthereumAddress=m;exports.validateFieldName=a;exports.validateFieldType=c;exports.validateSchemaFields=r;//# sourceMappingURL=eas.cjs.map
+//# sourceMappingURL=eas.cjs.map

package/dist/eas.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema.ts","../src/eas.ts"],"names":["EAS_FIELD_TYPES","validateFieldName","name","validateFieldType","type","validateSchemaFields","fields","seenNames","field","buildSchemaString","validateEthereumAddress","address","isAddress","registerSchema","options","resolverAddress","revocable","schemaString","createEASClient"],"mappings":"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","file":"eas.cjs","sourcesContent":["/**\n * Supported EAS schema field types.\n * Maps user-friendly type names to EAS-compatible type strings.\n * @example\n * ```ts\n * import { EAS_FIELD_TYPES } from '@settlemint/sdk-eas';\n *\n * // Use in type definitions\n * type MyFieldType = keyof typeof EAS_FIELD_TYPES;\n *\n * // Check if a type is supported\n * const isValidType = \"string\" in EAS_FIELD_TYPES;\n * ```\n */\nexport const EAS_FIELD_TYPES = {\n  string: \"string\",\n  address: \"address\",\n  bool: \"bool\",\n  bytes: \"bytes\",\n  bytes32: \"bytes32\",\n  uint256: \"uint256\",\n  int256: \"int256\",\n  uint8: \"uint8\",\n  int8: \"int8\",\n} as const;\n\n/**\n * Type representing all valid EAS field types.\n */\nexport type EASFieldType = keyof typeof EAS_FIELD_TYPES;\n\n/**\n * Interface for defining a schema field.\n * @example\n * ```ts\n * import { SchemaField } from '@settlemint/sdk-eas';\n *\n * const field: SchemaField = {\n *   name: \"userAddress\",\n *   type: \"address\",\n *   description: \"The Ethereum address of the user\"\n * };\n * ```\n */\nexport interface SchemaField {\n  /** The name of the field */\n  name: string;\n  /** The type of the field */\n  type: EASFieldType;\n  /** Optional description of the field */\n  description?: string;\n}\n\n/**\n * Validates a schema field name.\n * @param name - The field name to validate\n * @throws Error if the name is invalid\n * @example\n * ```ts\n * import { validateFieldName } from '@settlemint/sdk-eas';\n *\n * // Valid names\n * validateFieldName(\"userAddress\"); // OK\n * validateFieldName(\"user_address\"); // OK\n *\n * // Invalid names\n * validateFieldName(\"user address\"); // Throws: \"Field name cannot contain spaces\"\n * validateFieldName(\"123user\"); // Throws: \"Field name must start with a letter or underscore\"\n * ```\n */\nexport function validateFieldName(name: string): void {\n  if (!name) {\n    throw new Error(\"Field name cannot be empty\");\n  }\n  if (name.includes(\" \")) {\n    throw new Error(\"Field name cannot contain spaces\");\n  }\n  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {\n    throw new Error(\n      \"Field name must start with a letter or underscore and contain only alphanumeric characters and underscores\",\n    );\n  }\n}\n\n/**\n * Validates a schema field type.\n * @param type - The field type to validate\n * @throws Error if the type is invalid\n * @example\n * ```ts\n * import { validateFieldType } from '@settlemint/sdk-eas';\n *\n * // Valid types\n * validateFieldType(\"string\"); // OK\n * validateFieldType(\"address\"); // OK\n *\n * // Invalid types\n * validateFieldType(\"invalidType\"); // Throws: \"Invalid field type: invalidType\"\n * ```\n */\nexport function validateFieldType(type: string): asserts type is EASFieldType {\n  if (!(type in EAS_FIELD_TYPES)) {\n    throw new Error(`Invalid field type: ${type}. Must be one of: ${Object.keys(EAS_FIELD_TYPES).join(\", \")}`);\n  }\n}\n\n/**\n * Validates an array of schema fields.\n * @param fields - The fields to validate\n * @throws Error if any field is invalid\n * @example\n * ```ts\n * import { validateSchemaFields, SchemaField } from '@settlemint/sdk-eas';\n *\n * const fields: SchemaField[] = [\n *   { name: \"userAddress\", type: \"address\" },\n *   { name: \"age\", type: \"uint8\" }\n * ];\n *\n * validateSchemaFields(fields); // OK\n *\n * // Invalid fields\n * validateSchemaFields([]); // Throws: \"Schema must have at least one field\"\n * validateSchemaFields([\n *   { name: \"userAddress\", type: \"address\" },\n *   { name: \"userAddress\", type: \"uint8\" }\n * ]); // Throws: \"Duplicate field name: userAddress\"\n * ```\n */\nexport function validateSchemaFields(fields: SchemaField[]): void {\n  if (!fields || fields.length === 0) {\n    throw new Error(\"Schema must have at least one field\");\n  }\n\n  const seenNames = new Set<string>();\n  for (const field of fields) {\n    validateFieldName(field.name);\n    validateFieldType(field.type);\n\n    if (seenNames.has(field.name)) {\n      throw new Error(`Duplicate field name: ${field.name}`);\n    }\n    seenNames.add(field.name);\n  }\n}\n\n/**\n * Builds an EAS schema string from an array of fields.\n * @param fields - The fields to include in the schema\n * @returns The EAS-compatible schema string\n * @throws Error if any field is invalid\n * @example\n * ```ts\n * import { buildSchemaString, SchemaField } from '@settlemint/sdk-eas';\n *\n * const fields: SchemaField[] = [\n *   { name: \"userAddress\", type: \"address\" },\n *   { name: \"age\", type: \"uint8\" },\n *   { name: \"isActive\", type: \"bool\" }\n * ];\n *\n * const schemaString = buildSchemaString(fields);\n * // Result: \"address userAddress, uint8 age, bool isActive\"\n * ```\n */\nexport function buildSchemaString(fields: SchemaField[]): string {\n  validateSchemaFields(fields);\n  return fields.map((field) => `${field.type} ${field.name}`).join(\", \");\n}\n\n/**\n * Options for registering a schema.\n * @example\n * ```ts\n * import { RegisterSchemaOptions, SchemaField } from '@settlemint/sdk-eas';\n *\n * const options: RegisterSchemaOptions = {\n *   fields: [\n *     { name: \"userAddress\", type: \"address\" },\n *     { name: \"age\", type: \"uint8\" }\n *   ],\n *   resolverAddress: \"0x1234567890123456789012345678901234567890\",\n *   revocable: true\n * };\n * ```\n */\nexport interface RegisterSchemaOptions {\n  /** The fields that make up the schema */\n  fields: SchemaField[];\n  /** The Ethereum address of the resolver */\n  resolverAddress: string;\n  /** Whether attestations using this schema can be revoked */\n  revocable: boolean;\n}\n\nimport { isAddress } from \"viem\";\n\n/**\n * Validates an Ethereum address.\n * @param address - The address to validate\n * @throws Error if the address is invalid\n * @example\n * ```ts\n * import { validateEthereumAddress } from '@settlemint/sdk-eas';\n *\n * // Valid address\n * validateEthereumAddress(\"0x1234567890123456789012345678901234567890\"); // OK\n *\n * // Invalid addresses\n * validateEthereumAddress(\"0x123\"); // Throws: \"Invalid Ethereum address format\"\n * validateEthereumAddress(\"\"); // Throws: \"Resolver address cannot be empty\"\n * ```\n */\nexport function validateEthereumAddress(address: string): void {\n  if (!address) {\n    throw new Error(\"Resolver address cannot be empty\");\n  }\n  if (!isAddress(address)) {\n    throw new Error(\"Invalid Ethereum address format\");\n  }\n}\n\n/**\n * Registers a new schema with EAS.\n * @param options - The schema registration options\n * @returns A promise that resolves to the schema UID\n * @throws Error if the schema registration fails\n * @example\n * ```ts\n * import { registerSchema, SchemaField } from '@settlemint/sdk-eas';\n *\n * const fields: SchemaField[] = [\n *   { name: \"userAddress\", type: \"address\" },\n *   { name: \"age\", type: \"uint8\" }\n * ];\n *\n * const schemaUID = await registerSchema({\n *   fields,\n *   resolverAddress: \"0x1234567890123456789012345678901234567890\",\n *   revocable: true\n * });\n *\n * console.log(`Schema registered with UID: ${schemaUID}`);\n * ```\n */\nexport async function registerSchema(options: RegisterSchemaOptions): Promise<string> {\n  const { fields, resolverAddress, revocable } = options;\n\n  // Validate the schema fields\n  validateSchemaFields(fields);\n\n  // Validate the resolver address\n  validateEthereumAddress(resolverAddress);\n\n  // Build the schema string\n  const schemaString = buildSchemaString(fields);\n\n  // TODO: Implement actual EAS SDK registration\n  // This is a placeholder that will be replaced with actual EAS SDK integration\n  console.log(`[EAS] Registering schema: ${schemaString}`);\n  console.log(`[EAS] Resolver: ${resolverAddress}`);\n  console.log(`[EAS] Revocable: ${revocable}`);\n\n  // Return a mock UID for now\n  return `0x${\"0\".repeat(64)}`;\n}\n","export * from \"./schema.js\";\n\nexport function createEASClient() {\n  return {\n    submitAttestation() {\n      console.log(\"[EAS] Submitting attestation\");\n    },\n\n    parseAttestation() {\n      console.log(\"[EAS] Parsing attestation\");\n    },\n\n    createSchema() {\n      console.log(\"[EAS] Creating schema\");\n    },\n\n    getSchema() {\n      console.log(\"[EAS] Getting schema\");\n    },\n\n    getAttestations() {\n      console.log(\"[EAS] Getting attestations\");\n    },\n  };\n}\n"]}

package/dist/eas.d.cts

@@ -0,0 +1,204 @@
+/**
+ * Supported EAS schema field types.
+ * Maps user-friendly type names to EAS-compatible type strings.
+ * @example
+ * ```ts
+ * import { EAS_FIELD_TYPES } from '@settlemint/sdk-eas';
+ *
+ * // Use in type definitions
+ * type MyFieldType = keyof typeof EAS_FIELD_TYPES;
+ *
+ * // Check if a type is supported
+ * const isValidType = "string" in EAS_FIELD_TYPES;
+ * ```
+ */
+declare const EAS_FIELD_TYPES: {
+    readonly string: "string";
+    readonly address: "address";
+    readonly bool: "bool";
+    readonly bytes: "bytes";
+    readonly bytes32: "bytes32";
+    readonly uint256: "uint256";
+    readonly int256: "int256";
+    readonly uint8: "uint8";
+    readonly int8: "int8";
+};
+/**
+ * Type representing all valid EAS field types.
+ */
+type EASFieldType = keyof typeof EAS_FIELD_TYPES;
+/**
+ * Interface for defining a schema field.
+ * @example
+ * ```ts
+ * import { SchemaField } from '@settlemint/sdk-eas';
+ *
+ * const field: SchemaField = {
+ *   name: "userAddress",
+ *   type: "address",
+ *   description: "The Ethereum address of the user"
+ * };
+ * ```
+ */
+interface SchemaField {
+    /** The name of the field */
+    name: string;
+    /** The type of the field */
+    type: EASFieldType;
+    /** Optional description of the field */
+    description?: string;
+}
+/**
+ * Validates a schema field name.
+ * @param name - The field name to validate
+ * @throws Error if the name is invalid
+ * @example
+ * ```ts
+ * import { validateFieldName } from '@settlemint/sdk-eas';
+ *
+ * // Valid names
+ * validateFieldName("userAddress"); // OK
+ * validateFieldName("user_address"); // OK
+ *
+ * // Invalid names
+ * validateFieldName("user address"); // Throws: "Field name cannot contain spaces"
+ * validateFieldName("123user"); // Throws: "Field name must start with a letter or underscore"
+ * ```
+ */
+declare function validateFieldName(name: string): void;
+/**
+ * Validates a schema field type.
+ * @param type - The field type to validate
+ * @throws Error if the type is invalid
+ * @example
+ * ```ts
+ * import { validateFieldType } from '@settlemint/sdk-eas';
+ *
+ * // Valid types
+ * validateFieldType("string"); // OK
+ * validateFieldType("address"); // OK
+ *
+ * // Invalid types
+ * validateFieldType("invalidType"); // Throws: "Invalid field type: invalidType"
+ * ```
+ */
+declare function validateFieldType(type: string): asserts type is EASFieldType;
+/**
+ * Validates an array of schema fields.
+ * @param fields - The fields to validate
+ * @throws Error if any field is invalid
+ * @example
+ * ```ts
+ * import { validateSchemaFields, SchemaField } from '@settlemint/sdk-eas';
+ *
+ * const fields: SchemaField[] = [
+ *   { name: "userAddress", type: "address" },
+ *   { name: "age", type: "uint8" }
+ * ];
+ *
+ * validateSchemaFields(fields); // OK
+ *
+ * // Invalid fields
+ * validateSchemaFields([]); // Throws: "Schema must have at least one field"
+ * validateSchemaFields([
+ *   { name: "userAddress", type: "address" },
+ *   { name: "userAddress", type: "uint8" }
+ * ]); // Throws: "Duplicate field name: userAddress"
+ * ```
+ */
+declare function validateSchemaFields(fields: SchemaField[]): void;
+/**
+ * Builds an EAS schema string from an array of fields.
+ * @param fields - The fields to include in the schema
+ * @returns The EAS-compatible schema string
+ * @throws Error if any field is invalid
+ * @example
+ * ```ts
+ * import { buildSchemaString, SchemaField } from '@settlemint/sdk-eas';
+ *
+ * const fields: SchemaField[] = [
+ *   { name: "userAddress", type: "address" },
+ *   { name: "age", type: "uint8" },
+ *   { name: "isActive", type: "bool" }
+ * ];
+ *
+ * const schemaString = buildSchemaString(fields);
+ * // Result: "address userAddress, uint8 age, bool isActive"
+ * ```
+ */
+declare function buildSchemaString(fields: SchemaField[]): string;
+/**
+ * Options for registering a schema.
+ * @example
+ * ```ts
+ * import { RegisterSchemaOptions, SchemaField } from '@settlemint/sdk-eas';
+ *
+ * const options: RegisterSchemaOptions = {
+ *   fields: [
+ *     { name: "userAddress", type: "address" },
+ *     { name: "age", type: "uint8" }
+ *   ],
+ *   resolverAddress: "0x1234567890123456789012345678901234567890",
+ *   revocable: true
+ * };
+ * ```
+ */
+interface RegisterSchemaOptions {
+    /** The fields that make up the schema */
+    fields: SchemaField[];
+    /** The Ethereum address of the resolver */
+    resolverAddress: string;
+    /** Whether attestations using this schema can be revoked */
+    revocable: boolean;
+}
+/**
+ * Validates an Ethereum address.
+ * @param address - The address to validate
+ * @throws Error if the address is invalid
+ * @example
+ * ```ts
+ * import { validateEthereumAddress } from '@settlemint/sdk-eas';
+ *
+ * // Valid address
+ * validateEthereumAddress("0x1234567890123456789012345678901234567890"); // OK
+ *
+ * // Invalid addresses
+ * validateEthereumAddress("0x123"); // Throws: "Invalid Ethereum address format"
+ * validateEthereumAddress(""); // Throws: "Resolver address cannot be empty"
+ * ```
+ */
+declare function validateEthereumAddress(address: string): void;
+/**
+ * Registers a new schema with EAS.
+ * @param options - The schema registration options
+ * @returns A promise that resolves to the schema UID
+ * @throws Error if the schema registration fails
+ * @example
+ * ```ts
+ * import { registerSchema, SchemaField } from '@settlemint/sdk-eas';
+ *
+ * const fields: SchemaField[] = [
+ *   { name: "userAddress", type: "address" },
+ *   { name: "age", type: "uint8" }
+ * ];
+ *
+ * const schemaUID = await registerSchema({
+ *   fields,
+ *   resolverAddress: "0x1234567890123456789012345678901234567890",
+ *   revocable: true
+ * });
+ *
+ * console.log(`Schema registered with UID: ${schemaUID}`);
+ * ```
+ */
+declare function registerSchema(options: RegisterSchemaOptions): Promise<string>;
+
+declare function createEASClient(): {
+    submitAttestation(): void;
+    parseAttestation(): void;
+    createSchema(): void;
+    getSchema(): void;
+    getAttestations(): void;
+};
+
+export { type EASFieldType, EAS_FIELD_TYPES, type RegisterSchemaOptions, type SchemaField, buildSchemaString, createEASClient, registerSchema, validateEthereumAddress, validateFieldName, validateFieldType, validateSchemaFields };

package/dist/eas.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Supported EAS schema field types.
+ * Maps user-friendly type names to EAS-compatible type strings.
+ * @example
+ * ```ts
+ * import { EAS_FIELD_TYPES } from '@settlemint/sdk-eas';
+ *
+ * // Use in type definitions
+ * type MyFieldType = keyof typeof EAS_FIELD_TYPES;
+ *
+ * // Check if a type is supported
+ * const isValidType = "string" in EAS_FIELD_TYPES;
+ * ```
+ */
+declare const EAS_FIELD_TYPES: {
+    readonly string: "string";
+    readonly address: "address";
+    readonly bool: "bool";
+    readonly bytes: "bytes";
+    readonly bytes32: "bytes32";
+    readonly uint256: "uint256";
+    readonly int256: "int256";
+    readonly uint8: "uint8";
+    readonly int8: "int8";
+};
+/**
+ * Type representing all valid EAS field types.
+ */
+type EASFieldType = keyof typeof EAS_FIELD_TYPES;
+/**
+ * Interface for defining a schema field.
+ * @example
+ * ```ts
+ * import { SchemaField } from '@settlemint/sdk-eas';
+ *
+ * const field: SchemaField = {
+ *   name: "userAddress",
+ *   type: "address",
+ *   description: "The Ethereum address of the user"
+ * };
+ * ```
+ */
+interface SchemaField {
+    /** The name of the field */
+    name: string;
+    /** The type of the field */
+    type: EASFieldType;
+    /** Optional description of the field */
+    description?: string;
+}
+/**
+ * Validates a schema field name.
+ * @param name - The field name to validate
+ * @throws Error if the name is invalid
+ * @example
+ * ```ts
+ * import { validateFieldName } from '@settlemint/sdk-eas';
+ *
+ * // Valid names
+ * validateFieldName("userAddress"); // OK
+ * validateFieldName("user_address"); // OK
+ *
+ * // Invalid names
+ * validateFieldName("user address"); // Throws: "Field name cannot contain spaces"
+ * validateFieldName("123user"); // Throws: "Field name must start with a letter or underscore"
+ * ```
+ */
+declare function validateFieldName(name: string): void;
+/**
+ * Validates a schema field type.
+ * @param type - The field type to validate
+ * @throws Error if the type is invalid
+ * @example
+ * ```ts
+ * import { validateFieldType } from '@settlemint/sdk-eas';
+ *
+ * // Valid types
+ * validateFieldType("string"); // OK
+ * validateFieldType("address"); // OK
+ *
+ * // Invalid types
+ * validateFieldType("invalidType"); // Throws: "Invalid field type: invalidType"
+ * ```
+ */
+declare function validateFieldType(type: string): asserts type is EASFieldType;
+/**
+ * Validates an array of schema fields.
+ * @param fields - The fields to validate
+ * @throws Error if any field is invalid
+ * @example
+ * ```ts
+ * import { validateSchemaFields, SchemaField } from '@settlemint/sdk-eas';
+ *
+ * const fields: SchemaField[] = [
+ *   { name: "userAddress", type: "address" },
+ *   { name: "age", type: "uint8" }
+ * ];
+ *
+ * validateSchemaFields(fields); // OK
+ *
+ * // Invalid fields
+ * validateSchemaFields([]); // Throws: "Schema must have at least one field"
+ * validateSchemaFields([
+ *   { name: "userAddress", type: "address" },
+ *   { name: "userAddress", type: "uint8" }
+ * ]); // Throws: "Duplicate field name: userAddress"
+ * ```
+ */
+declare function validateSchemaFields(fields: SchemaField[]): void;
+/**
+ * Builds an EAS schema string from an array of fields.
+ * @param fields - The fields to include in the schema
+ * @returns The EAS-compatible schema string
+ * @throws Error if any field is invalid
+ * @example
+ * ```ts
+ * import { buildSchemaString, SchemaField } from '@settlemint/sdk-eas';
+ *
+ * const fields: SchemaField[] = [
+ *   { name: "userAddress", type: "address" },
+ *   { name: "age", type: "uint8" },
+ *   { name: "isActive", type: "bool" }
+ * ];
+ *
+ * const schemaString = buildSchemaString(fields);
+ * // Result: "address userAddress, uint8 age, bool isActive"
+ * ```
+ */
+declare function buildSchemaString(fields: SchemaField[]): string;
+/**
+ * Options for registering a schema.
+ * @example
+ * ```ts
+ * import { RegisterSchemaOptions, SchemaField } from '@settlemint/sdk-eas';
+ *
+ * const options: RegisterSchemaOptions = {
+ *   fields: [
+ *     { name: "userAddress", type: "address" },
+ *     { name: "age", type: "uint8" }
+ *   ],
+ *   resolverAddress: "0x1234567890123456789012345678901234567890",
+ *   revocable: true
+ * };
+ * ```
+ */
+interface RegisterSchemaOptions {
+    /** The fields that make up the schema */
+    fields: SchemaField[];
+    /** The Ethereum address of the resolver */
+    resolverAddress: string;
+    /** Whether attestations using this schema can be revoked */
+    revocable: boolean;
+}
+/**
+ * Validates an Ethereum address.
+ * @param address - The address to validate
+ * @throws Error if the address is invalid
+ * @example
+ * ```ts
+ * import { validateEthereumAddress } from '@settlemint/sdk-eas';
+ *
+ * // Valid address
+ * validateEthereumAddress("0x1234567890123456789012345678901234567890"); // OK
+ *
+ * // Invalid addresses
+ * validateEthereumAddress("0x123"); // Throws: "Invalid Ethereum address format"
+ * validateEthereumAddress(""); // Throws: "Resolver address cannot be empty"
+ * ```
+ */
+declare function validateEthereumAddress(address: string): void;
+/**
+ * Registers a new schema with EAS.
+ * @param options - The schema registration options
+ * @returns A promise that resolves to the schema UID
+ * @throws Error if the schema registration fails
+ * @example
+ * ```ts
+ * import { registerSchema, SchemaField } from '@settlemint/sdk-eas';
+ *
+ * const fields: SchemaField[] = [
+ *   { name: "userAddress", type: "address" },
+ *   { name: "age", type: "uint8" }
+ * ];
+ *
+ * const schemaUID = await registerSchema({
+ *   fields,
+ *   resolverAddress: "0x1234567890123456789012345678901234567890",
+ *   revocable: true
+ * });
+ *
+ * console.log(`Schema registered with UID: ${schemaUID}`);
+ * ```
+ */
+declare function registerSchema(options: RegisterSchemaOptions): Promise<string>;
+
+declare function createEASClient(): {
+    submitAttestation(): void;
+    parseAttestation(): void;
+    createSchema(): void;
+    getSchema(): void;
+    getAttestations(): void;
+};
+
+export { type EASFieldType, EAS_FIELD_TYPES, type RegisterSchemaOptions, type SchemaField, buildSchemaString, createEASClient, registerSchema, validateEthereumAddress, validateFieldName, validateFieldType, validateSchemaFields };

package/dist/eas.mjs

@@ -0,0 +1,2 @@
+import {isAddress}from'viem';var o={string:"string",address:"address",bool:"bool",bytes:"bytes",bytes32:"bytes32",uint256:"uint256",int256:"int256",uint8:"uint8",int8:"int8"};function a(e){if(!e)throw new Error("Field name cannot be empty");if(e.includes(" "))throw new Error("Field name cannot contain spaces");if(!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(e))throw new Error("Field name must start with a letter or underscore and contain only alphanumeric characters and underscores")}function c(e){if(!(e in o))throw new Error(`Invalid field type: ${e}. Must be one of: ${Object.keys(o).join(", ")}`)}function r(e){if(!e||e.length===0)throw new Error("Schema must have at least one field");let t=new Set;for(let n of e){if(a(n.name),c(n.type),t.has(n.name))throw new Error(`Duplicate field name: ${n.name}`);t.add(n.name);}}function l(e){return r(e),e.map(t=>`${t.type} ${t.name}`).join(", ")}function m(e){if(!e)throw new Error("Resolver address cannot be empty");if(!isAddress(e))throw new Error("Invalid Ethereum address format")}async function p(e){let{fields:t,resolverAddress:n,revocable:i}=e;r(t),m(n);let s=l(t);return console.log(`[EAS] Registering schema: ${s}`),console.log(`[EAS] Resolver: ${n}`),console.log(`[EAS] Revocable: ${i}`),`0x${"0".repeat(64)}`}function S(){return {submitAttestation(){console.log("[EAS] Submitting attestation");},parseAttestation(){console.log("[EAS] Parsing attestation");},createSchema(){console.log("[EAS] Creating schema");},getSchema(){console.log("[EAS] Getting schema");},getAttestations(){console.log("[EAS] Getting attestations");}}}export{o as EAS_FIELD_TYPES,l as buildSchemaString,S as createEASClient,p as registerSchema,m as validateEthereumAddress,a as validateFieldName,c as validateFieldType,r as validateSchemaFields};//# sourceMappingURL=eas.mjs.map
+//# sourceMappingURL=eas.mjs.map

package/dist/eas.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema.ts","../src/eas.ts"],"names":["EAS_FIELD_TYPES","validateFieldName","name","validateFieldType","type","validateSchemaFields","fields","seenNames","field","buildSchemaString","validateEthereumAddress","address","isAddress","registerSchema","options","resolverAddress","revocable","schemaString","createEASClient"],"mappings":"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","file":"eas.mjs","sourcesContent":["/**\n * Supported EAS schema field types.\n * Maps user-friendly type names to EAS-compatible type strings.\n * @example\n * ```ts\n * import { EAS_FIELD_TYPES } from '@settlemint/sdk-eas';\n *\n * // Use in type definitions\n * type MyFieldType = keyof typeof EAS_FIELD_TYPES;\n *\n * // Check if a type is supported\n * const isValidType = \"string\" in EAS_FIELD_TYPES;\n * ```\n */\nexport const EAS_FIELD_TYPES = {\n  string: \"string\",\n  address: \"address\",\n  bool: \"bool\",\n  bytes: \"bytes\",\n  bytes32: \"bytes32\",\n  uint256: \"uint256\",\n  int256: \"int256\",\n  uint8: \"uint8\",\n  int8: \"int8\",\n} as const;\n\n/**\n * Type representing all valid EAS field types.\n */\nexport type EASFieldType = keyof typeof EAS_FIELD_TYPES;\n\n/**\n * Interface for defining a schema field.\n * @example\n * ```ts\n * import { SchemaField } from '@settlemint/sdk-eas';\n *\n * const field: SchemaField = {\n *   name: \"userAddress\",\n *   type: \"address\",\n *   description: \"The Ethereum address of the user\"\n * };\n * ```\n */\nexport interface SchemaField {\n  /** The name of the field */\n  name: string;\n  /** The type of the field */\n  type: EASFieldType;\n  /** Optional description of the field */\n  description?: string;\n}\n\n/**\n * Validates a schema field name.\n * @param name - The field name to validate\n * @throws Error if the name is invalid\n * @example\n * ```ts\n * import { validateFieldName } from '@settlemint/sdk-eas';\n *\n * // Valid names\n * validateFieldName(\"userAddress\"); // OK\n * validateFieldName(\"user_address\"); // OK\n *\n * // Invalid names\n * validateFieldName(\"user address\"); // Throws: \"Field name cannot contain spaces\"\n * validateFieldName(\"123user\"); // Throws: \"Field name must start with a letter or underscore\"\n * ```\n */\nexport function validateFieldName(name: string): void {\n  if (!name) {\n    throw new Error(\"Field name cannot be empty\");\n  }\n  if (name.includes(\" \")) {\n    throw new Error(\"Field name cannot contain spaces\");\n  }\n  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {\n    throw new Error(\n      \"Field name must start with a letter or underscore and contain only alphanumeric characters and underscores\",\n    );\n  }\n}\n\n/**\n * Validates a schema field type.\n * @param type - The field type to validate\n * @throws Error if the type is invalid\n * @example\n * ```ts\n * import { validateFieldType } from '@settlemint/sdk-eas';\n *\n * // Valid types\n * validateFieldType(\"string\"); // OK\n * validateFieldType(\"address\"); // OK\n *\n * // Invalid types\n * validateFieldType(\"invalidType\"); // Throws: \"Invalid field type: invalidType\"\n * ```\n */\nexport function validateFieldType(type: string): asserts type is EASFieldType {\n  if (!(type in EAS_FIELD_TYPES)) {\n    throw new Error(`Invalid field type: ${type}. Must be one of: ${Object.keys(EAS_FIELD_TYPES).join(\", \")}`);\n  }\n}\n\n/**\n * Validates an array of schema fields.\n * @param fields - The fields to validate\n * @throws Error if any field is invalid\n * @example\n * ```ts\n * import { validateSchemaFields, SchemaField } from '@settlemint/sdk-eas';\n *\n * const fields: SchemaField[] = [\n *   { name: \"userAddress\", type: \"address\" },\n *   { name: \"age\", type: \"uint8\" }\n * ];\n *\n * validateSchemaFields(fields); // OK\n *\n * // Invalid fields\n * validateSchemaFields([]); // Throws: \"Schema must have at least one field\"\n * validateSchemaFields([\n *   { name: \"userAddress\", type: \"address\" },\n *   { name: \"userAddress\", type: \"uint8\" }\n * ]); // Throws: \"Duplicate field name: userAddress\"\n * ```\n */\nexport function validateSchemaFields(fields: SchemaField[]): void {\n  if (!fields || fields.length === 0) {\n    throw new Error(\"Schema must have at least one field\");\n  }\n\n  const seenNames = new Set<string>();\n  for (const field of fields) {\n    validateFieldName(field.name);\n    validateFieldType(field.type);\n\n    if (seenNames.has(field.name)) {\n      throw new Error(`Duplicate field name: ${field.name}`);\n    }\n    seenNames.add(field.name);\n  }\n}\n\n/**\n * Builds an EAS schema string from an array of fields.\n * @param fields - The fields to include in the schema\n * @returns The EAS-compatible schema string\n * @throws Error if any field is invalid\n * @example\n * ```ts\n * import { buildSchemaString, SchemaField } from '@settlemint/sdk-eas';\n *\n * const fields: SchemaField[] = [\n *   { name: \"userAddress\", type: \"address\" },\n *   { name: \"age\", type: \"uint8\" },\n *   { name: \"isActive\", type: \"bool\" }\n * ];\n *\n * const schemaString = buildSchemaString(fields);\n * // Result: \"address userAddress, uint8 age, bool isActive\"\n * ```\n */\nexport function buildSchemaString(fields: SchemaField[]): string {\n  validateSchemaFields(fields);\n  return fields.map((field) => `${field.type} ${field.name}`).join(\", \");\n}\n\n/**\n * Options for registering a schema.\n * @example\n * ```ts\n * import { RegisterSchemaOptions, SchemaField } from '@settlemint/sdk-eas';\n *\n * const options: RegisterSchemaOptions = {\n *   fields: [\n *     { name: \"userAddress\", type: \"address\" },\n *     { name: \"age\", type: \"uint8\" }\n *   ],\n *   resolverAddress: \"0x1234567890123456789012345678901234567890\",\n *   revocable: true\n * };\n * ```\n */\nexport interface RegisterSchemaOptions {\n  /** The fields that make up the schema */\n  fields: SchemaField[];\n  /** The Ethereum address of the resolver */\n  resolverAddress: string;\n  /** Whether attestations using this schema can be revoked */\n  revocable: boolean;\n}\n\nimport { isAddress } from \"viem\";\n\n/**\n * Validates an Ethereum address.\n * @param address - The address to validate\n * @throws Error if the address is invalid\n * @example\n * ```ts\n * import { validateEthereumAddress } from '@settlemint/sdk-eas';\n *\n * // Valid address\n * validateEthereumAddress(\"0x1234567890123456789012345678901234567890\"); // OK\n *\n * // Invalid addresses\n * validateEthereumAddress(\"0x123\"); // Throws: \"Invalid Ethereum address format\"\n * validateEthereumAddress(\"\"); // Throws: \"Resolver address cannot be empty\"\n * ```\n */\nexport function validateEthereumAddress(address: string): void {\n  if (!address) {\n    throw new Error(\"Resolver address cannot be empty\");\n  }\n  if (!isAddress(address)) {\n    throw new Error(\"Invalid Ethereum address format\");\n  }\n}\n\n/**\n * Registers a new schema with EAS.\n * @param options - The schema registration options\n * @returns A promise that resolves to the schema UID\n * @throws Error if the schema registration fails\n * @example\n * ```ts\n * import { registerSchema, SchemaField } from '@settlemint/sdk-eas';\n *\n * const fields: SchemaField[] = [\n *   { name: \"userAddress\", type: \"address\" },\n *   { name: \"age\", type: \"uint8\" }\n * ];\n *\n * const schemaUID = await registerSchema({\n *   fields,\n *   resolverAddress: \"0x1234567890123456789012345678901234567890\",\n *   revocable: true\n * });\n *\n * console.log(`Schema registered with UID: ${schemaUID}`);\n * ```\n */\nexport async function registerSchema(options: RegisterSchemaOptions): Promise<string> {\n  const { fields, resolverAddress, revocable } = options;\n\n  // Validate the schema fields\n  validateSchemaFields(fields);\n\n  // Validate the resolver address\n  validateEthereumAddress(resolverAddress);\n\n  // Build the schema string\n  const schemaString = buildSchemaString(fields);\n\n  // TODO: Implement actual EAS SDK registration\n  // This is a placeholder that will be replaced with actual EAS SDK integration\n  console.log(`[EAS] Registering schema: ${schemaString}`);\n  console.log(`[EAS] Resolver: ${resolverAddress}`);\n  console.log(`[EAS] Revocable: ${revocable}`);\n\n  // Return a mock UID for now\n  return `0x${\"0\".repeat(64)}`;\n}\n","export * from \"./schema.js\";\n\nexport function createEASClient() {\n  return {\n    submitAttestation() {\n      console.log(\"[EAS] Submitting attestation\");\n    },\n\n    parseAttestation() {\n      console.log(\"[EAS] Parsing attestation\");\n    },\n\n    createSchema() {\n      console.log(\"[EAS] Creating schema\");\n    },\n\n    getSchema() {\n      console.log(\"[EAS] Getting schema\");\n    },\n\n    getAttestations() {\n      console.log(\"[EAS] Getting attestations\");\n    },\n  };\n}\n"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@settlemint/sdk-eas",
   "description": "Ethereum Attestation Service (EAS) integration for SettleMint SDK",
-  "version": "2.2.2-pr75b59b5f",
+  "version": "2.2.2-pr8fc22dc7",
   "type": "module",
   "private": false,
   "license": "FSL-1.1-MIT",
@@ -21,19 +21,19 @@
     "email": "support@settlemint.com"
   },
   "files": ["dist"],
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/eas.cjs",
+  "module": "./dist/eas.mjs",
+  "types": "./dist/eas.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
       "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.mjs"
+        "types": "./dist/eas.d.ts",
+        "default": "./dist/eas.mjs"
       },
       "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
+        "types": "./dist/eas.d.cts",
+        "default": "./dist/eas.cjs"
       }
     }
   },
@@ -47,11 +47,11 @@
     "typecheck": "tsc --noEmit",
     "publish-npm": "bun publish --tag ${TAG} --access public || exit 0",
     "prepack": "cp ../../LICENSE .",
-    "docs": "typedoc --options '../../typedoc.config.mjs' --entryPoints src/index.ts --out ./docs"
+    "docs": "typedoc --options '../../typedoc.config.mjs' --entryPoints src/eas.ts --out ./docs"
   },
   "devDependencies": {},
   "dependencies": {
-    "@settlemint/sdk-utils": "2.2.2-pr75b59b5f",
+    "@settlemint/sdk-utils": "2.2.2-pr8fc22dc7",
     "viem": "^2.7.9"
   },
   "peerDependencies": {},

package/dist/index.cjs

@@ -1,2 +0,0 @@
-'use strict';var o={string:"string",address:"address",bool:"bool",bytes:"bytes",bytes32:"bytes32",uint256:"uint256",int256:"int256",uint8:"uint8",int8:"int8"};function a(e){if(!e)throw new Error("Field name cannot be empty");if(e.includes(" "))throw new Error("Field name cannot contain spaces");if(!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(e))throw new Error("Field name must start with a letter or underscore and contain only alphanumeric characters and underscores")}function c(e){if(!(e in o))throw new Error(`Invalid field type: ${e}. Must be one of: ${Object.keys(o).join(", ")}`)}function r(e){if(!e||e.length===0)throw new Error("Schema must have at least one field");let t=new Set;for(let n of e){if(a(n.name),c(n.type),t.has(n.name))throw new Error(`Duplicate field name: ${n.name}`);t.add(n.name);}}function l(e){return r(e),e.map(t=>`${t.type} ${t.name}`).join(", ")}function d(e){if(!e)throw new Error("Resolver address cannot be empty");if(!/^0x[a-fA-F0-9]{40}$/.test(e))throw new Error("Invalid Ethereum address format")}async function m(e){let{fields:t,resolverAddress:n,revocable:i}=e;r(t),d(n);let s=l(t);return console.log(`[EAS] Registering schema: ${s}`),console.log(`[EAS] Resolver: ${n}`),console.log(`[EAS] Revocable: ${i}`),`0x${"0".repeat(64)}`}function p(){return {submitAttestation(){console.log("[EAS] Submitting attestation");},parseAttestation(){console.log("[EAS] Parsing attestation");},createSchema(){console.log("[EAS] Creating schema");},getSchema(){console.log("[EAS] Getting schema");},getAttestations(){console.log("[EAS] Getting attestations");}}}exports.EAS_FIELD_TYPES=o;exports.buildSchemaString=l;exports.createEASClient=p;exports.registerSchema=m;exports.validateEthereumAddress=d;exports.validateFieldName=a;exports.validateFieldType=c;exports.validateSchemaFields=r;//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/schema.ts","../src/index.ts"],"names":["EAS_FIELD_TYPES","validateFieldName","name","validateFieldType","type","validateSchemaFields","fields","seenNames","field","buildSchemaString","validateEthereumAddress","address","registerSchema","options","resolverAddress","revocable","schemaString","createEASClient"],"mappings":"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","file":"index.cjs","sourcesContent":["/**\n * Supported EAS schema field types.\n * Maps user-friendly type names to EAS-compatible type strings.\n */\nexport const EAS_FIELD_TYPES = {\n  string: \"string\",\n  address: \"address\",\n  bool: \"bool\",\n  bytes: \"bytes\",\n  bytes32: \"bytes32\",\n  uint256: \"uint256\",\n  int256: \"int256\",\n  uint8: \"uint8\",\n  int8: \"int8\",\n} as const;\n\n/**\n * Type representing all valid EAS field types.\n */\nexport type EASFieldType = keyof typeof EAS_FIELD_TYPES;\n\n/**\n * Interface for defining a schema field.\n */\nexport interface SchemaField {\n  /** The name of the field */\n  name: string;\n  /** The type of the field */\n  type: EASFieldType;\n  /** Optional description of the field */\n  description?: string;\n}\n\n/**\n * Validates a schema field name.\n * @param name - The field name to validate\n * @throws Error if the name is invalid\n */\nexport function validateFieldName(name: string): void {\n  if (!name) {\n    throw new Error(\"Field name cannot be empty\");\n  }\n  if (name.includes(\" \")) {\n    throw new Error(\"Field name cannot contain spaces\");\n  }\n  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {\n    throw new Error(\n      \"Field name must start with a letter or underscore and contain only alphanumeric characters and underscores\",\n    );\n  }\n}\n\n/**\n * Validates a schema field type.\n * @param type - The field type to validate\n * @throws Error if the type is invalid\n */\nexport function validateFieldType(type: string): asserts type is EASFieldType {\n  if (!(type in EAS_FIELD_TYPES)) {\n    throw new Error(`Invalid field type: ${type}. Must be one of: ${Object.keys(EAS_FIELD_TYPES).join(\", \")}`);\n  }\n}\n\n/**\n * Validates an array of schema fields.\n * @param fields - The fields to validate\n * @throws Error if any field is invalid\n */\nexport function validateSchemaFields(fields: SchemaField[]): void {\n  if (!fields || fields.length === 0) {\n    throw new Error(\"Schema must have at least one field\");\n  }\n\n  const seenNames = new Set<string>();\n  for (const field of fields) {\n    validateFieldName(field.name);\n    validateFieldType(field.type);\n\n    if (seenNames.has(field.name)) {\n      throw new Error(`Duplicate field name: ${field.name}`);\n    }\n    seenNames.add(field.name);\n  }\n}\n\n/**\n * Builds an EAS schema string from an array of fields.\n * @param fields - The fields to include in the schema\n * @returns The EAS-compatible schema string\n * @throws Error if any field is invalid\n */\nexport function buildSchemaString(fields: SchemaField[]): string {\n  validateSchemaFields(fields);\n  return fields.map((field) => `${field.type} ${field.name}`).join(\", \");\n}\n\n/**\n * Options for registering a schema.\n */\nexport interface RegisterSchemaOptions {\n  /** The fields that make up the schema */\n  fields: SchemaField[];\n  /** The Ethereum address of the resolver */\n  resolverAddress: string;\n  /** Whether attestations using this schema can be revoked */\n  revocable: boolean;\n}\n\n/**\n * Validates an Ethereum address.\n * @param address - The address to validate\n * @throws Error if the address is invalid\n */\nexport function validateEthereumAddress(address: string): void {\n  if (!address) {\n    throw new Error(\"Resolver address cannot be empty\");\n  }\n  if (!/^0x[a-fA-F0-9]{40}$/.test(address)) {\n    throw new Error(\"Invalid Ethereum address format\");\n  }\n}\n\n/**\n * Registers a new schema with EAS.\n * @param options - The schema registration options\n * @returns A promise that resolves to the schema UID\n * @throws Error if the schema registration fails\n */\nexport async function registerSchema(options: RegisterSchemaOptions): Promise<string> {\n  const { fields, resolverAddress, revocable } = options;\n\n  // Validate the schema fields\n  validateSchemaFields(fields);\n\n  // Validate the resolver address\n  validateEthereumAddress(resolverAddress);\n\n  // Build the schema string\n  const schemaString = buildSchemaString(fields);\n\n  // TODO: Implement actual EAS SDK registration\n  // This is a placeholder that will be replaced with actual EAS SDK integration\n  console.log(`[EAS] Registering schema: ${schemaString}`);\n  console.log(`[EAS] Resolver: ${resolverAddress}`);\n  console.log(`[EAS] Revocable: ${revocable}`);\n\n  // Return a mock UID for now\n  return `0x${\"0\".repeat(64)}`;\n}\n","export * from \"./schema.js\";\n\nexport function createEASClient() {\n  return {\n    submitAttestation() {\n      console.log(\"[EAS] Submitting attestation\");\n    },\n\n    parseAttestation() {\n      console.log(\"[EAS] Parsing attestation\");\n    },\n\n    createSchema() {\n      console.log(\"[EAS] Creating schema\");\n    },\n\n    getSchema() {\n      console.log(\"[EAS] Getting schema\");\n    },\n\n    getAttestations() {\n      console.log(\"[EAS] Getting attestations\");\n    },\n  };\n}\n"]}

package/dist/index.d.cts

@@ -1,89 +0,0 @@
-/**
- * Supported EAS schema field types.
- * Maps user-friendly type names to EAS-compatible type strings.
- */
-declare const EAS_FIELD_TYPES: {
-    readonly string: "string";
-    readonly address: "address";
-    readonly bool: "bool";
-    readonly bytes: "bytes";
-    readonly bytes32: "bytes32";
-    readonly uint256: "uint256";
-    readonly int256: "int256";
-    readonly uint8: "uint8";
-    readonly int8: "int8";
-};
-/**
- * Type representing all valid EAS field types.
- */
-type EASFieldType = keyof typeof EAS_FIELD_TYPES;
-/**
- * Interface for defining a schema field.
- */
-interface SchemaField {
-    /** The name of the field */
-    name: string;
-    /** The type of the field */
-    type: EASFieldType;
-    /** Optional description of the field */
-    description?: string;
-}
-/**
- * Validates a schema field name.
- * @param name - The field name to validate
- * @throws Error if the name is invalid
- */
-declare function validateFieldName(name: string): void;
-/**
- * Validates a schema field type.
- * @param type - The field type to validate
- * @throws Error if the type is invalid
- */
-declare function validateFieldType(type: string): asserts type is EASFieldType;
-/**
- * Validates an array of schema fields.
- * @param fields - The fields to validate
- * @throws Error if any field is invalid
- */
-declare function validateSchemaFields(fields: SchemaField[]): void;
-/**
- * Builds an EAS schema string from an array of fields.
- * @param fields - The fields to include in the schema
- * @returns The EAS-compatible schema string
- * @throws Error if any field is invalid
- */
-declare function buildSchemaString(fields: SchemaField[]): string;
-/**
- * Options for registering a schema.
- */
-interface RegisterSchemaOptions {
-    /** The fields that make up the schema */
-    fields: SchemaField[];
-    /** The Ethereum address of the resolver */
-    resolverAddress: string;
-    /** Whether attestations using this schema can be revoked */
-    revocable: boolean;
-}
-/**
- * Validates an Ethereum address.
- * @param address - The address to validate
- * @throws Error if the address is invalid
- */
-declare function validateEthereumAddress(address: string): void;
-/**
- * Registers a new schema with EAS.
- * @param options - The schema registration options
- * @returns A promise that resolves to the schema UID
- * @throws Error if the schema registration fails
- */
-declare function registerSchema(options: RegisterSchemaOptions): Promise<string>;
-
-declare function createEASClient(): {
-    submitAttestation(): void;
-    parseAttestation(): void;
-    createSchema(): void;
-    getSchema(): void;
-    getAttestations(): void;
-};
-
-export { type EASFieldType, EAS_FIELD_TYPES, type RegisterSchemaOptions, type SchemaField, buildSchemaString, createEASClient, registerSchema, validateEthereumAddress, validateFieldName, validateFieldType, validateSchemaFields };

package/dist/index.d.ts

@@ -1,89 +0,0 @@
-/**
- * Supported EAS schema field types.
- * Maps user-friendly type names to EAS-compatible type strings.
- */
-declare const EAS_FIELD_TYPES: {
-    readonly string: "string";
-    readonly address: "address";
-    readonly bool: "bool";
-    readonly bytes: "bytes";
-    readonly bytes32: "bytes32";
-    readonly uint256: "uint256";
-    readonly int256: "int256";
-    readonly uint8: "uint8";
-    readonly int8: "int8";
-};
-/**
- * Type representing all valid EAS field types.
- */
-type EASFieldType = keyof typeof EAS_FIELD_TYPES;
-/**
- * Interface for defining a schema field.
- */
-interface SchemaField {
-    /** The name of the field */
-    name: string;
-    /** The type of the field */
-    type: EASFieldType;
-    /** Optional description of the field */
-    description?: string;
-}
-/**
- * Validates a schema field name.
- * @param name - The field name to validate
- * @throws Error if the name is invalid
- */
-declare function validateFieldName(name: string): void;
-/**
- * Validates a schema field type.
- * @param type - The field type to validate
- * @throws Error if the type is invalid
- */
-declare function validateFieldType(type: string): asserts type is EASFieldType;
-/**
- * Validates an array of schema fields.
- * @param fields - The fields to validate
- * @throws Error if any field is invalid
- */
-declare function validateSchemaFields(fields: SchemaField[]): void;
-/**
- * Builds an EAS schema string from an array of fields.
- * @param fields - The fields to include in the schema
- * @returns The EAS-compatible schema string
- * @throws Error if any field is invalid
- */
-declare function buildSchemaString(fields: SchemaField[]): string;
-/**
- * Options for registering a schema.
- */
-interface RegisterSchemaOptions {
-    /** The fields that make up the schema */
-    fields: SchemaField[];
-    /** The Ethereum address of the resolver */
-    resolverAddress: string;
-    /** Whether attestations using this schema can be revoked */
-    revocable: boolean;
-}
-/**
- * Validates an Ethereum address.
- * @param address - The address to validate
- * @throws Error if the address is invalid
- */
-declare function validateEthereumAddress(address: string): void;
-/**
- * Registers a new schema with EAS.
- * @param options - The schema registration options
- * @returns A promise that resolves to the schema UID
- * @throws Error if the schema registration fails
- */
-declare function registerSchema(options: RegisterSchemaOptions): Promise<string>;
-
-declare function createEASClient(): {
-    submitAttestation(): void;
-    parseAttestation(): void;
-    createSchema(): void;
-    getSchema(): void;
-    getAttestations(): void;
-};
-
-export { type EASFieldType, EAS_FIELD_TYPES, type RegisterSchemaOptions, type SchemaField, buildSchemaString, createEASClient, registerSchema, validateEthereumAddress, validateFieldName, validateFieldType, validateSchemaFields };

package/dist/index.mjs

@@ -1,2 +0,0 @@
-var o={string:"string",address:"address",bool:"bool",bytes:"bytes",bytes32:"bytes32",uint256:"uint256",int256:"int256",uint8:"uint8",int8:"int8"};function a(e){if(!e)throw new Error("Field name cannot be empty");if(e.includes(" "))throw new Error("Field name cannot contain spaces");if(!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(e))throw new Error("Field name must start with a letter or underscore and contain only alphanumeric characters and underscores")}function c(e){if(!(e in o))throw new Error(`Invalid field type: ${e}. Must be one of: ${Object.keys(o).join(", ")}`)}function r(e){if(!e||e.length===0)throw new Error("Schema must have at least one field");let t=new Set;for(let n of e){if(a(n.name),c(n.type),t.has(n.name))throw new Error(`Duplicate field name: ${n.name}`);t.add(n.name);}}function l(e){return r(e),e.map(t=>`${t.type} ${t.name}`).join(", ")}function d(e){if(!e)throw new Error("Resolver address cannot be empty");if(!/^0x[a-fA-F0-9]{40}$/.test(e))throw new Error("Invalid Ethereum address format")}async function m(e){let{fields:t,resolverAddress:n,revocable:i}=e;r(t),d(n);let s=l(t);return console.log(`[EAS] Registering schema: ${s}`),console.log(`[EAS] Resolver: ${n}`),console.log(`[EAS] Revocable: ${i}`),`0x${"0".repeat(64)}`}function p(){return {submitAttestation(){console.log("[EAS] Submitting attestation");},parseAttestation(){console.log("[EAS] Parsing attestation");},createSchema(){console.log("[EAS] Creating schema");},getSchema(){console.log("[EAS] Getting schema");},getAttestations(){console.log("[EAS] Getting attestations");}}}export{o as EAS_FIELD_TYPES,l as buildSchemaString,p as createEASClient,m as registerSchema,d as validateEthereumAddress,a as validateFieldName,c as validateFieldType,r as validateSchemaFields};//# sourceMappingURL=index.mjs.map
-//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/schema.ts","../src/index.ts"],"names":["EAS_FIELD_TYPES","validateFieldName","name","validateFieldType","type","validateSchemaFields","fields","seenNames","field","buildSchemaString","validateEthereumAddress","address","registerSchema","options","resolverAddress","revocable","schemaString","createEASClient"],"mappings":"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","file":"index.mjs","sourcesContent":["/**\n * Supported EAS schema field types.\n * Maps user-friendly type names to EAS-compatible type strings.\n */\nexport const EAS_FIELD_TYPES = {\n  string: \"string\",\n  address: \"address\",\n  bool: \"bool\",\n  bytes: \"bytes\",\n  bytes32: \"bytes32\",\n  uint256: \"uint256\",\n  int256: \"int256\",\n  uint8: \"uint8\",\n  int8: \"int8\",\n} as const;\n\n/**\n * Type representing all valid EAS field types.\n */\nexport type EASFieldType = keyof typeof EAS_FIELD_TYPES;\n\n/**\n * Interface for defining a schema field.\n */\nexport interface SchemaField {\n  /** The name of the field */\n  name: string;\n  /** The type of the field */\n  type: EASFieldType;\n  /** Optional description of the field */\n  description?: string;\n}\n\n/**\n * Validates a schema field name.\n * @param name - The field name to validate\n * @throws Error if the name is invalid\n */\nexport function validateFieldName(name: string): void {\n  if (!name) {\n    throw new Error(\"Field name cannot be empty\");\n  }\n  if (name.includes(\" \")) {\n    throw new Error(\"Field name cannot contain spaces\");\n  }\n  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {\n    throw new Error(\n      \"Field name must start with a letter or underscore and contain only alphanumeric characters and underscores\",\n    );\n  }\n}\n\n/**\n * Validates a schema field type.\n * @param type - The field type to validate\n * @throws Error if the type is invalid\n */\nexport function validateFieldType(type: string): asserts type is EASFieldType {\n  if (!(type in EAS_FIELD_TYPES)) {\n    throw new Error(`Invalid field type: ${type}. Must be one of: ${Object.keys(EAS_FIELD_TYPES).join(\", \")}`);\n  }\n}\n\n/**\n * Validates an array of schema fields.\n * @param fields - The fields to validate\n * @throws Error if any field is invalid\n */\nexport function validateSchemaFields(fields: SchemaField[]): void {\n  if (!fields || fields.length === 0) {\n    throw new Error(\"Schema must have at least one field\");\n  }\n\n  const seenNames = new Set<string>();\n  for (const field of fields) {\n    validateFieldName(field.name);\n    validateFieldType(field.type);\n\n    if (seenNames.has(field.name)) {\n      throw new Error(`Duplicate field name: ${field.name}`);\n    }\n    seenNames.add(field.name);\n  }\n}\n\n/**\n * Builds an EAS schema string from an array of fields.\n * @param fields - The fields to include in the schema\n * @returns The EAS-compatible schema string\n * @throws Error if any field is invalid\n */\nexport function buildSchemaString(fields: SchemaField[]): string {\n  validateSchemaFields(fields);\n  return fields.map((field) => `${field.type} ${field.name}`).join(\", \");\n}\n\n/**\n * Options for registering a schema.\n */\nexport interface RegisterSchemaOptions {\n  /** The fields that make up the schema */\n  fields: SchemaField[];\n  /** The Ethereum address of the resolver */\n  resolverAddress: string;\n  /** Whether attestations using this schema can be revoked */\n  revocable: boolean;\n}\n\n/**\n * Validates an Ethereum address.\n * @param address - The address to validate\n * @throws Error if the address is invalid\n */\nexport function validateEthereumAddress(address: string): void {\n  if (!address) {\n    throw new Error(\"Resolver address cannot be empty\");\n  }\n  if (!/^0x[a-fA-F0-9]{40}$/.test(address)) {\n    throw new Error(\"Invalid Ethereum address format\");\n  }\n}\n\n/**\n * Registers a new schema with EAS.\n * @param options - The schema registration options\n * @returns A promise that resolves to the schema UID\n * @throws Error if the schema registration fails\n */\nexport async function registerSchema(options: RegisterSchemaOptions): Promise<string> {\n  const { fields, resolverAddress, revocable } = options;\n\n  // Validate the schema fields\n  validateSchemaFields(fields);\n\n  // Validate the resolver address\n  validateEthereumAddress(resolverAddress);\n\n  // Build the schema string\n  const schemaString = buildSchemaString(fields);\n\n  // TODO: Implement actual EAS SDK registration\n  // This is a placeholder that will be replaced with actual EAS SDK integration\n  console.log(`[EAS] Registering schema: ${schemaString}`);\n  console.log(`[EAS] Resolver: ${resolverAddress}`);\n  console.log(`[EAS] Revocable: ${revocable}`);\n\n  // Return a mock UID for now\n  return `0x${\"0\".repeat(64)}`;\n}\n","export * from \"./schema.js\";\n\nexport function createEASClient() {\n  return {\n    submitAttestation() {\n      console.log(\"[EAS] Submitting attestation\");\n    },\n\n    parseAttestation() {\n      console.log(\"[EAS] Parsing attestation\");\n    },\n\n    createSchema() {\n      console.log(\"[EAS] Creating schema\");\n    },\n\n    getSchema() {\n      console.log(\"[EAS] Getting schema\");\n    },\n\n    getAttestations() {\n      console.log(\"[EAS] Getting attestations\");\n    },\n  };\n}\n"]}