kokio-sdk 1.1.0 → 2.1.0

package/dist/esm/logic/admin/reads/deviceWalletFactory.reads.js

@@ -1,15 +1,13 @@
 import { publicActions } from "viem";
 import { _getChainSpecificConstants } from "../../constants.js";
 import { DeviceWalletFactory } from "../../../abis/index.js";
-/**
- * Read-only admin logic for `DeviceWalletFactory` - the contract's public
- * storage getters and `view` functions, surfaced for the backend.
- *
- * A viem `WalletClient` carries no public actions, so each read extends it with
- * `publicActions` (reusing the same transport, so it also works under an anvil
- * fork) before calling `readContract`. Reads need no EOA account, so there is no
- * `MissingEOAWalletError` guard.
- */
+// Read-only admin logic for `DeviceWalletFactory` - the contract's public
+// storage getters and `view` functions, surfaced for the backend.
+//
+// A viem `WalletClient` carries no public actions, so each read extends it with
+// `publicActions` (reusing the same transport, so it also works under an anvil
+// fork) before calling `readContract`. Reads need no EOA account, so there is no
+// `MissingEOAWalletError` guard.
 /** The admin EOA (`eSIMWalletAdmin`) currently set on the factory. */
 export const _eSIMWalletAdmin = async (client) => {
     const chainID = await client.getChainId();
@@ -22,54 +20,87 @@ export const _eSIMWalletAdmin = async (client) => {
         args: []
     });
 };
-/** The vault EOA that receives eSIM payments. */
-export const _vault = async (client) => {
+/** Whether a device wallet has been registered with the factory. */
+export const _deviceWalletInfoAdded = async (client, deviceWallet) => {
     const chainID = await client.getChainId();
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.extend(publicActions).readContract({
         address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
         abi: DeviceWalletFactory,
-        functionName: "vault",
-        args: []
+        functionName: "deviceWalletInfoAdded",
+        args: [deviceWallet]
     });
 };
-/** The pending admin proposed via `requestAdminUpdate` (zero address if none). */
-export const _newRequestedAdmin = async (client) => {
+/** The current device-wallet beacon implementation. */
+export const _getCurrentDeviceWalletImplementation = async (client) => {
     const chainID = await client.getChainId();
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.extend(publicActions).readContract({
         address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
         abi: DeviceWalletFactory,
-        functionName: "newRequestedAdmin",
+        functionName: "getCurrentDeviceWalletImplementation",
         args: []
     });
 };
-/** Whether a device wallet has been registered with the factory. */
-export const _deviceWalletInfoAdded = async (client, deviceWallet) => {
+/**
+ * Check an identifier and owner key before deploying. Answers the zero address
+ * when both are free, or the wallet already holding one of them.
+ *
+ * `createAccount` runs inside EntryPoint validation, where the 4337 rules bar it
+ * from reading the registry, so it cannot see that an identifier or a key is
+ * taken: it deploys a second wallet at a fresh address and the
+ * `postCreateAccount` that would register it fails afterwards. Checking here
+ * first is what stops that.
+ *
+ * Reverts on an empty identifier or a key that is not a point on the P256 curve.
+ */
+export const _preCreateAccountValidation = async (client, deviceUniqueIdentifier, deviceWalletOwnerKey) => {
     const chainID = await client.getChainId();
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.extend(publicActions).readContract({
         address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
         abi: DeviceWalletFactory,
-        functionName: "deviceWalletInfoAdded",
-        args: [deviceWallet]
+        functionName: "preCreateAccountValidation",
+        args: [deviceUniqueIdentifier, deviceWalletOwnerKey]
     });
 };
-/** The current device-wallet beacon implementation. */
-export const _getCurrentDeviceWalletImplementation = async (client) => {
+const _addressGetter = async (client, functionName) => {
     const chainID = await client.getChainId();
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.extend(publicActions).readContract({
         address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
         abi: DeviceWalletFactory,
-        functionName: "getCurrentDeviceWalletImplementation",
+        functionName,
         args: []
     });
 };
+/**
+ * The beacon every device wallet reads its implementation from. One update moves
+ * all of them and no wallet can decline it.
+ */
+export const _beacon = (client) => _addressGetter(client, "beacon");
+/** The registry the factory writes new wallets into. */
+export const _registry = (client) => _addressGetter(client, "registry");
+/** The EntryPoint baked into every device wallet this factory deploys. */
+export const _entryPoint = (client) => _addressGetter(client, "entryPoint");
+/** The contract new device wallets verify WebAuthn assertions through. */
+export const _verifier = (client) => _addressGetter(client, "verifier");
+/**
+ * Who holds `onlyOwner` on the factory. On the live deployment this is the
+ * `ProtocolAdmin` timelock, so an owner call sent from an EOA reverts and has to
+ * be scheduled instead.
+ */
+export const _owner = (client) => _addressGetter(client, "owner");
+/**
+ * The address a `transferOwnership` is waiting on. Worth reading before
+ * `protocolAdmin.acceptOwnershipBatch`, which reverts on any target that has not
+ * been offered to the timelock.
+ */
+export const _pendingOwner = (client) => _addressGetter(client, "pendingOwner");
 /**
  * The counterfactual (CREATE2) device-wallet address for an owner key. On-chain
  * arg order is `(ownerKey, uid, salt)` - note this differs from `createAccount`.
@@ -85,3 +116,31 @@ export const _getCounterFactualAddress = async (client, deviceWalletOwnerKey, de
         args: [deviceWalletOwnerKey, deviceUniqueIdentifier, salt]
     });
 };
+/**
+ * The ERC-1822 storage slot this proxy keeps its implementation in. An upgrade
+ * reverts unless the incoming implementation answers with the same value, which
+ * is what stops a non-UUPS address being installed.
+ */
+export const _proxiableUUID = async (client) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
+        abi: DeviceWalletFactory,
+        functionName: "proxiableUUID",
+        args: []
+    });
+};
+/** The OpenZeppelin upgrade interface this proxy speaks, currently `"5.0.0"`. */
+export const _upgradeInterfaceVersion = async (client) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
+        abi: DeviceWalletFactory,
+        functionName: "UPGRADE_INTERFACE_VERSION",
+        args: []
+    });
+};

