@symmio/trading-core 3.0.0 → 3.1.0

package/dist/symmio-contracts/account-layer/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","names":[],"sources":["../../../src/symmio-contracts/account-layer/types.ts"],"sourcesContent":["import type { Address, Hex } from \"viem\";\n\n/**\n * A single Schnorr signature produced by the Muon network's TSS, mirrored from\n * the on-chain `ISymmio.SchnorrSign` struct field-for-field (same order).\n *\n * @remarks\n * Both `owner` and `nonce` are `address` on-chain (not numbers) — `nonce` is the\n * Muon nonce **address**, not a numeric nonce.\n *\n * @see {@link https://github.com/SYMM-IO/perps-core/blob/version_0.8.6/contracts/accountLayer/interfaces/ISymmio.sol}\n */\nexport interface SchnorrSign {\n  /** Aggregated Schnorr signature scalar. */\n  signature: bigint;\n  /** Signer (gateway) address. */\n  owner: Address;\n  /** Muon nonce address (an `address`, not a numeric nonce). */\n  nonce: Address;\n}\n\n/**\n * A Muon uPnL attestation, mirrored from the on-chain `ISymmio.SingleUpnlSig`\n * struct field-for-field (same order) so the object encodes directly as the\n * contract tuple without translation.\n *\n * @remarks\n * This is what {@link removeMargin} requires as its `upnlSig` argument: the\n * contract verifies it to prove the virtual account stays solvent after the\n * deallocation. Fetch a fresh one from the Muon service immediately before\n * submitting — the attestation is timestamped and short-lived. Note there is\n * **no** `price` field (this is the uPnL-only sig, not `SingleUpnlAndPriceSig`).\n *\n * @see {@link https://github.com/SYMM-IO/perps-core/blob/version_0.8.6/contracts/accountLayer/interfaces/ISymmio.sol}\n */\nexport interface SingleUpnlSig {\n  /** Muon request id (opaque bytes). */\n  reqId: Hex;\n  /** Attestation timestamp (seconds). */\n  timestamp: bigint;\n  /** Signed unrealized PnL of the party, `int256` (may be negative). */\n  upnl: bigint;\n  /** Muon gateway signature over the request (opaque bytes). */\n  gatewaySignature: Hex;\n  /** The Schnorr TSS signature pieces. */\n  sigs: SchnorrSign;\n}\n\n/**\n * Strategy the AccountLayer uses to create Virtual Accounts (VAs) for trades\n * placed through this subaccount.\n *\n * @remarks\n * Names and ordering mirror the on-chain `enum SubAccountIsolationType` in\n * `AccountStorage.sol` (perps-core v0.8.6) exactly, so a `uint8` returned by\n * `getUserSubAccounts` casts directly to this enum without translation.\n *\n * @see {@link https://github.com/SYMM-IO/perps-core/blob/version_0.8.6/contracts/accountLayer/storages/AccountStorage.sol}\n */\nexport enum SubAccountIsolationType {\n  /**\n   * One VA per trade. Each position lives in its own VA, fully isolated.\n   */\n  POSITION = 0,\n  /**\n   * One VA per market. All trades on the same market share a VA.\n   */\n  MARKET = 1,\n  /**\n   * One VA per market + direction. Longs and shorts on the same market are\n   * isolated from each other.\n   */\n  MARKET_DIRECTION = 2,\n  /**\n   * No automatic VA creation. Trades execute on the SubAccount directly or on\n   * manually-created VAs.\n   */\n  CUSTOM = 3,\n}\n\n/**\n * One subaccount owned by a user EOA on a SYMMIO `AccountLayer` deployment.\n *\n * Field shapes mirror the on-chain `SubAccountDetail` struct exactly so callers\n * comparing against raw viem decodings do not have to translate.\n */\nexport interface SubAccountDetail {\n  /**\n   * The subaccount's proxy address on-chain.\n   */\n  accountAddress: Address;\n  /**\n   * The EOA that created and owns the subaccount.\n   */\n  owner: Address;\n  /**\n   * User-defined display name. Editable via the `editAccountName` write.\n   */\n  name: string;\n  /**\n   * `false` for a subaccount that has been deleted on-chain.\n   */\n  isExists: boolean;\n  /**\n   * `true` when the subaccount routes successive quotes for the same market\n   * into the existing active VA instead of creating a fresh VA per `sendQuote`.\n   * Toggleable only while no VAs are active on the subaccount.\n   */\n  singleVAMode: boolean;\n  /**\n   * Affiliate address attributed to the subaccount, or the zero address.\n   */\n  affiliate: Address;\n  /**\n   * The Symmio core (diamond) address this subaccount trades against.\n   */\n  symmioCore: Address;\n  /**\n   * Free-form contract metadata blob. May be `0x` (empty) for most accounts.\n   */\n  metadata: Hex;\n  /**\n   * Strategy the AccountLayer uses to create VAs for this subaccount's trades.\n   */\n  isolationType: SubAccountIsolationType;\n}\n\n/**\n * Raw balance fields returned by `balanceInfoOfPartyA(account)` on a SYMMIO\n * core/diamond contract.\n *\n * Values are returned in the collateral token's raw units.\n */\nexport interface AccountBalanceInfo {\n  /** Total allocated balance. */\n  allocatedBalance: bigint;\n  /** Locked CVA margin. */\n  lockedCVA: bigint;\n  /** Locked LF margin. */\n  lockedLF: bigint;\n  /** Locked PartyA maintenance margin. */\n  lockedPartyAMM: bigint;\n  /** Locked PartyB maintenance margin. */\n  lockedPartyBMM: bigint;\n  /** Pending locked CVA margin. */\n  pendingLockedCVA: bigint;\n  /** Pending locked LF margin. */\n  pendingLockedLF: bigint;\n  /** Pending locked PartyA maintenance margin. */\n  pendingLockedPartyAMM: bigint;\n  /** Pending locked PartyB maintenance margin. */\n  pendingLockedPartyBMM: bigint;\n}\n\n/**\n * Input parameters for creating one subaccount via `createSubAccounts`.\n *\n * Field shapes and ordering mirror the on-chain `SubAccountCreationData` struct\n * in `AccountStorage.sol` (perps-core v0.8.6) exactly, so the object encodes\n * directly as the contract tuple without translation.\n *\n * @see {@link https://github.com/SYMM-IO/perps-core/blob/version_0.8.6/contracts/accountLayer/storages/AccountStorage.sol}\n */\nexport interface SubAccountCreationData {\n  /**\n   * Display name for the subaccount. Validated on-chain to 1-100 characters.\n   */\n  name: string;\n  /**\n   * Free-form metadata blob forwarded to the affiliate's `onAccountCreation`\n   * hook. Pass `0x` when unused.\n   */\n  metadata: Hex;\n  /**\n   * The Symmio core (diamond) the subaccount trades against. Must be whitelisted\n   * on the AccountLayer and registered for `affiliate`.\n   */\n  symmioCore: Address;\n  /**\n   * Strategy the AccountLayer uses to create VAs for this subaccount's trades.\n   */\n  isolationType: SubAccountIsolationType;\n  /**\n   * Route successive same-market quotes into the existing active VA instead of\n   * creating a fresh VA per `sendQuote`. Only valid with `MARKET` or\n   * `MARKET_DIRECTION` isolation; the contract reverts otherwise.\n   */\n  singleVAMode: boolean;\n}\n\n/**\n * Lifecycle state of an affiliate on the `AccountLayer`.\n *\n * @remarks\n * Names and ordering mirror the on-chain `enum AffiliateState` in\n * `AffiliateStorage.sol` (perps-core v0.8.6) exactly, so a `uint8` returned by\n * `getAffiliateState` casts directly to this enum without translation.\n *\n * @see {@link https://github.com/SYMM-IO/perps-core/blob/version_0.8.6/contracts/accountLayer/storages/AffiliateStorage.sol}\n */\nexport enum AffiliateState {\n  /** No registration exists for this address. */\n  NONE = 0,\n  /** A registration request has been submitted and is awaiting approval. */\n  PENDING = 1,\n  /** The affiliate has been approved and can attribute trades and collect fees. */\n  ACTIVE = 2,\n  /** The affiliate has been paused by an approver; trading attribution is halted. */\n  PAUSED = 3,\n}\n\n/**\n * A single fee recipient within an affiliate registration, mirrored from the\n * on-chain `Stakeholder` struct field-for-field (same order).\n *\n * @remarks\n * `share` is scaled to `1e18`; the sum of every stakeholder's `share` plus the\n * registration's `symmioShare` must equal exactly `1e18` or the contract reverts.\n *\n * @see {@link https://github.com/SYMM-IO/perps-core/blob/version_0.8.6/contracts/accountLayer/storages/AffiliateStorage.sol}\n */\nexport interface Stakeholder {\n  /** Address that receives this stakeholder's cut of affiliate fees. */\n  receiver: Address;\n  /** This stakeholder's fee share, scaled to `1e18` (e.g. `0.4e18` for 40%). */\n  share: bigint;\n}\n\n/**\n * The `AffiliateRegistration` tuple passed to {@link requestToRegisterAffiliate},\n * mirrored from the on-chain struct field-for-field (same order) so the object\n * encodes directly as the contract tuple without translation.\n *\n * @remarks\n * The returned affiliate address is a **new, deterministic** `AccountManager`\n * contract derived from `(msg.sender, name)` — not the caller's EOA. Predict it\n * ahead of time with {@link generateAccountManagerAddress}. Registration only\n * creates a `PENDING` affiliate; an `APPROVER_ROLE` holder must approve it before\n * it becomes `ACTIVE`.\n *\n * @see {@link https://github.com/SYMM-IO/perps-core/blob/version_0.8.6/contracts/accountLayer/storages/AffiliateStorage.sol}\n */\nexport interface AffiliateRegistration {\n  /** Display name for the affiliate. Validated on-chain to 1..maxNameLength characters. */\n  name: string;\n  /** UI brand color for the affiliate (free-form string, e.g. a hex color). */\n  brandColor: string;\n  /** The affiliate admin address. Must be non-zero; controls the affiliate after approval. */\n  admin: Address;\n  /** Fee recipients and their shares. Shares plus `symmioShare` must sum to `1e18`. */\n  stakeholders: Stakeholder[];\n  /** The Symmio protocol's fee share, scaled to `1e18`. With `stakeholders` shares, sums to `1e18`. */\n  symmioShare: bigint;\n  /** Free-form metadata blob. Pass `0x` when unused. */\n  metadata: Hex;\n  /** Legacy `MultiAccount` contracts to migrate into this affiliate. Pass `[]` when none. */\n  legacyMultiAccounts: Address[];\n  /** Symmio core (diamond) addresses to register the affiliate on. Each must be whitelisted. */\n  symmioCores: Address[];\n}\n"],"mappings":";AA2DA,IAAY,IAAL,yBAAA,GAAA;QAIL,EAAA,EAAA,WAAA,KAAA,YAIA,EAAA,EAAA,SAAA,KAAA,UAKA,EAAA,EAAA,mBAAA,KAAA,oBAKA,EAAA,EAAA,SAAA,KAAA;AACF,EAAA,CAAA,CAAA,GA0HY,IAAL,yBAAA,GAAA;QAEL,EAAA,EAAA,OAAA,KAAA,QAEA,EAAA,EAAA,UAAA,KAAA,WAEA,EAAA,EAAA,SAAA,KAAA,UAEA,EAAA,EAAA,SAAA,KAAA;AACF,EAAA,CAAA,CAAA"}
+{"version":3,"file":"types.js","names":[],"sources":["../../../src/symmio-contracts/account-layer/types.ts"],"sourcesContent":["import type { Address, Hex } from \"viem\";\n\n/**\n * A single Schnorr signature produced by the Muon network's TSS, mirrored from\n * the on-chain `ISymmio.SchnorrSign` struct field-for-field (same order).\n *\n * @remarks\n * Both `owner` and `nonce` are `address` on-chain (not numbers) — `nonce` is the\n * Muon nonce **address**, not a numeric nonce.\n *\n * @see {@link https://github.com/SYMM-IO/perps-core/blob/version_0.8.6/contracts/accountLayer/interfaces/ISymmio.sol}\n */\nexport interface SchnorrSign {\n  /** Aggregated Schnorr signature scalar. */\n  signature: bigint;\n  /** Signer (gateway) address. */\n  owner: Address;\n  /** Muon nonce address (an `address`, not a numeric nonce). */\n  nonce: Address;\n}\n\n/**\n * A Muon uPnL attestation, mirrored from the on-chain `ISymmio.SingleUpnlSig`\n * struct field-for-field (same order) so the object encodes directly as the\n * contract tuple without translation.\n *\n * @remarks\n * This is what {@link removeMargin} requires as its `upnlSig` argument: the\n * contract verifies it to prove the virtual account stays solvent after the\n * deallocation. Fetch a fresh one from the Muon service immediately before\n * submitting — the attestation is timestamped and short-lived. Note there is\n * **no** `price` field (this is the uPnL-only sig, not `SingleUpnlAndPriceSig`).\n *\n * @see {@link https://github.com/SYMM-IO/perps-core/blob/version_0.8.6/contracts/accountLayer/interfaces/ISymmio.sol}\n */\nexport interface SingleUpnlSig {\n  /** Muon request id (opaque bytes). */\n  reqId: Hex;\n  /** Attestation timestamp (seconds). */\n  timestamp: bigint;\n  /** Signed unrealized PnL of the party, `int256` (may be negative). */\n  upnl: bigint;\n  /** Muon gateway signature over the request (opaque bytes). */\n  gatewaySignature: Hex;\n  /** The Schnorr TSS signature pieces. */\n  sigs: SchnorrSign;\n}\n\n/**\n * Strategy the AccountLayer uses to create Virtual Accounts (VAs) for trades\n * placed through this subaccount.\n *\n * @remarks\n * Names and ordering mirror the on-chain `enum SubAccountIsolationType` in\n * `AccountStorage.sol` (perps-core v0.8.6) exactly, so a `uint8` returned by\n * `getUserSubAccounts` casts directly to this enum without translation.\n *\n * @see {@link https://github.com/SYMM-IO/perps-core/blob/version_0.8.6/contracts/accountLayer/storages/AccountStorage.sol}\n */\nexport enum SubAccountIsolationType {\n  /**\n   * One VA per trade. Each position lives in its own VA, fully isolated.\n   */\n  POSITION = 0,\n  /**\n   * One VA per market. All trades on the same market share a VA.\n   */\n  MARKET = 1,\n  /**\n   * One VA per market + direction. Longs and shorts on the same market are\n   * isolated from each other.\n   */\n  MARKET_DIRECTION = 2,\n  /**\n   * No automatic VA creation. Trades execute on the SubAccount directly or on\n   * manually-created VAs.\n   */\n  CUSTOM = 3,\n}\n\n/**\n * One subaccount owned by a user EOA on a SYMMIO `AccountLayer` deployment.\n *\n * Field shapes mirror the on-chain `SubAccountDetail` struct exactly so callers\n * comparing against raw viem decodings do not have to translate.\n */\nexport interface SubAccountDetail {\n  /**\n   * The subaccount's proxy address on-chain.\n   */\n  accountAddress: Address;\n  /**\n   * The EOA that created and owns the subaccount.\n   */\n  owner: Address;\n  /**\n   * User-defined display name. Editable via the `editAccountName` write.\n   */\n  name: string;\n  /**\n   * `false` for a subaccount that has been deleted on-chain.\n   */\n  isExists: boolean;\n  /**\n   * `true` when the subaccount routes successive quotes for the same market\n   * into the existing active VA instead of creating a fresh VA per `sendQuote`.\n   * Toggleable only while no VAs are active on the subaccount.\n   */\n  singleVAMode: boolean;\n  /**\n   * Affiliate address attributed to the subaccount, or the zero address.\n   */\n  affiliate: Address;\n  /**\n   * The Symmio core (diamond) address this subaccount trades against.\n   */\n  symmioCore: Address;\n  /**\n   * Free-form contract metadata blob. May be `0x` (empty) for most accounts.\n   */\n  metadata: Hex;\n  /**\n   * Strategy the AccountLayer uses to create VAs for this subaccount's trades.\n   */\n  isolationType: SubAccountIsolationType;\n}\n\n/**\n * Raw balance fields returned by `balanceInfoOfPartyA(account)` on a SYMMIO\n * core/diamond contract.\n *\n * Values are in SYMMIO Core's **18-decimal** units, whatever the collateral\n * token's decimals — convert a token amount with `collateralToCore18` before\n * comparing.\n */\nexport interface AccountBalanceInfo {\n  /** Total allocated balance. */\n  allocatedBalance: bigint;\n  /** Locked CVA margin. */\n  lockedCVA: bigint;\n  /** Locked LF margin. */\n  lockedLF: bigint;\n  /** Locked PartyA maintenance margin. */\n  lockedPartyAMM: bigint;\n  /** Locked PartyB maintenance margin. */\n  lockedPartyBMM: bigint;\n  /** Pending locked CVA margin. */\n  pendingLockedCVA: bigint;\n  /** Pending locked LF margin. */\n  pendingLockedLF: bigint;\n  /** Pending locked PartyA maintenance margin. */\n  pendingLockedPartyAMM: bigint;\n  /** Pending locked PartyB maintenance margin. */\n  pendingLockedPartyBMM: bigint;\n}\n\n/**\n * Input parameters for creating one subaccount via `createSubAccounts`.\n *\n * Field shapes and ordering mirror the on-chain `SubAccountCreationData` struct\n * in `AccountStorage.sol` (perps-core v0.8.6) exactly, so the object encodes\n * directly as the contract tuple without translation.\n *\n * @see {@link https://github.com/SYMM-IO/perps-core/blob/version_0.8.6/contracts/accountLayer/storages/AccountStorage.sol}\n */\nexport interface SubAccountCreationData {\n  /**\n   * Display name for the subaccount. Validated on-chain to 1-100 characters.\n   */\n  name: string;\n  /**\n   * Free-form metadata blob forwarded to the affiliate's `onAccountCreation`\n   * hook. Pass `0x` when unused.\n   */\n  metadata: Hex;\n  /**\n   * The Symmio core (diamond) the subaccount trades against. Must be whitelisted\n   * on the AccountLayer and registered for `affiliate`.\n   */\n  symmioCore: Address;\n  /**\n   * Strategy the AccountLayer uses to create VAs for this subaccount's trades.\n   */\n  isolationType: SubAccountIsolationType;\n  /**\n   * Route successive same-market quotes into the existing active VA instead of\n   * creating a fresh VA per `sendQuote`. Only valid with `MARKET` or\n   * `MARKET_DIRECTION` isolation; the contract reverts otherwise.\n   */\n  singleVAMode: boolean;\n}\n\n/**\n * Lifecycle state of an affiliate on the `AccountLayer`.\n *\n * @remarks\n * Names and ordering mirror the on-chain `enum AffiliateState` in\n * `AffiliateStorage.sol` (perps-core v0.8.6) exactly, so a `uint8` returned by\n * `getAffiliateState` casts directly to this enum without translation.\n *\n * @see {@link https://github.com/SYMM-IO/perps-core/blob/version_0.8.6/contracts/accountLayer/storages/AffiliateStorage.sol}\n */\nexport enum AffiliateState {\n  /** No registration exists for this address. */\n  NONE = 0,\n  /** A registration request has been submitted and is awaiting approval. */\n  PENDING = 1,\n  /** The affiliate has been approved and can attribute trades and collect fees. */\n  ACTIVE = 2,\n  /** The affiliate has been paused by an approver; trading attribution is halted. */\n  PAUSED = 3,\n}\n\n/**\n * A single fee recipient within an affiliate registration, mirrored from the\n * on-chain `Stakeholder` struct field-for-field (same order).\n *\n * @remarks\n * `share` is scaled to `1e18`; the sum of every stakeholder's `share` plus the\n * registration's `symmioShare` must equal exactly `1e18` or the contract reverts.\n *\n * @see {@link https://github.com/SYMM-IO/perps-core/blob/version_0.8.6/contracts/accountLayer/storages/AffiliateStorage.sol}\n */\nexport interface Stakeholder {\n  /** Address that receives this stakeholder's cut of affiliate fees. */\n  receiver: Address;\n  /** This stakeholder's fee share, scaled to `1e18` (e.g. `0.4e18` for 40%). */\n  share: bigint;\n}\n\n/**\n * The `AffiliateRegistration` tuple passed to {@link requestToRegisterAffiliate},\n * mirrored from the on-chain struct field-for-field (same order) so the object\n * encodes directly as the contract tuple without translation.\n *\n * @remarks\n * The returned affiliate address is a **new, deterministic** `AccountManager`\n * contract derived from `(msg.sender, name)` — not the caller's EOA. Predict it\n * ahead of time with {@link generateAccountManagerAddress}. Registration only\n * creates a `PENDING` affiliate; an `APPROVER_ROLE` holder must approve it before\n * it becomes `ACTIVE`.\n *\n * @see {@link https://github.com/SYMM-IO/perps-core/blob/version_0.8.6/contracts/accountLayer/storages/AffiliateStorage.sol}\n */\nexport interface AffiliateRegistration {\n  /** Display name for the affiliate. Validated on-chain to 1..maxNameLength characters. */\n  name: string;\n  /** UI brand color for the affiliate (free-form string, e.g. a hex color). */\n  brandColor: string;\n  /** The affiliate admin address. Must be non-zero; controls the affiliate after approval. */\n  admin: Address;\n  /** Fee recipients and their shares. Shares plus `symmioShare` must sum to `1e18`. */\n  stakeholders: Stakeholder[];\n  /** The Symmio protocol's fee share, scaled to `1e18`. With `stakeholders` shares, sums to `1e18`. */\n  symmioShare: bigint;\n  /** Free-form metadata blob. Pass `0x` when unused. */\n  metadata: Hex;\n  /** Legacy `MultiAccount` contracts to migrate into this affiliate. Pass `[]` when none. */\n  legacyMultiAccounts: Address[];\n  /** Symmio core (diamond) addresses to register the affiliate on. Each must be whitelisted. */\n  symmioCores: Address[];\n}\n"],"mappings":";AA2DA,IAAY,IAAL,yBAAA,GAAA;QAIL,EAAA,EAAA,WAAA,KAAA,YAIA,EAAA,EAAA,SAAA,KAAA,UAKA,EAAA,EAAA,mBAAA,KAAA,oBAKA,EAAA,EAAA,SAAA,KAAA;AACF,EAAA,CAAA,CAAA,GA4HY,IAAL,yBAAA,GAAA;QAEL,EAAA,EAAA,OAAA,KAAA,QAEA,EAAA,EAAA,UAAA,KAAA,WAEA,EAAA,EAAA,SAAA,KAAA,UAEA,EAAA,EAAA,SAAA,KAAA;AACF,EAAA,CAAA,CAAA"}

