@permissionless-technologies/upd-sdk 0.1.0

package/dist/chunk-R64I3LAO.js

@@ -0,0 +1,701 @@
+import { computeSystemHealth } from './chunk-63FIKV36.js';
+import { UPD_TOKEN_ABI, OVERCOLLATERALIZATION_REPORTER_ABI, STABILIZER_NFT_ABI, POSITION_ESCROW_ABI, STABILIZER_ESCROW_ABI, SUPD_ABI } from './chunk-4RBWWS2X.js';
+import { createOracleClient } from './chunk-DJBU2OEB.js';
+import { hexToBytes, bytesToHex } from 'viem';
+
+// src/deployments/31337.json
+var __default = {
+  contracts: {
+    UPDToken: "0x0000000000000000000000000000000000000000",
+    PriceOracle: "0x0000000000000000000000000000000000000000",
+    StabilizerNFT: "0x0000000000000000000000000000000000000000",
+    OvercollateralizationReporter: "0x0000000000000000000000000000000000000000",
+    InsuranceEscrow: "0x0000000000000000000000000000000000000000",
+    BridgeEscrow: "0x0000000000000000000000000000000000000000",
+    sUPD: "0x0000000000000000000000000000000000000000"
+  },
+  implementations: {
+    PriceOracle: "0x0000000000000000000000000000000000000000",
+    StabilizerNFT: "0x0000000000000000000000000000000000000000",
+    OvercollateralizationReporter: "0x0000000000000000000000000000000000000000"
+  },
+  libraries: {
+    LinkedListLib: "0x0000000000000000000000000000000000000000",
+    CollateralMathLib: "0x0000000000000000000000000000000000000000"
+  },
+  templates: {
+    StabilizerEscrow: "0x0000000000000000000000000000000000000000",
+    PositionEscrow: "0x0000000000000000000000000000000000000000"
+  },
+  external: {
+    stETH: "0x0000000000000000000000000000000000000000",
+    lido: "0x0000000000000000000000000000000000000000",
+    oracleSigner: "0x0000000000000000000000000000000000000000"
+  },
+  metadata: {
+    chainId: 31337,
+    deployBlock: 0,
+    deployTimestamp: 0,
+    deployer: "0x0000000000000000000000000000000000000000"
+  }
+};
+
+// src/deployments/11155111.json
+var __default2 = {
+  contracts: {
+    UPDToken: "0x0000000000000000000000000000000000000000",
+    PriceOracle: "0x0000000000000000000000000000000000000000",
+    StabilizerNFT: "0x0000000000000000000000000000000000000000",
+    OvercollateralizationReporter: "0x0000000000000000000000000000000000000000",
+    InsuranceEscrow: "0x0000000000000000000000000000000000000000",
+    BridgeEscrow: "0x0000000000000000000000000000000000000000",
+    sUPD: "0x0000000000000000000000000000000000000000"
+  },
+  implementations: {
+    PriceOracle: "0x0000000000000000000000000000000000000000",
+    StabilizerNFT: "0x0000000000000000000000000000000000000000",
+    OvercollateralizationReporter: "0x0000000000000000000000000000000000000000"
+  },
+  libraries: {
+    LinkedListLib: "0x0000000000000000000000000000000000000000",
+    CollateralMathLib: "0x0000000000000000000000000000000000000000"
+  },
+  templates: {
+    StabilizerEscrow: "0x0000000000000000000000000000000000000000",
+    PositionEscrow: "0x0000000000000000000000000000000000000000"
+  },
+  external: {
+    stETH: "0x0000000000000000000000000000000000000000",
+    lido: "0x0000000000000000000000000000000000000000",
+    oracleSigner: "0x0000000000000000000000000000000000000000"
+  },
+  metadata: {
+    chainId: 11155111,
+    deployBlock: 0,
+    deployTimestamp: 0,
+    deployer: "0x0000000000000000000000000000000000000000"
+  }
+};
+
+// src/deployments/index.ts
+function parseDeployment(json, chainId) {
+  return {
+    chainId,
+    contracts: {
+      UPDToken: json.contracts.UPDToken,
+      PriceOracle: json.contracts.PriceOracle,
+      StabilizerNFT: json.contracts.StabilizerNFT,
+      OvercollateralizationReporter: json.contracts.OvercollateralizationReporter,
+      InsuranceEscrow: json.contracts.InsuranceEscrow,
+      BridgeEscrow: json.contracts.BridgeEscrow,
+      sUPD: json.contracts.sUPD
+    },
+    implementations: {
+      PriceOracle: json.implementations.PriceOracle,
+      StabilizerNFT: json.implementations.StabilizerNFT,
+      OvercollateralizationReporter: json.implementations.OvercollateralizationReporter
+    },
+    libraries: {
+      LinkedListLib: json.libraries.LinkedListLib,
+      CollateralMathLib: json.libraries.CollateralMathLib
+    },
+    templates: {
+      StabilizerEscrow: json.templates.StabilizerEscrow,
+      PositionEscrow: json.templates.PositionEscrow
+    },
+    external: {
+      stETH: json.external.stETH,
+      lido: json.external.lido,
+      oracleSigner: json.external.oracleSigner
+    },
+    metadata: {
+      deployBlock: json.metadata.deployBlock,
+      deployTimestamp: json.metadata.deployTimestamp,
+      deployer: json.metadata.deployer
+    }
+  };
+}
+var deployments = {
+  31337: parseDeployment(__default, 31337),
+  11155111: parseDeployment(__default2, 11155111)
+};
+function getDeployment(chainId) {
+  return deployments[chainId] ?? null;
+}
+function getDeploymentOrThrow(chainId) {
+  const deployment = getDeployment(chainId);
+  if (!deployment) {
+    throw new Error(
+      `No UPD deployment found for chain ${chainId}. Supported chains: ${getSupportedChainIds().join(", ")}`
+    );
+  }
+  return deployment;
+}
+function hasDeployment(chainId) {
+  return chainId in deployments;
+}
+function getSupportedChainIds() {
+  return Object.keys(deployments).map(Number);
+}
+function getContractAddress(chainId, contractName) {
+  const deployment = getDeployment(chainId);
+  if (!deployment) return null;
+  return deployment.contracts[contractName] ?? null;
+}
+
+// src/core/client.ts
+var UPDClient = class {
+  config;
+  deployment;
+  oracle;
+  constructor(config) {
+    this.config = config;
+    this.deployment = getDeploymentOrThrow(config.chainId);
+    this.oracle = createOracleClient({ oracleUrl: config.oracleUrl });
+  }
+  // ============================================================
+  //                      READ OPERATIONS
+  // ============================================================
+  /** Get UPD token balance for an address. */
+  async getUPDBalance(address) {
+    return this.config.publicClient.readContract({
+      address: this.deployment.contracts.UPDToken,
+      abi: UPD_TOKEN_ABI,
+      functionName: "balanceOf",
+      args: [address]
+    });
+  }
+  /** Get total UPD supply. */
+  async getTotalSupply() {
+    return this.config.publicClient.readContract({
+      address: this.deployment.contracts.UPDToken,
+      abi: UPD_TOKEN_ABI,
+      functionName: "totalSupply"
+    });
+  }
+  /** Get system collateral info: total stETH collateral and total UPD supply. */
+  async getCollateralInfo() {
+    const [totalStEthCollateral, totalUPDSupply] = await Promise.all([
+      this.config.publicClient.readContract({
+        address: this.deployment.contracts.OvercollateralizationReporter,
+        abi: OVERCOLLATERALIZATION_REPORTER_ABI,
+        functionName: "totalStEthCollateral"
+      }),
+      this.getTotalSupply()
+    ]);
+    return { totalStEthCollateral, totalUPDSupply };
+  }
+  /** Get details for a specific stabilizer position. */
+  async getStabilizerPosition(tokenId) {
+    const stabNFT = this.deployment.contracts.StabilizerNFT;
+    const [posEscrowAddr, stabEscrowAddr, minRatio] = await Promise.all([
+      this.config.publicClient.readContract({
+        address: stabNFT,
+        abi: STABILIZER_NFT_ABI,
+        functionName: "positionEscrows",
+        args: [tokenId]
+      }),
+      this.config.publicClient.readContract({
+        address: stabNFT,
+        abi: STABILIZER_NFT_ABI,
+        functionName: "stabilizerEscrows",
+        args: [tokenId]
+      }),
+      this.config.publicClient.readContract({
+        address: stabNFT,
+        abi: STABILIZER_NFT_ABI,
+        functionName: "minCollateralRatios",
+        args: [tokenId]
+      })
+    ]);
+    const [backedUPDAmount, stETHBalance, unallocatedStETH] = await Promise.all([
+      this.config.publicClient.readContract({
+        address: posEscrowAddr,
+        abi: POSITION_ESCROW_ABI,
+        functionName: "backedUPDAmount"
+      }),
+      this.config.publicClient.readContract({
+        address: posEscrowAddr,
+        abi: POSITION_ESCROW_ABI,
+        functionName: "getCurrentStEthBalance"
+      }),
+      this.config.publicClient.readContract({
+        address: stabEscrowAddr,
+        abi: STABILIZER_ESCROW_ABI,
+        functionName: "unallocatedStETH"
+      })
+    ]);
+    let collateralizationRatio2 = 0n;
+    if (backedUPDAmount > 0n && stETHBalance > 0n) {
+      collateralizationRatio2 = 0n;
+    }
+    return {
+      tokenId,
+      positionEscrowAddress: posEscrowAddr,
+      stabilizerEscrowAddress: stabEscrowAddr,
+      collateralizationRatio: collateralizationRatio2,
+      backedUPDAmount,
+      stETHBalance,
+      unallocatedStETH,
+      minCollateralRatio: minRatio
+    };
+  }
+  // ============================================================
+  //                      WRITE OPERATIONS
+  // ============================================================
+  /**
+   * Mint UPD by sending ETH. Requires walletClient.
+   *
+   * @example
+   * ```ts
+   * const attestation = createMockAttestation(2000n * 10n**18n)
+   * const hash = await client.mint({
+   *   to: '0x...',
+   *   ethAmount: parseEther('1'),
+   *   priceAttestation: attestation,
+   * })
+   * ```
+   */
+  async mint(params) {
+    const walletClient = this._requireWallet();
+    const { to, ethAmount, priceAttestation } = params;
+    return walletClient.writeContract({
+      address: this.deployment.contracts.StabilizerNFT,
+      abi: STABILIZER_NFT_ABI,
+      functionName: "mintUPD",
+      args: [to, this._toSolidityAttestation(priceAttestation)],
+      value: ethAmount,
+      chain: walletClient.chain ?? null,
+      account: walletClient.account
+    });
+  }
+  /**
+   * Burn UPD to receive stETH. Requires walletClient.
+   *
+   * @example
+   * ```ts
+   * const attestation = createMockAttestation(2000n * 10n**18n)
+   * const hash = await client.burn({
+   *   updAmount: parseUnits('2000', 18),
+   *   priceAttestation: attestation,
+   * })
+   * ```
+   */
+  async burn(params) {
+    const walletClient = this._requireWallet();
+    const { updAmount, priceAttestation } = params;
+    return walletClient.writeContract({
+      address: this.deployment.contracts.StabilizerNFT,
+      abi: STABILIZER_NFT_ABI,
+      functionName: "burnUPD",
+      args: [updAmount, this._toSolidityAttestation(priceAttestation)],
+      chain: walletClient.chain ?? null,
+      account: walletClient.account
+    });
+  }
+  // ============================================================
+  //                      sUPD OPERATIONS
+  // ============================================================
+  /** Get sUPD contract info: share value, APY, supply, liability. */
+  async getSUPDInfo() {
+    const supdAddr = this.deployment.contracts.sUPD;
+    if (!supdAddr) throw new Error("sUPD not deployed on this chain");
+    const [shareValue, annualYieldBps, totalSupply, totalLiabilityUSD] = await Promise.all([
+      this.config.publicClient.readContract({
+        address: supdAddr,
+        abi: SUPD_ABI,
+        functionName: "currentShareValue"
+      }),
+      this.config.publicClient.readContract({
+        address: supdAddr,
+        abi: SUPD_ABI,
+        functionName: "annualYieldBps"
+      }),
+      this.config.publicClient.readContract({
+        address: supdAddr,
+        abi: SUPD_ABI,
+        functionName: "totalSupply"
+      }),
+      this.config.publicClient.readContract({
+        address: supdAddr,
+        abi: SUPD_ABI,
+        functionName: "totalLiabilityUSD"
+      })
+    ]);
+    return { shareValue, annualYieldBps, totalSupply, totalLiabilityUSD };
+  }
+  /** Stake UPD to receive sUPD shares. Requires walletClient. */
+  async stakeUPD(params) {
+    const walletClient = this._requireWallet();
+    const supdAddr = this.deployment.contracts.sUPD;
+    if (!supdAddr) throw new Error("sUPD not deployed on this chain");
+    return walletClient.writeContract({
+      address: supdAddr,
+      abi: SUPD_ABI,
+      functionName: "stakeUPD",
+      args: [params.updAmount, this._toSolidityAttestation(params.priceAttestation)],
+      chain: walletClient.chain ?? null,
+      account: walletClient.account
+    });
+  }
+  /** Unstake sUPD shares to receive UPD. Requires walletClient. */
+  async unstakeUPD(params) {
+    const walletClient = this._requireWallet();
+    const supdAddr = this.deployment.contracts.sUPD;
+    if (!supdAddr) throw new Error("sUPD not deployed on this chain");
+    return walletClient.writeContract({
+      address: supdAddr,
+      abi: SUPD_ABI,
+      functionName: "unstakeToUPD",
+      args: [params.shares, this._toSolidityAttestation(params.priceAttestation)],
+      chain: walletClient.chain ?? null,
+      account: walletClient.account
+    });
+  }
+  // ============================================================
+  //                   CONVENIENCE METHODS
+  // ============================================================
+  /**
+   * Mint UPD by sending ETH, automatically fetching a price attestation from the oracle.
+   *
+   * @example
+   * ```ts
+   * const hash = await client.mintWithOracle({
+   *   to: '0x...',
+   *   ethAmount: parseEther('1'),
+   * })
+   * ```
+   */
+  async mintWithOracle(params) {
+    const attestation = await this.oracle.getEthUsdAttestation();
+    return this.mint({ ...params, priceAttestation: attestation });
+  }
+  /**
+   * Burn UPD to receive stETH, automatically fetching a price attestation from the oracle.
+   *
+   * @example
+   * ```ts
+   * const hash = await client.burnWithOracle({
+   *   updAmount: parseUnits('2000', 18),
+   * })
+   * ```
+   */
+  async burnWithOracle(params) {
+    const attestation = await this.oracle.getEthUsdAttestation();
+    return this.burn({ ...params, priceAttestation: attestation });
+  }
+  /**
+   * Get system health metrics by combining on-chain collateral data with oracle price.
+   *
+   * @example
+   * ```ts
+   * const health = await client.getSystemHealth()
+   * console.log(`System ratio: ${health.systemCollateralRatioBps} bps`)
+   * console.log(`Healthy: ${health.isHealthy}`)
+   * ```
+   */
+  async getSystemHealth() {
+    const [collateral, { price }] = await Promise.all([
+      this.getCollateralInfo(),
+      this.oracle.getEthUsdPrice()
+    ]);
+    return computeSystemHealth(collateral, price);
+  }
+  /** Stake UPD, fetching oracle attestation automatically. */
+  async stakeUPDWithOracle(params) {
+    const attestation = await this.oracle.getEthUsdAttestation();
+    return this.stakeUPD({ ...params, priceAttestation: attestation });
+  }
+  /** Unstake sUPD, fetching oracle attestation automatically. */
+  async unstakeUPDWithOracle(params) {
+    const attestation = await this.oracle.getEthUsdAttestation();
+    return this.unstakeUPD({ ...params, priceAttestation: attestation });
+  }
+  // ============================================================
+  //                      HELPERS
+  // ============================================================
+  _requireWallet() {
+    if (!this.config.walletClient) {
+      throw new Error(
+        "UPDClient: walletClient is required for write operations. Pass a walletClient in the config to use mint/burn."
+      );
+    }
+    return this.config.walletClient;
+  }
+  _toSolidityAttestation(a) {
+    return {
+      price: a.price,
+      decimals: a.decimals,
+      dataTimestamp: a.dataTimestamp,
+      assetPair: a.assetPair,
+      signature: a.signature
+    };
+  }
+};
+function createUPDClient(config) {
+  return new UPDClient(config);
+}
+var EIP3009_DOMAIN_VERSION = "1";
+function randomNonce() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return bytesToHex(bytes);
+}
+function eip3009Domain(tokenAddress, chainId, tokenName) {
+  return {
+    name: tokenName,
+    version: EIP3009_DOMAIN_VERSION,
+    chainId,
+    verifyingContract: tokenAddress
+  };
+}
+async function signTransferAuthorization(params, tokenName = "Universal Private Dollar") {
+  const {
+    walletClient,
+    tokenAddress,
+    from,
+    to,
+    value,
+    validAfter = 0n,
+    validBefore = BigInt(Math.floor(Date.now() / 1e3) + 3600),
+    nonce = randomNonce()
+  } = params;
+  const chainId = walletClient.chain?.id;
+  if (!chainId) throw new Error("walletClient must have a chain configured");
+  const signature = await walletClient.signTypedData({
+    account: from,
+    domain: eip3009Domain(tokenAddress, chainId, tokenName),
+    types: {
+      TransferWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" }
+      ]
+    },
+    primaryType: "TransferWithAuthorization",
+    message: { from, to, value, validAfter, validBefore, nonce }
+  });
+  const sigBytes = hexToBytes(signature);
+  const r = bytesToHex(sigBytes.slice(0, 32));
+  const s = bytesToHex(sigBytes.slice(32, 64));
+  const v = sigBytes[64];
+  return { from, to, value, validAfter, validBefore, nonce, v, r, s };
+}
+async function signReceiveAuthorization(params, tokenName = "Universal Private Dollar") {
+  const {
+    walletClient,
+    tokenAddress,
+    from,
+    to,
+    value,
+    validAfter = 0n,
+    validBefore = BigInt(Math.floor(Date.now() / 1e3) + 3600),
+    nonce = randomNonce()
+  } = params;
+  const chainId = walletClient.chain?.id;
+  if (!chainId) throw new Error("walletClient must have a chain configured");
+  const signature = await walletClient.signTypedData({
+    account: from,
+    domain: eip3009Domain(tokenAddress, chainId, tokenName),
+    types: {
+      ReceiveWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" }
+      ]
+    },
+    primaryType: "ReceiveWithAuthorization",
+    message: { from, to, value, validAfter, validBefore, nonce }
+  });
+  const sigBytes = hexToBytes(signature);
+  const r = bytesToHex(sigBytes.slice(0, 32));
+  const s = bytesToHex(sigBytes.slice(32, 64));
+  const v = sigBytes[64];
+  return { from, to, value, validAfter, validBefore, nonce, v, r, s };
+}
+async function signCancelAuthorization(params, tokenName = "Universal Private Dollar") {
+  const { walletClient, tokenAddress, authorizer, nonce } = params;
+  const chainId = walletClient.chain?.id;
+  if (!chainId) throw new Error("walletClient must have a chain configured");
+  const signature = await walletClient.signTypedData({
+    account: authorizer,
+    domain: eip3009Domain(tokenAddress, chainId, tokenName),
+    types: {
+      CancelAuthorization: [
+        { name: "authorizer", type: "address" },
+        { name: "nonce", type: "bytes32" }
+      ]
+    },
+    primaryType: "CancelAuthorization",
+    message: { authorizer, nonce }
+  });
+  const sigBytes = hexToBytes(signature);
+  const r = bytesToHex(sigBytes.slice(0, 32));
+  const s = bytesToHex(sigBytes.slice(32, 64));
+  const v = sigBytes[64];
+  return { authorizer, nonce, v, r, s };
+}
+
+// src/core/verify.ts
+var ERC1967_IMPL_SLOT = "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
+async function verifyDeployment(publicClient, deployment) {
+  const checks = [];
+  await _verifyBytecode(publicClient, checks, "UPDToken", deployment.contracts.UPDToken);
+  await _verifyBytecode(publicClient, checks, "PriceOracle", deployment.contracts.PriceOracle);
+  await _verifyBytecode(publicClient, checks, "StabilizerNFT", deployment.contracts.StabilizerNFT);
+  await _verifyBytecode(publicClient, checks, "Reporter", deployment.contracts.OvercollateralizationReporter);
+  await _verifyBytecode(publicClient, checks, "InsuranceEscrow", deployment.contracts.InsuranceEscrow);
+  await _verifyProxyImpl(publicClient, checks, "PriceOracle", deployment.contracts.PriceOracle, deployment.implementations.PriceOracle);
+  await _verifyProxyImpl(publicClient, checks, "StabilizerNFT", deployment.contracts.StabilizerNFT, deployment.implementations.StabilizerNFT);
+  await _verifyProxyImpl(publicClient, checks, "Reporter", deployment.contracts.OvercollateralizationReporter, deployment.implementations.OvercollateralizationReporter);
+  await _verifyStabilizerNFTStorage(publicClient, checks, deployment);
+  await _verifyReporterStorage(publicClient, checks, deployment);
+  await _verifyRole(
+    publicClient,
+    checks,
+    "UPDToken MINTER_ROLE -> StabilizerNFT",
+    deployment.contracts.UPDToken,
+    UPD_TOKEN_ABI,
+    "0x9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a6",
+    // keccak256("MINTER_ROLE")
+    deployment.contracts.StabilizerNFT
+  );
+  await _verifyRole(
+    publicClient,
+    checks,
+    "UPDToken BURNER_ROLE -> StabilizerNFT",
+    deployment.contracts.UPDToken,
+    UPD_TOKEN_ABI,
+    "0x3c11d16cbaffd01df69ce1c404f6340ee057498f5f00246190ea54220576a848",
+    // keccak256("BURNER_ROLE")
+    deployment.contracts.StabilizerNFT
+  );
+  const passed = checks.filter((c) => c.passed).length;
+  const failed = checks.filter((c) => !c.passed).length;
+  return {
+    chainId: deployment.chainId,
+    checks,
+    passed,
+    failed,
+    allPassed: failed === 0
+  };
+}
+async function _verifyBytecode(client, checks, name, address) {
+  try {
+    const code = await client.getCode({ address });
+    const exists = code !== void 0 && code !== "0x" && code.length > 2;
+    checks.push({ name: `${name} bytecode exists`, passed: exists });
+  } catch {
+    checks.push({ name: `${name} bytecode exists`, passed: false });
+  }
+}
+async function _verifyProxyImpl(client, checks, name, proxyAddress, expectedImpl) {
+  try {
+    const implSlot = await client.getStorageAt({
+      address: proxyAddress,
+      slot: ERC1967_IMPL_SLOT
+    });
+    const actualImpl = ("0x" + (implSlot ?? "0x").slice(26)).toLowerCase();
+    const expected = expectedImpl.toLowerCase();
+    checks.push({
+      name: `${name} proxy -> impl`,
+      passed: actualImpl === expected,
+      expected: expectedImpl,
+      actual: actualImpl
+    });
+  } catch {
+    checks.push({ name: `${name} proxy -> impl`, passed: false, expected: expectedImpl });
+  }
+}
+async function _verifyStabilizerNFTStorage(client, checks, d) {
+  try {
+    const nft = d.contracts.StabilizerNFT;
+    const updToken = await client.readContract({
+      address: nft,
+      abi: STABILIZER_NFT_ABI,
+      functionName: "updToken"
+    });
+    checks.push({
+      name: "StabilizerNFT.updToken",
+      passed: updToken.toLowerCase() === d.contracts.UPDToken.toLowerCase(),
+      expected: d.contracts.UPDToken,
+      actual: updToken
+    });
+    const oracle = await client.readContract({
+      address: nft,
+      abi: STABILIZER_NFT_ABI,
+      functionName: "oracle"
+    });
+    checks.push({
+      name: "StabilizerNFT.oracle",
+      passed: oracle.toLowerCase() === d.contracts.PriceOracle.toLowerCase(),
+      expected: d.contracts.PriceOracle,
+      actual: oracle
+    });
+    const stETH = await client.readContract({
+      address: nft,
+      abi: STABILIZER_NFT_ABI,
+      functionName: "stETH"
+    });
+    checks.push({
+      name: "StabilizerNFT.stETH",
+      passed: stETH.toLowerCase() === d.external.stETH.toLowerCase(),
+      expected: d.external.stETH,
+      actual: stETH
+    });
+  } catch {
+    checks.push({ name: "StabilizerNFT storage", passed: false });
+  }
+}
+async function _verifyReporterStorage(client, checks, d) {
+  try {
+    const reporter = d.contracts.OvercollateralizationReporter;
+    const stabNFT = await client.readContract({
+      address: reporter,
+      abi: OVERCOLLATERALIZATION_REPORTER_ABI,
+      functionName: "stabilizerNFTContract"
+    });
+    checks.push({
+      name: "Reporter.stabilizerNFT",
+      passed: stabNFT.toLowerCase() === d.contracts.StabilizerNFT.toLowerCase(),
+      expected: d.contracts.StabilizerNFT,
+      actual: stabNFT
+    });
+    const updToken = await client.readContract({
+      address: reporter,
+      abi: OVERCOLLATERALIZATION_REPORTER_ABI,
+      functionName: "updToken"
+    });
+    checks.push({
+      name: "Reporter.updToken",
+      passed: updToken.toLowerCase() === d.contracts.UPDToken.toLowerCase(),
+      expected: d.contracts.UPDToken,
+      actual: updToken
+    });
+  } catch {
+    checks.push({ name: "Reporter storage", passed: false });
+  }
+}
+async function _verifyRole(client, checks, name, contractAddress, abi, roleHash, account) {
+  try {
+    const hasRole = await client.readContract({
+      address: contractAddress,
+      abi,
+      functionName: "hasRole",
+      args: [roleHash, account]
+    });
+    checks.push({ name, passed: hasRole });
+  } catch {
+    checks.push({ name, passed: false });
+  }
+}
+
+export { UPDClient, createUPDClient, getContractAddress, getDeployment, getDeploymentOrThrow, getSupportedChainIds, hasDeployment, signCancelAuthorization, signReceiveAuthorization, signTransferAuthorization, verifyDeployment };
+//# sourceMappingURL=chunk-R64I3LAO.js.map
+//# sourceMappingURL=chunk-R64I3LAO.js.map