kokio-sdk 1.1.0 → 2.1.0

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

@@ -1,15 +1,18 @@
 import { _getChainSpecificConstants } from "../constants.js";
-import { MissingEOAWalletError } from "../errors.js";
+import { MissingEOAWalletError, writeContractOrThrow } from "../errors.js";
 import { DeviceWalletFactory } from "../../abis/index.js";
-/**
- * Admin-EOA logic for `DeviceWalletFactory`.
- *
- * Every function here is `onlyAdmin` / `onlyAdminOrRegistry` / `onlyOwner` on
- * chain, i.e. the caller must be the `eSIMWalletAdmin` (or `upgradeManager`)
- * EOA - never a device-wallet userOp. They therefore live on the EOA surface
- * (`KokioAdmin`) and use `writeContract`, mirroring `_createAccountWithEOA`
- * (which is reused as-is from `../deviceWalletFactory.js`).
- */
+// Admin-EOA logic for `DeviceWalletFactory`.
+//
+// Every function here is `onlyAdmin` / `onlyAdminOrRegistry` / `onlyOwner` on
+// chain, i.e. the caller must be the `eSIMWalletAdmin` (or `upgradeManager`)
+// EOA - never a device-wallet userOp. They therefore live on the EOA surface
+// (`KokioAdmin`) and use `writeContract`, mirroring `_createAccountWithEOA`
+// (which is reused as-is from `../deviceWalletFactory.js`).
+//
+// 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.
 /**
  * Batch-deploy device wallets for lazy/fiat users. `onlyAdminOrRegistry`,
  * `payable`: `value` is the total ETH pot from which each `depositAmounts[i]`
@@ -21,7 +24,7 @@ export const _deployDeviceWalletForUsers = async (client, deviceUniqueIdentifier
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
         throw new MissingEOAWalletError();
-    return client.writeContract({
+    return writeContractOrThrow(client, {
         address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
         chain: values.chain,
         account: client.account.address,
@@ -31,20 +34,24 @@ export const _deployDeviceWalletForUsers = async (client, deviceUniqueIdentifier
         value
     });
 };
-/** Register a freshly created device wallet with the factory. `onlyAdminOrRegistry`. */
-export const _postCreateAccount = async (client, deviceWallet, deviceUniqueIdentifier, deviceWalletOwnerKey) => {
+/**
+ * Register a freshly created device wallet with the factory. `onlyAdminOrRegistry`.
+ * The salt has to be the one the deploying `createAccount` used, since the
+ * factory rederives the counterfactual address from it to check the wallet.
+ */
+export const _postCreateAccount = async (client, deviceWallet, deviceUniqueIdentifier, deviceWalletOwnerKey, salt) => {
     const chainID = await client.getChainId();
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
         throw new MissingEOAWalletError();
-    return client.writeContract({
+    return writeContractOrThrow(client, {
         address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
         chain: values.chain,
         account: client.account.address,
         abi: DeviceWalletFactory,
         functionName: 'postCreateAccount',
-        args: [deviceWallet, deviceUniqueIdentifier, deviceWalletOwnerKey]
+        args: [deviceWallet, deviceUniqueIdentifier, deviceWalletOwnerKey, salt]
     });
 };
 /** One-time wiring of the registry into the factory. `onlyAdmin`. */
@@ -54,7 +61,7 @@ export const _addRegistryAddress = async (client, registryContractAddress) => {
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
         throw new MissingEOAWalletError();
-    return client.writeContract({
+    return writeContractOrThrow(client, {
         address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
         chain: values.chain,
         account: client.account.address,
@@ -63,71 +70,85 @@ export const _addRegistryAddress = async (client, registryContractAddress) => {
         args: [registryContractAddress]
     });
 };
-/** Update the vault that receives eSIM payments. `onlyAdmin`. */
-export const _updateVaultAddress = async (client, newVaultAddress) => {
+/** Point the device-wallet beacon at a new implementation. `onlyOwner` (upgradeManager). */
+export const _updateDeviceWalletImplementation = async (client, newDeviceImpl) => {
     const chainID = await client.getChainId();
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
         throw new MissingEOAWalletError();
-    return client.writeContract({
+    return writeContractOrThrow(client, {
         address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
         chain: values.chain,
         account: client.account.address,
         abi: DeviceWalletFactory,
-        functionName: 'updateVaultAddress',
-        args: [newVaultAddress]
+        functionName: 'updateDeviceWalletImplementation',
+        args: [newDeviceImpl]
     });
 };
-/** Step 1 of the 2-step admin handover: propose a new admin. `onlyAdmin`. */
-export const _requestAdminUpdate = async (client, newAdmin) => {
+// ---------------------------------------------------------------------------
+// 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 changes nothing until the named address calls
+ * `acceptOwnership`. Note this hands over the beacon too, since the factory owns
+ * it, so the new owner can move every deployed device wallet at once.
+ */
+export const _transferOwnershipCall = async (client, newOwner) => {
     const chainID = await client.getChainId();
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
-    if (!client.account)
-        throw new MissingEOAWalletError();
-    return client.writeContract({
+    return {
         address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
-        chain: values.chain,
-        account: client.account.address,
         abi: DeviceWalletFactory,
-        functionName: 'requestAdminUpdate',
-        args: [newAdmin]
-    });
+        functionName: 'transferOwnership',
+        args: [newOwner],
+    };
 };
 /**
- * Step 2 of the 2-step admin handover: the proposed admin accepts. The chain
- * requires `msg.sender` to equal the pending admin, so the `client` here must
- * be the newly proposed admin EOA.
+ * Point the factory's own proxy at a new implementation. Builds
+ * `upgradeToAndCall`. Pass the result to `schedule`.
+ *
+ * This does not touch deployed device wallets. They read their implementation
+ * from the beacon, which moves through `updateDeviceWalletImplementation`
+ * instead. Changing what the factory deploys next is a beacon update, not this.
  */
-export const _acceptAdminUpdate = async (client) => {
+export const _upgradeCall = async (client, newImplementation, data = '0x') => {
     const chainID = await client.getChainId();
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
-    if (!client.account)
-        throw new MissingEOAWalletError();
-    return client.writeContract({
+    return {
         address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
-        chain: values.chain,
-        account: client.account.address,
         abi: DeviceWalletFactory,
-        functionName: 'acceptAdminUpdate',
-        args: []
-    });
+        functionName: 'upgradeToAndCall',
+        args: [newImplementation, data],
+    };
 };
-/** Point the device-wallet beacon at a new implementation. `onlyOwner` (upgradeManager). */
-export const _updateDeviceWalletImplementation = async (client, newDeviceImpl) => {
+/**
+ * Take ownership after a `transferOwnership` named this client. `msg.sender`
+ * must equal `pendingOwner`, so the `client` is the incoming owner.
+ *
+ * Where the incoming owner is the timelock, use
+ * `protocolAdmin.acceptOwnershipBatch` instead, which accepts for every contract
+ * at once.
+ */
+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({
+    return writeContractOrThrow(client, {
         address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
         chain: values.chain,
         account: client.account.address,
         abi: DeviceWalletFactory,
-        functionName: 'updateDeviceWalletImplementation',
-        args: [newDeviceImpl]
+        functionName: 'acceptOwnership',
+        args: []
     });
 };

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

@@ -1,11 +1,9 @@
 import { _getChainSpecificConstants } from "../constants.js";
-import { MissingEOAWalletError } from "../errors.js";
+import { MissingEOAWalletError, writeContractOrThrow } from "../errors.js";
 import { ESIMWallet } from "../../abis/index.js";
-/**
- * Admin-EOA logic targeting a specific `ESIMWallet` instance (address passed in).
- * `buyDataBundle` is `onlyDeviceWalletOrESIMWalletAdmin`, so the admin EOA can
- * call it directly.
- */
+// Admin-EOA logic targeting a specific `ESIMWallet` instance (address passed in).
+// `buyDataBundle` is `onlyDeviceWalletOrESIMWalletAdmin`, so the admin EOA can
+// call it directly.
 /**
  * Buy a data bundle for an eSIM wallet. `onlyDeviceWalletOrESIMWalletAdmin`,
  * `payable`. `value` is optional: the contract pulls any shortfall from the
@@ -18,7 +16,7 @@ export const _buyDataBundle = async (client, eSIMWalletAddress, dataBundleDetail
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
         throw new MissingEOAWalletError();
-    return client.writeContract({
+    return writeContractOrThrow(client, {
         address: eSIMWalletAddress,
         chain: values.chain,
         account: client.account.address,

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

@@ -1,14 +1,17 @@
 import { _getChainSpecificConstants } from "../constants.js";
-import { MissingEOAWalletError } from "../errors.js";
+import { MissingEOAWalletError, writeContractOrThrow } from "../errors.js";
 import { ESIMWalletFactory } from "../../abis/index.js";
-/**
- * Admin-EOA logic for `ESIMWalletFactory`. Both functions are owner-gated
- * (`addRegistryAddress` requires `msg.sender == owner()`, `updateESIMWalletImplementation`
- * is `onlyOwner`), so the `client` must carry the `upgradeManager` EOA.
- *
- * Note: `ESIMWalletFactory.deployESIMWallet` is intentionally NOT exposed - it is
- * `onlyRegistryOrDeviceWalletFactoryOrDeviceWallet`, so a bare EOA always reverts.
- */
+// Admin-EOA logic for `ESIMWalletFactory`. Both functions are owner-gated
+// (`addRegistryAddress` requires `msg.sender == owner()`, `updateESIMWalletImplementation`
+// is `onlyOwner`), so the `client` must carry the `upgradeManager` EOA.
+//
+// On the live deployment the owner is the `ProtocolAdmin` timelock, not an EOA,
+// so either call sent directly reverts. Route them through
+// `protocolAdmin.proposer.schedule` instead. The direct path stays for
+// deployments whose owner is a plain EOA or multisig.
+//
+// Note: `ESIMWalletFactory.deployESIMWallet` is intentionally NOT exposed - it is
+// `onlyRegistryOrDeviceWalletFactoryOrDeviceWallet`, so a bare EOA always reverts.
 /** One-time wiring of the registry into the eSIM factory. Owner only. */
 export const _addRegistryAddress = async (client, registryContractAddress) => {
     const chainID = await client.getChainId();
@@ -16,7 +19,7 @@ export const _addRegistryAddress = async (client, registryContractAddress) => {
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
         throw new MissingEOAWalletError();
-    return client.writeContract({
+    return writeContractOrThrow(client, {
         address: values.factoryAddresses.ESIM_WALLET_FACTORY,
         chain: values.chain,
         account: client.account.address,
@@ -32,7 +35,7 @@ export const _updateESIMWalletImplementation = async (client, eSIMWalletImpl) =>
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
         throw new MissingEOAWalletError();
-    return client.writeContract({
+    return writeContractOrThrow(client, {
         address: values.factoryAddresses.ESIM_WALLET_FACTORY,
         chain: values.chain,
         account: client.account.address,
@@ -41,3 +44,68 @@ export const _updateESIMWalletImplementation = async (client, eSIMWalletImpl) =>
         args: [eSIMWalletImpl]
     });
 };
+// ---------------------------------------------------------------------------
+// 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 changes nothing until the named address calls
+ * `acceptOwnership`. Note this hands over the beacon too, since the factory owns
+ * it, so the new owner can move every deployed eSIM wallet at once.
+ */
+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.ESIM_WALLET_FACTORY,
+        abi: ESIMWalletFactory,
+        functionName: 'transferOwnership',
+        args: [newOwner],
+    };
+};
+/**
+ * Point the factory's own proxy at a new implementation. Builds
+ * `upgradeToAndCall`. Pass the result to `schedule`.
+ *
+ * This does not touch deployed eSIM wallets. They read their implementation from
+ * the beacon, which moves through `updateESIMWalletImplementation` instead.
+ */
+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.ESIM_WALLET_FACTORY,
+        abi: ESIMWalletFactory,
+        functionName: 'upgradeToAndCall',
+        args: [newImplementation, data],
+    };
+};
+/**
+ * Take ownership after a `transferOwnership` named this client. `msg.sender`
+ * must equal `pendingOwner`, so the `client` is the incoming owner.
+ *
+ * Where the incoming owner is the timelock, use
+ * `protocolAdmin.acceptOwnershipBatch` instead, which accepts for every contract
+ * at once.
+ */
+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 writeContractOrThrow(client, {
+        address: values.factoryAddresses.ESIM_WALLET_FACTORY,
+        chain: values.chain,
+        account: client.account.address,
+        abi: ESIMWalletFactory,
+        functionName: 'acceptOwnership',
+        args: []
+    });
+};