package/dist/esm/logic/admin/reads/eSIMWallet.reads.js

@@ -1,11 +1,9 @@
 import { publicActions } from "viem";
 import { ESIMWallet } from "../../../abis/index.js";
-/**
- * Read-only admin logic targeting a specific `ESIMWallet` instance (its address
- * is passed in). Surfaces the instance's public storage getters + `owner` view
- * for the backend. Each read extends the `WalletClient` with `publicActions`; no
- * EOA account is required.
- */
+// Read-only admin logic targeting a specific `ESIMWallet` instance (its address
+// is passed in). Surfaces the instance's public storage getters + `owner` view
+// for the backend. Each read extends the `WalletClient` with `publicActions`; no
+// EOA account is required.
 /** The `ESIMWalletFactory` that deployed this eSIM wallet. */
 export const _eSIMWalletFactory = async (client, eSIMWalletAddress) => {
     return client.extend(publicActions).readContract({
@@ -24,6 +22,20 @@ export const _eSIMUniqueIdentifier = async (client, eSIMWalletAddress) => {
         args: []
     });
 };
+/**
+ * This wallet's own price ceiling in wei. Zero means it follows the registry's
+ * `defaultDataBundlePriceCap` instead, which is the state a fresh wallet and a
+ * newly handed-over wallet both start in. Worth reading before naming a price on
+ * `buyDataBundle`, since a price over the ceiling reverts.
+ */
+export const _dataBundlePriceCap = async (client, eSIMWalletAddress) => {
+    return client.extend(publicActions).readContract({
+        address: eSIMWalletAddress,
+        abi: ESIMWallet,
+        functionName: "dataBundlePriceCap",
+        args: []
+    });
+};
 /** The pending owner proposed via `requestTransferOwnership` (zero if none). */
 export const _newRequestedOwner = async (client, eSIMWalletAddress) => {
     return client.extend(publicActions).readContract({
@@ -42,3 +54,35 @@ export const _owner = async (client, eSIMWalletAddress) => {
         args: []
     });
 };
+/**
+ * The device wallet this eSIM wallet belongs to. Tracks `owner` today, but it is
+ * a separate storage slot with its own typed getter, so read whichever one the
+ * calling code actually means.
+ */
+export const _deviceWallet = async (client, eSIMWalletAddress) => {
+    return client.extend(publicActions).readContract({
+        address: eSIMWalletAddress,
+        abi: ESIMWallet,
+        functionName: "deviceWallet",
+        args: []
+    });
+};
+/**
+ * One data bundle purchase, by position. The array holds every purchase this
+ * wallet has made, and for a wallet that started life on the fiat path it also
+ * holds the pre-deployment purchases the lazy registry copies in.
+ *
+ * The contract publishes no length getter, so there is no way to ask how many
+ * entries exist. Read upwards from zero until a call reverts, or track the count
+ * from the `DataBundleBought` and `TransactionHistoryPopulated` events, whose
+ * `_totalEntries` is the length after the batch landed.
+ */
+export const _transactionHistory = async (client, eSIMWalletAddress, index) => {
+    const [dataBundleID, dataBundlePrice] = await client.extend(publicActions).readContract({
+        address: eSIMWalletAddress,
+        abi: ESIMWallet,
+        functionName: "transactionHistory",
+        args: [index]
+    });
+    return { dataBundleID, dataBundlePrice };
+};

package/dist/esm/logic/admin/reads/eSIMWalletFactory.reads.js

@@ -1,11 +1,9 @@
 import { publicActions } from "viem";
 import { _getChainSpecificConstants } from "../../constants.js";
 import { ESIMWalletFactory } from "../../../abis/index.js";
-/**
- * Read-only admin logic for `ESIMWalletFactory` - its public storage getter and
- * `view` function, surfaced for the backend. Each read extends the `WalletClient`
- * with `publicActions` (no EOA account required).
- */
+// Read-only admin logic for `ESIMWalletFactory` - its public storage getter and
+// `view` function, surfaced for the backend. Each read extends the `WalletClient`
+// with `publicActions` (no EOA account required).
 /** Whether an eSIM wallet was deployed by this factory. */
 export const _isESIMWalletDeployed = async (client, eSIMWallet) => {
     const chainID = await client.getChainId();
@@ -30,3 +28,63 @@ export const _getCurrentESIMWalletImplementation = async (client) => {
         args: []
     });
 };
+/**
+ * The ERC-1822 storage slot this proxy keeps its implementation in. An upgrade
+ * reverts unless the incoming implementation answers with the same value, which
+ * is what stops a non-UUPS address being installed.
+ */
+export const _proxiableUUID = async (client) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.ESIM_WALLET_FACTORY,
+        abi: ESIMWalletFactory,
+        functionName: "proxiableUUID",
+        args: []
+    });
+};
+/** The OpenZeppelin upgrade interface this proxy speaks, currently `"5.0.0"`. */
+export const _upgradeInterfaceVersion = async (client) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.ESIM_WALLET_FACTORY,
+        abi: ESIMWalletFactory,
+        functionName: "UPGRADE_INTERFACE_VERSION",
+        args: []
+    });
+};
+/**
+ * Who holds `onlyOwner` here. On the live deployment this is the
+ * `ProtocolAdmin` timelock, so an owner call sent from an EOA reverts and has to
+ * be scheduled instead.
+ */
+export const _owner = async (client) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.ESIM_WALLET_FACTORY,
+        abi: ESIMWalletFactory,
+        functionName: "owner",
+        args: []
+    });
+};
+/**
+ * The address a `transferOwnership` is waiting on. Worth reading before
+ * `protocolAdmin.acceptOwnershipBatch`, which reverts on any target that has not
+ * been offered to the timelock.
+ */
+export const _pendingOwner = async (client) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.ESIM_WALLET_FACTORY,
+        abi: ESIMWalletFactory,
+        functionName: "pendingOwner",
+        args: []
+    });
+};

