Session Keys And Policies · Vibenet · base/skills · Skills Docs

Session Keys And Policies · Vibenet · base/skills · Skills Docs

import {
  key, authorizeActor, actorScope,
  defineSessionPolicy, encodeSessionPolicyConfig, encodeSessionPolicyAction,
} from "viem/eip8130";

const policyConfig = encodeSessionPolicyConfig({
  tokenLimits: [{ token: usdv, limit: 100_000_000n, period: 604_800n }], // 100 USDV / week
  callScopes: [{ target: usdv, selectorRules: [{ selector: "0xa9059cbb" }] }], // transfer only
});
// `manager` / `policy` default to the canonical PolicyManager / SessionPolicy
// (same addresses on every chain — verified equal to
// getEip8130Deployment(84538453).policies on vibenet). Override only for your
// own contracts.
const session = defineSessionPolicy({
  account: account.address,
  policyConfig,
  validUntil: 1_900_000_000n,
});

// There is no install step. Every execute carries the full PolicyBinding and
// the manager recomputes its authorized commitment.
const call = session.executeCall(encodeSessionPolicyAction({ target, value: 0n, data }));

// Actor identity for authorize (not a LocalAccount). SCOPE_POLICY is set
// automatically when `policy` is present.
const sessionActor = key.p256({ x: "0x…", y: "0x…" }); // or key.p256(p256Signer.publicKey)
const change = authorizeActor(sessionActor, {
  // POLICY gates every call to the manager; SELF_PAYER lets the key pay gas
  // from the account (needed for self-paid session sends — see "Use the
  // session key"). Adding `operator` would bypass the gate.
  scope: actorScope.policy | actorScope.selfPayer,
  expiry: 1_900_000_000n,
  policy: session.actorPolicy,
});
// `change` is an unsigned change object. Apply it via account.change([change],
// { chainId, sequence }) with a LIVE-read sequence — see Sequence correctness
// below — then include the result in a sendTransaction signed by an admin
// actor. Don't hand-build accountChanges with a hardcoded sequence; that is
// the #1 cause of a silently skipped authorize.

Bit	Grants	Add it when
`policy` (8)	initiation gated to the PolicyManager	always, for a session key — it is set for you when `policy` is passed
`selfPayer` (2)	the key may pay gas from the account	the session key sends self-paid txs (live-confirmed required)
`sponsorPayer` (4)	the key’s txs may be payer-sponsored	the session key sends through an ERC-8168 payer
`nonce` (16)	ordered (expiry-free) nonces	you don’t want to be confined to nonce-free (expiring) sends
`operator` (1)	ungated initiation	never on a policy key — it bypasses the gate

import { toAccount, toP256Signer, sendTransaction, estimateGas, waitForTransactionReceipt,
  canonicalAuthenticators, nonceKeyMax, encodeSessionPolicyAction } from "viem/eip8130";

// A second handle on the SAME address, driven by the session signer. Don't
// pass `scope` here — the handle reads it on-chain, and a declared value that
// disagrees fails with `Declared signing scope 0x8 does not match on-chain
// actor scope 0xa`.
const sessionAccount = toAccount({
  signer: toP256Signer({ privateKey: sessionPrivateKey }),
  address: account.address,
  authenticator: canonicalAuthenticators.p256,
});

const action = session.executeCall(
  encodeSessionPolicyAction({ target: recipient, value: parseEther("0.001"), data: "0x" }),
); // → a call to the PolicyManager; the manager enforces the committed policy

const gas = await estimateGas(client, {
  sender: account.address,
  calls: [[action]],
  senderAuthAuthenticator: canonicalAuthenticators.p256,
  senderActorId: sessionKey.actorId,
});
const { timestamp } = await client.getBlock();
const hash = await sendTransaction(client, {
  account: sessionAccount,
  calls: [action],
  gas: (gas * 120n) / 100n,
  nonceKey: nonceKeyMax,   // nonce-free: required without the `nonce` scope bit
  now: timestamp * 1000n,  // anchor the 20s expiry to chain time, not the laptop clock
});
const receipt = await waitForTransactionReceipt(client, { hash, pollingInterval: 100 });
// status 0x1, phaseStatuses ['0x1'], and the recipient's balance moved by exactly 0.001 ETH.

Deploy path	First local sequence
CREATE2 smart account (`newSmartAccount` + `account.createChange`)	`1` (create bumps local 0→1)
Configured account on an existing address (`toAccount({ address })`)	`1`
Bare 7702 delegation (`toEoaAccount` + `account.delegate`)	`0` (delegation does not initialize state)

import { getConfigSequence, isActor } from "viem/eip8130";

// The Keystore address is built in (`keystoreAddress`) — no per-chain
// `accountConfiguration` argument any more.
const { local } = await getConfigSequence(client, { account: account.address });
// `local` is the NEXT local-channel sequence word (epoch<<32 | seq), read
// live — do not assume 0 or 1. Live-observed on vibenet: 0 before the create
// tx, 1 right after it, 2 after one authorize.
const change = await account.change([authorizeActor(/* … */)], {
  chainId, // local channel for session keys
  sequence: local,
});
// … send the tx, then verify by read-back (polled for ~1 block of lag):
const bound = await isActor(client, { account: account.address, actorId });
if (!bound) throw new Error("authorize was skipped — check sequence/channel");
// getActorConfig(client, { account, actorId }) → { authenticator, scope, expiry, hasPolicy }