package/dist/symmio-contracts/instant-layer/actions/finalize-revoke-delegation.d.ts

@@ -0,0 +1,60 @@
+import { Address, Hash, Hex } from 'viem';
+import { Config } from '../../../core/config/index.js';
+import { Compute, WriteContractParameter } from '../../../shared/types/properties.js';
+import { InstantLayerAccount } from '../types.js';
+/**
+ * Parameters for {@link finalizeRevokeDelegation}.
+ */
+export type FinalizeRevokeDelegationParameters = Compute<WriteContractParameter & {
+    /** Account the delegation was granted under. */
+    account: InstantLayerAccount;
+    /** Delegated signer whose scheduled revocation is being completed. */
+    delegate: Address;
+    /** Function selectors (`bytes4[]`) to clear. */
+    selectors: readonly Hex[];
+}>;
+/** Return type of {@link finalizeRevokeDelegation}: the submitted transaction hash. */
+export type FinalizeRevokeDelegationReturnType = Hash;
+/**
+ * Complete a scheduled Instant Layer revocation, deleting the stored grant.
+ *
+ * **Permissionless.** Unlike {@link initiateRevokeDelegation}, the contract
+ * lets *anyone* call this once the cooldown ETA has passed — so a backend, a
+ * keeper, or the user's own wallet can finish a revocation the owner started.
+ * It reverts `RevocationCooldownNotOver` while the ETA is still in the future,
+ * and silently skips any selector that was never scheduled.
+ *
+ * **This write cannot be relayed, and deliberately takes no `gasless` option.**
+ * `_verifyOperation` routes every operation targeting the InstantLayer itself
+ * to `_verifyGrantOperation`, which accepts only `grantDelegation` /
+ * `grantDelegations` and reverts `InvalidGrantOperation` for anything else — a
+ * relayed revocation would always revert. See {@link initiateRevokeDelegation}.
+ *
+ * **It is optional.** Enforcement reads `pendingRevocationEta` on every
+ * operation, so authority ends on its own at the ETA — this call is the
+ * bookkeeping leg, not the moment the key loses access, and skipping it leaves
+ * a revoked key just as powerless. Nor is it a prerequisite for re-granting:
+ * {@link grantDelegation} deletes the pending ETA for each selector it grants,
+ * so a stale schedule cannot silently neuter a fresh grant. Present it as
+ * cleanup — never as "the revoke".
+ *
+ * Dry-runs the call first unless `simulateBeforeWrite` is `false` (per-call,
+ * falling back to the config default).
+ *
+ * @param config - The SDK config (must have a `getWalletClient` resolver).
+ * @param parameters - Delegating account, delegate, selectors, optional chain id.
+ * @returns The submitted transaction hash. The caller waits on the receipt.
+ * @throws {SymmError} when the chain is unsupported or no wallet is available.
+ * @throws Viem's write errors (`ContractFunctionExecutionError`, ...).
+ *
+ * @example
+ * ```ts
+ * const hash = await finalizeRevokeDelegation(config, {
+ *   account: { addr: subAccount, isPartyB: false },
+ *   delegate: sessionKeyAddress,
+ *   selectors,
+ * });
+ * ```
+ */
+export declare function finalizeRevokeDelegation(config: Config, parameters: FinalizeRevokeDelegationParameters): Promise<FinalizeRevokeDelegationReturnType>;
+//# sourceMappingURL=finalize-revoke-delegation.d.ts.map

