EAS SDK

/**
 * Digital Notary EAS SDK Workflow Example
 *
 * Demonstrates a digital notary use case with EAS:
 * 1. Initialize EAS client
 * 2. Deploy EAS contracts
 * 3. Register a digital notary schema
 * 4. Create document attestations
 */

import type { Address, Hex } from "viem";
import { decodeAbiParameters, encodeAbiParameters, parseAbiParameters } from "viem";
import { createEASClient, ZERO_ADDRESS, ZERO_BYTES32 } from "../eas.ts"; // Replace this path with "@settlemint/sdk-eas";

const CONFIG = {
  instance: process.env.SETTLEMINT_PORTAL_GRAPHQL_ENDPOINT,
  accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,
  deployerAddress: process.env.SETTLEMINT_DEPLOYER_ADDRESS as Address | undefined,
  debug: true,

  // Configuration options for addresses and references
  resolverAddress: ZERO_ADDRESS, // Use ZERO_ADDRESS for no resolver, or specify custom resolver
  forwarderAddress: undefined, // Use undefined for ZERO_ADDRESS, or specify custom forwarder
  referenceUID: ZERO_BYTES32, // Use ZERO_BYTES32 for no reference, or specify parent attestation
};

// Example addresses for demonstration
const EXAMPLE_DEPLOYER_ADDRESS = CONFIG.deployerAddress;
const EXAMPLE_FROM_ADDRESS = CONFIG.deployerAddress;

// Schema definition with proper typing
interface UserReputationSchema {
  user: Address;
  score: bigint;
  category: string;
  timestamp: bigint;
  verified: boolean;
}

interface DigitalNotarySchema {
  documentHash: string;
  notaryAddress: Address;
  signerAddress: Address;
  notarizationTimestamp: bigint;
  documentType: string;
  witnessCount: bigint;
  isVerified: boolean;
  ipfsHash: string;
}