package/dist/esm/logic/admin/reads/lazyWalletRegistry.reads.js

@@ -1,16 +1,14 @@
 import { publicActions } from "viem";
 import { _getChainSpecificConstants } from "../../constants.js";
 import { LazyWalletRegistry } from "../../../abis/index.js";
-/**
- * Read-only admin logic for `LazyWalletRegistry` - its public storage getters,
- * surfaced for the backend's fiat/lazy provisioning flows. Each read extends the
- * `WalletClient` with `publicActions`; no EOA account is required.
- *
- * Note: `deviceIdentifierToESIMDetails` and
- * `eSIMIdentifiersAssociatedWithDeviceIdentifier` back dynamic arrays on chain,
- * so their auto-generated getters take an element `index` and return one entry -
- * callers iterate indices to read the whole list (there is no full-array getter).
- */
+// Read-only admin logic for `LazyWalletRegistry` - its public storage getters,
+// surfaced for the backend's fiat/lazy provisioning flows. Each read extends the
+// `WalletClient` with `publicActions`; no EOA account is required.
+//
+// Note: `deviceIdentifierToESIMDetails` and
+// `eSIMIdentifiersAssociatedWithDeviceIdentifier` back dynamic arrays on chain,
+// so their auto-generated getters take an element `index` and return one entry -
+// callers iterate indices to read the whole list (there is no full-array getter).
 /** The upgrade-manager (owner) EOA of the lazy registry. */
 export const _upgradeManager = async (client) => {
     const chainID = await client.getChainId();
@@ -48,6 +46,109 @@ export const _deviceIdentifierToESIMDetails = async (client, deviceIdentifier, e
     });
     return { dataBundleID, dataBundlePrice };
 };