package/dist/symmio-contracts/instant-layer/actions/finalize-revoke-delegation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalize-revoke-delegation.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/instant-layer/actions/finalize-revoke-delegation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,GAAG,EAAE,MAAM,MAAM,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAGxF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAEpD;;GAEG;AACH,MAAM,MAAM,kCAAkC,GAAG,OAAO,CACtD,sBAAsB,GAAG;IACvB,gDAAgD;IAChD,OAAO,EAAE,mBAAmB,CAAC;IAC7B,sEAAsE;IACtE,QAAQ,EAAE,OAAO,CAAC;IAClB,gDAAgD;IAChD,SAAS,EAAE,SAAS,GAAG,EAAE,CAAC;CAC3B,CACF,CAAC;AAEF,uFAAuF;AACvF,MAAM,MAAM,kCAAkC,GAAG,IAAI,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,kCAAkC,GAC7C,OAAO,CAAC,kCAAkC,CAAC,CAwB7C"}

package/dist/symmio-contracts/instant-layer/actions/finalize-revoke-delegation.js

@@ -0,0 +1,35 @@
+import { instantLayerAbi as e } from "../../abi/v0.8.6/instant-layer.js";
+import { shouldSimulateBeforeWrite as t } from "../../../shared/utils/simulate-before-write.js";
+//#region src/symmio-contracts/instant-layer/actions/finalize-revoke-delegation.ts
+async function n(n, r) {
+	let { chainId: i, account: a, delegate: o, selectors: s, from: c } = r, { addresses: l } = n.getChainConfig(i), u = await n.getWalletClient({
+		chainId: i,
+		from: c
+	});
+	return t(n, r) && await n.getClient({ chainId: i }).simulateContract({
+		address: l.instantLayerAddress,
+		abi: e,
+		functionName: "finalizeRevokeDelegation",
+		args: [
+			a,
+			o,
+			s
+		],
+		account: u.account.address
+	}), u.writeContract({
+		address: l.instantLayerAddress,
+		abi: e,
+		functionName: "finalizeRevokeDelegation",
+		args: [
+			a,
+			o,
+			s
+		],
+		account: u.account,
+		chain: u.chain
+	});
+}
+//#endregion
+export { n as finalizeRevokeDelegation };
+
+//# sourceMappingURL=finalize-revoke-delegation.js.map