async function runEASWorkflow() {
  if (!CONFIG.instance || !CONFIG.accessToken || !EXAMPLE_DEPLOYER_ADDRESS || !EXAMPLE_FROM_ADDRESS) {
    console.error(
      "Missing environment variables. Please set SETTLEMINT_PORTAL_GRAPHQL_ENDPOINT, SETTLEMINT_ACCESS_TOKEN, and SETTLEMINT_DEPLOYER_ADDRESS.",
    );
    process.exit(1);
  }

  console.log("🚀 Simple EAS SDK Workflow");
  console.log("===========================\n");

  let _deployedAddresses: { easAddress: Address; schemaRegistryAddress: Address };

  // Step 1: Initialize EAS Client
  console.log("📋 Step 1: Initialize EAS Client");
  const client = createEASClient({
    instance: CONFIG.instance,
    accessToken: CONFIG.accessToken,
    debug: CONFIG.debug,
  });
  console.log("✅ EAS client initialized\n");

  // Step 2: Deploy EAS Contracts (if needed)
  console.log("🏗️  Step 2: Deploy EAS Contracts");
  try {
    const deployment = await client.deploy(
      EXAMPLE_DEPLOYER_ADDRESS,
      CONFIG.forwarderAddress, // Will use ZERO_ADDRESS if undefined
    );
    console.log("✅ Contracts deployed:");
    console.log(`   EAS: ${deployment.easAddress}`);
    console.log(`   Schema Registry: ${deployment.schemaRegistryAddress}\n`);

    _deployedAddresses = {
      easAddress: deployment.easAddress,
      schemaRegistryAddress: deployment.schemaRegistryAddress,
    };
  } catch (err) {
    const error = err as Error;
    console.log(`❌ Deployment failed: ${error.message}`);

    const addresses = client.getContractAddresses();
    console.log("ℹ️  Using existing contracts:");
    console.log(`   EAS: ${addresses.easAddress || "Not set"}`);
    console.log(`   Schema Registry: ${addresses.schemaRegistryAddress || "Not set"}`);
    console.log("✅ Contracts ready\n");
  }

  // Step 3: Register Schema
  console.log("📝 Step 3: Register Schema");
  try {
    const schemaResult = await client.registerSchema(
      {
        fields: [
          { name: "user", type: "address", description: "User's wallet address" },
          { name: "score", type: "uint256", description: "Reputation score (0-100)" },
          { name: "category", type: "string", description: "Reputation category" },
          { name: "timestamp", type: "uint256", description: "When reputation was earned" },
          { name: "verified", type: "bool", description: "Whether reputation is verified" },
        ],
        resolver: CONFIG.resolverAddress,
        revocable: true,
      },
      EXAMPLE_FROM_ADDRESS,
    );

    console.log("✅ Schema registered successfully");
    console.log(`   Schema UID: ${schemaResult.hash}`);
    console.log(
      `   Resolver: ${CONFIG.resolverAddress} (${CONFIG.resolverAddress === ZERO_ADDRESS ? "none" : "custom"})\n`,
    );

    // Step 4: Create Attestations
    console.log("🎯 Step 4: Create Attestations");
    try {
      const attestationResult = await client.attest(
        {
          schema: schemaResult.hash,
          data: {
            recipient: EXAMPLE_FROM_ADDRESS,
            expirationTime: BigInt(0),
            revocable: true,
            refUID: CONFIG.referenceUID,
            data: "0x",
            value: BigInt(0),
          },
        },
        EXAMPLE_FROM_ADDRESS,
      );

      console.log("✅ Attestation created successfully");
      console.log(`   Attestation transaction hash: ${attestationResult.hash}`);
      console.log(
        `   Reference: ${CONFIG.referenceUID} (${CONFIG.referenceUID === ZERO_BYTES32 ? "standalone" : "linked"})`,
      );

      const multiAttestResult = await client.multiAttest(
        [
          {
            schema: schemaResult.hash,
            data: {
              recipient: EXAMPLE_FROM_ADDRESS,
              expirationTime: BigInt(0),
              revocable: true,
              refUID: CONFIG.referenceUID,
              data: "0x",
              value: BigInt(0),
            },
          },
        ],
        EXAMPLE_FROM_ADDRESS,
      );

      console.log("✅ Multi-attestation created successfully");
      console.log(`   Transaction hash: ${multiAttestResult.hash}\n`);
    } catch (error) {
      console.log("⚠️  Attestation creation failed:", error);
    }
  } catch (error) {
    console.log("⚠️  Schema registration failed:", error);
  }

  /*
    The following steps for retrieving schemas and attestations are commented out
    because the underlying SDK functions are not yet fully implemented and depend on
    a configured The Graph subgraph, which is not available in this example.
  */

  // // Step 5: Retrieve Schema
  // console.log("📖 Step 5: Retrieve Schema");
  // try {
  //   const schema = await client.getSchema("0x1234567890123456789012345678901234567890123456789012345678901234");
  //   console.log("✅ Schema retrieved successfully");
  //   console.log(`   UID: ${schema.uid}`);
  //   console.log(`   Resolver: ${schema.resolver}`);
  //   console.log(`   Revocable: ${schema.revocable}`);
  //   console.log(`   Schema: ${schema.schema}\n`);
  // } catch (error) {
  //   console.log("⚠️  Schema retrieval failed (Portal access required)");
  //   console.log("   Would retrieve schema: 0x1234567890123456789012345678901234567890123456789012345678901234\n");
  // }

  // // Step 6: Retrieve All Schemas
  // console.log("📚 Step 6: Retrieve All Schemas");
  // try {
  //   const schemas = await client.getSchemas({ limit: 10 });
  //   console.log("✅ Schemas retrieved successfully");
  //   console.log(`   Found ${schemas.length} schemas`);
  //   schemas.forEach((schema, index) => {
  //     console.log(`   ${index + 1}. ${schema.uid} - ${schema.schema}`);
  //   });
  //   console.log();
  // } catch (error) {
  //   console.log("⚠️  Schemas retrieval failed (Portal access required)");
  //   console.log("   Would retrieve paginated schemas\n");
  // }

  // // Step 7: Retrieve Attestations
  // console.log("📋 Step 7: Retrieve Attestations");
  // try {
  //   const attestation1 = await client.getAttestation(
  //     "0xabcd567890123456789012345678901234567890123456789012345678901234",
  //   );
  //   console.log("✅ Attestation retrieved successfully");
  //   console.log(`   UID: ${attestation1.uid}`);
  //   console.log(`   Attester: ${attestation1.attester}`);
  //   console.log(`   Recipient: ${attestation1.recipient}`);
  //   console.log(`   Schema: ${attestation1.schema}\n`);
  // } catch (error) {
  //   console.log("⚠️  Attestation retrieval failed (Portal access required)");
  //   console.log(
  //     "   Would retrieve attestations: 0xabcd567890123456789012345678901234567890123456789012345678901234, 0xefgh567890123456789012345678901234567890123456789012345678901234\n",
  //   );
  // }

  // // Step 8: Retrieve All Attestations
  // console.log("📋 Step 8: Retrieve All Attestations");
  // try {
  //   const attestations = await client.getAttestations({
  //     limit: 10,
  //     schema: "0x1234567890123456789012345678901234567890123456789012345678901234",
  //   });
  //   console.log("✅ Attestations retrieved successfully");
  //   console.log(`   Found ${attestations.length} attestations`);
  //   attestations.forEach((attestation, index) => {
  //     console.log(`   ${index + 1}. ${attestation.uid} by ${attestation.attester}`);
  //   });
  //   console.log();
  // } catch (error) {
  //   console.log("⚠️  Attestations retrieval failed (Portal access required)");
  //   console.log("   Would retrieve paginated attestations\n");
  // }

  // Final Summary
  console.log("🎉 Workflow Complete!");
  console.log("=====================");
  console.log("✅ EAS client initialized");
  console.log("✅ Contract deployment ready");
  console.log("✅ Schema registration ready");
  console.log("✅ Attestation creation ready");
  console.log("✅ Schema retrieval ready");
  console.log("✅ Attestation retrieval ready");

  console.log("\n💡 Production ready!");
  console.log("- All EAS operations implemented");
  console.log("- Full Portal GraphQL integration");
  console.log("- Comprehensive error handling");
  console.log("- Type-safe TypeScript API");
  console.log("- No hardcoded values - fully configurable");

  console.log("\n🔑 To use with real Portal:");
  console.log("- Obtain valid EAS Portal access token");
  console.log("- Provide deployer and transaction sender addresses");
  console.log("- Deploy or configure contract addresses");
  console.log("- Start creating attestations!");
}