+/** Most eSIM wallets one `deployLazyWalletAndSetESIMIdentifier` call will deploy. */
+export const _maxESIMWalletsPerCall = async (client) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.LAZY_WALLET_REGISTRY,
+        abi: LazyWalletRegistry,
+        functionName: "MAX_ESIM_WALLETS_PER_CALL",
+        args: []
+    });
+};
+/** Most history entries one `setHistoryForLazyWallet` call will copy. */
+export const _maxHistoryEntriesPerCall = async (client) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.LAZY_WALLET_REGISTRY,
+        abi: LazyWalletRegistry,
+        functionName: "MAX_HISTORY_ENTRIES_PER_CALL",
+        args: []
+    });
+};
+/**
+ * How many of a device's eSIM wallets are already deployed. Non-zero exactly when
+ * the lazy route ran the device's first batch, so it doubles as the marker for
+ * the route itself.
+ */
+export const _eSIMWalletsDeployed = async (client, deviceIdentifier) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.LAZY_WALLET_REGISTRY,
+        abi: LazyWalletRegistry,
+        functionName: "eSIMWalletsDeployed",
+        args: [deviceIdentifier]
+    });
+};
+/** Salt the device's first deployment batch started from. Every later batch derives from it. */
+export const _lazyDeploymentSalt = async (client, deviceIdentifier) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.LAZY_WALLET_REGISTRY,
+        abi: LazyWalletRegistry,
+        functionName: "lazyDeploymentSalt",
+        args: [deviceIdentifier]
+    });
+};
+/**
+ * The eSIM wallet this registry deployed for an identifier. Zero for anything it
+ * did not deploy, which is what authorises the history copy.
+ */
+export const _lazyDeployedESIMWallet = async (client, eSIMIdentifier) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.LAZY_WALLET_REGISTRY,
+        abi: LazyWalletRegistry,
+        functionName: "lazyDeployedESIMWallet",
+        args: [eSIMIdentifier]
+    });
+};
+/** How many of an eSIM's stored purchase entries have already reached its wallet. */
+export const _historyEntriesCopied = async (client, eSIMIdentifier) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.LAZY_WALLET_REGISTRY,
+        abi: LazyWalletRegistry,
+        functionName: "historyEntriesCopied",
+        args: [eSIMIdentifier]
+    });
+};
+/** Whether a device identifier has purchases recorded against it here. */
+export const _isDeviceIdentifierReserved = async (client, deviceIdentifier) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.LAZY_WALLET_REGISTRY,
+        abi: LazyWalletRegistry,
+        functionName: "isDeviceIdentifierReserved",
+        args: [deviceIdentifier]
+    });
+};
+/** Whether an eSIM identifier is bound to a device here. */
+export const _isESIMIdentifierReserved = async (client, eSIMIdentifier) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.LAZY_WALLET_REGISTRY,
+        abi: LazyWalletRegistry,
+        functionName: "isESIMIdentifierReserved",
+        args: [eSIMIdentifier]
+    });
+};
 /** One eSIM identifier associated with a device identifier, by array index. */
 export const _eSIMIdentifiersAssociatedWithDeviceIdentifier = async (client, deviceIdentifier, index) => {
     const chainID = await client.getChainId();
@@ -60,3 +161,63 @@ export const _eSIMIdentifiersAssociatedWithDeviceIdentifier = async (client, dev
         args: [deviceIdentifier, index]
     });
 };
