@babylonlabs-io/ts-sdk 3.0.2 → 3.1.1

package/dist/types-BueQoMjO.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-BueQoMjO.cjs","sources":["../src/tbv/core/clients/eth/contract-address-resolver.ts","../src/tbv/core/clients/eth/operation-key-reader.ts","../src/tbv/core/clients/eth/protocol-params-reader.ts","../src/tbv/core/clients/eth/signer-set-reader.ts","../src/tbv/core/clients/eth/types.ts"],"sourcesContent":["/**\n * Contract Address Resolver\n *\n * Resolves ProtocolParams and ApplicationRegistry contract addresses\n * from the BTCVaultRegistry contract. These addresses are needed to\n * construct the SDK's contract readers.\n *\n * @module clients/eth/contract-address-resolver\n */\n\nimport type { Address, PublicClient } from \"viem\";\n\nimport { BTCVaultRegistryABI } from \"../../contracts/abis/BTCVaultRegistry.abi\";\n\nexport interface ProtocolAddresses {\n  /** Address of the ProtocolParams contract */\n  protocolParams: Address;\n  /** Address of the ApplicationRegistry contract */\n  applicationRegistry: Address;\n}\n\n/**\n * Resolve ProtocolParams and ApplicationRegistry addresses from BTCVaultRegistry.\n *\n * Uses a single multicall for atomicity and efficiency.\n *\n * @param publicClient - viem PublicClient instance\n * @param btcVaultRegistryAddress - Address of the BTCVaultRegistry contract\n * @returns Resolved contract addresses\n */\nexport async function resolveProtocolAddresses(\n  publicClient: PublicClient,\n  btcVaultRegistryAddress: Address,\n): Promise<ProtocolAddresses> {\n  const [protocolParams, applicationRegistry] = await publicClient.multicall({\n    contracts: [\n      {\n        address: btcVaultRegistryAddress,\n        abi: BTCVaultRegistryABI,\n        functionName: \"protocolParams\",\n      },\n      {\n        address: btcVaultRegistryAddress,\n        abi: BTCVaultRegistryABI,\n        functionName: \"applicationRegistry\",\n      },\n    ],\n    allowFailure: false,\n  });\n\n  return {\n    protocolParams: protocolParams as Address,\n    applicationRegistry: applicationRegistry as Address,\n  };\n}\n","/**\n * Concrete RFC-006 operation-key reader spanning all three registries.\n *\n * This is an optional utility — callers can use their own implementation of\n * the {@link OperationKeyReader} interface.\n */\n\nimport type { Abi, Address, Hex, PublicClient } from \"viem\";\n\nimport { ApplicationRegistryABI } from \"../../contracts/abis/ApplicationRegistry.abi\";\nimport { BTCVaultRegistryABI } from \"../../contracts/abis/BTCVaultRegistry.abi\";\nimport { ProtocolParamsABI } from \"../../contracts/abis/ProtocolParams.abi\";\nimport type {\n  KeyEpochs,\n  OperationKeyQuery,\n  OperationKeyReader,\n  RawOperationKeys,\n  RawPayoutScripts,\n} from \"./types\";\n\n/** Addresses of the three registries an operation-key resolution spans. */\nexport interface OperationKeyContracts {\n  btcVaultRegistry: Address;\n  applicationRegistry: Address;\n  protocolParams: Address;\n}\n\n/** One `multicall` entry. Loosely typed because the three ABIs differ. */\ntype Call = {\n  address: Address;\n  abi: Abi;\n  functionName: string;\n  args: readonly unknown[];\n};\n\n/**\n * Reject a multicall result that is not one-per-call.\n *\n * Every method here relies on positional alignment between calls and results,\n * so a short array does not fail — it silently hands back `undefined` for the\n * tail entries. Downstream that surfaces as a complaint about whichever\n * operator happens to occupy the missing slot, blaming a participant that is\n * perfectly fine for a read that came back incomplete. Assert the length where\n * the array arrives so the error names the real fault.\n */\nfunction assertMulticallLength(\n  actual: number,\n  expected: number,\n  label: string,\n): void {\n  if (actual !== expected) {\n    throw new Error(\n      `${label}: multicall returned ${actual} results for ${expected} calls, ` +\n        `so the results are not roster-aligned; refusing to use them`,\n    );\n  }\n}\n\n/**\n * Split a flat multicall result into VP / keepers / challengers.\n *\n * Every method below builds its calls in the same order — vault provider\n * first, then keepers in roster order, then challengers in roster order — so\n * the results stay index-aligned with `query.vaultKeepers` /\n * `query.universalChallengers`. That alignment is what lets the resolver pair\n * a resolved key back to its admin address; the sorted key arrays it exposes\n * are derived from those pairs, never the other way round.\n */\nfunction partition<T>(\n  results: readonly T[],\n  keeperCount: number,\n): { vaultProvider: T; vaultKeepers: T[]; universalChallengers: T[] } {\n  return {\n    vaultProvider: results[0],\n    vaultKeepers: results.slice(1, 1 + keeperCount),\n    universalChallengers: results.slice(1 + keeperCount),\n  };\n}\n\n/**\n * Reads RFC-006 operation keys and payout scripts.\n *\n * Usage:\n * ```ts\n * const reader = new ViemOperationKeyReader(publicClient, contracts);\n * const keys = await reader.getCurrentOperationKeys(query);\n * ```\n */\nexport class ViemOperationKeyReader implements OperationKeyReader {\n  constructor(\n    private publicClient: PublicClient,\n    private contracts: OperationKeyContracts,\n  ) {}\n\n  /**\n   * One multicall, `allowFailure: false`, so every key in the set is read at\n   * the same block. A rotation landing between two separate `eth_call`s would\n   * otherwise produce a mixed-epoch key set and a lock no counterparty agrees\n   * with.\n   */\n  private async readAll<T>(\n    calls: Call[],\n    keeperCount: number,\n    challengerCount: number,\n    label: string,\n    blockNumber?: bigint,\n  ) {\n    const results = (await this.publicClient.multicall({\n      contracts: calls,\n      allowFailure: false,\n      blockNumber,\n    })) as readonly T[];\n\n    assertMulticallLength(\n      results.length,\n      1 + keeperCount + challengerCount,\n      label,\n    );\n\n    return partition(results, keeperCount);\n  }\n\n  async getCurrentOperationKeys(\n    query: OperationKeyQuery,\n    blockNumber?: bigint,\n  ): Promise<RawOperationKeys> {\n    const calls: Call[] = [\n      {\n        address: this.contracts.btcVaultRegistry,\n        abi: BTCVaultRegistryABI as Abi,\n        functionName: \"getCurrentOperationBtcKey\",\n        args: [query.vaultProviderEthAddress],\n      },\n      ...query.vaultKeepers.map((keeper) => ({\n        address: this.contracts.applicationRegistry,\n        abi: ApplicationRegistryABI as Abi,\n        functionName: \"getCurrentOperationBtcKey\",\n        args: [query.applicationEntryPoint, keeper.ethAddress],\n      })),\n      ...query.universalChallengers.map((challenger) => ({\n        address: this.contracts.protocolParams,\n        abi: ProtocolParamsABI as Abi,\n        functionName: \"getCurrentOperationBtcKey\",\n        args: [challenger.ethAddress],\n      })),\n    ];\n\n    return this.readAll<Hex>(\n      calls,\n      query.vaultKeepers.length,\n      query.universalChallengers.length,\n      \"getCurrentOperationKeys\",\n      blockNumber,\n    );\n  }\n\n  async getOperationKeysAtEpochs(\n    query: OperationKeyQuery,\n    epochs: KeyEpochs,\n  ): Promise<RawOperationKeys> {\n    const calls: Call[] = [\n      // The VP takes the plain `AtEpoch` variant: it has no membership\n      // version, so its genesis (the registration key at version 0) is\n      // unambiguous and the contract resolves it internally.\n      {\n        address: this.contracts.btcVaultRegistry,\n        abi: BTCVaultRegistryABI as Abi,\n        functionName: \"getOperationBtcKeyAtEpoch\",\n        args: [query.vaultProviderEthAddress, epochs.vpKeyEpoch],\n      },\n      // Keepers and challengers take `...OrGenesis` with their roster key\n      // passed explicitly, because the correct genesis for them is their key\n      // in *this vault's frozen membership version*. An operator dropped from\n      // the current roster, or listed under a different key in an older\n      // version, would otherwise resolve against the wrong genesis.\n      ...query.vaultKeepers.map((keeper) => ({\n        address: this.contracts.applicationRegistry,\n        abi: ApplicationRegistryABI as Abi,\n        functionName: \"getOperationBtcKeyAtEpochOrGenesis\",\n        args: [\n          query.applicationEntryPoint,\n          keeper.ethAddress,\n          epochs.appKeeperKeyEpoch,\n          keeper.btcPubKey,\n        ],\n      })),\n      ...query.universalChallengers.map((challenger) => ({\n        address: this.contracts.protocolParams,\n        abi: ProtocolParamsABI as Abi,\n        functionName: \"getOperationBtcKeyAtEpochOrGenesis\",\n        args: [challenger.ethAddress, epochs.ucKeyEpoch, challenger.btcPubKey],\n      })),\n    ];\n\n    return this.readAll<Hex>(\n      calls,\n      query.vaultKeepers.length,\n      query.universalChallengers.length,\n      \"getOperationKeysAtEpochs\",\n    );\n  }\n\n  async getPayoutScriptsAtEpochs(\n    query: OperationKeyQuery,\n    epochs: KeyEpochs,\n  ): Promise<RawPayoutScripts> {\n    // Universal challengers are never claimers, so they have no payout script\n    // and no call here.\n    const results = (await this.publicClient.multicall({\n      contracts: [\n        {\n          address: this.contracts.btcVaultRegistry,\n          abi: BTCVaultRegistryABI as Abi,\n          functionName: \"getPayoutScriptAtEpoch\",\n          args: [query.vaultProviderEthAddress, epochs.vpKeyEpoch],\n        },\n        ...query.vaultKeepers.map((keeper) => ({\n          address: this.contracts.applicationRegistry,\n          abi: ApplicationRegistryABI as Abi,\n          functionName: \"getPayoutScriptAtEpoch\",\n          args: [\n            query.applicationEntryPoint,\n            keeper.ethAddress,\n            epochs.appKeeperKeyEpoch,\n          ],\n        })),\n      ],\n      allowFailure: false,\n    })) as readonly Hex[];\n\n    // Expected length is `1 + keepers`, with no challenger term — see the\n    // comment above on why universal challengers have no call here.\n    assertMulticallLength(\n      results.length,\n      1 + query.vaultKeepers.length,\n      \"getPayoutScriptsAtEpochs\",\n    );\n\n    return {\n      vaultProvider: results[0],\n      vaultKeepers: [...results.slice(1)],\n    };\n  }\n}\n","/**\n * Concrete ProtocolParams reader using viem's readContract and multicall.\n *\n * This is an optional utility — callers can use their own implementation\n * of the ProtocolParamsReader interface.\n */\n\nimport type { Abi, Address, Hex, PublicClient } from \"viem\";\n\nimport { ProtocolParamsABI } from \"../../contracts/abis/ProtocolParams.abi\";\nimport {\n  assertValidOffchainParamsVersion,\n  validateOffchainParams,\n  validatePegInConfiguration,\n  validateTBVProtocolParams,\n} from \"./protocol-params-validation\";\nimport type {\n  AllOffchainParamsData,\n  OnSkippedOffchainParamsVersion,\n  PegInConfiguration,\n  ProtocolParamsReader,\n  TBVProtocolParams,\n  VersionedOffchainParams,\n} from \"./types\";\n\n/**\n * Maximum value for a Solidity uint16.\n * PeginLogic.sol casts timelockAssert to uint16, so values above this are invalid.\n */\nconst UINT16_MAX = 65535;\n\n\n/**\n * Raw shape viem returns for VersionedOffchainParams struct.\n * viem resolves ABI struct outputs to named objects (not tuples).\n */\ninterface RawOffchainParams {\n  timelockAssert: bigint;\n  timelockChallengeAssert: bigint;\n  securityCouncilKeys: readonly Hex[];\n  councilQuorum: number;\n  feeRate: bigint;\n  babeTotalInstances: number;\n  babeInstancesToFinalize: number;\n  minVpCommissionBps: number;\n  tRefund: number;\n  tStale: number;\n  minPeginFeeRate: bigint;\n  proverCircuitVersion: number;\n  minPrepeginDepth: number;\n}\n\n/** Raw shape viem returns for TBVProtocolParams struct. */\ninterface RawTBVParams {\n  minimumPegInAmount: bigint;\n  maxPegInAmount: bigint;\n  pegInAckTimeout: bigint;\n  pegInActivationTimeout: bigint;\n  maxHtlcOutputCount: number;\n  expiredPegInGraceBlocks: bigint;\n}\n\n/** Map viem struct result to VersionedOffchainParams. */\nfunction mapOffchainParams(result: RawOffchainParams): VersionedOffchainParams {\n  return {\n    timelockAssert: result.timelockAssert,\n    timelockChallengeAssert: result.timelockChallengeAssert,\n    securityCouncilKeys: [...result.securityCouncilKeys],\n    councilQuorum: result.councilQuorum,\n    feeRate: result.feeRate,\n    babeTotalInstances: result.babeTotalInstances,\n    babeInstancesToFinalize: result.babeInstancesToFinalize,\n    minVpCommissionBps: result.minVpCommissionBps,\n    tRefund: result.tRefund,\n    tStale: result.tStale,\n    minPeginFeeRate: result.minPeginFeeRate,\n    proverCircuitVersion: result.proverCircuitVersion,\n    minPrepeginDepth: result.minPrepeginDepth,\n  };\n}\n\n/** Map viem struct result to TBVProtocolParams. */\nfunction mapTBVParams(result: RawTBVParams): TBVProtocolParams {\n  return {\n    minimumPegInAmount: result.minimumPegInAmount,\n    maxPegInAmount: result.maxPegInAmount,\n    pegInAckTimeout: result.pegInAckTimeout,\n    pegInActivationTimeout: result.pegInActivationTimeout,\n    maxHtlcOutputCount: result.maxHtlcOutputCount,\n    expiredPegInGraceBlocks: result.expiredPegInGraceBlocks,\n  };\n}\n\n/**\n * Derive timelockPegin from timelockAssert.\n *\n * Matches PeginLogic.sol: `uint16(timelockAssert)`.\n * The contract validates `timelockAssert <= type(uint16).max` on write,\n * but we enforce the same bound here to reject invalid values early\n * rather than silently truncating.\n *\n * @throws if timelockAssert exceeds uint16 max (65535)\n */\nfunction deriveTimelockPegin(timelockAssert: bigint): number {\n  if (timelockAssert > BigInt(UINT16_MAX)) {\n    throw new Error(\n      `timelockAssert value ${timelockAssert} exceeds uint16 max (${UINT16_MAX})`,\n    );\n  }\n  return Number(timelockAssert);\n}\n\n/**\n * Concrete protocol params reader using viem.\n *\n * Every read method runs the matching validator from\n * `protocol-params-validation` before returning, so callers don't have to\n * remember to validate.\n *\n * Usage:\n * ```ts\n * const reader = new ViemProtocolParamsReader(publicClient, protocolParamsAddress);\n * const config = await reader.getPegInConfiguration();\n * ```\n */\nexport class ViemProtocolParamsReader implements ProtocolParamsReader {\n  constructor(\n    private publicClient: PublicClient,\n    private contractAddress: Address,\n  ) {}\n\n  async getTBVProtocolParams(): Promise<TBVProtocolParams> {\n    const result = (await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: ProtocolParamsABI,\n      functionName: \"getTBVProtocolParams\",\n    })) as RawTBVParams;\n\n    const params = mapTBVParams(result);\n    validateTBVProtocolParams(params);\n    return params;\n  }\n\n  async getLatestOffchainParams(): Promise<VersionedOffchainParams> {\n    const result = (await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: ProtocolParamsABI,\n      functionName: \"getLatestOffchainParams\",\n    })) as RawOffchainParams;\n\n    const params = mapOffchainParams(result);\n    validateOffchainParams(params);\n    return params;\n  }\n\n  async getOffchainParamsByVersion(\n    version: number,\n  ): Promise<VersionedOffchainParams> {\n    const result = (await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: ProtocolParamsABI,\n      functionName: \"getOffchainParamsByVersion\",\n      args: [version],\n    })) as RawOffchainParams;\n\n    const params = mapOffchainParams(result);\n    validateOffchainParams(params);\n    return params;\n  }\n\n  async getLatestOffchainParamsVersion(): Promise<number> {\n    const raw = await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: ProtocolParamsABI,\n      functionName: \"latestOffchainParamsVersion\",\n    });\n    const version = Number(raw);\n    assertValidOffchainParamsVersion(version);\n    return version;\n  }\n\n  async getTimelockPeginByVersion(version: number): Promise<number> {\n    const params = await this.getOffchainParamsByVersion(version);\n    return deriveTimelockPegin(params.timelockAssert);\n  }\n\n  /**\n   * Returned as `bigint` with no `Number` narrowing: the registry compares it\n   * against `block.number`, so callers must do the same arithmetic the\n   * contract does. `0` is the documented \"disabled\" case and is returned as\n   * `0n`. A missing getter or a non-bigint payload throws — never coerced to\n   * `0`, which would fail open and skip the observation window.\n   *\n   * @throws If the deployment does not expose `peginActivationDelay()`, or\n   *   the decoded payload is not a `bigint`.\n   */\n  async getPeginActivationDelay(): Promise<bigint> {\n    const raw: unknown = await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: ProtocolParamsABI,\n      functionName: \"peginActivationDelay\",\n    });\n    if (typeof raw !== \"bigint\") {\n      throw new Error(\n        `Invalid peginActivationDelay from contract: must be a bigint, got ${typeof raw}`,\n      );\n    }\n    return raw;\n  }\n\n  /**\n   * Read TBV protocol params, latest offchain params, and the latest version\n   * label atomically via multicall. The version is paired with the params so\n   * that a governance update between separate reads cannot let JS build BTC\n   * scripts with version N params while the contract registers the vault\n   * under version N+1.\n   *\n   * That guarantee holds only within this multicall. A caller that also reads\n   * participant keys — every fresh peg-in build does — must pass the same\n   * `blockNumber` here and to those reads, or the two describe different\n   * blocks and the pairing above buys nothing across the seam.\n   */\n  async getPegInConfiguration(\n    blockNumber?: bigint,\n  ): Promise<PegInConfiguration> {\n    const results = await this.publicClient.multicall({\n      blockNumber,\n      contracts: [\n        {\n          address: this.contractAddress,\n          abi: ProtocolParamsABI,\n          functionName: \"getTBVProtocolParams\",\n        },\n        {\n          address: this.contractAddress,\n          abi: ProtocolParamsABI,\n          functionName: \"getLatestOffchainParams\",\n        },\n        {\n          address: this.contractAddress,\n          abi: ProtocolParamsABI,\n          functionName: \"latestOffchainParamsVersion\",\n        },\n        {\n          address: this.contractAddress,\n          abi: ProtocolParamsABI,\n          functionName: \"activeVaultCoreVersion\",\n        },\n      ],\n      allowFailure: false,\n    });\n\n    const tbvParams = mapTBVParams(results[0] as RawTBVParams);\n    const offchainParams = mapOffchainParams(results[1] as RawOffchainParams);\n    const offchainParamsVersion = Number(results[2]);\n    const activeVaultCoreVersion = Number(results[3]);\n\n    const config: PegInConfiguration = {\n      minimumPegInAmount: tbvParams.minimumPegInAmount,\n      maxPegInAmount: tbvParams.maxPegInAmount,\n      pegInAckTimeout: tbvParams.pegInAckTimeout,\n      pegInActivationTimeout: tbvParams.pegInActivationTimeout,\n      maxHtlcOutputCount: tbvParams.maxHtlcOutputCount,\n      expiredPegInGraceBlocks: tbvParams.expiredPegInGraceBlocks,\n      timelockPegin: deriveTimelockPegin(offchainParams.timelockAssert),\n      timelockRefund: offchainParams.tRefund,\n      minVpCommissionBps: offchainParams.minVpCommissionBps,\n      offchainParams,\n      offchainParamsVersion,\n      activeVaultCoreVersion,\n    };\n\n    validatePegInConfiguration(config);\n    return config;\n  }\n\n  /**\n   * Fetch every historical offchain params version in a single multicall.\n   * Iterates 1..latestVersion and calls `getOffchainParamsByVersion` for each.\n   * Versions whose payload fails validation are skipped (not included in the\n   * returned map) so a single bad historical version doesn't block the\n   * lookup of the rest.\n   *\n   * @param onSkippedVersion - optional observer invoked once per skipped\n   *   version. Use to log/telemeter without coupling the SDK to a logger.\n   */\n  async fetchAllOffchainParams(\n    onSkippedVersion?: OnSkippedOffchainParamsVersion,\n  ): Promise<AllOffchainParamsData> {\n    const latestVersion = await this.getLatestOffchainParamsVersion();\n    if (latestVersion === 0) {\n      return { byVersion: new Map(), latestVersion: 0 };\n    }\n\n    const versions = Array.from({ length: latestVersion }, (_, i) => i + 1);\n    const contracts = versions.map((v) => ({\n      address: this.contractAddress,\n      abi: ProtocolParamsABI as Abi,\n      functionName: \"getOffchainParamsByVersion\" as const,\n      args: [v] as const,\n    }));\n\n    const results = await this.publicClient.multicall({\n      contracts,\n      allowFailure: false,\n    });\n\n    const byVersion = new Map<number, VersionedOffchainParams>();\n    for (let i = 0; i < versions.length; i++) {\n      const params = mapOffchainParams(results[i] as RawOffchainParams);\n      try {\n        validateOffchainParams(params);\n        byVersion.set(versions[i], params);\n      } catch (error) {\n        // A malformed historical version mustn't block lookup of the rest.\n        // Surface the skip to the caller's observer if one was supplied.\n        onSkippedVersion?.(\n          versions[i],\n          error instanceof Error ? error : new Error(String(error)),\n        );\n      }\n    }\n\n    return { byVersion, latestVersion };\n  }\n}\n","/**\n * Concrete signer-set readers for vault keepers and universal challengers.\n *\n * These are optional utilities — callers can use their own implementations\n * of the VaultKeeperReader and UniversalChallengerReader interfaces.\n */\n\nimport type { Address, Hex, PublicClient } from \"viem\";\n\nimport { ApplicationRegistryABI } from \"../../contracts/abis/ApplicationRegistry.abi\";\nimport { ProtocolParamsABI } from \"../../contracts/abis/ProtocolParams.abi\";\nimport type {\n  AddressBTCKeyPair,\n  UniversalChallengerReader,\n  VaultKeeperReader,\n} from \"./types\";\n\n/** Map viem tuple array to AddressBTCKeyPair[]. */\nfunction mapKeyPairs(\n  result: readonly { ethAddress: Address; btcPubKey: Hex }[],\n): AddressBTCKeyPair[] {\n  return result.map((pair) => ({\n    ethAddress: pair.ethAddress,\n    btcPubKey: pair.btcPubKey,\n  }));\n}\n\n/**\n * Both key-epoch getters return `uint64` and feed the peg-in config\n * fingerprint, where the contract encodes them as `uint64`. A `Number`\n * narrowing would silently truncate above 2^53 and produce a fingerprint the\n * registry cannot reproduce, so the payload is asserted to be a `bigint` and\n * carried as one — never coerced, never defaulted.\n */\nfunction assertKeyEpoch(raw: unknown, label: string): bigint {\n  if (typeof raw !== \"bigint\") {\n    throw new Error(\n      `Invalid ${label} from contract: must be a bigint, got ${typeof raw}`,\n    );\n  }\n  return raw;\n}\n\n/**\n * Reads vault keepers from the ApplicationRegistry contract.\n *\n * Usage:\n * ```ts\n * const reader = new ViemVaultKeeperReader(publicClient, applicationRegistryAddress);\n * const keepers = await reader.getCurrentVaultKeepers(appEntryPoint);\n * ```\n */\nexport class ViemVaultKeeperReader implements VaultKeeperReader {\n  constructor(\n    private publicClient: PublicClient,\n    private contractAddress: Address,\n  ) {}\n\n  async getVaultKeepersByVersion(\n    appEntryPoint: Address,\n    version: number,\n    blockNumber?: bigint,\n  ): Promise<AddressBTCKeyPair[]> {\n    const result = (await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: ApplicationRegistryABI,\n      functionName: \"getVaultKeepersByVersion\",\n      args: [appEntryPoint, version],\n      blockNumber,\n    })) as readonly { ethAddress: Address; btcPubKey: Hex }[];\n\n    return mapKeyPairs(result);\n  }\n\n  async getCurrentVaultKeepers(\n    appEntryPoint: Address,\n  ): Promise<AddressBTCKeyPair[]> {\n    const result = (await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: ApplicationRegistryABI,\n      functionName: \"getCurrentVaultKeepers\",\n      args: [appEntryPoint],\n    })) as readonly { ethAddress: Address; btcPubKey: Hex }[];\n\n    return mapKeyPairs(result);\n  }\n\n  async getCurrentVaultKeepersVersion(\n    appEntryPoint: Address,\n    blockNumber?: bigint,\n  ): Promise<number> {\n    const result = (await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: ApplicationRegistryABI,\n      functionName: \"getCurrentVaultKeepersVersion\",\n      args: [appEntryPoint],\n      blockNumber,\n    })) as number;\n\n    return result;\n  }\n\n  async getCurrentAppKeeperKeyEpoch(\n    appEntryPoint: Address,\n    blockNumber?: bigint,\n  ): Promise<bigint> {\n    const raw: unknown = await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: ApplicationRegistryABI,\n      functionName: \"appKeeperKeyEpochCurrent\",\n      args: [appEntryPoint],\n      blockNumber,\n    });\n\n    return assertKeyEpoch(raw, \"appKeeperKeyEpochCurrent\");\n  }\n}\n\n/**\n * Reads universal challengers from the ProtocolParams contract.\n *\n * Usage:\n * ```ts\n * const reader = new ViemUniversalChallengerReader(publicClient, protocolParamsAddress);\n * const challengers = await reader.getCurrentUniversalChallengers();\n * ```\n */\nexport class ViemUniversalChallengerReader implements UniversalChallengerReader {\n  constructor(\n    private publicClient: PublicClient,\n    private contractAddress: Address,\n  ) {}\n\n  async getUniversalChallengersByVersion(\n    version: number,\n    blockNumber?: bigint,\n  ): Promise<AddressBTCKeyPair[]> {\n    const result = (await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: ProtocolParamsABI,\n      functionName: \"getUniversalChallengersByVersion\",\n      args: [version],\n      blockNumber,\n    })) as readonly { ethAddress: Address; btcPubKey: Hex }[];\n\n    return mapKeyPairs(result);\n  }\n\n  async getCurrentUniversalChallengers(): Promise<AddressBTCKeyPair[]> {\n    const result = (await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: ProtocolParamsABI,\n      functionName: \"getCurrentUniversalChallengers\",\n    })) as readonly { ethAddress: Address; btcPubKey: Hex }[];\n\n    return mapKeyPairs(result);\n  }\n\n  async getLatestUniversalChallengersVersion(\n    blockNumber?: bigint,\n  ): Promise<number> {\n    const result = (await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: ProtocolParamsABI,\n      functionName: \"latestUniversalChallengersVersion\",\n      blockNumber,\n    })) as number;\n\n    return result;\n  }\n\n  async getCurrentUcKeyEpoch(blockNumber?: bigint): Promise<bigint> {\n    const raw: unknown = await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: ProtocolParamsABI,\n      functionName: \"ucKeyEpochCurrent\",\n      blockNumber,\n    });\n\n    return assertKeyEpoch(raw, \"ucKeyEpochCurrent\");\n  }\n}\n","/**\n * Types and interfaces for ETH contract readers.\n *\n * These are optional utilities — callers can use them or build their own.\n * Core service functions never import from this module.\n */\n\nimport type { Address, Hex } from \"viem\";\n\n// ============================================================================\n// Vault Registry Types\n// ============================================================================\n\ndeclare const onChainBtcPubkeyBrand: unique symbol;\n\n/**\n * 64-char lowercase hex (no `0x`) x-only BTC pubkey sourced from an on-chain\n * registry. Minted only by `assertOnChainBtcPubkey`, which is the shared\n * validator behind both producers:\n * {@link VaultRegistryReader.getVaultProviderGenesisBtcPubKey} (the fixed\n * registration key) and {@link OperationKeyReader} (RFC-006 operation keys,\n * resolved current or at a vault's frozen epoch).\n *\n * @stability frozen\n */\nexport type OnChainBtcPubkey = string & {\n  readonly [onChainBtcPubkeyBrand]: true;\n};\n\n/**\n * Mirrors `IBTCVaultRegistry.BTCVaultStatus` in BTCVaultRegistry.sol exactly.\n * Use this when consuming `status` from `getVaultBasicInfo` /\n * `getBtcVaultBasicInfo`.\n *\n * Do NOT confuse with the app-side `ContractStatus` enum\n * (`services/deposit/peginState.ts`) — that one is for the indexer and\n * extends this with values 5-7, reassigning 4 to LIQUIDATED. Reading an\n * on-chain status through `ContractStatus[n]` for labels will mislabel\n * Expired(4) as LIQUIDATED.\n */\nexport enum OnChainBtcVaultStatus {\n  PENDING = 0,\n  VERIFIED = 1,\n  ACTIVE = 2,\n  REDEEMED = 3,\n  EXPIRED = 4,\n}\n\n/** Basic vault info from BTCVaultRegistry.getBtcVaultBasicInfo */\nexport interface VaultBasicInfo {\n  depositor: Address;\n  depositorBtcPubKey: Hex;\n  amount: bigint;\n  vaultProvider: Address;\n  status: number;\n  applicationEntryPoint: Address;\n  createdAt: bigint;\n}\n\n/** Protocol info from BTCVaultRegistry.getBtcVaultProtocolInfo */\nexport interface VaultProtocolInfo {\n  depositorSignedPeginTx: Hex;\n  universalChallengersVersion: number;\n  appVaultKeepersVersion: number;\n  offchainParamsVersion: number;\n  /**\n   * ETH block number stamped at the Pending→Verified transition.\n   * Compared against `block.number` (inclusive:\n   * `block.number >= verifiedAt + peginActivationDelay`), never a unix timestamp.\n   */\n  verifiedAt: bigint;\n  depositorWotsPkHash: Hex;\n  hashlock: Hex;\n  htlcVout: number;\n  depositorPopSignature: Hex;\n  prePeginTxHash: Hex;\n  vaultProviderCommissionBps: number;\n  /** Vault core version (uint16) stamped at registration. VP-side gating only — see #1690. */\n  vaultCoreVersion: number;\n}\n\n/** Combined vault data (basic + protocol) */\nexport interface VaultData {\n  basic: VaultBasicInfo;\n  protocol: VaultProtocolInfo;\n}\n\n/**\n * RFC-006 operation-key epochs a vault froze at `submitPeginRequest`.\n *\n * Each registry keeps a monotonic epoch counter that every key/payout setter\n * pre-increments. A vault stamps the counters live at its creation, and every\n * participant resolves \"which key did this vault bond?\" by asking the registry\n * for the key whose appended version is the latest stamped `<=` this epoch. A\n * rotation after the vault was created therefore never moves its keys.\n *\n * `uint64` — kept as `bigint` end-to-end and passed straight back to the\n * `...AtEpoch` getters, never narrowed through `Number`.\n *\n * Only ever read through {@link VaultRegistryReader.getVaultKeyEpochs}, which\n * uses the extended ABI. See `BTCVaultRegistryKeyEpochs.abi.ts` for why that\n * read is quarantined to its own ABI.\n */\nexport interface KeyEpochs {\n  vpKeyEpoch: bigint;\n  appKeeperKeyEpoch: bigint;\n  ucKeyEpoch: bigint;\n}\n\n/** Interface for reading vault data from the BTCVaultRegistry contract. */\nexport interface VaultRegistryReader {\n  getVaultBasicInfo(vaultId: Hex): Promise<VaultBasicInfo>;\n  getVaultProtocolInfo(vaultId: Hex): Promise<VaultProtocolInfo>;\n  getProtocolInfoBatch(vaultIds: readonly Hex[]): Promise<VaultProtocolInfo[]>;\n  getVaultData(vaultId: Hex): Promise<VaultData>;\n  /**\n   * Read a vault provider's *genesis* (registration) BTC key — the key bonded\n   * at version 0, which never moves when the operator rotates.\n   *\n   * Used only as the genesis fallback for epoch-based resolution and as a\n   * candidate when cross-checking an indexer hint. Never the key to build a\n   * Bitcoin lock with; that comes from `OperationKeyReader`.\n   *\n   * Resolves via `getOperationBtcKeyAtEpoch` at epoch 0, so it requires an\n   * RFC-006 registry — as does every caller.\n   */\n  getVaultProviderGenesisBtcPubKey(\n    vpAddress: Address,\n    blockNumber?: bigint,\n  ): Promise<OnChainBtcPubkey>;\n  /**\n   * Read the vault provider operation key selected by an RFC-006 epoch.\n   * Existing-vault consumers pass the vault's frozen `vpKeyEpoch` here so a\n   * later rotation cannot move the result.\n   */\n  getVaultProviderOperationBtcKeyAtEpoch(\n    vpAddress: Address,\n    epoch: bigint,\n    blockNumber?: bigint,\n  ): Promise<OnChainBtcPubkey>;\n  /** Read the protocol pegin fee (in wei) for a given vault provider. */\n  getPegInFee(vaultProvider: Address): Promise<bigint>;\n  /**\n   * Read a vault provider's current commission in basis points.\n   *\n   * Validates the contract-enforced `[0, 9999]` range — an out-of-range\n   * value signals a wrong contract address or ABI drift, not a real rate.\n   */\n  getVaultProviderCommission(vaultProvider: Address): Promise<number>;\n  /**\n   * Read a vault's frozen RFC-006 key epochs.\n   *\n   * Uses the extended `getBtcVaultProtocolInfo` ABI. Against a registry whose\n   * `BTCVaultProtocolInfo` struct is not extended this returns silent garbage\n   * for a populated vault rather than throwing, so it must only be called\n   * against an RFC-006 registry — a deployment invariant, not something this\n   * call can detect. A registry missing the operation-key getters altogether is\n   * the safer case: key resolution reverts downstream and these epochs are never\n   * used. See `BTCVaultRegistryKeyEpochs.abi.ts`.\n   */\n  getVaultKeyEpochs(vaultId: Hex): Promise<KeyEpochs>;\n  /** {@link getVaultKeyEpochs} for many vaults in one multicall. */\n  getVaultKeyEpochsBatch(vaultIds: readonly Hex[]): Promise<KeyEpochs[]>;\n  /**\n   * Read a vault provider's *current* RFC-006 operation BTC key — the key its\n   * server uses for the JSON-RPC token subject. Falls back to the registration\n   * key when the provider has never rotated.\n   */\n  getCurrentVaultProviderOperationBtcKey(\n    vpAddress: Address,\n  ): Promise<OnChainBtcPubkey>;\n  /**\n   * Read the depositor's commission ceiling (`maxAcceptableCommissionBps`)\n   * for vaults registered in the same block `createdAt`, from their\n   * `PegInSubmittedV2` logs, in `vaultIds` order. The contract discards the\n   * ceiling after bound-checking it, so the log is its only on-chain source.\n   *\n   * @throws {RegistrationLogsUnavailableError} (transient, retry) when the\n   * node answers with no registration logs for the block at all.\n   * @throws when a vault has only its `PegInSubmitted` log (a registration\n   * that predates the V2 event), none, or more than one V2 log.\n   */\n  getMaxAcceptableCommissionBpsBatch(\n    vaultIds: readonly Hex[],\n    createdAt: bigint,\n  ): Promise<number[]>;\n  /**\n   * Read the application entry point a vault provider is registered for.\n   *\n   * The peg-in submit path resolves this internally and uses it to pick the\n   * keeper roster, the roster version and the keeper key epoch a deposit is\n   * bonded to. Pass `blockNumber` when the result will shape a Bitcoin lock,\n   * so it describes the same block as the roster reads that follow it.\n   */\n  getVaultProviderApplication(\n    vpAddress: Address,\n    blockNumber?: bigint,\n  ): Promise<Address>;\n}\n\n// ============================================================================\n// Protocol Params Types (from IProtocolParams.sol)\n// ============================================================================\n\n/**\n * TBV protocol parameters from the ProtocolParams contract.\n * Matches Solidity struct `IProtocolParams.TBVProtocolParams` exactly.\n *\n * All uint64 amounts use bigint (satoshi values can exceed 2^53).\n * uint8 uses number (bounded, max 255).\n */\nexport interface TBVProtocolParams {\n  minimumPegInAmount: bigint;\n  maxPegInAmount: bigint;\n  pegInAckTimeout: bigint;\n  pegInActivationTimeout: bigint;\n  maxHtlcOutputCount: number;\n  /**\n   * Number of blocks added to the activation deadline as a grace window\n   * during which a depositor may still reclaim an expired pegin via the\n   * HTLC preimage. Source: `IProtocolParams.TBVProtocolParams.expiredPegInGraceBlocks`.\n   */\n  expiredPegInGraceBlocks: bigint;\n}\n\n/**\n * Versioned offchain parameters from the ProtocolParams contract.\n * Matches Solidity struct `IProtocolParams.VersionedOffchainParams` exactly.\n *\n * bigint for: uint256 timelocks, uint64 fee rates/amounts.\n * number for: uint8/uint16/uint32 fields (bounded, safe for JS arithmetic).\n */\nexport interface VersionedOffchainParams {\n  timelockAssert: bigint;\n  timelockChallengeAssert: bigint;\n  securityCouncilKeys: Hex[];\n  councilQuorum: number;\n  feeRate: bigint;\n  babeTotalInstances: number;\n  babeInstancesToFinalize: number;\n  minVpCommissionBps: number;\n  tRefund: number;\n  tStale: number;\n  minPeginFeeRate: bigint;\n  proverCircuitVersion: number;\n  minPrepeginDepth: number;\n}\n\n/**\n * Combined peg-in configuration read atomically via multicall.\n * Prevents TOCTOU inconsistency if governance updates params between reads.\n */\nexport interface PegInConfiguration {\n  minimumPegInAmount: bigint;\n  maxPegInAmount: bigint;\n  pegInAckTimeout: bigint;\n  pegInActivationTimeout: bigint;\n  maxHtlcOutputCount: number;\n  expiredPegInGraceBlocks: bigint;\n  timelockPegin: number;\n  timelockRefund: number;\n  minVpCommissionBps: number;\n  offchainParams: VersionedOffchainParams;\n  /**\n   * Version label paired atomically with `offchainParams`.\n   * Read in the same multicall as the params struct so that, if a parameter\n   * update lands between separate reads, the script-construction code and\n   * the version label stay consistent.\n   */\n  offchainParamsVersion: number;\n  /**\n   * Currently-active vault core (tx-graph) version\n   * (`ProtocolParams.activeVaultCoreVersion()`, uint16 ≥ 1). Stamped onto\n   * every new vault at peg-in submission; fresh deposits must build this\n   * graph version. Read in the same multicall so a governance version bump\n   * can't land between reading the params and reading the version.\n   */\n  activeVaultCoreVersion: number;\n}\n\n/**\n * All offchain params snapshots indexed by version, plus the latest version\n * number known when the snapshot was taken. Used by consumers that need to\n * resolve any historical version (e.g. signing for an existing vault locked\n * to an older version).\n */\nexport interface AllOffchainParamsData {\n  byVersion: Map<number, VersionedOffchainParams>;\n  latestVersion: number;\n}\n\n/**\n * Optional observer invoked by `fetchAllOffchainParams` when a historical\n * version fails validation. Called once per skipped version so callers can\n * log/telemeter without coupling the SDK to a specific logger.\n */\nexport type OnSkippedOffchainParamsVersion = (\n  version: number,\n  error: Error,\n) => void;\n\n/** Interface for reading protocol parameters from the ProtocolParams contract. */\nexport interface ProtocolParamsReader {\n  getTBVProtocolParams(): Promise<TBVProtocolParams>;\n  getOffchainParamsByVersion(version: number): Promise<VersionedOffchainParams>;\n  getLatestOffchainParams(): Promise<VersionedOffchainParams>;\n  getLatestOffchainParamsVersion(): Promise<number>;\n  getTimelockPeginByVersion(version: number): Promise<number>;\n  /**\n   * Pass `blockNumber` when the result will shape a Bitcoin lock, so this\n   * multicall and the participant-key reads describe the same block. Omit it\n   * for display-only reads, where a slightly stale value is harmless.\n   */\n  getPegInConfiguration(blockNumber?: bigint): Promise<PegInConfiguration>;\n  /**\n   * Observation window enforced between a vault's final ACK and its\n   * activation, in ETH blocks measured from `verifiedAt`. `0` disables it.\n   *\n   * Deliberately its own read rather than a field on\n   * {@link PegInConfiguration}: the parameter is absent from deployments that\n   * predate it, so folding it into the shared multicall would make every\n   * protocol-param read fail wherever it is missing.\n   *\n   * @throws If the deployment does not expose `peginActivationDelay()`, or\n   *   the decoded payload is not a `bigint`.\n   */\n  getPeginActivationDelay(): Promise<bigint>;\n  fetchAllOffchainParams(\n    onSkippedVersion?: OnSkippedOffchainParamsVersion,\n  ): Promise<AllOffchainParamsData>;\n}\n\n// ============================================================================\n// Signer-Set Types (from BTCVaultTypes.sol)\n// ============================================================================\n\n/**\n * Matches Solidity struct `BTCVaultTypes.AddressBTCKeyPair` exactly.\n * Used for vault keepers and universal challengers.\n */\nexport interface AddressBTCKeyPair {\n  ethAddress: Address;\n  btcPubKey: Hex;\n}\n\n/**\n * Interface for reading vault keepers from the ApplicationRegistry contract.\n *\n * The reads used to build a peg-in — here and on the sibling reader interfaces\n * — take an optional `blockNumber` that pins them to one block instead of\n * `latest`. Omitting it, the historical behaviour, is correct for every read\n * that resolves against a vault's already-frozen epochs, because those are\n * immutable once stamped. It is NOT correct for a fresh peg-in build: the\n * participant keys, roster versions and protocol params that shape the Bitcoin\n * lock must all describe the same block, or the lock commits to a mixture of\n * chain states that never existed at once. See\n * `services/deposit/validateOnChainParticipantKeys`.\n *\n * The `getCurrent*` roster reads are the exception and take no block. Nothing\n * on the build path uses them — it resolves rosters by version instead — so\n * they were left alone rather than given a pin no caller would pass.\n */\nexport interface VaultKeeperReader {\n  getVaultKeepersByVersion(\n    appEntryPoint: Address,\n    version: number,\n    blockNumber?: bigint,\n  ): Promise<AddressBTCKeyPair[]>;\n  getCurrentVaultKeepers(appEntryPoint: Address): Promise<AddressBTCKeyPair[]>;\n  getCurrentVaultKeepersVersion(\n    appEntryPoint: Address,\n    blockNumber?: bigint,\n  ): Promise<number>;\n  /**\n   * Read the application's current vault-keeper operation-key epoch.\n   *\n   * One counter for the whole application, bumped by any keeper's\n   * operation-key or payout-script append. The peg-in config fingerprint\n   * commits to it in place of the N resolved keeper keys, so it must be read\n   * at the same block as the roster it labels. Returned as `bigint`; the\n   * contract encodes it as `uint64` and a `Number` would truncate.\n   */\n  getCurrentAppKeeperKeyEpoch(\n    appEntryPoint: Address,\n    blockNumber?: bigint,\n  ): Promise<bigint>;\n}\n\n/** Interface for reading universal challengers from the ProtocolParams contract. */\nexport interface UniversalChallengerReader {\n  getUniversalChallengersByVersion(\n    version: number,\n    blockNumber?: bigint,\n  ): Promise<AddressBTCKeyPair[]>;\n  getCurrentUniversalChallengers(): Promise<AddressBTCKeyPair[]>;\n  getLatestUniversalChallengersVersion(blockNumber?: bigint): Promise<number>;\n  /**\n   * Read the protocol's current universal-challenger operation-key epoch.\n   *\n   * The challenger-axis counterpart to\n   * {@link VaultKeeperReader.getCurrentAppKeeperKeyEpoch}: one protocol-wide\n   * counter the fingerprint commits to in place of the M resolved challenger\n   * keys. Returned as `bigint` for the same `uint64` reason.\n   */\n  getCurrentUcKeyEpoch(blockNumber?: bigint): Promise<bigint>;\n}\n\n// ============================================================================\n// RFC-006 Operation-Key Types\n// ============================================================================\n\n/**\n * The participants whose operation keys are being resolved, and the roster\n * they are resolved against.\n *\n * A roster entry's `ethAddress` is the operator's **admin** address — the\n * lookup key for its key history — and its `btcPubKey` is the operator's\n * **genesis** key. Both are needed: the `...AtEpochOrGenesis` getters take the\n * roster key explicitly because the correct genesis for a keeper/challenger is\n * its key in the vault's *frozen membership version*, which an operator that\n * was later dropped from the roster no longer has a current entry for.\n */\nexport interface OperationKeyQuery {\n  vaultProviderEthAddress: Address;\n  /**\n   * The VP's genesis (registration) key, from\n   * {@link VaultRegistryReader.getVaultProviderGenesisBtcPubKey}.\n   *\n   * The VP has no roster entry to carry a genesis key the way keepers and\n   * challengers do, so it is supplied here. Every call site already reads it:\n   * it is what the indexer hint is compared against, and what makes the VP's\n   * `rotated` flag mean the same thing as everyone else's.\n   */\n  vaultProviderGenesisBtcPubkey: Hex;\n  applicationEntryPoint: Address;\n  /** Keeper roster at the membership version being resolved against. */\n  vaultKeepers: readonly AddressBTCKeyPair[];\n  /** Challenger roster at the membership version being resolved against. */\n  universalChallengers: readonly AddressBTCKeyPair[];\n}\n\n/** Raw registry-returned operation keys, index-aligned with the query rosters. */\nexport interface RawOperationKeys {\n  vaultProvider: Hex;\n  vaultKeepers: Hex[];\n  universalChallengers: Hex[];\n}\n\n/**\n * Registry-returned payout scriptPubKeys, index-aligned with the query\n * rosters. `universalChallengers` has no counterpart: a UC is never a claimer,\n * so it has no payout script.\n */\nexport interface RawPayoutScripts {\n  vaultProvider: Hex;\n  vaultKeepers: Hex[];\n}\n\n/**\n * Reads RFC-006 operation keys and payout scripts across all three registries\n * (BTCVaultRegistry, ApplicationRegistry, ProtocolParams).\n *\n * Every method resolves the whole participant set in a **single** multicall so\n * the keys are pinned to one block. That atomicity is load-bearing: a rotation\n * landing between two `eth_call`s would yield a self-inconsistent key set that\n * builds a lock no counterparty agrees with.\n */\nexport interface OperationKeyReader {\n  /**\n   * Resolve every participant's *current* operation key.\n   *\n   * Used for new peg-ins. The VP-only current getter separately supplies the\n   * JSON-RPC auth pin. Needs no epoch read at all — each registry's\n   * `getCurrentOperationBtcKey` resolves its own genesis fallback, so an\n   * operator that never rotated yields its registration key.\n   */\n  getCurrentOperationKeys(\n    query: OperationKeyQuery,\n    blockNumber?: bigint,\n  ): Promise<RawOperationKeys>;\n  /**\n   * Resolve every participant's operation key bonded at a vault's frozen\n   * epochs. Used for every existing-vault path (resume, payout, refund).\n   */\n  getOperationKeysAtEpochs(\n    query: OperationKeyQuery,\n    epochs: KeyEpochs,\n  ): Promise<RawOperationKeys>;\n  /**\n   * Resolve the VP's commission payout script and each keeper's payout script\n   * at a vault's frozen epochs.\n   *\n   * The registry backfills BIP-86 P2TR of the epoch's operation key for any\n   * operator that never called `setPayoutScript`, so this returns byte-identical\n   * results to local BIP-86 derivation until an operator registers a custom\n   * script.\n   */\n  getPayoutScriptsAtEpochs(\n    query: OperationKeyQuery,\n    epochs: KeyEpochs,\n  ): Promise<RawPayoutScripts>;\n}\n"],"names":["resolveProtocolAddresses","publicClient","btcVaultRegistryAddress","protocolParams","applicationRegistry","BTCVaultRegistryABI","assertMulticallLength","actual","expected","label","partition","results","keeperCount","ViemOperationKeyReader","contracts","calls","challengerCount","blockNumber","query","keeper","ApplicationRegistryABI","challenger","ProtocolParamsABI","epochs","UINT16_MAX","mapOffchainParams","result","mapTBVParams","deriveTimelockPegin","timelockAssert","ViemProtocolParamsReader","contractAddress","params","validateTBVProtocolParams","validateOffchainParams","version","raw","assertValidOffchainParamsVersion","tbvParams","offchainParams","offchainParamsVersion","activeVaultCoreVersion","config","validatePegInConfiguration","onSkippedVersion","latestVersion","versions","_","i","v","byVersion","error","mapKeyPairs","pair","assertKeyEpoch","ViemVaultKeeperReader","appEntryPoint","ViemUniversalChallengerReader","OnChainBtcVaultStatus"],"mappings":"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"}