package/dist/symmio-contracts/instant-layer/actions/finalize-revoke-delegation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalize-revoke-delegation.js","names":[],"sources":["../../../../src/symmio-contracts/instant-layer/actions/finalize-revoke-delegation.ts"],"sourcesContent":["import { type Address, type Hash, type Hex } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport type { Compute, WriteContractParameter } from \"../../../shared/types/properties\";\nimport { shouldSimulateBeforeWrite } from \"../../../shared/utils/simulate-before-write\";\nimport { instantLayerAbi } from \"../../abi/v0.8.6/instant-layer\";\nimport type { InstantLayerAccount } from \"../types\";\n\n/**\n * Parameters for {@link finalizeRevokeDelegation}.\n */\nexport type FinalizeRevokeDelegationParameters = Compute<\n  WriteContractParameter & {\n    /** Account the delegation was granted under. */\n    account: InstantLayerAccount;\n    /** Delegated signer whose scheduled revocation is being completed. */\n    delegate: Address;\n    /** Function selectors (`bytes4[]`) to clear. */\n    selectors: readonly Hex[];\n  }\n>;\n\n/** Return type of {@link finalizeRevokeDelegation}: the submitted transaction hash. */\nexport type FinalizeRevokeDelegationReturnType = Hash;\n\n/**\n * Complete a scheduled Instant Layer revocation, deleting the stored grant.\n *\n * **Permissionless.** Unlike {@link initiateRevokeDelegation}, the contract\n * lets *anyone* call this once the cooldown ETA has passed — so a backend, a\n * keeper, or the user's own wallet can finish a revocation the owner started.\n * It reverts `RevocationCooldownNotOver` while the ETA is still in the future,\n * and silently skips any selector that was never scheduled.\n *\n * **This write cannot be relayed, and deliberately takes no `gasless` option.**\n * `_verifyOperation` routes every operation targeting the InstantLayer itself\n * to `_verifyGrantOperation`, which accepts only `grantDelegation` /\n * `grantDelegations` and reverts `InvalidGrantOperation` for anything else — a\n * relayed revocation would always revert. See {@link initiateRevokeDelegation}.\n *\n * **It is optional.** Enforcement reads `pendingRevocationEta` on every\n * operation, so authority ends on its own at the ETA — this call is the\n * bookkeeping leg, not the moment the key loses access, and skipping it leaves\n * a revoked key just as powerless. Nor is it a prerequisite for re-granting:\n * {@link grantDelegation} deletes the pending ETA for each selector it grants,\n * so a stale schedule cannot silently neuter a fresh grant. Present it as\n * cleanup — never as \"the revoke\".\n *\n * Dry-runs the call first unless `simulateBeforeWrite` is `false` (per-call,\n * falling back to the config default).\n *\n * @param config - The SDK config (must have a `getWalletClient` resolver).\n * @param parameters - Delegating account, delegate, selectors, optional chain id.\n * @returns The submitted transaction hash. The caller waits on the receipt.\n * @throws {SymmError} when the chain is unsupported or no wallet is available.\n * @throws Viem's write errors (`ContractFunctionExecutionError`, ...).\n *\n * @example\n * ```ts\n * const hash = await finalizeRevokeDelegation(config, {\n *   account: { addr: subAccount, isPartyB: false },\n *   delegate: sessionKeyAddress,\n *   selectors,\n * });\n * ```\n */\nexport async function finalizeRevokeDelegation(\n  config: Config,\n  parameters: FinalizeRevokeDelegationParameters,\n): Promise<FinalizeRevokeDelegationReturnType> {\n  const { chainId, account, delegate, selectors, from } = parameters;\n\n  const { addresses } = config.getChainConfig(chainId);\n  const walletClient = await config.getWalletClient({ chainId, from });\n\n  if (shouldSimulateBeforeWrite(config, parameters)) {\n    await config.getClient({ chainId }).simulateContract({\n      address: addresses.instantLayerAddress,\n      abi: instantLayerAbi,\n      functionName: \"finalizeRevokeDelegation\",\n      args: [account, delegate, selectors],\n      account: walletClient.account.address,\n    });\n  }\n\n  return walletClient.writeContract({\n    address: addresses.instantLayerAddress,\n    abi: instantLayerAbi,\n    functionName: \"finalizeRevokeDelegation\",\n    args: [account, delegate, selectors],\n    account: walletClient.account,\n    chain: walletClient.chain,\n  });\n}\n"],"mappings":";;;AAiEA,eAAsB,EACpB,GACA,GAC6C;CAC7C,IAAM,EAAE,YAAS,YAAS,aAAU,cAAW,YAAS,GAElD,EAAE,iBAAc,EAAO,eAAe,CAAO,GAC7C,IAAe,MAAM,EAAO,gBAAgB;EAAE;EAAS;CAAK,CAAC;CAYnE,OAVI,EAA0B,GAAQ,CAAU,KAC9C,MAAM,EAAO,UAAU,EAAE,WAAQ,CAAC,EAAE,iBAAiB;EACnD,SAAS,EAAU;EACnB,KAAK;EACL,cAAc;EACd,MAAM;GAAC;GAAS;GAAU;EAAS;EACnC,SAAS,EAAa,QAAQ;CAChC,CAAC,GAGI,EAAa,cAAc;EAChC,SAAS,EAAU;EACnB,KAAK;EACL,cAAc;EACd,MAAM;GAAC;GAAS;GAAU;EAAS;EACnC,SAAS,EAAa;EACtB,OAAO,EAAa;CACtB,CAAC;AACH"}

package/dist/symmio-contracts/instant-layer/actions/get-active-delegations.d.ts

@@ -0,0 +1,91 @@
+import { Address, Hex } from 'viem';
+import { Config } from '../../../core/config/index.js';
+import { ChainIdParameter, Compute } from '../../../shared/types/properties.js';
+import { InstantLayerAccount } from '../types.js';
+/**
+ * Parameters for {@link getActiveDelegations}.
+ */
+export type GetActiveDelegationsParameters = Compute<ChainIdParameter & {
+    /** Account whose delegations are inspected. May be a sub-account or a virtual account. */
+    delegator: InstantLayerAccount;
+    /** Delegated signers to probe. */
+    delegates: readonly Address[];
+    /**
+     * Selectors to probe per delegate: `selectors[i]` is the `bytes4[]` checked
+     * for `delegates[i]`, so the two arrays are parallel and must be the same
+     * length.
+     */
+    selectors: readonly (readonly Hex[])[];
+}>;
+/**
+ * One delegation the Instant Layer reports as currently active.
+ *
+ * Mirrors the contract's `InstantLayer.DelegationInfo` struct.
+ */
+export interface ActiveDelegationInfo {
+    /** The canonical account the delegation is enforced under. */
+    account: InstantLayerAccount;
+    /** Signer holding the delegated authority. */
+    delegatedSigner: Address;
+    /** Selectors of the probed set that are actually delegated and live. */
+    selectors: readonly Hex[];
+    /**
+     * The **earliest** expiry among {@link ActiveDelegationInfo.selectors}, as a
+     * Unix timestamp in seconds — not a single grant-wide expiry.
+     *
+     * The contract tracks `minExpiry` while collecting the active selectors and
+     * returns the soonest (`InstantLayer.getActiveDelegations`). Selectors granted
+     * in different transactions therefore expire at different times, and a UI that
+     * renders this as "expires at" understates every selector but the
+     * shortest-lived one. Read {@link getDelegationExpiry} per selector when the
+     * exact per-selector expiry matters.
+     */
+    expiryTimestamp: bigint;
+}
+/** Return type of {@link getActiveDelegations}: only the delegations that are live. */
+export type GetActiveDelegationsReturnType = readonly ActiveDelegationInfo[];
+/**
+ * Read which of the probed (delegate, selector) pairs are currently active
+ * delegations for one delegator, in a single call.
+ *
+ * **This is the canonicalizing getter — prefer it.** {@link getIsDelegationActive}
+ * and {@link getDelegationExpiry} read the raw `delegations` mapping verbatim:
+ * they do **not** canonicalize a virtual account to its parent sub-account,
+ * while the Instant Layer's own enforcement path does. So a caller holding a
+ * virtual account address gets `false` / `0n` from the raw readers even though
+ * the delegate really can act through that VA. `getActiveDelegations` resolves
+ * the account the way enforcement does, which makes it the only read that
+ * answers "may this key act right now?" correctly for every account shape.
+ *
+ * **It is also a filter, not a mirror.** The returned entries cover only the
+ * probed pairs that are live; a delegate you passed that holds nothing (or
+ * whose grant expired) is simply absent from the result rather than present
+ * with an empty selector list.
+ *
+ * **Revocation timing.** A delegation stays in this result for the whole
+ * revocation cooldown after `initiateRevokeDelegation` — enforcement only
+ * stops at `pendingRevocationEta`, and `finalizeRevokeDelegation` clears the
+ * stored grant afterwards. The contract's `DelegationInfo` struct carries no
+ * pending-ETA field, so a UI that wants to show "revoking, live until …" must
+ * read the InstantLayer's `pendingRevocationEta(delegator, delegate, selector)`
+ * mapping alongside this call.
+ *
+ * @param config - The SDK config.
+ * @param parameters - Delegator account, parallel delegate and selector lists, optional chain id.
+ * @returns The subset of probed delegations that are active, with their expiry timestamps.
+ * @throws {SymmError} when the chain is unsupported.
+ * @throws Viem read errors.
+ *
+ * @example
+ * ```ts
+ * // Safe for a virtual account address — this read canonicalizes, the raw mapping readers do not.
+ * const active = await getActiveDelegations(config, {
+ *   delegator: { addr: virtualAccount, isPartyB: false },
+ *   delegates: [sessionKeyAddress],
+ *   selectors: [sessionKeySelectors],
+ * });
+ * const stillDelegated = active.length > 0;
+ * ```
+ */
+export declare function getActiveDelegations(config: Config, parameters: GetActiveDelegationsParameters): Promise<GetActiveDelegationsReturnType>;
+//# sourceMappingURL=get-active-delegations.d.ts.map