+/**
+ * The ERC-1822 storage slot this proxy keeps its implementation in. An upgrade
+ * reverts unless the incoming implementation answers with the same value, which
+ * is what stops a non-UUPS address being installed.
+ */
+export const _proxiableUUID = async (client) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.LAZY_WALLET_REGISTRY,
+        abi: LazyWalletRegistry,
+        functionName: "proxiableUUID",
+        args: []
+    });
+};
+/** The OpenZeppelin upgrade interface this proxy speaks, currently `"5.0.0"`. */
+export const _upgradeInterfaceVersion = async (client) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.LAZY_WALLET_REGISTRY,
+        abi: LazyWalletRegistry,
+        functionName: "UPGRADE_INTERFACE_VERSION",
+        args: []
+    });
+};
+/**
+ * Who holds `onlyOwner` here. On the live deployment this is the
+ * `ProtocolAdmin` timelock, so an owner call sent from an EOA reverts and has to
+ * be scheduled instead.
+ */
+export const _owner = async (client) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.LAZY_WALLET_REGISTRY,
+        abi: LazyWalletRegistry,
+        functionName: "owner",
+        args: []
+    });
+};
+/**
+ * The address a `transferOwnership` is waiting on. Worth reading before
+ * `protocolAdmin.acceptOwnershipBatch`, which reverts on any target that has not
+ * been offered to the timelock.
+ */
+export const _pendingOwner = async (client) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.LAZY_WALLET_REGISTRY,
+        abi: LazyWalletRegistry,
+        functionName: "pendingOwner",
+        args: []
+    });
+};

package/dist/esm/logic/admin/reads/protocolAdmin.reads.js