package/dist/types-DGkejGZH.js

@@ -1,456 +0,0 @@
-import { B as u } from "./BTCVaultRegistry.abi-B0x9_Bza.js";
-import { A as o, P as n } from "./ProtocolParams.abi-q0AidvYX.js";
-import { b as C, v as h, e as v, a as E } from "./pegin-registration-client-ilkV1mLP.js";
-async function R(a, t) {
-  const [e, r] = await a.multicall({
-    contracts: [
-      {
-        address: t,
-        abi: u,
-        functionName: "protocolParams"
-      },
-      {
-        address: t,
-        abi: u,
-        functionName: "applicationRegistry"
-      }
-    ],
-    allowFailure: !1
-  });
-  return {
-    protocolParams: e,
-    applicationRegistry: r
-  };
-}
-function f(a, t, e) {
-  if (a !== t)
-    throw new Error(
-      `${e}: multicall returned ${a} results for ${t} calls, so the results are not roster-aligned; refusing to use them`
-    );
-}
-function K(a, t) {
-  return {
-    vaultProvider: a[0],
-    vaultKeepers: a.slice(1, 1 + t),
-    universalChallengers: a.slice(1 + t)
-  };
-}
-class B {
-  constructor(t, e) {
-    this.publicClient = t, this.contracts = e;
-  }
-  /**
-   * One multicall, `allowFailure: false`, so every key in the set is read at
-   * the same block. A rotation landing between two separate `eth_call`s would
-   * otherwise produce a mixed-epoch key set and a lock no counterparty agrees
-   * with.
-   */
-  async readAll(t, e, r, s, l) {
-    const c = await this.publicClient.multicall({
-      contracts: t,
-      allowFailure: !1,
-      blockNumber: l
-    });
-    return f(
-      c.length,
-      1 + e + r,
-      s
-    ), K(c, e);
-  }
-  async getCurrentOperationKeys(t, e) {
-    const r = [
-      {
-        address: this.contracts.btcVaultRegistry,
-        abi: u,
-        functionName: "getCurrentOperationBtcKey",
-        args: [t.vaultProviderEthAddress]
-      },
-      ...t.vaultKeepers.map((s) => ({
-        address: this.contracts.applicationRegistry,
-        abi: o,
-        functionName: "getCurrentOperationBtcKey",
-        args: [t.applicationEntryPoint, s.ethAddress]
-      })),
-      ...t.universalChallengers.map((s) => ({
-        address: this.contracts.protocolParams,
-        abi: n,
-        functionName: "getCurrentOperationBtcKey",
-        args: [s.ethAddress]
-      }))
-    ];
-    return this.readAll(
-      r,
-      t.vaultKeepers.length,
-      t.universalChallengers.length,
-      "getCurrentOperationKeys",
-      e
-    );
-  }
-  async getOperationKeysAtEpochs(t, e) {
-    const r = [
-      // The VP takes the plain `AtEpoch` variant: it has no membership
-      // version, so its genesis (the registration key at version 0) is
-      // unambiguous and the contract resolves it internally.
-      {
-        address: this.contracts.btcVaultRegistry,
-        abi: u,
-        functionName: "getOperationBtcKeyAtEpoch",
-        args: [t.vaultProviderEthAddress, e.vpKeyEpoch]
-      },
-      // Keepers and challengers take `...OrGenesis` with their roster key
-      // passed explicitly, because the correct genesis for them is their key
-      // in *this vault's frozen membership version*. An operator dropped from
-      // the current roster, or listed under a different key in an older
-      // version, would otherwise resolve against the wrong genesis.
-      ...t.vaultKeepers.map((s) => ({
-        address: this.contracts.applicationRegistry,
-        abi: o,
-        functionName: "getOperationBtcKeyAtEpochOrGenesis",
-        args: [
-          t.applicationEntryPoint,
-          s.ethAddress,
-          e.appKeeperKeyEpoch,
-          s.btcPubKey
-        ]
-      })),
-      ...t.universalChallengers.map((s) => ({
-        address: this.contracts.protocolParams,
-        abi: n,
-        functionName: "getOperationBtcKeyAtEpochOrGenesis",
-        args: [s.ethAddress, e.ucKeyEpoch, s.btcPubKey]
-      }))
-    ];
-    return this.readAll(
-      r,
-      t.vaultKeepers.length,
-      t.universalChallengers.length,
-      "getOperationKeysAtEpochs"
-    );
-  }
-  async getPayoutScriptsAtEpochs(t, e) {
-    const r = await this.publicClient.multicall({
-      contracts: [
-        {
-          address: this.contracts.btcVaultRegistry,
-          abi: u,
-          functionName: "getPayoutScriptAtEpoch",
-          args: [t.vaultProviderEthAddress, e.vpKeyEpoch]
-        },
-        ...t.vaultKeepers.map((s) => ({
-          address: this.contracts.applicationRegistry,
-          abi: o,
-          functionName: "getPayoutScriptAtEpoch",
-          args: [
-            t.applicationEntryPoint,
-            s.ethAddress,
-            e.appKeeperKeyEpoch
-          ]
-        }))
-      ],
-      allowFailure: !1
-    });
-    return f(
-      r.length,
-      1 + t.vaultKeepers.length,
-      "getPayoutScriptsAtEpochs"
-    ), {
-      vaultProvider: r[0],
-      vaultKeepers: [...r.slice(1)]
-    };
-  }
-}
-const b = 65535;
-function d(a) {
-  return {
-    timelockAssert: a.timelockAssert,
-    timelockChallengeAssert: a.timelockChallengeAssert,
-    securityCouncilKeys: [...a.securityCouncilKeys],
-    councilQuorum: a.councilQuorum,
-    feeRate: a.feeRate,
-    babeTotalInstances: a.babeTotalInstances,
-    babeInstancesToFinalize: a.babeInstancesToFinalize,
-    minVpCommissionBps: a.minVpCommissionBps,
-    tRefund: a.tRefund,
-    tStale: a.tStale,
-    minPeginFeeRate: a.minPeginFeeRate,
-    proverCircuitVersion: a.proverCircuitVersion,
-    minPrepeginDepth: a.minPrepeginDepth
-  };
-}
-function P(a) {
-  return {
-    minimumPegInAmount: a.minimumPegInAmount,
-    maxPegInAmount: a.maxPegInAmount,
-    pegInAckTimeout: a.pegInAckTimeout,
-    pegInActivationTimeout: a.pegInActivationTimeout,
-    maxHtlcOutputCount: a.maxHtlcOutputCount,
-    expiredPegInGraceBlocks: a.expiredPegInGraceBlocks
-  };
-}
-function A(a) {
-  if (a > BigInt(b))
-    throw new Error(
-      `timelockAssert value ${a} exceeds uint16 max (${b})`
-    );
-  return Number(a);
-}
-class O {
-  constructor(t, e) {
-    this.publicClient = t, this.contractAddress = e;
-  }
-  async getTBVProtocolParams() {
-    const t = await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: n,
-      functionName: "getTBVProtocolParams"
-    }), e = P(t);
-    return C(e), e;
-  }
-  async getLatestOffchainParams() {
-    const t = await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: n,
-      functionName: "getLatestOffchainParams"
-    }), e = d(t);
-    return h(e), e;
-  }
-  async getOffchainParamsByVersion(t) {
-    const e = await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: n,
-      functionName: "getOffchainParamsByVersion",
-      args: [t]
-    }), r = d(e);
-    return h(r), r;
-  }
-  async getLatestOffchainParamsVersion() {
-    const t = await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: n,
-      functionName: "latestOffchainParamsVersion"
-    }), e = Number(t);
-    return v(e), e;
-  }
-  async getTimelockPeginByVersion(t) {
-    const e = await this.getOffchainParamsByVersion(t);
-    return A(e.timelockAssert);
-  }
-  /**
-   * Returned as `bigint` with no `Number` narrowing: the registry compares it
-   * against `block.number`, so callers must do the same arithmetic the
-   * contract does. `0` is the documented "disabled" case and is returned as
-   * `0n`. A missing getter or a non-bigint payload throws — never coerced to
-   * `0`, which would fail open and skip the observation window.
-   *
-   * @throws If the deployment does not expose `peginActivationDelay()`, or
-   *   the decoded payload is not a `bigint`.
-   */
-  async getPeginActivationDelay() {
-    const t = await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: n,
-      functionName: "peginActivationDelay"
-    });
-    if (typeof t != "bigint")
-      throw new Error(
-        `Invalid peginActivationDelay from contract: must be a bigint, got ${typeof t}`
-      );
-    return t;
-  }
-  /**
-   * Read TBV protocol params, latest offchain params, and the latest version
-   * label atomically via multicall. The version is paired with the params so
-   * that a governance update between separate reads cannot let JS build BTC
-   * scripts with version N params while the contract registers the vault
-   * under version N+1.
-   *
-   * That guarantee holds only within this multicall. A caller that also reads
-   * participant keys — every fresh peg-in build does — must pass the same
-   * `blockNumber` here and to those reads, or the two describe different
-   * blocks and the pairing above buys nothing across the seam.
-   */
-  async getPegInConfiguration(t) {
-    const e = await this.publicClient.multicall({
-      blockNumber: t,
-      contracts: [
-        {
-          address: this.contractAddress,
-          abi: n,
-          functionName: "getTBVProtocolParams"
-        },
-        {
-          address: this.contractAddress,
-          abi: n,
-          functionName: "getLatestOffchainParams"
-        },
-        {
-          address: this.contractAddress,
-          abi: n,
-          functionName: "latestOffchainParamsVersion"
-        },
-        {
-          address: this.contractAddress,
-          abi: n,
-          functionName: "activeVaultCoreVersion"
-        }
-      ],
-      allowFailure: !1
-    }), r = P(e[0]), s = d(e[1]), l = Number(e[2]), c = Number(e[3]), i = {
-      minimumPegInAmount: r.minimumPegInAmount,
-      maxPegInAmount: r.maxPegInAmount,
-      pegInAckTimeout: r.pegInAckTimeout,
-      pegInActivationTimeout: r.pegInActivationTimeout,
-      maxHtlcOutputCount: r.maxHtlcOutputCount,
-      expiredPegInGraceBlocks: r.expiredPegInGraceBlocks,
-      timelockPegin: A(s.timelockAssert),
-      timelockRefund: s.tRefund,
-      minVpCommissionBps: s.minVpCommissionBps,
-      offchainParams: s,
-      offchainParamsVersion: l,
-      activeVaultCoreVersion: c
-    };
-    return E(i), i;
-  }
-  /**
-   * Fetch every historical offchain params version in a single multicall.
-   * Iterates 1..latestVersion and calls `getOffchainParamsByVersion` for each.
-   * Versions whose payload fails validation are skipped (not included in the
-   * returned map) so a single bad historical version doesn't block the
-   * lookup of the rest.
-   *
-   * @param onSkippedVersion - optional observer invoked once per skipped
-   *   version. Use to log/telemeter without coupling the SDK to a logger.
-   */
-  async fetchAllOffchainParams(t) {
-    const e = await this.getLatestOffchainParamsVersion();
-    if (e === 0)
-      return { byVersion: /* @__PURE__ */ new Map(), latestVersion: 0 };
-    const r = Array.from({ length: e }, (i, m) => m + 1), s = r.map((i) => ({
-      address: this.contractAddress,
-      abi: n,
-      functionName: "getOffchainParamsByVersion",
-      args: [i]
-    })), l = await this.publicClient.multicall({
-      contracts: s,
-      allowFailure: !1
-    }), c = /* @__PURE__ */ new Map();
-    for (let i = 0; i < r.length; i++) {
-      const m = d(l[i]);
-      try {
-        h(m), c.set(r[i], m);
-      } catch (g) {
-        t == null || t(
-          r[i],
-          g instanceof Error ? g : new Error(String(g))
-        );
-      }
-    }
-    return { byVersion: c, latestVersion: e };
-  }
-}
-function p(a) {
-  return a.map((t) => ({
-    ethAddress: t.ethAddress,
-    btcPubKey: t.btcPubKey
-  }));
-}
-function y(a, t) {
-  if (typeof a != "bigint")
-    throw new Error(
-      `Invalid ${t} from contract: must be a bigint, got ${typeof a}`
-    );
-  return a;
-}
-class T {
-  constructor(t, e) {
-    this.publicClient = t, this.contractAddress = e;
-  }
-  async getVaultKeepersByVersion(t, e, r) {
-    const s = await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: o,
-      functionName: "getVaultKeepersByVersion",
-      args: [t, e],
-      blockNumber: r
-    });
-    return p(s);
-  }
-  async getCurrentVaultKeepers(t) {
-    const e = await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: o,
-      functionName: "getCurrentVaultKeepers",
-      args: [t]
-    });
-    return p(e);
-  }
-  async getCurrentVaultKeepersVersion(t, e) {
-    return await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: o,
-      functionName: "getCurrentVaultKeepersVersion",
-      args: [t],
-      blockNumber: e
-    });
-  }
-  async getCurrentAppKeeperKeyEpoch(t, e) {
-    const r = await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: o,
-      functionName: "appKeeperKeyEpochCurrent",
-      args: [t],
-      blockNumber: e
-    });
-    return y(r, "appKeeperKeyEpochCurrent");
-  }
-}
-class D {
-  constructor(t, e) {
-    this.publicClient = t, this.contractAddress = e;
-  }
-  async getUniversalChallengersByVersion(t, e) {
-    const r = await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: n,
-      functionName: "getUniversalChallengersByVersion",
-      args: [t],
-      blockNumber: e
-    });
-    return p(r);
-  }
-  async getCurrentUniversalChallengers() {
-    const t = await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: n,
-      functionName: "getCurrentUniversalChallengers"
-    });
-    return p(t);
-  }
-  async getLatestUniversalChallengersVersion(t) {
-    return await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: n,
-      functionName: "latestUniversalChallengersVersion",
-      blockNumber: t
-    });
-  }
-  async getCurrentUcKeyEpoch(t) {
-    const e = await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: n,
-      functionName: "ucKeyEpochCurrent",
-      blockNumber: t
-    });
-    return y(e, "ucKeyEpochCurrent");
-  }
-}
-var V = /* @__PURE__ */ ((a) => (a[a.PENDING = 0] = "PENDING", a[a.VERIFIED = 1] = "VERIFIED", a[a.ACTIVE = 2] = "ACTIVE", a[a.REDEEMED = 3] = "REDEEMED", a[a.EXPIRED = 4] = "EXPIRED", a))(V || {});
-export {
-  V as O,
-  B as V,
-  O as a,
-  D as b,
-  T as c,
-  R as r
-};
-//# sourceMappingURL=types-DGkejGZH.js.map