package/dist/symmio-contracts/instant-layer/actions/get-active-delegations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-active-delegations.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/instant-layer/actions/get-active-delegations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAElF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAEpD;;GAEG;AACH,MAAM,MAAM,8BAA8B,GAAG,OAAO,CAClD,gBAAgB,GAAG;IACjB,0FAA0F;IAC1F,SAAS,EAAE,mBAAmB,CAAC;IAC/B,kCAAkC;IAClC,SAAS,EAAE,SAAS,OAAO,EAAE,CAAC;IAC9B;;;;OAIG;IACH,SAAS,EAAE,SAAS,CAAC,SAAS,GAAG,EAAE,CAAC,EAAE,CAAC;CACxC,CACF,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,8DAA8D;IAC9D,OAAO,EAAE,mBAAmB,CAAC;IAC7B,8CAA8C;IAC9C,eAAe,EAAE,OAAO,CAAC;IACzB,wEAAwE;IACxE,SAAS,EAAE,SAAS,GAAG,EAAE,CAAC;IAC1B;;;;;;;;;;OAUG;IACH,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,uFAAuF;AACvF,MAAM,MAAM,8BAA8B,GAAG,SAAS,oBAAoB,EAAE,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,8BAA8B,GACzC,OAAO,CAAC,8BAA8B,CAAC,CAYzC"}

package/dist/symmio-contracts/instant-layer/actions/get-active-delegations.js

@@ -0,0 +1,19 @@
+import { instantLayerAbi as e } from "../../abi/v0.8.6/instant-layer.js";
+//#region src/symmio-contracts/instant-layer/actions/get-active-delegations.ts
+async function t(t, n) {
+	let { chainId: r, delegator: i, delegates: a, selectors: o } = n, { addresses: s } = t.getChainConfig(r);
+	return t.getClient({ chainId: r }).readContract({
+		address: s.instantLayerAddress,
+		abi: e,
+		functionName: "getActiveDelegations",
+		args: [
+			i,
+			a,
+			o
+		]
+	});
+}
+//#endregion
+export { t as getActiveDelegations };
+
+//# sourceMappingURL=get-active-delegations.js.map

package/dist/symmio-contracts/instant-layer/actions/get-active-delegations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-active-delegations.js","names":[],"sources":["../../../../src/symmio-contracts/instant-layer/actions/get-active-delegations.ts"],"sourcesContent":["import type { Address, Hex } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport type { ChainIdParameter, Compute } from \"../../../shared/types/properties\";\nimport { instantLayerAbi } from \"../../abi/v0.8.6/instant-layer\";\nimport type { InstantLayerAccount } from \"../types\";\n\n/**\n * Parameters for {@link getActiveDelegations}.\n */\nexport type GetActiveDelegationsParameters = Compute<\n  ChainIdParameter & {\n    /** Account whose delegations are inspected. May be a sub-account or a virtual account. */\n    delegator: InstantLayerAccount;\n    /** Delegated signers to probe. */\n    delegates: readonly Address[];\n    /**\n     * Selectors to probe per delegate: `selectors[i]` is the `bytes4[]` checked\n     * for `delegates[i]`, so the two arrays are parallel and must be the same\n     * length.\n     */\n    selectors: readonly (readonly Hex[])[];\n  }\n>;\n\n/**\n * One delegation the Instant Layer reports as currently active.\n *\n * Mirrors the contract's `InstantLayer.DelegationInfo` struct.\n */\nexport interface ActiveDelegationInfo {\n  /** The canonical account the delegation is enforced under. */\n  account: InstantLayerAccount;\n  /** Signer holding the delegated authority. */\n  delegatedSigner: Address;\n  /** Selectors of the probed set that are actually delegated and live. */\n  selectors: readonly Hex[];\n  /**\n   * The **earliest** expiry among {@link ActiveDelegationInfo.selectors}, as a\n   * Unix timestamp in seconds — not a single grant-wide expiry.\n   *\n   * The contract tracks `minExpiry` while collecting the active selectors and\n   * returns the soonest (`InstantLayer.getActiveDelegations`). Selectors granted\n   * in different transactions therefore expire at different times, and a UI that\n   * renders this as \"expires at\" understates every selector but the\n   * shortest-lived one. Read {@link getDelegationExpiry} per selector when the\n   * exact per-selector expiry matters.\n   */\n  expiryTimestamp: bigint;\n}\n\n/** Return type of {@link getActiveDelegations}: only the delegations that are live. */\nexport type GetActiveDelegationsReturnType = readonly ActiveDelegationInfo[];\n\n/**\n * Read which of the probed (delegate, selector) pairs are currently active\n * delegations for one delegator, in a single call.\n *\n * **This is the canonicalizing getter — prefer it.** {@link getIsDelegationActive}\n * and {@link getDelegationExpiry} read the raw `delegations` mapping verbatim:\n * they do **not** canonicalize a virtual account to its parent sub-account,\n * while the Instant Layer's own enforcement path does. So a caller holding a\n * virtual account address gets `false` / `0n` from the raw readers even though\n * the delegate really can act through that VA. `getActiveDelegations` resolves\n * the account the way enforcement does, which makes it the only read that\n * answers \"may this key act right now?\" correctly for every account shape.\n *\n * **It is also a filter, not a mirror.** The returned entries cover only the\n * probed pairs that are live; a delegate you passed that holds nothing (or\n * whose grant expired) is simply absent from the result rather than present\n * with an empty selector list.\n *\n * **Revocation timing.** A delegation stays in this result for the whole\n * revocation cooldown after `initiateRevokeDelegation` — enforcement only\n * stops at `pendingRevocationEta`, and `finalizeRevokeDelegation` clears the\n * stored grant afterwards. The contract's `DelegationInfo` struct carries no\n * pending-ETA field, so a UI that wants to show \"revoking, live until …\" must\n * read the InstantLayer's `pendingRevocationEta(delegator, delegate, selector)`\n * mapping alongside this call.\n *\n * @param config - The SDK config.\n * @param parameters - Delegator account, parallel delegate and selector lists, optional chain id.\n * @returns The subset of probed delegations that are active, with their expiry timestamps.\n * @throws {SymmError} when the chain is unsupported.\n * @throws Viem read errors.\n *\n * @example\n * ```ts\n * // Safe for a virtual account address — this read canonicalizes, the raw mapping readers do not.\n * const active = await getActiveDelegations(config, {\n *   delegator: { addr: virtualAccount, isPartyB: false },\n *   delegates: [sessionKeyAddress],\n *   selectors: [sessionKeySelectors],\n * });\n * const stillDelegated = active.length > 0;\n * ```\n */\nexport async function getActiveDelegations(\n  config: Config,\n  parameters: GetActiveDelegationsParameters,\n): Promise<GetActiveDelegationsReturnType> {\n  const { chainId, delegator, delegates, selectors } = parameters;\n\n  const { addresses } = config.getChainConfig(chainId);\n  const client = config.getClient({ chainId });\n\n  return client.readContract({\n    address: addresses.instantLayerAddress,\n    abi: instantLayerAbi,\n    functionName: \"getActiveDelegations\",\n    args: [delegator, delegates, selectors],\n  });\n}\n"],"mappings":";;AAgGA,eAAsB,EACpB,GACA,GACyC;CACzC,IAAM,EAAE,YAAS,cAAW,cAAW,iBAAc,GAE/C,EAAE,iBAAc,EAAO,eAAe,CAAO;CAGnD,OAFe,EAAO,UAAU,EAAE,WAAQ,CAEnC,EAAO,aAAa;EACzB,SAAS,EAAU;EACnB,KAAK;EACL,cAAc;EACd,MAAM;GAAC;GAAW;GAAW;EAAS;CACxC,CAAC;AACH"}

package/dist/symmio-contracts/instant-layer/actions/get-instant-layer-nonce.d.ts