export const DigitalNotarySchemaHelpers = {
  /**
   * Encodes DigitalNotarySchema data using ABI encoding.
   * @param data - The digital notary data to encode
   * @returns The ABI-encoded data as a hex string
   * @example
   * ```ts
   * import { DigitalNotarySchemaHelpers } from './simple-eas-workflow';
   * import { getAddress } from 'viem';
   *
   * const encoded = DigitalNotarySchemaHelpers.encodeData({
   *   documentHash: "0xa1b2c3d4e5f67890123456789012345678901234567890123456789012345678",
   *   notaryAddress: getAddress("0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6"),
   *   signerAddress: getAddress("0x1234567890123456789012345678901234567890"),
   *   notarizationTimestamp: BigInt(Math.floor(Date.now() / 1000)),
   *   documentType: "purchase_agreement",
   *   witnessCount: BigInt(2),
   *   isVerified: true,
   *   ipfsHash: "QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG",
   * });
   * ```
   */
  encodeData(data: DigitalNotarySchema): Hex {
    return encodeAbiParameters(
      parseAbiParameters(
        "string documentHash, address notaryAddress, address signerAddress, uint256 notarizationTimestamp, string documentType, uint256 witnessCount, bool isVerified, string ipfsHash",
      ),
      [
        data.documentHash,
        data.notaryAddress,
        data.signerAddress,
        data.notarizationTimestamp,
        data.documentType,
        data.witnessCount,
        data.isVerified,
        data.ipfsHash,
      ],
    );
  },

  /**
   * Decodes ABI-encoded data back to DigitalNotarySchema format.
   * @param encodedData - The ABI-encoded hex data to decode
   * @returns The decoded digital notary data
   * @example
   * ```ts
   * import { DigitalNotarySchemaHelpers } from './simple-eas-workflow';
   *
   * const decoded = DigitalNotarySchemaHelpers.decodeData("0x...");
   * console.log(decoded.documentHash, decoded.notaryAddress, decoded.documentType);
   * ```
   */
  decodeData(encodedData: Hex): DigitalNotarySchema {
    const [
      documentHash,
      notaryAddress,
      signerAddress,
      notarizationTimestamp,
      documentType,
      witnessCount,
      isVerified,
      ipfsHash,
    ] = decodeAbiParameters(
      parseAbiParameters(
        "string documentHash, address notaryAddress, address signerAddress, uint256 notarizationTimestamp, string documentType, uint256 witnessCount, bool isVerified, string ipfsHash",
      ),
      encodedData,
    );

    return {
      documentHash: documentHash as string,
      notaryAddress: notaryAddress as Address,
      signerAddress: signerAddress as Address,
      notarizationTimestamp: notarizationTimestamp as bigint,
      documentType: documentType as string,
      witnessCount: witnessCount as bigint,
      isVerified: isVerified as boolean,
      ipfsHash: ipfsHash as string,
    };
  },

  /**
   * Validates that a document hash follows the expected format.
   * @param documentHash - The document hash to validate
   * @returns Whether the hash is valid
   */
  validateDocumentHash(documentHash: string): boolean {
    return /^0x[a-fA-F0-9]{64}$/.test(documentHash);
  },

  /**
   * Validates that witness count is within reasonable bounds.
   * @param witnessCount - The number of witnesses
   * @returns Whether the witness count is valid
   */
  validateWitnessCount(witnessCount: bigint): boolean {
    return witnessCount >= BigInt(0) && witnessCount <= BigInt(10);
  },

  /**
   * Gets the supported document types for notarization.
   * @returns Array of supported document types
   */
  getDocumentTypes(): readonly string[] {
    return [
      "purchase_agreement",
      "last_will_testament",
      "power_of_attorney",
      "real_estate_deed",
      "business_contract",
      "loan_agreement",
      "affidavit",
      "other",
    ] as const;
  },

  /**
   * Validates that the IPFS hash follows the expected format.
   * @param ipfsHash - The IPFS hash to validate
   * @returns Whether the IPFS hash is valid
   */
  validateIpfsHash(ipfsHash: string): boolean {
    return /^Qm[1-9A-HJ-NP-Za-km-z]{44}$/.test(ipfsHash);
  },
};