@@ -0,0 +1,154 @@
+import { publicActions } from "viem";
+import { _getChainSpecificConstants } from "../../constants.js";
+import { ProtocolAdmin } from "../../../abis/index.js";
+// Read-only logic for `ProtocolAdmin`, the timelock that owns the four
+// upgradeable contracts. Every read extends the `WalletClient` with
+// `publicActions`; no EOA account is required.
+/** Operation lifecycle, matching the on-chain `OperationState` enum. */
+export var OperationState;
+(function (OperationState) {
+    OperationState[OperationState["Unset"] = 0] = "Unset";
+    OperationState[OperationState["Waiting"] = 1] = "Waiting";
+    OperationState[OperationState["Ready"] = 2] = "Ready";
+    OperationState[OperationState["Done"] = 3] = "Done";
+})(OperationState || (OperationState = {}));
+const _resolve = async (client) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    return _getChainSpecificConstants(chainID, rpcURL);
+};
+/**
+ * Shortest delay a new operation will be given. Read this rather than following
+ * `MinDelayChange`, which carries the value `updateDelay` stored and not the
+ * floor that overrides it.
+ */
+export const _getMinDelay = async (client) => {
+    const values = await _resolve(client);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.PROTOCOL_ADMIN,
+        abi: ProtocolAdmin,
+        functionName: "getMinDelay",
+        args: []
+    });
+};
+/**
+ * The floor `getMinDelay` clamps to. Immutable, so `updateDelay` can never bring
+ * the timelock below it.
+ */
+export const _minDelayFloor = async (client) => {
+    const values = await _resolve(client);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.PROTOCOL_ADMIN,
+        abi: ProtocolAdmin,
+        functionName: "minDelayFloor",
+        args: []
+    });
+};
+/** Where an operation is in its lifecycle. */
+export const _getOperationState = async (client, id) => {
+    const values = await _resolve(client);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.PROTOCOL_ADMIN,
+        abi: ProtocolAdmin,
+        functionName: "getOperationState",
+        args: [id]
+    });
+};
+/**
+ * When an operation becomes executable, as a unix timestamp. Reads `0` for an
+ * unknown operation and the literal `1` for one already done, so compare against
+ * the state rather than treating this as a time in both cases.
+ */
+export const _getTimestamp = async (client, id) => {
+    const values = await _resolve(client);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.PROTOCOL_ADMIN,
+        abi: ProtocolAdmin,
+        functionName: "getTimestamp",
+        args: [id]
+    });
+};
+/** Whether the timelock has ever seen this operation. */
+export const _isOperation = async (client, id) => {
+    const values = await _resolve(client);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.PROTOCOL_ADMIN,
+        abi: ProtocolAdmin,
+        functionName: "isOperation",
+        args: [id]
+    });
+};
+/** Scheduled and not yet executed, whether or not the delay has elapsed. */
+export const _isOperationPending = async (client, id) => {
+    const values = await _resolve(client);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.PROTOCOL_ADMIN,
+        abi: ProtocolAdmin,
+        functionName: "isOperationPending",
+        args: [id]
+    });
+};
+/** The delay has elapsed and the operation can be executed now. */
+export const _isOperationReady = async (client, id) => {
+    const values = await _resolve(client);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.PROTOCOL_ADMIN,
+        abi: ProtocolAdmin,
+        functionName: "isOperationReady",
+        args: [id]
+    });
+};
+/** The operation has already run. */
+export const _isOperationDone = async (client, id) => {
+    const values = await _resolve(client);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.PROTOCOL_ADMIN,
+        abi: ProtocolAdmin,
+        functionName: "isOperationDone",
+        args: [id]
+    });
+};
+/** Whether an account holds a role. Role ids come from the constants below. */
+export const _hasRole = async (client, role, account) => {
+    const values = await _resolve(client);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.PROTOCOL_ADMIN,
+        abi: ProtocolAdmin,
+        functionName: "hasRole",
+        args: [role, account]
+    });
+};
+/**
+ * The role that can grant and revoke the given one. Always `DEFAULT_ADMIN_ROLE`,
+ * which only the timelock itself holds, so every role change is a scheduled
+ * operation.
+ */
+export const _getRoleAdmin = async (client, role) => {
+    const values = await _resolve(client);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.PROTOCOL_ADMIN,
+        abi: ProtocolAdmin,
+        functionName: "getRoleAdmin",
+        args: [role]
+    });
+};
+// Reads one of the five role id constants off the contract.
+const _roleConstant = async (client, functionName) => {
+    const values = await _resolve(client);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.PROTOCOL_ADMIN,
+        abi: ProtocolAdmin,
+        functionName,
+        args: []
+    });
+};
+/** Held only by the timelock itself, which is what makes role changes wait. */
+export const _defaultAdminRole = (client) => _roleConstant(client, "DEFAULT_ADMIN_ROLE");
+/** Can schedule operations, and can cancel them. */
+export const _proposerRole = (client) => _roleConstant(client, "PROPOSER_ROLE");
+/** Can cancel a scheduled operation and nothing else. */
+export const _cancellerRole = (client) => _roleConstant(client, "CANCELLER_ROLE");
+/** Granted to the zero address, so execution is open to anyone. */
+export const _executorRole = (client) => _roleConstant(client, "EXECUTOR_ROLE");
+/** The three instant powers. Cannot be held alongside proposer or canceller. */
+export const _guardianRole = (client) => _roleConstant(client, "GUARDIAN_ROLE");