@@ -0,0 +1,36 @@
+import { Address } from 'viem';
+import { Config } from '../../../core/config/index.js';
+import { ChainIdParameter, Compute } from '../../../shared/types/properties.js';
+/**
+ * Parameters for {@link getInstantLayerNonce}.
+ */
+export type GetInstantLayerNonceParameters = Compute<ChainIdParameter & {
+    /** InstantLayer signer account (the sub-account the operation runs under). */
+    account: Address;
+}>;
+/** Return type of {@link getInstantLayerNonce}: the account's current replay nonce. */
+export type GetInstantLayerNonceReturnType = bigint;
+/**
+ * Read the Instant Layer replay nonce for a signer account.
+ *
+ * Nonces are **sequential**: an operation must be signed with the *next* nonce
+ * (`current + 1`), and a batch must carry strictly consecutive nonces in
+ * signed-op order (`current + 1`, `current + 2`, …). Read this immediately
+ * before building operations — a stale value produces signatures the relayer's
+ * simulation rejects. Two concurrent operations built from the same read will
+ * collide; serialize per account.
+ *
+ * @param config - The SDK config.
+ * @param parameters - Signer account, optional chain id.
+ * @returns The current on-chain nonce. Sign with `nonce + 1n`.
+ * @throws {SymmError} when the chain is unsupported.
+ * @throws Viem read errors.
+ *
+ * @example
+ * ```ts
+ * const current = await getInstantLayerNonce(config, { account: subAccount });
+ * const operation = buildSignedOperation({ ...fields, nonce: current + 1n });
+ * ```
+ */
+export declare function getInstantLayerNonce(config: Config, parameters: GetInstantLayerNonceParameters): Promise<GetInstantLayerNonceReturnType>;
+//# sourceMappingURL=get-instant-layer-nonce.d.ts.map

package/dist/symmio-contracts/instant-layer/actions/get-instant-layer-nonce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-instant-layer-nonce.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/instant-layer/actions/get-instant-layer-nonce.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAGlF;;GAEG;AACH,MAAM,MAAM,8BAA8B,GAAG,OAAO,CAClD,gBAAgB,GAAG;IACjB,8EAA8E;IAC9E,OAAO,EAAE,OAAO,CAAC;CAClB,CACF,CAAC;AAEF,uFAAuF;AACvF,MAAM,MAAM,8BAA8B,GAAG,MAAM,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,8BAA8B,GACzC,OAAO,CAAC,8BAA8B,CAAC,CAYzC"}

package/dist/symmio-contracts/instant-layer/actions/get-instant-layer-nonce.js

@@ -0,0 +1,15 @@
+import { instantLayerAbi as e } from "../../abi/v0.8.6/instant-layer.js";
+//#region src/symmio-contracts/instant-layer/actions/get-instant-layer-nonce.ts
+async function t(t, n) {
+	let { chainId: r, account: i } = n, { addresses: a } = t.getChainConfig(r);
+	return t.getClient({ chainId: r }).readContract({
+		address: a.instantLayerAddress,
+		abi: e,
+		functionName: "nonces",
+		args: [i]
+	});
+}
+//#endregion
+export { t as getInstantLayerNonce };
+
+//# sourceMappingURL=get-instant-layer-nonce.js.map

package/dist/symmio-contracts/instant-layer/actions/get-instant-layer-nonce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-instant-layer-nonce.js","names":[],"sources":["../../../../src/symmio-contracts/instant-layer/actions/get-instant-layer-nonce.ts"],"sourcesContent":["import type { Address } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport type { ChainIdParameter, Compute } from \"../../../shared/types/properties\";\nimport { instantLayerAbi } from \"../../abi/v0.8.6/instant-layer\";\n\n/**\n * Parameters for {@link getInstantLayerNonce}.\n */\nexport type GetInstantLayerNonceParameters = Compute<\n  ChainIdParameter & {\n    /** InstantLayer signer account (the sub-account the operation runs under). */\n    account: Address;\n  }\n>;\n\n/** Return type of {@link getInstantLayerNonce}: the account's current replay nonce. */\nexport type GetInstantLayerNonceReturnType = bigint;\n\n/**\n * Read the Instant Layer replay nonce for a signer account.\n *\n * Nonces are **sequential**: an operation must be signed with the *next* nonce\n * (`current + 1`), and a batch must carry strictly consecutive nonces in\n * signed-op order (`current + 1`, `current + 2`, …). Read this immediately\n * before building operations — a stale value produces signatures the relayer's\n * simulation rejects. Two concurrent operations built from the same read will\n * collide; serialize per account.\n *\n * @param config - The SDK config.\n * @param parameters - Signer account, optional chain id.\n * @returns The current on-chain nonce. Sign with `nonce + 1n`.\n * @throws {SymmError} when the chain is unsupported.\n * @throws Viem read errors.\n *\n * @example\n * ```ts\n * const current = await getInstantLayerNonce(config, { account: subAccount });\n * const operation = buildSignedOperation({ ...fields, nonce: current + 1n });\n * ```\n */\nexport async function getInstantLayerNonce(\n  config: Config,\n  parameters: GetInstantLayerNonceParameters,\n): Promise<GetInstantLayerNonceReturnType> {\n  const { chainId, account } = parameters;\n\n  const { addresses } = config.getChainConfig(chainId);\n  const client = config.getClient({ chainId });\n\n  return client.readContract({\n    address: addresses.instantLayerAddress,\n    abi: instantLayerAbi,\n    functionName: \"nonces\",\n    args: [account],\n  });\n}\n"],"mappings":";;AAwCA,eAAsB,EACpB,GACA,GACyC;CACzC,IAAM,EAAE,YAAS,eAAY,GAEvB,EAAE,iBAAc,EAAO,eAAe,CAAO;CAGnD,OAFe,EAAO,UAAU,EAAE,WAAQ,CAEnC,EAAO,aAAa;EACzB,SAAS,EAAU;EACnB,KAAK;EACL,cAAc;EACd,MAAM,CAAC,CAAO;CAChB,CAAC;AACH"}

package/dist/symmio-contracts/instant-layer/actions/get-pending-revocation-etas.d.ts

@@ -0,0 +1,79 @@
+import { Address, Hex } from 'viem';
+import { Config } from '../../../core/config/index.js';
+import { ChainIdParameter, Compute } from '../../../shared/types/properties.js';
+import { InstantLayerAccount } from '../types.js';
+/**
+ * Parameters for {@link getPendingRevocationEtas}.
+ */
+export type GetPendingRevocationEtasParameters = Compute<ChainIdParameter & {
+    /**
+     * Account the delegation is enforced under — pass exactly the account that
+     * was handed to {@link initiateRevokeDelegation}.
+     */
+    delegator: InstantLayerAccount;
+    /** The delegated signer whose pending revocations are read. */
+    delegate: Address;
+    /**
+     * Selectors to probe — the **granted** set, not `getActiveDelegations`'
+     * matched selectors. Enforcement stops at the ETA while the schedule
+     * survives until someone finalizes, so the matched set empties out exactly
+     * when the revocation becomes finalizable.
+     */
+    selectors: readonly Hex[];
+    /** How many `pendingRevocationEta` reads to bundle per multicall. @default 10 */
+    batchSize?: number;
+}>;
+/**
+ * Return type of {@link getPendingRevocationEtas}: scheduled revocations keyed
+ * by selector, as Unix timestamps in seconds.
+ *
+ * A probed selector with no scheduled revocation is **absent** from the map
+ * rather than present with `0n`, so `map.size === 0` means "nothing is being
+ * revoked". Keys are the selectors exactly as they were passed in, so a caller
+ * can look one up with its own array element.
+ */
+export type GetPendingRevocationEtasReturnType = ReadonlyMap<Hex, bigint>;
+/**
+ * Read the Instant Layer's scheduled revocation ETA for each of a delegate's
+ * selectors — the only on-chain signal that a revocation is in flight.
+ *
+ * **Nothing else reveals a pending revocation.** {@link initiateRevokeDelegation}
+ * does not touch the `delegations` mapping; it only stamps
+ * `pendingRevocationEta = block.timestamp + revocationCooldown`. The contract
+ * keeps enforcing the delegation until that ETA passes, so
+ * {@link getIsDelegationActive} and {@link getActiveDelegations} both keep
+ * answering "active" for the whole cooldown — correctly, because the key really
+ * can still sign. A UI that wants to show "revoking, live until …" must read
+ * this mapping alongside them.
+ *
+ * **The ETA is per selector, not per grant.** A partial revoke schedules only
+ * the selectors it was given, so the result can cover a subset of `selectors`.
+ * The reads are bundled into **multicalls of `batchSize`** (default 10) to keep
+ * each RPC round-trip small.
+ *
+ * **This read does not canonicalize.** It keys the mapping on `delegator.addr`
+ * verbatim, which is exactly what `initiateRevokeDelegation` and
+ * `isDelegationActive` do — so pass the same account you revoked with. That is
+ * unlike {@link getActiveDelegations}, which resolves a virtual account to its
+ * parent sub-account: a VA address answers here only if the revocation was
+ * scheduled against that VA.
+ *
+ * @param config - The SDK config.
+ * @param parameters - Delegator account, delegate, selectors, optional chain id and batch size.
+ * @returns The scheduled ETAs, keyed by selector; empty when nothing is being revoked.
+ * @throws {SymmError} when the chain is unsupported.
+ * @throws Viem's `ContractFunctionExecutionError` / multicall errors for on-chain failures.
+ *
+ * @example
+ * ```ts
+ * const etas = await getPendingRevocationEtas(config, {
+ *   delegator: { addr: subAccount, isPartyB: false },
+ *   delegate: sessionKeyAddress,
+ *   selectors,
+ * });
+ * const now = BigInt(Math.floor(Date.now() / 1000));
+ * const isRevoking = [...etas.values()].some((eta) => eta > now);
+ * ```
+ */
+export declare function getPendingRevocationEtas(config: Config, parameters: GetPendingRevocationEtasParameters): Promise<GetPendingRevocationEtasReturnType>;
+//# sourceMappingURL=get-pending-revocation-etas.d.ts.map