if (typeof require !== "undefined" && require.main === module) {
  runEASWorkflow().catch(console.error);
}

export { runEASWorkflow, type UserReputationSchema };

import { createEASClient } from "@settlemint/sdk-eas";

const easClient = createEASClient({
  instance: "https://your-portal-instance.settlemint.com",
  accessToken: "your-access-token"
});

// Use the client
const deployment = await easClient.deploy("0x1234...deployer-address");

import { createEASClient } from "@settlemint/sdk-eas";

const easClient = createEASClient({
  instance: "https://your-portal-instance.settlemint.com",
  accessToken: "your-access-token"
});

// Deploy EAS contracts
const deployment = await easClient.deploy("0x1234...deployer-address");
console.log("EAS deployed at:", deployment.easAddress);

import { createEASClient } from "@settlemint/sdk-eas";

const easClient = createEASClient({
  instance: "https://your-portal-instance.settlemint.com",
  accessToken: "your-access-token"
});

const attestationResult = await easClient.attest(
  {
    schema: "0x1234567890123456789012345678901234567890123456789012345678901234",
    data: {
      recipient: "0x1234567890123456789012345678901234567890",
      expirationTime: BigInt(0), // No expiration
      revocable: true,
      refUID: "0x0000000000000000000000000000000000000000000000000000000000000000",
      data: "0x1234", // ABI-encoded data
      value: BigInt(0)
    }
  },
  "0x1234567890123456789012345678901234567890" // from address
);

console.log("Attestation created:", attestationResult.hash);

import { createEASClient } from "@settlemint/sdk-eas";

const easClient = createEASClient({
  instance: "https://your-portal-instance.settlemint.com",
  accessToken: "your-access-token"
});

const deployment = await easClient.deploy(
  "0x1234567890123456789012345678901234567890", // deployer address
  "0x0000000000000000000000000000000000000000", // forwarder (optional)
  "0x7a1200" // gas limit (optional)
);

console.log("Schema Registry:", deployment.schemaRegistryAddress);
console.log("EAS Contract:", deployment.easAddress);

import { createEASClient } from "@settlemint/sdk-eas";

const easClient = createEASClient({
  instance: "https://your-portal-instance.settlemint.com",
  accessToken: "your-access-token"
});

const multiAttestResult = await easClient.multiAttest(
  [
    {
      schema: "0x1234567890123456789012345678901234567890123456789012345678901234",
      data: {
        recipient: "0x1234567890123456789012345678901234567890",
        expirationTime: BigInt(0),
        revocable: true,
        refUID: "0x0000000000000000000000000000000000000000000000000000000000000000",
        data: "0x1234",
        value: BigInt(0)
      }
    },
    {
      schema: "0x5678901234567890123456789012345678901234567890123456789012345678",
      data: {
        recipient: "0x5678901234567890123456789012345678901234",
        expirationTime: BigInt(0),
        revocable: false,
        refUID: "0x0000000000000000000000000000000000000000000000000000000000000000",
        data: "0x5678",
        value: BigInt(0)
      }
    }
  ],
  "0x1234567890123456789012345678901234567890" // from address
);

console.log("Multiple attestations created:", multiAttestResult.hash);

import { createEASClient } from "@settlemint/sdk-eas";

const easClient = createEASClient({
  instance: "https://your-portal-instance.settlemint.com",
  accessToken: "your-access-token"
});

const schemaResult = await easClient.registerSchema(
  {
    schema: "uint256 eventId, uint8 voteIndex",
    resolver: "0x0000000000000000000000000000000000000000",
    revocable: true
  },
  "0x1234567890123456789012345678901234567890" // from address
);

console.log("Schema registered:", schemaResult.hash);

import { createEASClient } from "@settlemint/sdk-eas";

const easClient = createEASClient({
  instance: "https://your-portal-instance.settlemint.com",
  accessToken: "your-access-token"
});

const revokeResult = await easClient.revoke(
  "0x1234567890123456789012345678901234567890123456789012345678901234", // schema UID
  "0x5678901234567890123456789012345678901234567890123456789012345678", // attestation UID
  "0x1234567890123456789012345678901234567890", // from address
  BigInt(0) // value (optional)
);

console.log("Attestation revoked:", revokeResult.hash);