kokio-sdk 3.3.0 → 3.5.0

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

@@ -271,6 +271,25 @@ export const _cancel = async (client, id) => {
 // ---------------------------------------------------------------------------
 // Guardian powers - GUARDIAN_ROLE, no delay
 // ---------------------------------------------------------------------------
+/**
+ * Pause a protocol contract straight away. `GUARDIAN_ROLE`.
+ *
+ * Only stops the contract, which the admin key could already do, and a guardian
+ * can release it at once with `_unpauseInstantly`.
+ */
+export const _pauseInstantly = async (client, target) => {
+    const values = await _resolve(client);
+    if (!client.account)
+        throw new MissingEOAWalletError();
+    return writeContractOrThrow(client, {
+        address: values.factoryAddresses.PROTOCOL_ADMIN,
+        chain: values.chain,
+        account: client.account,
+        abi: ProtocolAdmin,
+        functionName: 'pauseInstantly',
+        args: [target]
+    });
+};
 /**
  * Release a pause on a protocol contract straight away. `GUARDIAN_ROLE`.
  *
@@ -472,6 +491,21 @@ export const _setDefaultPriceCapUSDCentsCall = async (client, cap, target) => {
         args: [cap],
     };
 };
+/**
+ * Set what the admin key may charge each newly created eSIM wallet, in USD
+ * cents. Pass the result to `schedule`. Existing wallets keep their own figure.
+ *
+ * `target` defaults to the registry.
+ */
+export const _setDefaultAdminAllowanceUSDCentsCall = async (client, allowance, target) => {
+    const values = await _resolve(client);
+    return {
+        address: target ?? values.factoryAddresses.REGISTRY,
+        abi: Registry,
+        functionName: 'setDefaultAdminAllowanceUSDCents',
+        args: [allowance],
+    };
+};
 /**
  * Point the registry at a new payment adapter. Pass the result to `schedule`.
  *

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

@@ -36,6 +36,18 @@ export const _priceCapUSDCents = async (client, eSIMWalletAddress) => {
         args: []
     });
 };
+/**
+ * What the admin key may still charge this eSIM wallet, in USD cents. Only the
+ * owner can raise it, so a purchase above it needs the user first.
+ */
+export const _adminAllowanceUSDCents = async (client, eSIMWalletAddress) => {
+    return client.extend(publicActions).readContract({
+        address: eSIMWalletAddress,
+        abi: ESIMWallet,
+        functionName: "adminAllowanceUSDCents",
+        args: []
+    });
+};
 /** The pending owner proposed via `requestTransferOwnership` (zero if none). */
 export const _newRequestedOwner = async (client, eSIMWalletAddress) => {
     return client.extend(publicActions).readContract({

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

@@ -83,6 +83,18 @@ export const _defaultPriceCapUSDCents = async (client) => {
         args: []
     });
 };
+/** What the admin key may charge a newly created eSIM wallet in total, in USD cents. */
+export const _defaultAdminAllowanceUSDCents = async (client) => {
+    const chainID = await _chainId(client);
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.extend(publicActions).readContract({
+        address: values.factoryAddresses.REGISTRY,
+        abi: Registry,
+        functionName: "defaultAdminAllowanceUSDCents",
+        args: []
+    });
+};
 /** The vault EOA recorded in the registry. */
 export const _vault = async (client) => {
     const chainID = await _chainId(client);

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

@@ -1,6 +1,9 @@
+import { encodeAbiParameters, keccak256, publicActions, stringToHex } from "viem";
 import { _chainId, _getChainSpecificConstants } from "../constants.js";
-import { MissingEOAWalletError, writeContractOrThrow } from "../errors.js";
+import { CouponSplitOutOfRangeError, InvalidPaymentReferenceError, MissingEOAWalletError, TransactionRevertedError, writeContractOrThrow, } from "../errors.js";
 import { Registry } from "../../abis/index.js";
+import { Settlement } from "../../types.js";
+import { PaymentReferenceKind, _parsePaymentReference } from "./utils/paymentReference.js";
 // 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`.
@@ -207,21 +210,92 @@ export const _assignESIMIdentifier = async (client, eSIMWalletAddress, eSIMUniqu
  * never sees a transfer to prove it), and `_tokenAmount` is recorded for
  * offchain matching but never checked against `_dataBundleDetail.priceUSDCents`.
  * `_paymentReference` is spendable once per eSIM wallet.
+ *
+ * Given `[couponRef, remainderRef]` and `couponUSDCents`, records a purchase
+ * split between a coupon and another payment as two lines, see
+ * {@link _couponSplitLines}. Lines already recorded are skipped, so a retry
+ * after a partial failure sends only what is missing. Returns the last hash
+ * sent; any earlier one is already mined.
  */
-export const _recordSettledPurchase = async (client, eSIMWalletAddress, dataBundleDetail, asset, tokenAmount, paymentReference) => {
+export const _recordSettledPurchase = async (client, eSIMWalletAddress, dataBundleDetail, asset, tokenAmount, paymentReference, couponUSDCents) => {
     const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
         throw new MissingEOAWalletError();
-    return writeContractOrThrow(client, {
+    const account = client.account;
+    const record = (line) => writeContractOrThrow(client, {
         address: values.factoryAddresses.REGISTRY,
         chain: values.chain,
-        account: client.account,
+        account,
         abi: Registry,
         functionName: 'recordSettledPurchase',
-        args: [eSIMWalletAddress, dataBundleDetail, asset, tokenAmount, paymentReference]
+        args: [eSIMWalletAddress, line.dataBundleDetail, line.asset, line.tokenAmount, line.paymentReference]
     });
+    if (typeof paymentReference === "string") {
+        return record({ dataBundleDetail, asset, tokenAmount, paymentReference });
+    }
+    const lines = _couponSplitLines(dataBundleDetail, asset, tokenAmount, paymentReference, couponUSDCents);
+    const publicClient = client.extend(publicActions);
+    const spent = await Promise.all(lines.map((line) => publicClient.readContract({
+        address: values.factoryAddresses.REGISTRY,
+        abi: Registry,
+        functionName: "usedPaymentReferences",
+        args: [keccak256(encodeAbiParameters([{ type: "address" }, { type: "bytes32" }], [eSIMWalletAddress, line.paymentReference]))]
+    })));
+    const missing = lines.filter((_, i) => !spent[i]);
+    // With both lines recorded, the remainder is sent anyway so the contract refuses it with
+    // `PaymentReferenceAlreadyUsed`, the same answer a retried single reference gets.
+    let hash;
+    for (const line of missing.length > 0 ? missing : [lines[0]]) {
+        if (hash) {
+            const receipt = await publicClient.waitForTransactionReceipt({ hash });
+            if (receipt.status !== "success")
+                throw new TransactionRevertedError(hash);
+        }
+        hash = await record(line);
+    }
+    return hash;
+};
+// Coupons are recorded as card payments in USD, whose smallest unit is a cent.
+const COUPON_ASSET = stringToHex("USD", { size: 32 });
+/**
+ * Splits one purchase into its remainder line and its coupon line, in that
+ * order. `dataBundleDetail` carries the full price and how the remainder was
+ * paid; `asset` and `tokenAmount` are what the user paid for the remainder.
+ * The coupon line is always `Fiat` in `USD`, with the coupon's cents as its
+ * token amount.
+ */
+export const _couponSplitLines = (dataBundleDetail, asset, tokenAmount, [couponRef, remainderRef], couponUSDCents) => {
+    const coupon = _parsePaymentReference(couponRef);
+    const remainder = _parsePaymentReference(remainderRef);
+    if (coupon.kind !== PaymentReferenceKind.CouponPart) {
+        throw new InvalidPaymentReferenceError(couponRef, "is not tagged as a coupon part");
+    }
+    if (remainder.kind !== PaymentReferenceKind.Remainder) {
+        throw new InvalidPaymentReferenceError(remainderRef, "is not tagged as a remainder");
+    }
+    if (coupon.reference !== remainder.reference) {
+        throw new InvalidPaymentReferenceError(remainderRef, `belongs to a different order than ${couponRef}`);
+    }
+    const price = dataBundleDetail.priceUSDCents;
+    if (couponUSDCents === undefined || couponUSDCents <= 0n || couponUSDCents >= price) {
+        throw new CouponSplitOutOfRangeError(couponUSDCents, price);
+    }
+    return [
+        {
+            dataBundleDetail: { ...dataBundleDetail, priceUSDCents: price - couponUSDCents },
+            asset,
+            tokenAmount,
+            paymentReference: remainderRef,
+        },
+        {
+            dataBundleDetail: { id: dataBundleDetail.id, priceUSDCents: couponUSDCents, settlement: Settlement.Fiat },
+            asset: COUPON_ASSET,
+            tokenAmount: couponUSDCents,
+            paymentReference: couponRef,
+        },
+    ];
 };
 /**
  * Step 2 of the 2-step admin handover: the nominee accepts. The chain requires

package/dist/esm/logic/admin/utils/paymentReference.js

@@ -0,0 +1,58 @@
+import { concat, isHex, pad, size, slice } from "viem";
+import { InvalidPaymentReferenceError } from "../../errors.js";
+/** How a purchase was paid for, as written into its payment reference. */
+export var PaymentReferenceKind;
+(function (PaymentReferenceKind) {
+    /** Paid in full without a coupon. Carries no tag. */
+    PaymentReferenceKind["Standard"] = "Standard";
+    /** Paid in full by a coupon. */
+    PaymentReferenceKind["Coupon"] = "Coupon";
+    /** The coupon's share of a purchase split between a coupon and another payment. */
+    PaymentReferenceKind["CouponPart"] = "CouponPart";
+    /** What the user paid on top of the coupon in a split purchase. */
+    PaymentReferenceKind["Remainder"] = "Remainder";
+})(PaymentReferenceKind || (PaymentReferenceKind = {}));
+// The backend puts the order id in the low 12 bytes, leaving the high 20 free for a tag.
+// Every coupon tag starts with 0xfee0ff ("fee off") so it stands out on an explorer.
+const TAG_SIZE = 20;
+const TAGS = {
+    [PaymentReferenceKind.Standard]: pad("0x", { size: TAG_SIZE }),
+    [PaymentReferenceKind.Coupon]: pad("0xfee0ff", { size: TAG_SIZE, dir: "right" }),
+    [PaymentReferenceKind.CouponPart]: pad("0xfee0ffc0de", { size: TAG_SIZE, dir: "right" }),
+    [PaymentReferenceKind.Remainder]: pad("0xfee0ffba1a5ce0", { size: TAG_SIZE, dir: "right" }),
+};
+// Lowercased so a checksum-style or uppercase input compares equal to the tags above.
+const _splitReference = (reference) => {
+    if (!isHex(reference, { strict: true }) || size(reference) !== 32) {
+        throw new InvalidPaymentReferenceError(reference, "is not 32 bytes of hex");
+    }
+    const lower = reference.toLowerCase();
+    const order = slice(lower, TAG_SIZE);
+    // The contracts refuse a zero reference, and a tag would hide an empty order id from that check.
+    if (BigInt(order) === 0n)
+        throw new InvalidPaymentReferenceError(reference, "has an empty order part");
+    return { tag: slice(lower, 0, TAG_SIZE), order };
+};
+/**
+ * Writes `kind`'s tag into the high 20 bytes of `reference`, which must be zero
+ * there. Tag both halves of a split purchase from the same reference, so each
+ * spends once onchain and both still point at the same order.
+ */
+export const _tagPaymentReference = (reference, kind) => {
+    const { tag, order } = _splitReference(reference);
+    if (tag !== TAGS[PaymentReferenceKind.Standard]) {
+        throw new InvalidPaymentReferenceError(reference, "is already tagged");
+    }
+    return concat([TAGS[kind], order]);
+};
+/**
+ * Reads back how a purchase was paid for, and the untagged reference it was
+ * built from. Throws on a tag this SDK did not write.
+ */
+export const _parsePaymentReference = (reference) => {
+    const { tag, order } = _splitReference(reference);
+    const kind = Object.keys(TAGS).find((k) => TAGS[k] === tag);
+    if (!kind)
+        throw new InvalidPaymentReferenceError(reference, "has an unknown tag");
+    return { kind, reference: pad(order, { size: 32 }) };
+};

package/dist/esm/logic/constants.js

@@ -25,18 +25,17 @@ export var CHAIN_ID;
     CHAIN_ID[CHAIN_ID["BASE_MAINNET"] = 8453] = "BASE_MAINNET";
     CHAIN_ID[CHAIN_ID["BASE_SEPOLIA"] = 84532] = "BASE_SEPOLIA";
 })(CHAIN_ID || (CHAIN_ID = {}));
-// Not yet deployed. Kept as a placeholder so mainnet has a documented shape to
-// fill in once the protocol ships there, following Base Sepolia's soak.
+// From smart-contract-suite `deployments/base-8453-entrypoint-v8.json`.
 export const baseMainnetFactoryAddresses = {
-    DEVICE_WALLET_FACTORY: '0x',
-    ESIM_WALLET_FACTORY: '0x',
-    LAZY_WALLET_REGISTRY: '0x',
-    REGISTRY: '0x',
-    ENTRY_POINT: '0x',
-    SENDER_CREATOR: '0x',
-    P256VERIFIER: '0x',
-    PROTOCOL_ADMIN: '0x',
-    PAYMENT_ADAPTER: '0x'
+    DEVICE_WALLET_FACTORY: '0xAC6B6A9F905e2593d587D244cEee6a0886952a6D',
+    ESIM_WALLET_FACTORY: '0xC88723826B9070ea89d9040387DE4C22A490EdB6',
+    LAZY_WALLET_REGISTRY: '0x2046aE906FB940Ad99147f233711Bb6711A2Ab0C',
+    REGISTRY: '0x76fB7F8C97457A5a6dF19a7041a66a7f1b3c910c',
+    ENTRY_POINT: '0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108',
+    SENDER_CREATOR: '0x449ED7C3e6Fee6a97311d4b55475DF59C44AdD33',
+    P256VERIFIER: '0x4E2C5B9B88184464162d581D6BF36615f0040fE6',
+    PROTOCOL_ADMIN: '0x0E664e956aAD2599D17dE2381cc22687a066778B',
+    PAYMENT_ADAPTER: '0xbb80B10BECB997b02a4BA4068C145Ef18129943d'
 };
 export const baseSepoliaFactoryAddresses = {
     DEVICE_WALLET_FACTORY: '0x0BB3BA8D9233514a4aA6D72c243a2473f9cFf0bb',
@@ -73,9 +72,7 @@ export const _extractChainID = async (client) => {
     }
     return _chainId(client);
 };
-// Maps each supported chain id to its factory-address book + viem chain. Base
-// Mainnet is listed with '0x' placeholders so the guard below rejects it with a
-// clear message rather than leaking '0x' into viem calls.
+// Maps each supported chain id to its factory-address book + viem chain.
 const CHAIN_CONFIG = {
     [CHAIN_ID.BASE_MAINNET]: { factoryAddresses: baseMainnetFactoryAddresses, chain: base },
     [CHAIN_ID.BASE_SEPOLIA]: { factoryAddresses: baseSepoliaFactoryAddresses, chain: baseSepolia },

package/dist/esm/logic/deviceWallet.js

@@ -134,12 +134,12 @@ export const _removeESIMWallet = async (client, address, eSIMWalletAddress, call
  * Rotate the P256 key that owns this wallet. The registry is told in the same
  * call, so its record of the owner cannot drift from the wallet's.
  *
- * A key that cannot produce a verifiable signature bricks the wallet: this is
- * reachable only through a signed userOp, so there is no rotating back and no
- * reaching the balance afterwards. The contract rejects a key it can tell is
- * unusable, but check the new key can sign before calling.
+ * `newOwnerSignature` is the new passkey's WebAuthn assertion over
+ * `rotationChallenge(newOwner)`, ABI-encoded as a `WebAuthnSignature` with no
+ * version or validUntil header. Without it the contract reverts with
+ * `NewOwnerKeyCannotSign`, so a wallet can only move to a key that can sign.
  */
-export const _transferOwnership = async (client, address, newOwner) => {
+export const _transferOwnership = async (client, address, newOwner, newOwnerSignature) => {
     if (!client.account)
         throw new MissingSmartWalletError();
     // UserOp - `onlySelf`.
@@ -150,7 +150,7 @@ export const _transferOwnership = async (client, address, newOwner) => {
                 data: encodeFunctionData({
                     abi: DeviceWallet,
                     functionName: "transferOwnership",
-                    args: [newOwner]
+                    args: [newOwner, newOwnerSignature]
                 })
             }]
     });
@@ -259,6 +259,19 @@ export const _isValidSignature = async (client, address, messageHash, signature)
         args: [messageHash, signature]
     });
 };
+/**
+ * The bytes the new passkey must sign before `transferOwnership` accepts it.
+ * Bound to this wallet, this chain and `newOwner`, so it cannot be reused for
+ * another rotation.
+ */
+export const _rotationChallenge = async (client, address, newOwner) => {
+    return client.readContract({
+        address,
+        abi: DeviceWallet,
+        functionName: "rotationChallenge",
+        args: [newOwner]
+    });
+};
 /** The registry this wallet reports its ownership changes to. */
 export const _registry = async (client, address) => {
     return client.readContract({

package/dist/esm/logic/eSIMWallet.js

@@ -37,6 +37,29 @@ export const _setPriceCapUSDCents = async (client, address, cap) => {
             }]
     });
 };
+/**
+ * Set the total the admin key may charge this eSIM wallet, in USD cents. It
+ * replaces what is left rather than adding to it, and zero stops admin charges.
+ *
+ * `onlyDeviceWallet`, so only the user can raise what the admin may spend. A
+ * handover resets it to the registry default.
+ */
+export const _setAdminAllowanceUSDCents = async (client, address, allowance) => {
+    if (!client.account)
+        throw new MissingSmartWalletError();
+    // UserOp - `onlyDeviceWallet`.
+    return client.sendUserOperation({
+        account: client.account,
+        calls: [{
+                to: address,
+                data: encodeFunctionData({
+                    abi: ESIMWallet,
+                    functionName: "setAdminAllowanceUSDCents",
+                    args: [allowance]
+                })
+            }]
+    });
+};
 /**
  * Buy a data bundle in `asset`, an ERC-20 the payment adapter accepts.
  *
@@ -135,6 +158,19 @@ export const _priceCapUSDCents = async (client, address) => {
     const registryCap = await _defaultPriceCapUSDCents(client);
     return registryCap === 0n ? maxUint256 : registryCap;
 };
+/**
+ * What the admin key may still charge this eSIM wallet, in USD cents. Each admin
+ * purchase lowers it and nothing refills it, so the owner tops it up with
+ * `setAdminAllowanceUSDCents`. The owner's own purchases do not touch it.
+ */
+export const _adminAllowanceUSDCents = async (client, address) => {
+    return client.readContract({
+        address,
+        abi: ESIMWallet,
+        functionName: "adminAllowanceUSDCents",
+        args: []
+    });
+};
 /**
  * The device wallet this eSIM wallet belongs to. Tracks `owner`, but it is its
  * own storage slot with its own getter, so read whichever one you mean.

package/dist/esm/logic/errors.js

@@ -228,6 +228,44 @@ export class PriceOutOfRangeError extends KokioError {
         this.priceUSDCents = priceUSDCents;
     }
 }
+/**
+ * An admin purchase priced above what the eSIM wallet's owner still allows the
+ * admin key to charge. Thrown before sending, since the contract would revert
+ * with `AdminAllowanceExceeded`. The owner raises it with `setAdminAllowanceUSDCents`.
+ */
+export class AdminAllowanceExceededError extends KokioError {
+    priceUSDCents;
+    remainingUSDCents;
+    constructor(priceUSDCents, remainingUSDCents) {
+        super("ADMIN_ALLOWANCE_EXCEEDED", `${priceUSDCents} cents is more than the ${remainingUSDCents} cents the owner still allows the admin to charge.`);
+        this.priceUSDCents = priceUSDCents;
+        this.remainingUSDCents = remainingUSDCents;
+    }
+}
+/**
+ * A payment reference that is not 32 bytes, has an empty order part, or
+ * carries a tag this SDK cannot write over or read back.
+ */
+export class InvalidPaymentReferenceError extends KokioError {
+    reference;
+    constructor(reference, reason) {
+        super("INVALID_PAYMENT_REFERENCE", `Payment reference "${reference}" ${reason}.`);
+        this.reference = reference;
+    }
+}
+/**
+ * A coupon that covers none or all of the price. Neither is a split: a coupon
+ * covering the whole price is a full-coupon order with a single reference.
+ */
+export class CouponSplitOutOfRangeError extends KokioError {
+    couponUSDCents;
+    priceUSDCents;
+    constructor(couponUSDCents, priceUSDCents) {
+        super("COUPON_SPLIT_OUT_OF_RANGE", `A coupon of ${couponUSDCents} cents does not split a price of ${priceUSDCents} cents.`);
+        this.couponUSDCents = couponUSDCents;
+        this.priceUSDCents = priceUSDCents;
+    }
+}
 // Every ABI that can surface a custom error from an on-chain revert. viem's
 // `decodeErrorResult` walks each ABI's `error` fragments to match the 4-byte
 // selector in the revert data.

package/dist/esm/logic/registry.js

@@ -218,6 +218,18 @@ export const _defaultPriceCapUSDCents = async (client) => {
         args: []
     });
 };
