@permissionless-technologies/upd-sdk 0.1.0

package/dist/contracts/index.js

@@ -0,0 +1,4 @@
+export { BRIDGE_ESCROW_ABI, INSURANCE_ESCROW_ABI, PRICE_ORACLE_ABI } from '../chunk-RIRT4JX6.js';
+export { OVERCOLLATERALIZATION_REPORTER_ABI, POSITION_ESCROW_ABI, STABILIZER_ESCROW_ABI, STABILIZER_NFT_ABI, SUPD_ABI, UPD_TOKEN_ABI } from '../chunk-4RBWWS2X.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/contracts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/core/index.cjs

@@ -0,0 +1,76 @@
+'use strict';
+
+var chunkWRPVPA7E_cjs = require('../chunk-WRPVPA7E.cjs');
+var chunkDF34ON56_cjs = require('../chunk-DF34ON56.cjs');
+var chunk4VXNJTNQ_cjs = require('../chunk-4VXNJTNQ.cjs');
+require('../chunk-ZSWETUGH.cjs');
+var chunkCZEDT3MS_cjs = require('../chunk-CZEDT3MS.cjs');
+
+
+
+Object.defineProperty(exports, "UPDClient", {
+  enumerable: true,
+  get: function () { return chunkWRPVPA7E_cjs.UPDClient; }
+});
+Object.defineProperty(exports, "createUPDClient", {
+  enumerable: true,
+  get: function () { return chunkWRPVPA7E_cjs.createUPDClient; }
+});
+Object.defineProperty(exports, "signCancelAuthorization", {
+  enumerable: true,
+  get: function () { return chunkWRPVPA7E_cjs.signCancelAuthorization; }
+});
+Object.defineProperty(exports, "signReceiveAuthorization", {
+  enumerable: true,
+  get: function () { return chunkWRPVPA7E_cjs.signReceiveAuthorization; }
+});
+Object.defineProperty(exports, "signTransferAuthorization", {
+  enumerable: true,
+  get: function () { return chunkWRPVPA7E_cjs.signTransferAuthorization; }
+});
+Object.defineProperty(exports, "verifyDeployment", {
+  enumerable: true,
+  get: function () { return chunkWRPVPA7E_cjs.verifyDeployment; }
+});
+Object.defineProperty(exports, "createMockAttestation", {
+  enumerable: true,
+  get: function () { return chunkDF34ON56_cjs.createMockAttestation; }
+});
+Object.defineProperty(exports, "DEFAULT_MIN_RATIO_BPS", {
+  enumerable: true,
+  get: function () { return chunk4VXNJTNQ_cjs.DEFAULT_MIN_RATIO_BPS; }
+});
+Object.defineProperty(exports, "collateralizationRatio", {
+  enumerable: true,
+  get: function () { return chunk4VXNJTNQ_cjs.collateralizationRatio; }
+});
+Object.defineProperty(exports, "computeSystemHealth", {
+  enumerable: true,
+  get: function () { return chunk4VXNJTNQ_cjs.computeSystemHealth; }
+});
+Object.defineProperty(exports, "quoteBurnUPD", {
+  enumerable: true,
+  get: function () { return chunk4VXNJTNQ_cjs.quoteBurnUPD; }
+});
+Object.defineProperty(exports, "quoteMintUPD", {
+  enumerable: true,
+  get: function () { return chunk4VXNJTNQ_cjs.quoteMintUPD; }
+});
+Object.defineProperty(exports, "quoteStakeUPD", {
+  enumerable: true,
+  get: function () { return chunk4VXNJTNQ_cjs.quoteStakeUPD; }
+});
+Object.defineProperty(exports, "quoteUnstakeUPD", {
+  enumerable: true,
+  get: function () { return chunk4VXNJTNQ_cjs.quoteUnstakeUPD; }
+});
+Object.defineProperty(exports, "stabilizerStEthNeeded", {
+  enumerable: true,
+  get: function () { return chunk4VXNJTNQ_cjs.stabilizerStEthNeeded; }
+});
+Object.defineProperty(exports, "ETH_USD_ASSET_PAIR", {
+  enumerable: true,
+  get: function () { return chunkCZEDT3MS_cjs.ETH_USD_ASSET_PAIR; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/core/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/core/index.d.cts

@@ -0,0 +1,5 @@
+export { C as CancelAuthorization, a as CancelAuthorizationParams, T as TransferAuthorization, b as TransferAuthorizationParams, U as UPDClient, V as VerificationCheck, d as VerificationResult, e as collateralizationRatio, f as createUPDClient, q as quoteBurnUPD, l as quoteMintUPD, m as quoteStakeUPD, n as quoteUnstakeUPD, s as signCancelAuthorization, o as signReceiveAuthorization, p as signTransferAuthorization, r as stabilizerStEthNeeded, v as verifyDeployment } from '../index-yRBqVOHV.cjs';
+export { B as BurnParams, C as CollateralInfo, M as MintParams, P as PriceAttestationQuery, S as SUPDInfo, a as StabilizerPosition, b as StakeParams, T as TransactionHash, U as UPDClientConfig, c as UnstakeParams } from '../types-DySv82My.cjs';
+export { E as ETH_USD_ASSET_PAIR, c as createMockAttestation } from '../constants-BlOP_9dy.cjs';
+export { D as DEFAULT_MIN_RATIO_BPS, S as SystemHealth, c as computeSystemHealth } from '../health-DPxBqH7b.cjs';
+import 'viem';

package/dist/core/index.d.ts

@@ -0,0 +1,5 @@
+export { C as CancelAuthorization, a as CancelAuthorizationParams, T as TransferAuthorization, b as TransferAuthorizationParams, U as UPDClient, V as VerificationCheck, d as VerificationResult, e as collateralizationRatio, f as createUPDClient, q as quoteBurnUPD, l as quoteMintUPD, m as quoteStakeUPD, n as quoteUnstakeUPD, s as signCancelAuthorization, o as signReceiveAuthorization, p as signTransferAuthorization, r as stabilizerStEthNeeded, v as verifyDeployment } from '../index-XNClksom.js';
+export { B as BurnParams, C as CollateralInfo, M as MintParams, P as PriceAttestationQuery, S as SUPDInfo, a as StabilizerPosition, b as StakeParams, T as TransactionHash, U as UPDClientConfig, c as UnstakeParams } from '../types-DySv82My.js';
+export { E as ETH_USD_ASSET_PAIR, c as createMockAttestation } from '../constants-Bk2bGYfX.js';
+export { D as DEFAULT_MIN_RATIO_BPS, S as SystemHealth, c as computeSystemHealth } from '../health-BUb4ItNt.js';
+import 'viem';

package/dist/core/index.js

@@ -0,0 +1,7 @@
+export { UPDClient, createUPDClient, signCancelAuthorization, signReceiveAuthorization, signTransferAuthorization, verifyDeployment } from '../chunk-R64I3LAO.js';
+export { createMockAttestation } from '../chunk-5NNXIJE4.js';
+export { DEFAULT_MIN_RATIO_BPS, collateralizationRatio, computeSystemHealth, quoteBurnUPD, quoteMintUPD, quoteStakeUPD, quoteUnstakeUPD, stabilizerStEthNeeded } from '../chunk-63FIKV36.js';
+import '../chunk-4RBWWS2X.js';
+export { ETH_USD_ASSET_PAIR } from '../chunk-DJBU2OEB.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/health-BUb4ItNt.d.ts

@@ -0,0 +1,46 @@
+import { C as CollateralInfo } from './types-DySv82My.js';
+
+/**
+ * System Health — Pure functions for computing UPD system health metrics.
+ *
+ * These functions take pre-fetched data (from UPDClient or React hooks) and
+ * compute derived health metrics. No blockchain calls — composable with
+ * any data source.
+ */
+
+/** Default minimum system collateral ratio: 125% (12500 bps). */
+declare const DEFAULT_MIN_RATIO_BPS = 12500n;
+interface SystemHealth {
+    /** System-wide collateralization ratio in basis points (e.g. 12500 = 125%). */
+    systemCollateralRatioBps: bigint;
+    /** Whether the system is at or above the minimum collateral threshold. */
+    isHealthy: boolean;
+    /** USD value of total stETH collateral (18 decimals). */
+    collateralValueUsd: bigint;
+    /** Total UPD supply (18 decimals). */
+    totalUPDSupply: bigint;
+    /** Overcollateralization buffer in USD (collateral - supply). Can be negative. */
+    bufferUsd: bigint;
+}
+/**
+ * Compute system health from collateral info and current ETH/USD price.
+ *
+ * @param collateral - Total stETH collateral and UPD supply (from getCollateralInfo)
+ * @param ethUsdPrice - Current ETH/USD price in 18 decimals
+ * @param minRatioBps - Minimum healthy ratio in basis points (default: 12500 = 125%)
+ * @returns Computed system health metrics
+ *
+ * @example
+ * ```ts
+ * const info = await client.getCollateralInfo()
+ * const { price } = await oracle.getEthUsdPrice()
+ * const health = computeSystemHealth(info, price)
+ *
+ * if (!health.isHealthy) {
+ *   console.warn(`System undercollateralized: ${health.systemCollateralRatioBps} bps`)
+ * }
+ * ```
+ */
+declare function computeSystemHealth(collateral: CollateralInfo, ethUsdPrice: bigint, minRatioBps?: bigint): SystemHealth;
+
+export { DEFAULT_MIN_RATIO_BPS as D, type SystemHealth as S, computeSystemHealth as c };

package/dist/health-DPxBqH7b.d.cts

@@ -0,0 +1,46 @@
+import { C as CollateralInfo } from './types-DySv82My.cjs';
+
+/**
+ * System Health — Pure functions for computing UPD system health metrics.
+ *
+ * These functions take pre-fetched data (from UPDClient or React hooks) and
+ * compute derived health metrics. No blockchain calls — composable with
+ * any data source.
+ */
+
+/** Default minimum system collateral ratio: 125% (12500 bps). */
+declare const DEFAULT_MIN_RATIO_BPS = 12500n;
+interface SystemHealth {
+    /** System-wide collateralization ratio in basis points (e.g. 12500 = 125%). */
+    systemCollateralRatioBps: bigint;
+    /** Whether the system is at or above the minimum collateral threshold. */
+    isHealthy: boolean;
+    /** USD value of total stETH collateral (18 decimals). */
+    collateralValueUsd: bigint;
+    /** Total UPD supply (18 decimals). */
+    totalUPDSupply: bigint;
+    /** Overcollateralization buffer in USD (collateral - supply). Can be negative. */
+    bufferUsd: bigint;
+}
+/**
+ * Compute system health from collateral info and current ETH/USD price.
+ *
+ * @param collateral - Total stETH collateral and UPD supply (from getCollateralInfo)
+ * @param ethUsdPrice - Current ETH/USD price in 18 decimals
+ * @param minRatioBps - Minimum healthy ratio in basis points (default: 12500 = 125%)
+ * @returns Computed system health metrics
+ *
+ * @example
+ * ```ts
+ * const info = await client.getCollateralInfo()
+ * const { price } = await oracle.getEthUsdPrice()
+ * const health = computeSystemHealth(info, price)
+ *
+ * if (!health.isHealthy) {
+ *   console.warn(`System undercollateralized: ${health.systemCollateralRatioBps} bps`)
+ * }
+ * ```
+ */
+declare function computeSystemHealth(collateral: CollateralInfo, ethUsdPrice: bigint, minRatioBps?: bigint): SystemHealth;
+
+export { DEFAULT_MIN_RATIO_BPS as D, type SystemHealth as S, computeSystemHealth as c };

package/dist/index-XNClksom.d.ts

@@ -0,0 +1,415 @@
+import { Address, Hash, Hex, WalletClient, PublicClient } from 'viem';
+import { U as UPDClientConfig, C as CollateralInfo, a as StabilizerPosition, M as MintParams, B as BurnParams, S as SUPDInfo, b as StakeParams, c as UnstakeParams } from './types-DySv82My.js';
+import { O as OracleClient } from './constants-Bk2bGYfX.js';
+import { S as SystemHealth } from './health-BUb4ItNt.js';
+
+/**
+ * Deployment Configuration Loader
+ *
+ * Loads UPD contract addresses based on chain ID.
+ * JSON structure matches Forge deployment output exactly — no transformation needed.
+ */
+
+interface UPDDeploymentConfig {
+    chainId: number;
+    /** Proxy/final contract addresses — what integrators use */
+    contracts: {
+        UPDToken: Address;
+        PriceOracle: Address;
+        StabilizerNFT: Address;
+        OvercollateralizationReporter: Address;
+        InsuranceEscrow: Address;
+        BridgeEscrow?: Address;
+        sUPD?: Address;
+    };
+    /** UUPS implementation addresses — for upgrades only */
+    implementations: {
+        PriceOracle: Address;
+        StabilizerNFT: Address;
+        OvercollateralizationReporter: Address;
+    };
+    /** Externally deployed Solidity libraries */
+    libraries: {
+        LinkedListLib: Address;
+        CollateralMathLib: Address;
+    };
+    /** Clone template implementations (used by StabilizerNFT for escrow deployment) */
+    templates: {
+        StabilizerEscrow: Address;
+        PositionEscrow: Address;
+    };
+    /** Third-party / external addresses */
+    external: {
+        stETH: Address;
+        lido: Address;
+        oracleSigner: Address;
+    };
+    metadata: {
+        deployBlock: number;
+        deployTimestamp: number;
+        deployer: Address;
+    };
+}
+/** Get deployment config for a chain. Returns null if not found. */
+declare function getDeployment(chainId: number): UPDDeploymentConfig | null;
+/** Get deployment config or throw if not found. */
+declare function getDeploymentOrThrow(chainId: number): UPDDeploymentConfig;
+/** Check if a chain has a deployment. */
+declare function hasDeployment(chainId: number): boolean;
+/** Get all supported chain IDs. */
+declare function getSupportedChainIds(): number[];
+/** Get a specific contract address for a chain. */
+declare function getContractAddress(chainId: number, contractName: keyof UPDDeploymentConfig['contracts']): Address | null;
+
+/**
+ * UPDClient — Main client for interacting with the UPD protocol.
+ *
+ * Read operations use publicClient only (no wallet needed).
+ * Write operations require a walletClient.
+ *
+ * @example
+ * ```ts
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { createUPDClient } from '@permissionless-technologies/upd-sdk'
+ *
+ * const publicClient = createPublicClient({ chain: mainnet, transport: http() })
+ * const client = createUPDClient({ publicClient, chainId: 1 })
+ *
+ * const balance = await client.getUPDBalance('0x...')
+ * const supply = await client.getTotalSupply()
+ * ```
+ */
+
+declare class UPDClient {
+    readonly config: UPDClientConfig;
+    readonly deployment: UPDDeploymentConfig;
+    readonly oracle: OracleClient;
+    constructor(config: UPDClientConfig);
+    /** Get UPD token balance for an address. */
+    getUPDBalance(address: Address): Promise<bigint>;
+    /** Get total UPD supply. */
+    getTotalSupply(): Promise<bigint>;
+    /** Get system collateral info: total stETH collateral and total UPD supply. */
+    getCollateralInfo(): Promise<CollateralInfo>;
+    /** Get details for a specific stabilizer position. */
+    getStabilizerPosition(tokenId: bigint): Promise<StabilizerPosition>;
+    /**
+     * 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,
+     * })
+     * ```
+     */
+    mint(params: MintParams): Promise<Hash>;
+    /**
+     * 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,
+     * })
+     * ```
+     */
+    burn(params: BurnParams): Promise<Hash>;
+    /** Get sUPD contract info: share value, APY, supply, liability. */
+    getSUPDInfo(): Promise<SUPDInfo>;
+    /** Stake UPD to receive sUPD shares. Requires walletClient. */
+    stakeUPD(params: StakeParams): Promise<Hash>;
+    /** Unstake sUPD shares to receive UPD. Requires walletClient. */
+    unstakeUPD(params: UnstakeParams): Promise<Hash>;
+    /**
+     * 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'),
+     * })
+     * ```
+     */
+    mintWithOracle(params: {
+        to: Address;
+        ethAmount: bigint;
+    }): Promise<Hash>;
+    /**
+     * Burn UPD to receive stETH, automatically fetching a price attestation from the oracle.
+     *
+     * @example
+     * ```ts
+     * const hash = await client.burnWithOracle({
+     *   updAmount: parseUnits('2000', 18),
+     * })
+     * ```
+     */
+    burnWithOracle(params: {
+        updAmount: bigint;
+    }): Promise<Hash>;
+    /**
+     * 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}`)
+     * ```
+     */
+    getSystemHealth(): Promise<SystemHealth>;
+    /** Stake UPD, fetching oracle attestation automatically. */
+    stakeUPDWithOracle(params: {
+        updAmount: bigint;
+    }): Promise<Hash>;
+    /** Unstake sUPD, fetching oracle attestation automatically. */
+    unstakeUPDWithOracle(params: {
+        shares: bigint;
+    }): Promise<Hash>;
+    private _requireWallet;
+    private _toSolidityAttestation;
+}
+/**
+ * Create a UPD client instance.
+ *
+ * @example
+ * ```ts
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { createUPDClient } from '@permissionless-technologies/upd-sdk'
+ *
+ * const client = createUPDClient({
+ *   publicClient: createPublicClient({ chain: mainnet, transport: http() }),
+ *   chainId: 1,
+ * })
+ * ```
+ */
+declare function createUPDClient(config: UPDClientConfig): UPDClient;
+
+/**
+ * UPD Quote Functions — Pure math for estimating mint/burn amounts.
+ *
+ * These functions require no blockchain calls. They mirror the Solidity
+ * CollateralMathLib logic so integrators can show users expected amounts
+ * before submitting a transaction.
+ */
+/**
+ * Estimate how much UPD a user will receive for a given ETH amount.
+ *
+ * @param ethAmount - ETH to deposit (in wei)
+ * @param ethUsdPrice - ETH/USD price (18 decimals, e.g. 2000e18 = $2000)
+ * @returns Expected UPD amount (18 decimals)
+ *
+ * @example
+ * ```ts
+ * const upd = quoteMintUPD(parseEther('1'), 2000n * 10n**18n)
+ * // → 2000000000000000000000n (2000 UPD)
+ * ```
+ */
+declare function quoteMintUPD(ethAmount: bigint, ethUsdPrice: bigint): bigint;
+/**
+ * Estimate how much stETH a user will receive for burning UPD.
+ *
+ * @param updAmount - UPD to burn (18 decimals)
+ * @param ethUsdPrice - ETH/USD price (18 decimals)
+ * @returns Expected stETH amount (in wei)
+ *
+ * @example
+ * ```ts
+ * const stEth = quoteBurnUPD(parseUnits('2000', 18), 2000n * 10n**18n)
+ * // → 1000000000000000000n (1 stETH)
+ * ```
+ */
+declare function quoteBurnUPD(updAmount: bigint, ethUsdPrice: bigint): bigint;
+/**
+ * Calculate the stabilizer stETH needed for a given user ETH deposit.
+ *
+ * @param userEth - User's ETH amount (in wei)
+ * @param minCollateralRatioBps - Minimum collateral ratio in basis points (e.g. 12500 = 125%)
+ * @returns Stabilizer stETH required (in wei)
+ *
+ * @example
+ * ```ts
+ * const needed = stabilizerStEthNeeded(parseEther('10'), 12500n)
+ * // → 2500000000000000000n (2.5 ETH worth of stETH at 125% ratio)
+ * ```
+ */
+declare function stabilizerStEthNeeded(userEth: bigint, minCollateralRatioBps: bigint): bigint;
+/**
+ * Calculate the collateralization ratio from stETH balance, price, and UPD liability.
+ *
+ * @param stEthBalance - stETH held in escrow (in wei)
+ * @param ethUsdPrice - ETH/USD price (18 decimals)
+ * @param backedUPDAmount - UPD liability (18 decimals)
+ * @returns Collateralization ratio in basis points (e.g. 12500 = 125%)
+ *
+ * @example
+ * ```ts
+ * const ratio = collateralizationRatio(parseEther('1.25'), 2000n * 10n**18n, parseUnits('2000', 18))
+ * // → 12500n (125%)
+ * ```
+ */
+/**
+ * Estimate sUPD shares received for staking UPD.
+ *
+ * Mirrors sUPD.sol line 136: shares = updAmount * SHARE_PRECISION / shareValue
+ *
+ * @param updAmount - UPD to stake (18 decimals)
+ * @param shareValue - Current sUPD share value (18 decimals, e.g. 1.05e18 = $1.05/share)
+ * @returns Expected sUPD shares (18 decimals)
+ *
+ * @example
+ * ```ts
+ * const shares = quoteStakeUPD(parseUnits('1000', 18), 1050000000000000000n)
+ * // → ~952.38e18 shares (1000 UPD at $1.05/share)
+ * ```
+ */
+declare function quoteStakeUPD(updAmount: bigint, shareValue: bigint): bigint;
+/**
+ * Estimate UPD received for unstaking sUPD shares.
+ *
+ * Mirrors sUPD.sol line 173: updOwed = shares * shareValue / SHARE_PRECISION
+ *
+ * @param shares - sUPD shares to unstake (18 decimals)
+ * @param shareValue - Current sUPD share value (18 decimals)
+ * @returns Expected UPD amount (18 decimals)
+ *
+ * @example
+ * ```ts
+ * const upd = quoteUnstakeUPD(parseUnits('952.38', 18), 1050000000000000000n)
+ * // → ~1000e18 UPD
+ * ```
+ */
+declare function quoteUnstakeUPD(shares: bigint, shareValue: bigint): bigint;
+declare function collateralizationRatio(stEthBalance: bigint, ethUsdPrice: bigint, backedUPDAmount: bigint): bigint;
+
+/**
+ * EIP-3009 Transfer Authorization helpers for UPD.
+ *
+ * Pure signing functions — no blockchain calls. Generate off-chain EIP-712
+ * signatures that can be submitted by any relayer or facilitator (e.g., x402).
+ *
+ * @example
+ * ```ts
+ * import { signTransferAuthorization } from '@permissionless-technologies/upd-sdk'
+ *
+ * const auth = await signTransferAuthorization({
+ *   walletClient,
+ *   tokenAddress: '0x...',
+ *   from: '0xAlice...',
+ *   to: '0xBob...',
+ *   value: parseUnits('100', 18),
+ *   validAfter: 0n,
+ *   validBefore: BigInt(Math.floor(Date.now() / 1000) + 3600),
+ * })
+ *
+ * // Submit via relayer, x402 facilitator, or directly
+ * await publicClient.writeContract({
+ *   address: tokenAddress,
+ *   abi: UPD_TOKEN_ABI,
+ *   functionName: 'transferWithAuthorization',
+ *   args: [auth.from, auth.to, auth.value, auth.validAfter, auth.validBefore, auth.nonce, auth.v, auth.r, auth.s],
+ * })
+ * ```
+ */
+
+interface TransferAuthorizationParams {
+    walletClient: WalletClient;
+    tokenAddress: Address;
+    from: Address;
+    to: Address;
+    value: bigint;
+    validAfter?: bigint;
+    validBefore?: bigint;
+    nonce?: Hex;
+}
+interface TransferAuthorization {
+    from: Address;
+    to: Address;
+    value: bigint;
+    validAfter: bigint;
+    validBefore: bigint;
+    nonce: Hex;
+    v: number;
+    r: Hex;
+    s: Hex;
+}
+interface CancelAuthorizationParams {
+    walletClient: WalletClient;
+    tokenAddress: Address;
+    authorizer: Address;
+    nonce: Hex;
+}
+interface CancelAuthorization {
+    authorizer: Address;
+    nonce: Hex;
+    v: number;
+    r: Hex;
+    s: Hex;
+}
+/**
+ * Sign a TransferWithAuthorization (EIP-3009).
+ *
+ * Generates a random nonce if none is provided. Default time window: now → +1 hour.
+ * The returned object contains all arguments needed for `transferWithAuthorization()`.
+ */
+declare function signTransferAuthorization(params: TransferAuthorizationParams, tokenName?: string): Promise<TransferAuthorization>;
+/**
+ * Sign a ReceiveWithAuthorization (EIP-3009).
+ *
+ * Same as transferWithAuthorization but the resulting signature can only be
+ * submitted by the `to` address (prevents front-running).
+ */
+declare function signReceiveAuthorization(params: TransferAuthorizationParams, tokenName?: string): Promise<TransferAuthorization>;
+/**
+ * Sign a CancelAuthorization (EIP-3009).
+ *
+ * Cancels a previously signed authorization before it's been used.
+ */
+declare function signCancelAuthorization(params: CancelAuthorizationParams, tokenName?: string): Promise<CancelAuthorization>;
+
+/**
+ * UPD Deployment Verification — Check on-chain state matches deployment config.
+ *
+ * Verifies:
+ * 1. Bytecode exists at all deployed addresses
+ * 2. UUPS proxy implementation slots point to correct implementations
+ * 3. Critical storage values are initialized correctly
+ * 4. Access control roles are granted properly
+ */
+
+interface VerificationCheck {
+    name: string;
+    passed: boolean;
+    expected?: string;
+    actual?: string;
+}
+interface VerificationResult {
+    chainId: number;
+    checks: VerificationCheck[];
+    passed: number;
+    failed: number;
+    allPassed: boolean;
+}
+/**
+ * Verify that a UPD deployment matches its on-chain state.
+ *
+ * @example
+ * ```ts
+ * const result = await verifyDeployment(publicClient, deployment)
+ * if (!result.allPassed) {
+ *   console.error('Deployment verification failed:', result.checks.filter(c => !c.passed))
+ * }
+ * ```
+ */
+declare function verifyDeployment(publicClient: PublicClient, deployment: UPDDeploymentConfig): Promise<VerificationResult>;
+
+export { type CancelAuthorization as C, type TransferAuthorization as T, UPDClient as U, type VerificationCheck as V, type CancelAuthorizationParams as a, type TransferAuthorizationParams as b, type UPDDeploymentConfig as c, type VerificationResult as d, collateralizationRatio as e, createUPDClient as f, getContractAddress as g, getDeployment as h, getDeploymentOrThrow as i, getSupportedChainIds as j, hasDeployment as k, quoteMintUPD as l, quoteStakeUPD as m, quoteUnstakeUPD as n, signReceiveAuthorization as o, signTransferAuthorization as p, quoteBurnUPD as q, stabilizerStEthNeeded as r, signCancelAuthorization as s, verifyDeployment as v };