@pafi-dev/issuer 0.1.2 → 0.2.0

package/dist/index.js

@@ -11,19 +11,21 @@ var MemoryPointLedger = class {
   // -------------------------------------------------------------------------
   // Read
   // -------------------------------------------------------------------------
-  async getBalance(userAddress) {
-    const key = getAddress(userAddress);
+  async getBalance(userAddress, tokenAddress) {
+    const user = getAddress(userAddress);
+    const token = normalizeToken(tokenAddress);
     this.purgeExpired();
-    const total = this.balances.get(key) ?? 0n;
-    const locked = this.lockedTotalFor(key);
+    const total = this.balances.get(balanceKey(user, token)) ?? 0n;
+    const locked = this.lockedTotalFor(user, token);
     return total - locked;
   }
-  async getLockedRequests(userAddress) {
-    const key = getAddress(userAddress);
+  async getLockedRequests(userAddress, tokenAddress) {
+    const user = getAddress(userAddress);
+    const token = normalizeToken(tokenAddress);
     this.purgeExpired();
     const out = [];
     for (const lock of this.locks.values()) {
-      if (lock.userAddress === key && lock.status === "PENDING") {
+      if (lock.userAddress === user && lock.status === "PENDING" && (lock.tokenAddress ?? DEFAULT_TOKEN_KEY) === token) {
         out.push({ ...lock });
       }
     }
@@ -32,25 +34,28 @@ var MemoryPointLedger = class {
   // -------------------------------------------------------------------------
   // Write
   // -------------------------------------------------------------------------
-  async creditBalance(userAddress, amount, _reason) {
+  async creditBalance(userAddress, amount, _reason, tokenAddress) {
     if (amount <= 0n) {
       throw new Error("MemoryPointLedger: credit amount must be positive");
     }
-    const key = getAddress(userAddress);
+    const user = getAddress(userAddress);
+    const token = normalizeToken(tokenAddress);
+    const key = balanceKey(user, token);
     const current = this.balances.get(key) ?? 0n;
     this.balances.set(key, current + amount);
   }
-  async lockForMinting(userAddress, amount, lockDurationMs) {
+  async lockForMinting(userAddress, amount, lockDurationMs, tokenAddress) {
     if (amount <= 0n) {
       throw new Error("MemoryPointLedger: lock amount must be positive");
     }
     if (lockDurationMs <= 0) {
       throw new Error("MemoryPointLedger: lockDurationMs must be positive");
     }
-    const key = getAddress(userAddress);
+    const user = getAddress(userAddress);
+    const token = normalizeToken(tokenAddress);
     this.purgeExpired();
-    const total = this.balances.get(key) ?? 0n;
-    const alreadyLocked = this.lockedTotalFor(key);
+    const total = this.balances.get(balanceKey(user, token)) ?? 0n;
+    const alreadyLocked = this.lockedTotalFor(user, token);
     const available = total - alreadyLocked;
     if (available < amount) {
       throw new Error(
@@ -59,14 +64,18 @@ var MemoryPointLedger = class {
     }
     const lockId = `lock-${this.nextLockId++}`;
     const now = this.now();
-    this.locks.set(lockId, {
+    const lock = {
       lockId,
-      userAddress: key,
+      userAddress: user,
       amount,
       status: "PENDING",
       createdAt: now,
       expiresAt: now + lockDurationMs
-    });
+    };
+    if (tokenAddress !== void 0) {
+      lock.tokenAddress = getAddress(tokenAddress);
+    }
+    this.locks.set(lockId, lock);
     return lockId;
   }
   async releaseLock(lockId) {
@@ -76,11 +85,13 @@ var MemoryPointLedger = class {
       this.locks.delete(lockId);
     }
   }
-  async deductBalance(userAddress, amount, txHash) {
+  async deductBalance(userAddress, amount, txHash, tokenAddress) {
     if (amount <= 0n) {
       throw new Error("MemoryPointLedger: deduct amount must be positive");
     }
-    const key = getAddress(userAddress);
+    const user = getAddress(userAddress);
+    const token = normalizeToken(tokenAddress);
+    const key = balanceKey(user, token);
     const current = this.balances.get(key) ?? 0n;
     if (current < amount) {
       throw new Error(
@@ -89,7 +100,7 @@ var MemoryPointLedger = class {
     }
     this.balances.set(key, current - amount);
     for (const lock of this.locks.values()) {
-      if (lock.userAddress === key && lock.status === "PENDING" && lock.amount === amount) {
+      if (lock.userAddress === user && lock.status === "PENDING" && lock.amount === amount && (lock.tokenAddress ?? DEFAULT_TOKEN_KEY) === token) {
         lock.status = "MINTED";
         lock.txHash = txHash;
         return;
@@ -119,16 +130,23 @@ var MemoryPointLedger = class {
       }
     }
   }
-  lockedTotalFor(userAddress) {
+  lockedTotalFor(userAddress, tokenKey) {
     let total = 0n;
     for (const lock of this.locks.values()) {
-      if (lock.userAddress === userAddress && lock.status === "PENDING") {
+      if (lock.userAddress === userAddress && lock.status === "PENDING" && (lock.tokenAddress ?? DEFAULT_TOKEN_KEY) === tokenKey) {
         total += lock.amount;
       }
     }
     return total;
   }
 };
+var DEFAULT_TOKEN_KEY = "default";
+function normalizeToken(tokenAddress) {
+  return tokenAddress === void 0 ? DEFAULT_TOKEN_KEY : getAddress(tokenAddress);
+}
+function balanceKey(user, tokenKey) {
+  return `${user}|${tokenKey}`;
+}
 
 // src/policy/defaultPolicy.ts
 var DefaultPolicyEngine = class {
@@ -150,7 +168,10 @@ var DefaultPolicyEngine = class {
     if (request.amount <= 0n) {
       return { approved: false, reason: "Amount must be positive" };
     }
-    const available = await this.ledger.getBalance(request.userAddress);
+    const available = await this.ledger.getBalance(
+      request.userAddress,
+      request.pointTokenAddress
+    );
     if (available < request.amount) {
       return {
         approved: false,
@@ -838,7 +859,8 @@ var MintingGateway = class {
       lockId = await this.ledger.lockForMinting(
         request.userAddress,
         receiverConsent.amount,
-        lockDurationMs
+        lockDurationMs,
+        request.pointTokenAddress
       );
     } catch (err) {
       throw new MintingGatewayError(
@@ -1128,11 +1150,19 @@ var PointIndexer = class {
    * issuer to mint without going through the gateway.
    */
   async finalize(evt) {
-    const locks = await this.ledger.getLockedRequests(evt.to);
+    const locks = await this.ledger.getLockedRequests(
+      evt.to,
+      this.pointTokenAddress
+    );
     const match = pickMatchingLock(locks, evt.amount);
     if (!match) return;
     try {
-      await this.ledger.deductBalance(evt.to, evt.amount, evt.txHash);
+      await this.ledger.deductBalance(
+        evt.to,
+        evt.amount,
+        evt.txHash,
+        this.pointTokenAddress
+      );
     } catch {
       return;
     }
@@ -1169,7 +1199,15 @@ var IssuerApiHandlers = class {
   gateway;
   ledger;
   provider;
-  pointTokenAddress;
+  /**
+   * Set of supported PointToken addresses (checksum-normalized). Handlers
+   * validate the request's `pointTokenAddress` against this set.
+   */
+  supportedTokens;
+  /** First supported token — used as default when a handler doesn't
+   * receive a `pointTokenAddress` in the request (shouldn't happen in
+   * practice, but keeps type-narrowing happy). */
+  defaultToken;
   chainId;
   contracts;
   feeManager;
@@ -1179,7 +1217,15 @@ var IssuerApiHandlers = class {
     this.gateway = config.gateway;
     this.ledger = config.ledger;
     this.provider = config.provider;
-    this.pointTokenAddress = config.pointTokenAddress;
+    const raw = config.pointTokenAddresses && config.pointTokenAddresses.length > 0 ? config.pointTokenAddresses : config.pointTokenAddress ? [config.pointTokenAddress] : [];
+    if (raw.length === 0) {
+      throw new Error(
+        "IssuerApiHandlers: pointTokenAddress or pointTokenAddresses required"
+      );
+    }
+    const normalized = raw.map((a) => getAddress5(a));
+    this.supportedTokens = new Set(normalized);
+    this.defaultToken = normalized[0];
     this.chainId = config.chainId;
     this.contracts = config.contracts;
     if (config.feeManager) this.feeManager = config.feeManager;
@@ -1276,7 +1322,7 @@ var IssuerApiHandlers = class {
       );
     }
     const pointToken = getAddress5(request.pointTokenAddress);
-    if (pointToken !== this.pointTokenAddress) {
+    if (!this.supportedTokens.has(pointToken)) {
       throw new Error(
         `handleUser: unsupported pointToken ${pointToken}`
       );
@@ -1284,7 +1330,7 @@ var IssuerApiHandlers = class {
     const [mintRequestNonce, receiverConsentNonce, offChainBalance, onChainBalance, minter] = await Promise.all([
       getMintRequestNonce(this.provider, pointToken, normalizedAuthed),
       getReceiverConsentNonce(this.provider, pointToken, normalizedAuthed),
-      this.ledger.getBalance(normalizedAuthed),
+      this.ledger.getBalance(normalizedAuthed, pointToken),
       getPointTokenBalance(this.provider, pointToken, normalizedAuthed),
       isMinter(this.provider, pointToken, normalizedAuthed)
     ]);
@@ -1319,7 +1365,7 @@ var IssuerApiHandlers = class {
       );
     }
     const pointToken = getAddress5(request.pointTokenAddress);
-    if (pointToken !== this.pointTokenAddress) {
+    if (!this.supportedTokens.has(pointToken)) {
       throw new Error(
         `handleBuildConsentTypedData: unsupported pointToken ${pointToken}`
       );
@@ -1353,7 +1399,7 @@ var IssuerApiHandlers = class {
       );
     }
     const pointToken = getAddress5(request.pointTokenAddress);
-    if (pointToken !== this.pointTokenAddress) {
+    if (!this.supportedTokens.has(pointToken)) {
       throw new Error(
         `handleClaimAndSwap: unsupported pointToken ${pointToken}`
       );
@@ -1591,6 +1637,7 @@ function toUsdtPerNative(priceFloat, usdtDecimals) {
 }
 
 // src/config.ts
+import { getAddress as getAddress6 } from "viem";
 function createIssuerService(config) {
   if (!config.provider) {
     throw new Error("createIssuerService: provider is required");
@@ -1601,9 +1648,6 @@ function createIssuerService(config) {
   if (!config.signer) {
     throw new Error("createIssuerService: signer is required");
   }
-  if (!config.pointTokenAddress) {
-    throw new Error("createIssuerService: pointTokenAddress is required");
-  }
   if (!config.relayAddress) {
     throw new Error("createIssuerService: relayAddress is required");
   }
@@ -1613,6 +1657,13 @@ function createIssuerService(config) {
   if (!config.auth?.domain) {
     throw new Error("createIssuerService: auth.domain is required");
   }
+  const rawAddresses = config.pointTokenAddresses && config.pointTokenAddresses.length > 0 ? config.pointTokenAddresses : config.pointTokenAddress ? [config.pointTokenAddress] : [];
+  if (rawAddresses.length === 0) {
+    throw new Error(
+      "createIssuerService: at least one of pointTokenAddress / pointTokenAddresses is required"
+    );
+  }
+  const tokenAddresses = rawAddresses.map((a) => getAddress6(a));
   const ledger = config.ledger ?? new MemoryPointLedger();
   const sessionStore = config.sessionStore ?? new MemorySessionStore();
   const policy = config.policy ?? new DefaultPolicyEngine({ ledger });
@@ -1656,33 +1707,37 @@ function createIssuerService(config) {
     gatewayConfig.defaultLockBufferMs = config.gateway.defaultLockBufferMs;
   }
   const gateway = new MintingGateway(gatewayConfig);
-  const indexerConfig = {
-    provider: config.provider,
-    pointTokenAddress: config.pointTokenAddress,
-    ledger
-  };
-  if (config.indexer?.fromBlock !== void 0) {
-    indexerConfig.fromBlock = config.indexer.fromBlock;
-  }
-  if (config.indexer?.cursorStore) {
-    indexerConfig.cursorStore = config.indexer.cursorStore;
-  }
-  if (config.indexer?.confirmations !== void 0) {
-    indexerConfig.confirmations = config.indexer.confirmations;
-  }
-  if (config.indexer?.batchSize !== void 0) {
-    indexerConfig.batchSize = config.indexer.batchSize;
-  }
-  if (config.indexer?.pollIntervalMs !== void 0) {
-    indexerConfig.pollIntervalMs = config.indexer.pollIntervalMs;
+  const indexers = /* @__PURE__ */ new Map();
+  for (const tokenAddress of tokenAddresses) {
+    const indexerConfig = {
+      provider: config.provider,
+      pointTokenAddress: tokenAddress,
+      ledger
+    };
+    if (config.indexer?.fromBlock !== void 0) {
+      indexerConfig.fromBlock = config.indexer.fromBlock;
+    }
+    if (config.indexer?.cursorStore) {
+      indexerConfig.cursorStore = config.indexer.cursorStore;
+    }
+    if (config.indexer?.confirmations !== void 0) {
+      indexerConfig.confirmations = config.indexer.confirmations;
+    }
+    if (config.indexer?.batchSize !== void 0) {
+      indexerConfig.batchSize = config.indexer.batchSize;
+    }
+    if (config.indexer?.pollIntervalMs !== void 0) {
+      indexerConfig.pollIntervalMs = config.indexer.pollIntervalMs;
+    }
+    indexers.set(tokenAddress, new PointIndexer(indexerConfig));
   }
-  const indexer = new PointIndexer(indexerConfig);
+  const firstIndexer = indexers.get(tokenAddresses[0]);
   const handlersConfig = {
     authService,
     gateway,
     ledger,
     provider: config.provider,
-    pointTokenAddress: config.pointTokenAddress,
+    pointTokenAddresses: tokenAddresses,
     chainId: config.chainId,
     contracts: config.contracts
   };
@@ -1690,7 +1745,9 @@ function createIssuerService(config) {
   if (config.poolsProvider) handlersConfig.poolsProvider = config.poolsProvider;
   const handlers = new IssuerApiHandlers(handlersConfig);
   if (config.indexer?.autoStart) {
-    indexer.start();
+    for (const idx of indexers.values()) {
+      idx.start();
+    }
   }
   return {
     authService,
@@ -1701,7 +1758,8 @@ function createIssuerService(config) {
     relayService,
     feeManager,
     gateway,
-    indexer,
+    indexers,
+    indexer: firstIndexer,
     handlers
   };
 }