package/dist/symmio-contracts/instant-layer/actions/get-pending-revocation-etas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-pending-revocation-etas.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/instant-layer/actions/get-pending-revocation-etas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAElF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAKpD;;GAEG;AACH,MAAM,MAAM,kCAAkC,GAAG,OAAO,CACtD,gBAAgB,GAAG;IACjB;;;OAGG;IACH,SAAS,EAAE,mBAAmB,CAAC;IAC/B,+DAA+D;IAC/D,QAAQ,EAAE,OAAO,CAAC;IAClB;;;;;OAKG;IACH,SAAS,EAAE,SAAS,GAAG,EAAE,CAAC;IAC1B,iFAAiF;IACjF,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CACF,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,kCAAkC,GAAG,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,kCAAkC,GAC7C,OAAO,CAAC,kCAAkC,CAAC,CA+B7C"}

package/dist/symmio-contracts/instant-layer/actions/get-pending-revocation-etas.js

@@ -0,0 +1,32 @@
+import { instantLayerAbi as e } from "../../abi/v0.8.6/instant-layer.js";
+//#region src/symmio-contracts/instant-layer/actions/get-pending-revocation-etas.ts
+var t = 10;
+async function n(n, r) {
+	let { chainId: i, delegator: a, delegate: o, selectors: s, batchSize: c = t } = r, l = /* @__PURE__ */ new Map();
+	if (s.length === 0) return l;
+	let { addresses: u } = n.getChainConfig(i), d = n.getClient({ chainId: i });
+	for (let t = 0; t < s.length; t += c) {
+		let n = s.slice(t, t + c), r = await d.multicall({
+			allowFailure: !1,
+			contracts: n.map((t) => ({
+				address: u.instantLayerAddress,
+				abi: e,
+				functionName: "pendingRevocationEta",
+				args: [
+					a.addr,
+					o,
+					t
+				]
+			}))
+		});
+		n.forEach((e, t) => {
+			let n = r[t];
+			n !== void 0 && n !== 0n && l.set(e, n);
+		});
+	}
+	return l;
+}
+//#endregion
+export { n as getPendingRevocationEtas };
+
+//# sourceMappingURL=get-pending-revocation-etas.js.map

package/dist/symmio-contracts/instant-layer/actions/get-pending-revocation-etas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-pending-revocation-etas.js","names":[],"sources":["../../../../src/symmio-contracts/instant-layer/actions/get-pending-revocation-etas.ts"],"sourcesContent":["import type { Address, Hex } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport type { ChainIdParameter, Compute } from \"../../../shared/types/properties\";\nimport { instantLayerAbi } from \"../../abi/v0.8.6/instant-layer\";\nimport type { InstantLayerAccount } from \"../types\";\n\n/** Default number of `pendingRevocationEta` reads per multicall batch. */\nconst DEFAULT_BATCH_SIZE = 10;\n\n/**\n * Parameters for {@link getPendingRevocationEtas}.\n */\nexport type GetPendingRevocationEtasParameters = Compute<\n  ChainIdParameter & {\n    /**\n     * Account the delegation is enforced under — pass exactly the account that\n     * was handed to {@link initiateRevokeDelegation}.\n     */\n    delegator: InstantLayerAccount;\n    /** The delegated signer whose pending revocations are read. */\n    delegate: Address;\n    /**\n     * Selectors to probe — the **granted** set, not `getActiveDelegations`'\n     * matched selectors. Enforcement stops at the ETA while the schedule\n     * survives until someone finalizes, so the matched set empties out exactly\n     * when the revocation becomes finalizable.\n     */\n    selectors: readonly Hex[];\n    /** How many `pendingRevocationEta` reads to bundle per multicall. @default 10 */\n    batchSize?: number;\n  }\n>;\n\n/**\n * Return type of {@link getPendingRevocationEtas}: scheduled revocations keyed\n * by selector, as Unix timestamps in seconds.\n *\n * A probed selector with no scheduled revocation is **absent** from the map\n * rather than present with `0n`, so `map.size === 0` means \"nothing is being\n * revoked\". Keys are the selectors exactly as they were passed in, so a caller\n * can look one up with its own array element.\n */\nexport type GetPendingRevocationEtasReturnType = ReadonlyMap<Hex, bigint>;\n\n/**\n * Read the Instant Layer's scheduled revocation ETA for each of a delegate's\n * selectors — the only on-chain signal that a revocation is in flight.\n *\n * **Nothing else reveals a pending revocation.** {@link initiateRevokeDelegation}\n * does not touch the `delegations` mapping; it only stamps\n * `pendingRevocationEta = block.timestamp + revocationCooldown`. The contract\n * keeps enforcing the delegation until that ETA passes, so\n * {@link getIsDelegationActive} and {@link getActiveDelegations} both keep\n * answering \"active\" for the whole cooldown — correctly, because the key really\n * can still sign. A UI that wants to show \"revoking, live until …\" must read\n * this mapping alongside them.\n *\n * **The ETA is per selector, not per grant.** A partial revoke schedules only\n * the selectors it was given, so the result can cover a subset of `selectors`.\n * The reads are bundled into **multicalls of `batchSize`** (default 10) to keep\n * each RPC round-trip small.\n *\n * **This read does not canonicalize.** It keys the mapping on `delegator.addr`\n * verbatim, which is exactly what `initiateRevokeDelegation` and\n * `isDelegationActive` do — so pass the same account you revoked with. That is\n * unlike {@link getActiveDelegations}, which resolves a virtual account to its\n * parent sub-account: a VA address answers here only if the revocation was\n * scheduled against that VA.\n *\n * @param config - The SDK config.\n * @param parameters - Delegator account, delegate, selectors, optional chain id and batch size.\n * @returns The scheduled ETAs, keyed by selector; empty when nothing is being revoked.\n * @throws {SymmError} when the chain is unsupported.\n * @throws Viem's `ContractFunctionExecutionError` / multicall errors for on-chain failures.\n *\n * @example\n * ```ts\n * const etas = await getPendingRevocationEtas(config, {\n *   delegator: { addr: subAccount, isPartyB: false },\n *   delegate: sessionKeyAddress,\n *   selectors,\n * });\n * const now = BigInt(Math.floor(Date.now() / 1000));\n * const isRevoking = [...etas.values()].some((eta) => eta > now);\n * ```\n */\nexport async function getPendingRevocationEtas(\n  config: Config,\n  parameters: GetPendingRevocationEtasParameters,\n): Promise<GetPendingRevocationEtasReturnType> {\n  const { chainId, delegator, delegate, selectors, batchSize = DEFAULT_BATCH_SIZE } = parameters;\n\n  const etas = new Map<Hex, bigint>();\n  if (selectors.length === 0) return etas;\n\n  const { addresses } = config.getChainConfig(chainId);\n  const client = config.getClient({ chainId });\n\n  for (let start = 0; start < selectors.length; start += batchSize) {\n    const batch = selectors.slice(start, start + batchSize);\n    const results = await client.multicall({\n      allowFailure: false,\n      contracts: batch.map(\n        (selector) =>\n          ({\n            address: addresses.instantLayerAddress,\n            abi: instantLayerAbi,\n            functionName: \"pendingRevocationEta\",\n            args: [delegator.addr, delegate, selector],\n          }) as const,\n      ),\n    });\n    batch.forEach((selector, index) => {\n      const eta = results[index];\n      /** The mapping returns `0n` for a selector that was never scheduled. */\n      if (eta !== undefined && eta !== 0n) etas.set(selector, eta);\n    });\n  }\n\n  return etas;\n}\n"],"mappings":";;AAOA,IAAM,IAAqB;AA+E3B,eAAsB,EACpB,GACA,GAC6C;CAC7C,IAAM,EAAE,YAAS,cAAW,aAAU,cAAW,eAAY,MAAuB,GAE9E,oBAAO,IAAI,IAAiB;CAClC,IAAI,EAAU,WAAW,GAAG,OAAO;CAEnC,IAAM,EAAE,iBAAc,EAAO,eAAe,CAAO,GAC7C,IAAS,EAAO,UAAU,EAAE,WAAQ,CAAC;CAE3C,KAAK,IAAI,IAAQ,GAAG,IAAQ,EAAU,QAAQ,KAAS,GAAW;EAChE,IAAM,IAAQ,EAAU,MAAM,GAAO,IAAQ,CAAS,GAChD,IAAU,MAAM,EAAO,UAAU;GACrC,cAAc;GACd,WAAW,EAAM,KACd,OACE;IACC,SAAS,EAAU;IACnB,KAAK;IACL,cAAc;IACd,MAAM;KAAC,EAAU;KAAM;KAAU;IAAQ;GAC3C,EACJ;EACF,CAAC;EACD,EAAM,SAAS,GAAU,MAAU;GACjC,IAAM,IAAM,EAAQ;GAEpB,AAAI,MAAQ,KAAA,KAAa,MAAQ,MAAI,EAAK,IAAI,GAAU,CAAG;EAC7D,CAAC;CACH;CAEA,OAAO;AACT"}

package/dist/symmio-contracts/instant-layer/actions/get-revocation-cooldown.d.ts

