kokio-sdk 1.1.0 → 2.0.0

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

@@ -1,13 +1,15 @@
 import { publicActions } from "viem";
 import { _getChainSpecificConstants } from "../../constants.js";
 import { Registry } from "../../../abis/index.js";
+// Read-only admin logic for `Registry` (which inherits `RegistryHelper`, so its
+// ABI carries the helper mappings too). Surfaces the public storage getters for
+// the backend. Each read extends the `WalletClient` with `publicActions`; no EOA
+// account is required.
 /**
- * Read-only admin logic for `Registry` (which inherits `RegistryHelper`, so its
- * ABI carries the helper mappings too). Surfaces the public storage getters for
- * the backend. Each read extends the `WalletClient` with `publicActions`; no EOA
- * account is required.
+ * The admin EOA (`eSIMWalletAdmin`) recorded in the registry. Reads zero while a
+ * nomination is pending or the admin is suspended, which means the role is
+ * dormant rather than unset.
  */
-/** The admin EOA (`eSIMWalletAdmin`) recorded in the registry. */
 export const _eSIMWalletAdmin = async (client) => {
     const chainID = await client.getChainId();
     const rpcURL = client.transport.url;
@@ -19,6 +21,68 @@ export const _eSIMWalletAdmin = async (client) => {
         args: []
     });
 };
+/**
+ * The admin address on the books, which keeps naming a suspended admin so the
+ * suspension can be lifted without supplying it again. Ask `_eSIMWalletAdmin`
+ * who may actually act.
+ */
+export const _adminOfRecord = 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.REGISTRY,
+        abi: Registry,
+        functionName: "adminOfRecord",
+        args: []
+    });
+};
+/**
+ * Whether the admin's powers are suspended protocol-wide. True and a pending
+ * nomination are separate reasons for `_eSIMWalletAdmin` to read zero, so read
+ * this alongside `_newRequestedAdmin` to tell them apart.
+ */
+export const _adminDisabled = 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.REGISTRY,
+        abi: Registry,
+        functionName: "adminDisabled",
+        args: []
+    });
+};
+/**
+ * Whether the protocol is paused. While true, every ETH-moving path on the
+ * device wallets and eSIM wallets reverts `ProtocolPaused`.
+ */
+export const _paused = 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.REGISTRY,
+        abi: Registry,
+        functionName: "paused",
+        args: []
+    });
+};
+/**
+ * The fallback price ceiling in wei, applied to any eSIM wallet holding no cap of
+ * its own. Never zero.
+ */
+export const _defaultDataBundlePriceCap = 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.REGISTRY,
+        abi: Registry,
+        functionName: "defaultDataBundlePriceCap",
+        args: []
+    });
+};
 /** The vault EOA recorded in the registry. */
 export const _vault = async (client) => {
     const chainID = await client.getChainId();
@@ -31,6 +95,34 @@ export const _vault = async (client) => {
         args: []
     });
 };
