@pafi-dev/issuer 0.5.8 → 0.5.10

package/dist/index.cjs

@@ -28,6 +28,8 @@ __export(index_exports, {
   FeeManager: () => FeeManager,
   InMemoryCursorStore: () => InMemoryCursorStore,
   IssuerApiHandlers: () => IssuerApiHandlers,
+  IssuerStateError: () => IssuerStateError,
+  IssuerStateValidator: () => IssuerStateValidator,
   MemorySessionStore: () => MemorySessionStore,
   NonceManager: () => NonceManager,
   PAFI_ISSUER_SDK_VERSION: () => PAFI_ISSUER_SDK_VERSION,
@@ -2093,6 +2095,176 @@ function createIssuerService(config) {
   };
 }
 
+// src/issuer-state/validator.ts
+var import_viem11 = require("viem");
+var import_core9 = require("@pafi-dev/core");
+
+// src/issuer-state/types.ts
+var IssuerStateError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "IssuerStateError";
+  }
+  code;
+  details;
+};
+
+// src/issuer-state/validator.ts
+var ISSUER_RECORD_TTL_MS = 3e4;
+var IssuerStateValidator = class _IssuerStateValidator {
+  constructor(provider, registryAddress) {
+    this.provider = provider;
+    this.registryAddress = registryAddress;
+  }
+  provider;
+  registryAddress;
+  pointTokenIssuerCache = /* @__PURE__ */ new Map();
+  stateCache = /* @__PURE__ */ new Map();
+  inflight = /* @__PURE__ */ new Map();
+  /**
+   * Convenience factory — reads `registryAddress` from the SDK
+   * `CONTRACT_ADDRESSES` map for the given chain.
+   */
+  static forChain(provider, chainId) {
+    const { issuerRegistry } = (0, import_core9.getContractAddresses)(chainId);
+    return new _IssuerStateValidator(provider, issuerRegistry);
+  }
+  /**
+   * Invalidate cached state for one PointToken, or everything if omitted.
+   * Call after admin txs that change registry or cap settings.
+   */
+  invalidate(pointToken) {
+    if (pointToken) {
+      const key = (0, import_viem11.getAddress)(pointToken);
+      this.pointTokenIssuerCache.delete(key);
+      this.stateCache.delete(key);
+      this.inflight.delete(key);
+    } else {
+      this.pointTokenIssuerCache.clear();
+      this.stateCache.clear();
+      this.inflight.clear();
+    }
+  }
+  /**
+   * Resolve `PointToken.issuer()` once per token and memoize.
+   * The issuer field is set at `initialize()` and never changes.
+   */
+  async getIssuerAddressForPointToken(pointToken) {
+    const key = (0, import_viem11.getAddress)(pointToken);
+    const cached = this.pointTokenIssuerCache.get(key);
+    if (cached) return cached;
+    const issuer = await this.provider.readContract({
+      address: key,
+      abi: import_core9.POINT_TOKEN_V2_ABI,
+      functionName: "issuer"
+    });
+    this.pointTokenIssuerCache.set(key, (0, import_viem11.getAddress)(issuer));
+    return (0, import_viem11.getAddress)(issuer);
+  }
+  /**
+   * Read registry record + totalSupply, with 30s cache and in-flight
+   * deduplication. Does NOT throw on inactive/missing — returns raw state.
+   */
+  async getIssuerState(pointToken) {
+    const tokenAddr = (0, import_viem11.getAddress)(pointToken);
+    const now = Date.now();
+    const cached = this.stateCache.get(tokenAddr);
+    if (cached && cached.expiresAt > now) return cached.value;
+    const existing = this.inflight.get(tokenAddr);
+    if (existing) return existing;
+    const promise = this.fetchIssuerState(tokenAddr).then((state) => {
+      this.stateCache.set(tokenAddr, {
+        value: state,
+        expiresAt: Date.now() + ISSUER_RECORD_TTL_MS
+      });
+      return state;
+    }).finally(() => {
+      this.inflight.delete(tokenAddr);
+    });
+    this.inflight.set(tokenAddr, promise);
+    return promise;
+  }
+  /**
+   * Validate that `amount` PT can be minted on `pointToken` right now.
+   *
+   * Throws `IssuerStateError` with:
+   *   - `ISSUER_NOT_REGISTERED` — registry has no record for this issuer
+   *   - `ISSUER_INACTIVE`       — issuer.active is false
+   *   - `MINT_CAP_EXCEEDED`     — totalSupply + amount would exceed hardCap
+   *
+   * Returns the fetched state on success so callers can log without a
+   * second RPC round-trip.
+   */
+  async preValidateMint(pointToken, amount) {
+    let state;
+    try {
+      state = await this.getIssuerState(pointToken);
+    } catch (err) {
+      if (err.message.includes("IssuerNotFound")) {
+        throw new IssuerStateError(
+          "ISSUER_NOT_REGISTERED",
+          `IssuerRegistry has no record for PointToken ${pointToken}`,
+          { pointToken }
+        );
+      }
+      throw err;
+    }
+    const { issuer, totalSupply, hardCap, remaining } = state;
+    if (!issuer.active) {
+      throw new IssuerStateError(
+        "ISSUER_INACTIVE",
+        `Issuer ${issuer.issuerAddress} is deactivated on IssuerRegistry`,
+        { issuer: issuer.issuerAddress, pointToken: issuer.pointToken }
+      );
+    }
+    if (totalSupply + amount > hardCap) {
+      throw new IssuerStateError(
+        "MINT_CAP_EXCEEDED",
+        `Requested ${amount} PT would exceed mint cap. Cap=${hardCap}, minted=${totalSupply}, remaining=${remaining}`,
+        {
+          requested: amount.toString(),
+          cap: hardCap.toString(),
+          minted: totalSupply.toString(),
+          remaining: remaining.toString()
+        }
+      );
+    }
+    return state;
+  }
+  async fetchIssuerState(tokenAddr) {
+    const issuerAddr = await this.getIssuerAddressForPointToken(tokenAddr);
+    const [tuple, totalSupply] = await Promise.all([
+      this.provider.readContract({
+        address: this.registryAddress,
+        abi: import_core9.issuerRegistryAbi,
+        functionName: "getIssuer",
+        args: [issuerAddr]
+      }),
+      this.provider.readContract({
+        address: tokenAddr,
+        abi: import_core9.POINT_TOKEN_V2_ABI,
+        functionName: "totalSupply"
+      })
+    ]);
+    const issuer = {
+      issuerAddress: tuple[0],
+      signerAddress: tuple[1],
+      name: tuple[2],
+      symbol: tuple[3],
+      declaredTotalSupply: tuple[4],
+      capBasisPoints: tuple[5],
+      active: tuple[6],
+      pointToken: tuple[7],
+      mintingOracle: tuple[8]
+    };
+    const hardCap = issuer.declaredTotalSupply * BigInt(issuer.capBasisPoints) / 10000n;
+    const remaining = hardCap > totalSupply ? hardCap - totalSupply : 0n;
+    return { issuer, totalSupply, hardCap, remaining };
+  }
+};
+
 // src/index.ts
 var PAFI_ISSUER_SDK_VERSION = "0.4.0";
 // Annotate the CommonJS export names for ESM import in node:
@@ -2105,6 +2277,8 @@ var PAFI_ISSUER_SDK_VERSION = "0.4.0";
   FeeManager,
   InMemoryCursorStore,
   IssuerApiHandlers,
+  IssuerStateError,
+  IssuerStateValidator,
   MemorySessionStore,
   NonceManager,
   PAFI_ISSUER_SDK_VERSION,