@oma3/omatrust 0.1.0-alpha.5 → 0.1.0-alpha.6

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 export { i as identity } from './index-QZDExA4I.cjs';
-export { i as reputation } from './index-ByNU5VpJ.cjs';
+export { i as reputation } from './index-BsUwj4r5.cjs';
 export { i as appRegistry } from './index-_Bkhoj8k.cjs';
-import './eip712-Dx9kvqtn.cjs';
+import './eip712-CevLiOcD.cjs';
 
 declare class OmaTrustError extends Error {
     code: string;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { i as identity } from './index-QZDExA4I.js';
-export { i as reputation } from './index-BUWbuvqZ.js';
+export { i as reputation } from './index-pYFRyitI.js';
 export { i as appRegistry } from './index-_Bkhoj8k.js';
-import './eip712-Dx9kvqtn.js';
+import './eip712-CevLiOcD.js';
 
 declare class OmaTrustError extends Error {
     code: string;

package/dist/index.js

@@ -1,4 +1,4 @@
-import { keccak256, toUtf8Bytes, isAddress, getAddress, sha256, ZeroAddress, Signature, Contract, formatUnits, verifyTypedData, hexlify, randomBytes, id } from 'ethers';
+import { keccak256, toUtf8Bytes, isAddress, getAddress, sha256, ZeroAddress, Signature, formatUnits, verifyTypedData, hexlify, randomBytes, id, Contract } from 'ethers';
 import canonicalize from 'canonicalize';
 import { SchemaEncoder, EAS } from '@ethereum-attestation-service/eas-sdk';
 import { resolveTxt } from 'dns/promises';
@@ -379,6 +379,7 @@ __export(reputation_exports, {
   formatSchemaUid: () => formatSchemaUid,
   formatTransferAmount: () => formatTransferAmount,
   getAttestation: () => getAttestation,
+  getAttestationsByAttester: () => getAttestationsByAttester,
   getAttestationsForDid: () => getAttestationsForDid,
   getChainConstants: () => getChainConstants,
   getExplorerAddressUrl: () => getExplorerAddressUrl,
@@ -394,10 +395,12 @@ __export(reputation_exports, {
   normalizeSchema: () => normalizeSchema,
   parseDnsTxtRecord: () => parseDnsTxtRecord,
   prepareDelegatedAttestation: () => prepareDelegatedAttestation,
+  revokeAttestation: () => revokeAttestation,
   schemaToString: () => schemaToString,
   splitSignature: () => splitSignature,
   submitAttestation: () => submitAttestation,
   submitDelegatedAttestation: () => submitDelegatedAttestation,
+  validateAttestationData: () => validateAttestationData,
   verifyAttestation: () => verifyAttestation,
   verifyDidDocumentControllerDid: () => verifyDidDocumentControllerDid,
   verifyDnsTxtControllerDid: () => verifyDnsTxtControllerDid,
@@ -439,6 +442,13 @@ function encodeAttestationData(schema, data) {
   if (!data || typeof data !== "object") {
     throw new OmaTrustError("INVALID_INPUT", "data must be an object");
   }
+  const validationErrors = validateAttestationData(schema, data);
+  if (validationErrors.length > 0) {
+    const summary = validationErrors.map((error) => `Field "${error.schemaFieldName}" (${error.expectedType}) got ${error.providedType}`).join("; ");
+    throw new OmaTrustError("INVALID_INPUT", `Attestation data validation failed: ${summary}`, {
+      errors: validationErrors
+    });
+  }
   const fields = normalizeSchema(schema);
   const schemaString = schemaToString(fields);
   const encoder = new SchemaEncoder(schemaString);
@@ -451,6 +461,99 @@ function encodeAttestationData(schema, data) {
   );
   return encoded;
 }
+function getActualType(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (value === void 0) {
+    return "undefined";
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? "number" : "non-finite-number";
+  }
+  return typeof value;
+}
+function isNumericValue(value, allowNegative) {
+  if (typeof value === "bigint") {
+    return allowNegative || value >= 0n;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || !Number.isInteger(value)) {
+      return false;
+    }
+    return allowNegative || value >= 0;
+  }
+  if (typeof value === "string") {
+    if (value.length === 0) {
+      return false;
+    }
+    const pattern = allowNegative ? /^-?\d+$/ : /^\d+$/;
+    return pattern.test(value);
+  }
+  return false;
+}
+function isHex(value) {
+  return typeof value === "string" && /^0x[0-9a-fA-F]*$/.test(value);
+}
+function validateFieldValue(type, value) {
+  const normalizedType = type.trim().toLowerCase();
+  const bytesNMatch = normalizedType.match(/^bytes([1-9]|[12]\d|3[0-2])$/);
+  if (/^uint\d*$/.test(normalizedType)) {
+    return isNumericValue(value, false);
+  }
+  if (/^int\d*$/.test(normalizedType)) {
+    return isNumericValue(value, true);
+  }
+  if (normalizedType === "string") {
+    return typeof value === "string";
+  }
+  if (normalizedType === "string[]") {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+  }
+  if (normalizedType === "bool") {
+    return typeof value === "boolean";
+  }
+  if (normalizedType === "address") {
+    return typeof value === "string" && isAddress(value);
+  }
+  if (normalizedType === "bytes") {
+    return isHex(value) && (value.length - 2) % 2 === 0;
+  }
+  if (bytesNMatch) {
+    const expectedBytes = Number(bytesNMatch[1]);
+    return isHex(value) && value.length === 2 + expectedBytes * 2;
+  }
+  return true;
+}
+function validateAttestationData(schema, data) {
+  if (!data || typeof data !== "object") {
+    return [{
+      schemaFieldName: "data",
+      expectedType: "object",
+      providedType: getActualType(data),
+      providedValue: data
+    }];
+  }
+  const fields = normalizeSchema(schema);
+  const errors = [];
+  for (const field of fields) {
+    const value = data[field.name];
+    const isValid = validateFieldValue(field.type, value);
+    if (isValid) {
+      continue;
+    }
+    errors.push({
+      schemaFieldName: field.name,
+      expectedType: field.type,
+      providedType: getActualType(value),
+      providedValue: value
+    });
+  }
+  return errors;
+}
 function decodeAttestationData(schema, encodedData) {
   if (typeof encodedData !== "string" || !encodedData.startsWith("0x")) {
     throw new OmaTrustError("INVALID_INPUT", "encodedData must be a hex string");
@@ -471,22 +574,11 @@ function decodeAttestationData(schema, encodedData) {
   return result;
 }
 function extractExpirationTime(data) {
-  const keys = ["expirationTime", "expiration", "validUntil", "expiresAt", "expires"];
-  for (const key of keys) {
-    const value = data[key];
-    if (value === void 0 || value === null) {
-      continue;
-    }
-    if (typeof value === "bigint") {
-      return value;
-    }
-    if (typeof value === "number") {
-      return value;
-    }
-    if (typeof value === "string" && /^\d+$/.test(value)) {
-      return BigInt(value);
-    }
-  }
+  const value = data["expiresAt"];
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number") return value;
+  if (typeof value === "string" && /^\d+$/.test(value)) return BigInt(value);
   return void 0;
 }
 var ZERO_UID = "0x0000000000000000000000000000000000000000000000000000000000000000";
@@ -615,6 +707,34 @@ async function submitAttestation(params) {
     throw new OmaTrustError("NETWORK_ERROR", "Failed to submit attestation", { err });
   }
 }
+async function revokeAttestation(params) {
+  if (!params || typeof params !== "object") {
+    throw new OmaTrustError("INVALID_INPUT", "params must be provided");
+  }
+  if (!params.signer) {
+    throw new OmaTrustError("INVALID_INPUT", "signer is required");
+  }
+  const eas = new EAS(params.easContractAddress);
+  eas.connect(params.signer);
+  try {
+    const tx = await eas.revoke({
+      schema: params.schemaUid,
+      data: {
+        uid: params.uid,
+        value: toBigIntOrDefault(params.value, 0n)
+      }
+    });
+    await tx.wait();
+    const txHash = getEasTransactionHash(tx) ?? ZERO_UID;
+    const receipt = getEasTransactionReceipt(tx);
+    return {
+      txHash,
+      receipt
+    };
+  } catch (err) {
+    throw new OmaTrustError("NETWORK_ERROR", "Failed to revoke attestation", { err });
+  }
+}
 function buildDelegatedTypedData(params) {
   return {
     domain: {
@@ -815,21 +935,18 @@ async function getAttestation(params) {
     throw new OmaTrustError("NETWORK_ERROR", "Failed to read attestation", { err });
   }
 }
-async function getAttestationsForDid(params) {
-  const provider = params.provider;
-  const contract = new Contract(params.easContractAddress, EAS_EVENT_ABI, provider);
-  const toBlock = params.toBlock ?? await provider.getBlockNumber();
-  const fromBlock = params.fromBlock ?? Math.max(0, toBlock - 5e4);
-  const filter = contract.filters.Attested(didToAddress(params.did));
+async function queryAttestationEvents(easContractAddress, provider, fromBlock, toBlock, options) {
+  const contract = new Contract(easContractAddress, EAS_EVENT_ABI, provider);
+  const filter = contract.filters.Attested(options?.recipient ?? null, options?.attester ?? null);
   let events;
   try {
     events = await contract.queryFilter(filter, fromBlock, toBlock);
   } catch (err) {
     throw new OmaTrustError("NETWORK_ERROR", "Failed to query attestation events", { err });
   }
-  const eas = new EAS(params.easContractAddress);
+  const eas = new EAS(easContractAddress);
   eas.connect(provider);
-  const schemaFilter = params.schemas?.map((schema) => schema.toLowerCase());
+  const schemaFilter = options?.schemas?.map((s) => s.toLowerCase());
   const results = [];
   for (const event of events) {
     if (!("args" in event && Array.isArray(event.args))) {
@@ -853,6 +970,34 @@ async function getAttestationsForDid(params) {
   results.sort((a, b) => Number(b.time - a.time));
   return results;
 }
+async function getAttestationsForDid(params) {
+  const provider = params.provider;
+  const toBlock = params.toBlock ?? await provider.getBlockNumber();
+  const fromBlock = params.fromBlock ?? Math.max(0, toBlock - 5e4);
+  return queryAttestationEvents(
+    params.easContractAddress,
+    provider,
+    fromBlock,
+    toBlock,
+    { recipient: didToAddress(params.did), schemas: params.schemas }
+  );
+}
+async function getAttestationsByAttester(params) {
+  const provider = params.provider;
+  const toBlock = params.toBlock ?? await provider.getBlockNumber();
+  const fromBlock = params.fromBlock ?? Math.max(0, toBlock - 5e4);
+  if (params.limit !== void 0 && params.limit <= 0) {
+    return [];
+  }
+  const results = await queryAttestationEvents(
+    params.easContractAddress,
+    provider,
+    fromBlock,
+    toBlock,
+    { attester: params.attester, schemas: params.schemas }
+  );
+  return params.limit !== void 0 ? results.slice(0, params.limit) : results;
+}
 async function listAttestations(params) {
   const limit = params.limit ?? 20;
   if (limit <= 0) {
@@ -863,34 +1008,15 @@ async function listAttestations(params) {
 }
 async function getLatestAttestations(params) {
   const provider = params.provider;
-  const contract = new Contract(params.easContractAddress, EAS_EVENT_ABI, provider);
-  const currentBlock = await provider.getBlockNumber();
-  const fromBlock = params.fromBlock ?? Math.max(0, currentBlock - 5e4);
-  const events = await contract.queryFilter(contract.filters.Attested(), fromBlock, currentBlock);
-  const eas = new EAS(params.easContractAddress);
-  eas.connect(provider);
-  const schemaFilter = params.schemas?.map((schema) => schema.toLowerCase());
-  const results = [];
-  for (const event of events) {
-    if (!("args" in event && Array.isArray(event.args))) {
-      continue;
-    }
-    const args = event.args;
-    const uid = args?.[2];
-    const schemaUid = args?.[3];
-    if (!uid || !schemaUid) {
-      continue;
-    }
-    if (schemaFilter && !schemaFilter.includes(schemaUid.toLowerCase())) {
-      continue;
-    }
-    const attestation = await eas.getAttestation(uid);
-    if (!attestation || !attestation.uid) {
-      continue;
-    }
-    results.push(parseAttestation(attestation, void 0, parseEventTxHash(event)));
-  }
-  results.sort((a, b) => Number(b.time - a.time));
+  const toBlock = await provider.getBlockNumber();
+  const fromBlock = params.fromBlock ?? Math.max(0, toBlock - 5e4);
+  const results = await queryAttestationEvents(
+    params.easContractAddress,
+    provider,
+    fromBlock,
+    toBlock,
+    { schemas: params.schemas }
+  );
   return results.slice(0, params.limit ?? 20);
 }
 function deduplicateReviews(attestations) {