+/** The pending admin nominated via `requestAdminUpdate` (zero address if none). */
+export const _newRequestedAdmin = 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.REGISTRY,
+        abi: Registry,
+        functionName: "newRequestedAdmin",
+        args: []
+    });
+};
+/**
+ * Who holds `onlyOwner` on the registry. 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.REGISTRY,
+        abi: Registry,
+        functionName: "owner",
+        args: []
+    });
+};
 /** The upgrade-manager (owner) EOA recorded in the registry. */
 export const _upgradeManager = async (client) => {
     const chainID = await client.getChainId();
@@ -43,6 +135,74 @@ export const _upgradeManager = async (client) => {
         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.REGISTRY,
+        abi: Registry,
+        functionName: "pendingOwner",
+        args: []
+    });
+};
+/** The `DeviceWalletFactory` address wired into the registry. */
+export const _deviceWalletFactory = 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.REGISTRY,
+        abi: Registry,
+        functionName: "deviceWalletFactory",
+        args: []
+    });
+};
+/** The `ESIMWalletFactory` address wired into the registry. */
+export const _eSIMWalletFactory = 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.REGISTRY,
+        abi: Registry,
+        functionName: "eSIMWalletFactory",
+        args: []
+    });
+};
+/** The EntryPoint the registry recognises. One per chain. */
+export const _entryPoint = 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.REGISTRY,
+        abi: Registry,
+        functionName: "entryPoint",
+        args: []
+    });
+};
+/**
+ * The same pause check the wallets themselves run, which throws rather than
+ * returning false. Use `_paused` to branch on it; use this when you want the
+ * failure to carry the protocol's own revert reason.
+ */
+export const _requireNotPaused = async (client) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    await client.extend(publicActions).readContract({
+        address: values.factoryAddresses.REGISTRY,
+        abi: Registry,
+        functionName: "requireNotPaused",
+        args: []
+    });
+};
 /** The `LazyWalletRegistry` address wired into the registry. */
 export const _lazyWalletRegistry = async (client) => {
     const chainID = await client.getChainId();
@@ -107,9 +267,13 @@ export const _isDeviceWalletValid = async (client, deviceWallet) => {
     });
 };
 /**
- * The device wallet that owns an eSIM wallet (zero address if the eSIM is not
- * valid). On-chain this getter is named `isESIMWalletValid` but returns the
- * associated device-wallet address, not a boolean.
+ * The device wallet an eSIM wallet is registered against, zero if the protocol
+ * never deployed it. Despite the name this returns an address, not a boolean.
+ *
+ * This is a registration record, not a current holder. Once it goes non-zero it
+ * stays non-zero for the rest of the wallet's life, and mid-transfer it still
+ * names the device wallet that last held it. To ask who holds it now, read
+ * `DeviceWallet.isValidESIMWallet` on the device wallet.
  */
 export const _isESIMWalletValid = async (client, eSIMWallet) => {
     const chainID = await client.getChainId();
@@ -122,7 +286,15 @@ export const _isESIMWalletValid = async (client, eSIMWallet) => {
         args: [eSIMWallet]
     });
 };
-/** Whether an eSIM wallet is currently on standby. */
+/**
+ * Whether a transfer is outstanding on an eSIM wallet. `bindESIMWallet` clears
+ * it once the new device wallet takes the eSIM wallet on.
+ *
+ * Independent of `isESIMWalletValid`, and neither implies the other. A `true`
+ * here is not a claim the wallet left the protocol, and it is normal for the
+ * association to still name the device wallet that raised the flag. Do not use
+ * this to decide whether an eSIM wallet belongs to the protocol.
+ */
 export const _isESIMWalletOnStandby = async (client, eSIMWallet) => {
     const chainID = await client.getChainId();
     const rpcURL = client.transport.url;
@@ -134,3 +306,111 @@ export const _isESIMWalletOnStandby = async (client, eSIMWallet) => {
         args: [eSIMWallet]
     });
 };