@@ -0,0 +1,43 @@
+import { Config } from '../../../core/config/index.js';
+import { ChainIdParameter, Compute } from '../../../shared/types/properties.js';
+/**
+ * Parameters for {@link getRevocationCooldown}.
+ */
+export type GetRevocationCooldownParameters = Compute<ChainIdParameter>;
+/** Return type of {@link getRevocationCooldown}: the cooldown in seconds. */
+export type GetRevocationCooldownReturnType = bigint;
+/**
+ * Read the Instant Layer's global delegation revocation cooldown, in seconds.
+ *
+ * This is the delay the two-step revocation enforces.
+ * {@link initiateRevokeDelegation} stamps
+ * `pendingRevocationEta = block.timestamp + revocationCooldown`;
+ * {@link finalizeRevokeDelegation} reverts until that ETA passes, and only then
+ * clears the stored grant.
+ *
+ * **The value is the size of the residual authority window.** Between the
+ * initiate and the ETA the delegation is still enforced — `isDelegationActive`
+ * keeps returning `true` and the delegate can keep acting — so a UI must show
+ * the revocation as *pending*, never as done, for exactly this long. Read the
+ * per-delegation `pendingRevocationEta(delegator, delegate, selector)` mapping
+ * on the InstantLayer to know when a specific revocation lands; this value only
+ * tells you how long a freshly-initiated one will take.
+ *
+ * The cooldown is a contract-level parameter, not per account, so it is the
+ * same for every delegator on the chain and is safe to cache for a long time.
+ *
+ * @param config - The SDK config.
+ * @param parameters - Optional chain id.
+ * @returns The cooldown in seconds.
+ * @throws {SymmError} when the chain is unsupported.
+ * @throws Viem read errors.
+ *
+ * @example
+ * ```ts
+ * const cooldown = await getRevocationCooldown(config);
+ * // The key keeps acting for this long after the revocation is initiated.
+ * const hours = Number(cooldown) / 3600;
+ * ```
+ */
+export declare function getRevocationCooldown(config: Config, parameters?: GetRevocationCooldownParameters): Promise<GetRevocationCooldownReturnType>;
+//# sourceMappingURL=get-revocation-cooldown.d.ts.map

package/dist/symmio-contracts/instant-layer/actions/get-revocation-cooldown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-revocation-cooldown.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/instant-layer/actions/get-revocation-cooldown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAGlF;;GAEG;AACH,MAAM,MAAM,+BAA+B,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;AAExE,6EAA6E;AAC7E,MAAM,MAAM,+BAA+B,GAAG,MAAM,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,MAAM,EACd,UAAU,GAAE,+BAAoC,GAC/C,OAAO,CAAC,+BAA+B,CAAC,CAW1C"}

package/dist/symmio-contracts/instant-layer/actions/get-revocation-cooldown.js

@@ -0,0 +1,14 @@
+import { instantLayerAbi as e } from "../../abi/v0.8.6/instant-layer.js";
+//#region src/symmio-contracts/instant-layer/actions/get-revocation-cooldown.ts
+async function t(t, n = {}) {
+	let { chainId: r } = n, { addresses: i } = t.getChainConfig(r);
+	return t.getClient({ chainId: r }).readContract({
+		address: i.instantLayerAddress,
+		abi: e,
+		functionName: "revocationCooldown"
+	});
+}
+//#endregion
+export { t as getRevocationCooldown };
+
+//# sourceMappingURL=get-revocation-cooldown.js.map

package/dist/symmio-contracts/instant-layer/actions/get-revocation-cooldown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-revocation-cooldown.js","names":[],"sources":["../../../../src/symmio-contracts/instant-layer/actions/get-revocation-cooldown.ts"],"sourcesContent":["import type { Config } from \"../../../core/config\";\nimport type { ChainIdParameter, Compute } from \"../../../shared/types/properties\";\nimport { instantLayerAbi } from \"../../abi/v0.8.6/instant-layer\";\n\n/**\n * Parameters for {@link getRevocationCooldown}.\n */\nexport type GetRevocationCooldownParameters = Compute<ChainIdParameter>;\n\n/** Return type of {@link getRevocationCooldown}: the cooldown in seconds. */\nexport type GetRevocationCooldownReturnType = bigint;\n\n/**\n * Read the Instant Layer's global delegation revocation cooldown, in seconds.\n *\n * This is the delay the two-step revocation enforces.\n * {@link initiateRevokeDelegation} stamps\n * `pendingRevocationEta = block.timestamp + revocationCooldown`;\n * {@link finalizeRevokeDelegation} reverts until that ETA passes, and only then\n * clears the stored grant.\n *\n * **The value is the size of the residual authority window.** Between the\n * initiate and the ETA the delegation is still enforced — `isDelegationActive`\n * keeps returning `true` and the delegate can keep acting — so a UI must show\n * the revocation as *pending*, never as done, for exactly this long. Read the\n * per-delegation `pendingRevocationEta(delegator, delegate, selector)` mapping\n * on the InstantLayer to know when a specific revocation lands; this value only\n * tells you how long a freshly-initiated one will take.\n *\n * The cooldown is a contract-level parameter, not per account, so it is the\n * same for every delegator on the chain and is safe to cache for a long time.\n *\n * @param config - The SDK config.\n * @param parameters - Optional chain id.\n * @returns The cooldown in seconds.\n * @throws {SymmError} when the chain is unsupported.\n * @throws Viem read errors.\n *\n * @example\n * ```ts\n * const cooldown = await getRevocationCooldown(config);\n * // The key keeps acting for this long after the revocation is initiated.\n * const hours = Number(cooldown) / 3600;\n * ```\n */\nexport async function getRevocationCooldown(\n  config: Config,\n  parameters: GetRevocationCooldownParameters = {},\n): Promise<GetRevocationCooldownReturnType> {\n  const { chainId } = parameters;\n\n  const { addresses } = config.getChainConfig(chainId);\n  const client = config.getClient({ chainId });\n\n  return client.readContract({\n    address: addresses.instantLayerAddress,\n    abi: instantLayerAbi,\n    functionName: \"revocationCooldown\",\n  });\n}\n"],"mappings":";;AA6CA,eAAsB,EACpB,GACA,IAA8C,CAAC,GACL;CAC1C,IAAM,EAAE,eAAY,GAEd,EAAE,iBAAc,EAAO,eAAe,CAAO;CAGnD,OAFe,EAAO,UAAU,EAAE,WAAQ,CAEnC,EAAO,aAAa;EACzB,SAAS,EAAU;EACnB,KAAK;EACL,cAAc;CAChB,CAAC;AACH"}

package/dist/symmio-contracts/instant-layer/actions/grant-delegation.d.ts

@@ -1,11 +1,11 @@
 import { Address, Hash, Hex } from 'viem';
 import { Config } from '../../../core/config/index.js';
-import { Compute, WriteContractParameter } from '../../../shared/types/properties.js';
+import { Compute, GaslessWriteParameter, WriteContractParameter } from '../../../shared/types/properties.js';
 import { InstantLayerAccount } from '../types.js';
 /**
  * Parameters for {@link grantDelegation}.
  */
-export type GrantDelegationParameters = Compute<WriteContractParameter & {
+export type GrantDelegationParameters = Compute<WriteContractParameter & GaslessWriteParameter & {
     /** Account that grants the delegation. The wallet must own this account. */
     account: InstantLayerAccount;
     /** Signer that may call the selected Instant Layer functions. */
@@ -15,7 +15,13 @@ export type GrantDelegationParameters = Compute<WriteContractParameter & {
     /** Expiry timestamp in seconds. */
     expiryTimestamp: bigint;
 }>;
-/** Return type of {@link grantDelegation}: the submitted transaction hash. */
+/**
+ * Return type of {@link grantDelegation}: the submitted transaction hash.
+ *
+ * A relayed grant returns the relayer's broadcast hash, which behaves exactly
+ * like a wallet-submitted one — so a caller's receipt wait and invalidation
+ * work the same either way, and the transport never leaks into the type.
+ */
 export type GrantDelegationReturnType = Hash;
 /**
  * Grant Instant Layer delegation access for one delegated signer.
@@ -26,6 +32,21 @@ export type GrantDelegationReturnType = Hash;
  * Dry-runs the call with {@link simulateGrantDelegation} first unless
  * `simulateBeforeWrite` is `false` (per-call, falling back to the config default).
  *
+ * Relays through the gasless service when the chain runs in gasless execution
+ * mode (or the call passes `gasless: true`), so onboarding a session key costs
+ * the owner no native gas — the grant itself is a relayable write. The relayed
+ * path signs an InstantLayer operation instead of sending a transaction, so it
+ * skips the local dry-run; the relayer simulates its own bundle.
+ *
+ * A `isPartyB: true` account cannot be relayed — the signed-operation encoder
+ * has no PartyB form — so it degrades to the wallet path, or throws when
+ * gasless was demanded explicitly.
+ *
+ * **Granting clears any pending revocation** for each selector it covers: the
+ * contract deletes `pendingRevocationEta` alongside writing the new expiry. A
+ * schedule left unfinalized therefore cannot silently neuter a fresh grant, and
+ * {@link finalizeRevokeDelegation} is never a prerequisite for re-granting.
+ *
  * @param config - The SDK config (must have a `getWalletClient` resolver).
  * @param parameters - Delegation account, signer, selectors, expiry, optional chain id.
  * @returns The submitted transaction hash. The caller waits on the receipt.