+/** What the admin key may charge a newly created eSIM wallet in total, in USD cents. */
+export const _defaultAdminAllowanceUSDCents = async (client) => {
+    const chainID = await _chainId(client);
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.readContract({
+        address: values.factoryAddresses.REGISTRY,
+        abi: Registry,
+        functionName: "defaultAdminAllowanceUSDCents",
+        args: []
+    });
+};
 /** The payment adapter this registry currently points at. */
 export const _paymentAdapter = async (client) => {
     const chainID = await _chainId(client);

package/dist/types/abis/DeviceWallet.d.ts

@@ -345,6 +345,20 @@ declare const DeviceWallet: readonly [{
     }];
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "rotationChallenge";
+    readonly inputs: readonly [{
+        readonly name: "newOwner";
+        readonly type: "bytes32[2]";
+        readonly internalType: "bytes32[2]";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly name: "supportsInterface";
@@ -380,6 +394,10 @@ declare const DeviceWallet: readonly [{
         readonly name: "newOwner";
         readonly type: "bytes32[2]";
         readonly internalType: "bytes32[2]";
+    }, {
+        readonly name: "newOwnerSignature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
     }];
     readonly outputs: readonly [{
         readonly name: "";
@@ -643,6 +661,10 @@ declare const DeviceWallet: readonly [{
     readonly type: "error";
     readonly name: "InvalidInitialization";
     readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "NewOwnerKeyCannotSign";
+    readonly inputs: readonly [];
 }, {
     readonly type: "error";
     readonly name: "NotInitializing";

package/dist/types/abis/ESIMWallet.d.ts

@@ -7,6 +7,16 @@ declare const ESIMWallet: readonly [{
     readonly inputs: readonly [];
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "adminAllowanceUSDCents";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint64";
+        readonly internalType: "uint64";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly name: "buyDataBundleWithToken";
@@ -218,6 +228,16 @@ declare const ESIMWallet: readonly [{
         readonly internalType: "uint256";
     }];
     readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "setAdminAllowanceUSDCents";
+    readonly inputs: readonly [{
+        readonly name: "_allowance";
+        readonly type: "uint64";
+        readonly internalType: "uint64";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly name: "setESIMUniqueIdentifier";
@@ -270,6 +290,16 @@ declare const ESIMWallet: readonly [{
     }];
     readonly outputs: readonly [];
     readonly stateMutability: "pure";
+}, {
+    readonly type: "event";
+    readonly name: "AdminAllowanceUSDCentsUpdated";
+    readonly inputs: readonly [{
+        readonly name: "_allowance";
+        readonly type: "uint64";
+        readonly indexed: false;
+        readonly internalType: "uint64";
+    }];
+    readonly anonymous: false;
 }, {
     readonly type: "event";
     readonly name: "DataBundleBoughtWithToken";
@@ -483,6 +513,18 @@ declare const ESIMWallet: readonly [{
         readonly internalType: "uint256";
     }];
     readonly anonymous: false;
+}, {
+    readonly type: "error";
+    readonly name: "AdminAllowanceExceeded";
+    readonly inputs: readonly [{
+        readonly name: "priceUSDCents";
+        readonly type: "uint64";
+        readonly internalType: "uint64";
+    }, {
+        readonly name: "remaining";
+        readonly type: "uint64";
+        readonly internalType: "uint64";
+    }];
 }, {
     readonly type: "error";
     readonly name: "AssetNotTransferable";

package/dist/types/abis/PaymentAdapter.d.ts

@@ -116,6 +116,24 @@ declare const PaymentAdapter: readonly [{
         readonly internalType: "uint256";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "recoverTokens";
+    readonly inputs: readonly [{
+        readonly name: "_token";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "_to";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "_amount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly name: "registerAsset";
@@ -443,6 +461,26 @@ declare const PaymentAdapter: readonly [{
         readonly internalType: "uint256";
     }];
     readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "TokensRecovered";
+    readonly inputs: readonly [{
+        readonly name: "_token";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "_to";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "_amount";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }];
+    readonly anonymous: false;
 }, {
     readonly type: "event";
     readonly name: "Upgraded";
@@ -653,6 +691,10 @@ declare const PaymentAdapter: readonly [{
         readonly type: "string";
         readonly internalType: "string";
     }];
+}, {
+    readonly type: "error";
+    readonly name: "ZeroAmount";
+    readonly inputs: readonly [];
 }, {
     readonly type: "error";
     readonly name: "ZeroDataBundlePrice";