+/**
+ * Whether a device identifier already has a wallet on chain. Not the same
+ * question as `lazyWalletRegistry.isDeviceIdentifierReserved`, which reads true
+ * as soon as history is recorded and well before anything is deployed.
+ */
+export const _isDeviceIdentifierAlreadyUsed = async (client, deviceUniqueIdentifier) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.REGISTRY,
+        abi: Registry,
+        functionName: "isDeviceIdentifierAlreadyUsed",
+        args: [deviceUniqueIdentifier]
+    });
+};
+/** Whether an eSIM identifier is already held by a wallet. */
+export const _isESIMIdentifierClaimed = async (client, eSIMUniqueIdentifier) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.REGISTRY,
+        abi: Registry,
+        functionName: "isESIMIdentifierClaimed",
+        args: [eSIMUniqueIdentifier]
+    });
+};
+/**
+ * The one eSIM wallet holding an eSIM identifier, zero if nobody holds it. Set
+ * once and never cleared, an ownership transfer included, because the eSIM
+ * belongs to the wallet rather than to whichever device is holding it.
+ */
+export const _eSIMWalletForIdentifier = async (client, eSIMUniqueIdentifier) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.REGISTRY,
+        abi: Registry,
+        functionName: "eSIMWalletForIdentifier",
+        args: [eSIMUniqueIdentifier]
+    });
+};
+/**
+ * The same answer as `_eSIMWalletForIdentifier`, keyed by the keccak256 of the
+ * identifier. Use it when the hash is what you already have; otherwise take the
+ * string version and skip the hashing.
+ */
+export const _claimedESIMIdentifiers = async (client, hashOfESIMIdentifier) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.REGISTRY,
+        abi: Registry,
+        functionName: "claimedESIMIdentifiers",
+        args: [hashOfESIMIdentifier]
+    });
+};
+/**
+ * The check `DeviceWalletFactory` runs before taking a device identifier.
+ * Resolves if the identifier is free, reverts `DeviceIdentifierReservedForLazyWallet`
+ * if a fiat user's eSIMs are already waiting on it.
+ *
+ * Worth calling ahead of a deployment: taking a reserved identifier strands the
+ * lazy user, since the history copy, the wallet deployment and the device switch
+ * all then refuse it.
+ */
+export const _requireDeviceIdentifierNotReserved = async (client, deviceUniqueIdentifier) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    await client.extend(publicActions).readContract({
+        address: values.factoryAddresses.REGISTRY,
+        abi: Registry,
+        functionName: "requireDeviceIdentifierNotReserved",
+        args: [deviceUniqueIdentifier]
+    });
+};
+/**
+ * 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.REGISTRY,
+        abi: Registry,
+        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.REGISTRY,
+        abi: Registry,
+        functionName: "UPGRADE_INTERFACE_VERSION",
+        args: []
+    });
+};

package/dist/esm/logic/admin/registry.eoa.js

@@ -1,10 +1,14 @@
 import { _getChainSpecificConstants } from "../constants.js";
 import { MissingEOAWalletError } from "../errors.js";
 import { Registry } from "../../abis/index.js";
-/**
- * Admin-EOA logic for `Registry`. `addOrUpdateLazyWalletRegistryAddress` is
- * `onlyOwner`, so the `client` must carry the `upgradeManager` EOA.
- */
+// Admin-EOA logic for `Registry`. Most of this is `onlyOwner`, so the `client`
+// must carry the owner EOA. `_acceptAdminUpdate` is the nominee's own call and
+// `_assignESIMIdentifier` is `onlyESIMWalletAdmin`.
+//
+// On the live deployment the owner is the `ProtocolAdmin` timelock, not an EOA,
+// so an `onlyOwner` call sent directly reverts. Route those through
+// `protocolAdmin.proposer.schedule` instead. The direct path stays for
+// deployments whose owner is a plain EOA or multisig.
 /** Wire (or rewire) the LazyWalletRegistry into the Registry. `onlyOwner`. */
 export const _addOrUpdateLazyWalletRegistryAddress = async (client, lazyWalletRegistry) => {
     const chainID = await client.getChainId();
@@ -21,3 +25,269 @@ export const _addOrUpdateLazyWalletRegistryAddress = async (client, lazyWalletRe
         args: [lazyWalletRegistry]
     });
 };
+/** Update the vault that receives eSIM payments. `onlyOwner`. */
+export const _updateVaultAddress = async (client, newVaultAddress) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    if (!client.account)
+        throw new MissingEOAWalletError();
+    return client.writeContract({
+        address: values.factoryAddresses.REGISTRY,
+        chain: values.chain,
+        account: client.account.address,
+        abi: Registry,
+        functionName: 'updateVaultAddress',
+        args: [newVaultAddress]
+    });
+};
+/**
+ * Step 1 of the 2-step admin handover: nominate the next admin. `onlyOwner`, so
+ * the `client` is the owner EOA, not the outgoing admin.
+ *
+ * The nomination takes the role off the incumbent straight away: `eSIMWalletAdmin`
+ * reads zero until the nominee accepts, and every admin gated call across the
+ * protocol reverts in that window. Send the two steps close together. Naming the
+ * incumbent instead withdraws a pending nomination and hands the role back.
+ */
+export const _requestAdminUpdate = async (client, newAdmin) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    if (!client.account)
+        throw new MissingEOAWalletError();
+    return client.writeContract({
+        address: values.factoryAddresses.REGISTRY,
+        chain: values.chain,
+        account: client.account.address,
+        abi: Registry,
+        functionName: 'requestAdminUpdate',
+        args: [newAdmin]
+    });
+};
+/**
+ * Suspend the admin's powers protocol-wide. `onlyOwner`.
+ *
+ * The address stays on the books as `adminOfRecord`, so lifting the suspension
+ * does not need it supplied again. Reverts if the admin is already suspended,
+ * rather than passing quietly and leaving the caller believing it acted.
+ */
+export const _disableAdmin = async (client) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    if (!client.account)
+        throw new MissingEOAWalletError();
+    return client.writeContract({
+        address: values.factoryAddresses.REGISTRY,
+        chain: values.chain,
+        account: client.account.address,
+        abi: Registry,
+        functionName: 'disableAdmin',
+        args: []
+    });
+};
+/**
+ * Give the suspended admin its powers back. `onlyOwner`.
+ *
+ * Does nothing about an outstanding nomination, which keeps the incumbent
+ * powerless on its own. Withdraw that with `_requestAdminUpdate` naming the
+ * incumbent. Reverts if the admin was never suspended.
+ */
+export const _enableAdmin = async (client) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    if (!client.account)
+        throw new MissingEOAWalletError();
+    return client.writeContract({
+        address: values.factoryAddresses.REGISTRY,
+        chain: values.chain,
+        account: client.account.address,
+        abi: Registry,
+        functionName: 'enableAdmin',
+        args: []
+    });
+};
+/**
+ * Stop the ETH-moving paths on every device wallet and eSIM wallet.
+ * `onlyESIMWalletAdmin`, so this is the one emergency lever the backend key can
+ * pull on its own.
+ *
+ * It cannot release it again: `_unpause` is `onlyOwner`. That split is what stops
+ * a compromised backend key holding user funds. Owners can still spend their own
+ * ETH through their device wallet's `execute`, which a pause never reaches.
+ */
+export const _pause = async (client) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    if (!client.account)
+        throw new MissingEOAWalletError();
+    return client.writeContract({
+        address: values.factoryAddresses.REGISTRY,
+        chain: values.chain,
+        account: client.account.address,
+        abi: Registry,
+        functionName: 'pause',
+        args: []
+    });
+};
+/**
+ * Release the pause. `onlyOwner`, not the admin, see `_pause`.
+ *
+ * On the live deployment the owner is the timelock, so this reverts from an EOA.
+ * Schedule `protocolAdmin.unpauseCall` instead, or have a guardian call
+ * `unpauseInstantly` if the wait is not acceptable.
+ */
+export const _unpause = async (client) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    if (!client.account)
+        throw new MissingEOAWalletError();
+    return client.writeContract({
+        address: values.factoryAddresses.REGISTRY,
+        chain: values.chain,
+        account: client.account.address,
+        abi: Registry,
+        functionName: 'unpause',
+        args: []
+    });
+};
+/**
+ * Set the price ceiling every eSIM wallet falls back to when it holds none of its
+ * own. `onlyOwner`, deliberately not the admin: the admin names the price on
+ * `buyDataBundle`, so it must not also be able to raise its own limit.
+ *
+ * Zero reverts `ZeroDataBundlePriceCap`, since a zero would read as "no ceiling"
+ * for every wallet without one of its own.
+ */
+export const _setDefaultDataBundlePriceCap = async (client, cap) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    if (!client.account)
+        throw new MissingEOAWalletError();
+    return client.writeContract({
+        address: values.factoryAddresses.REGISTRY,
+        chain: values.chain,
+        account: client.account.address,
+        abi: Registry,
+        functionName: 'setDefaultDataBundlePriceCap',
+        args: [cap]
+    });
+};
+/**
+ * Bind an eSIM's unique identifier to its wallet. `onlyESIMWalletAdmin`.
+ *
+ * The identifier is claimed protocol-wide, so a string already bound to another
+ * wallet reverts rather than moving.
+ */
+export const _assignESIMIdentifier = async (client, eSIMWalletAddress, eSIMUniqueIdentifier) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    if (!client.account)
+        throw new MissingEOAWalletError();
+    return client.writeContract({
+        address: values.factoryAddresses.REGISTRY,
+        chain: values.chain,
+        account: client.account.address,
+        abi: Registry,
+        functionName: 'assignESIMIdentifier',
+        args: [eSIMWalletAddress, eSIMUniqueIdentifier]
+    });
+};
+/**
+ * Step 2 of the 2-step admin handover: the nominee accepts. The chain requires
+ * `msg.sender` to equal the pending admin, so the `client` here must be the
+ * newly nominated admin EOA.
+ */
+export const _acceptAdminUpdate = async (client) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    if (!client.account)
+        throw new MissingEOAWalletError();
+    return client.writeContract({
+        address: values.factoryAddresses.REGISTRY,
+        chain: values.chain,
+        account: client.account.address,
+        abi: Registry,
+        functionName: 'acceptAdminUpdate',
+        args: []
+    });
+};
+/**
+ * Take ownership after a `transferOwnership` named this client. The chain
+ * requires `msg.sender` to equal `pendingOwner`, so the `client` is the incoming
+ * owner, not the outgoing one.
+ *
+ * Permissionless in the sense that it needs no role, so where the incoming owner
+ * is the timelock this is not the call to use: `protocolAdmin.acceptOwnershipBatch`
+ * accepts for every contract at once and needs no delay.
+ */
+export const _acceptOwnership = async (client) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    if (!client.account)
+        throw new MissingEOAWalletError();
+    return client.writeContract({
+        address: values.factoryAddresses.REGISTRY,
+        chain: values.chain,
+        account: client.account.address,
+        abi: Registry,
+        functionName: 'acceptOwnership',
+        args: []
+    });
+};
+// ---------------------------------------------------------------------------
+// Owner payloads - only reachable through schedule
+// ---------------------------------------------------------------------------
+// Both are `onlyOwner`, and on the live deployment the owner is the timelock, so
+// they exist as something to schedule rather than to send. Each returns the
+// `OwnerCall` to hand to `protocolAdmin.schedule`.
+/**
+ * Offer ownership to a new address. Pass the result to `schedule`.
+ *
+ * Ownable2Step, so the offer alone changes nothing: the named address has to
+ * call `acceptOwnership` before it holds anything. Until then the current owner
+ * keeps every power. Naming an address that cannot call back leaves the
+ * ownership where it is rather than stranding it.
+ */
+export const _transferOwnershipCall = async (client, newOwner) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return {
+        address: values.factoryAddresses.REGISTRY,
+        abi: Registry,
+        functionName: 'transferOwnership',
+        args: [newOwner],
+    };
+};
+/**
+ * Point the proxy at a new implementation. Builds `upgradeToAndCall`. Pass the
+ * result to `schedule`.
+ *
+ * `data` runs on the proxy straight after the swap, in the same transaction, and
+ * is where a `reinitializer` goes. Leave it empty when the new implementation
+ * needs no setup.
+ *
+ * There is no undo. The implementation is checked for a matching `proxiableUUID`
+ * and nothing else, so an address that answers correctly but cannot upgrade
+ * again ends the proxy's life. Diff the storage layout before scheduling.
+ */
+export const _upgradeCall = async (client, newImplementation, data = '0x') => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return {
+        address: values.factoryAddresses.REGISTRY,
+        abi: Registry,
+        functionName: 'upgradeToAndCall',
+        args: [newImplementation, data],
+    };
+};